Struct apollo_smith::DocumentBuilder

pub struct DocumentBuilder<'a> { /* private fields */ }

DocumentBuilder is a struct to build an arbitrary valid GraphQL document

// fuzz/fuzz_targets/my_apollo_smith_fuzz_target.rs
#![no_main]

use libfuzzer_sys::fuzz_target;
use arbitrary::Unstructured;
use apollo_smith::DocumentBuilder;

fuzz_target!(|input: &[u8]| {
    let mut u = Unstructured::new(input);
    let gql_doc = DocumentBuilder::new(&mut u)?;
    let document = gql_doc.finish();
    let document_str = String::from(document);

    // Your code here...
});

Implementations

impl<'a> DocumentBuilder<'a>

pub fn arguments(&mut self) -> ArbitraryResult<Vec<Argument>>

Create an arbitrary vector of Argument

pub fn arguments_with_def( &mut self, args_def: &ArgumentsDef ) -> ArbitraryResult<Vec<Argument>>

Create an arbitrary vector of Argument given ArgumentsDef

pub fn argument(&mut self) -> ArbitraryResult<Argument>

Create an arbitrary Argument

pub fn argument_with_def( &mut self, input_val_def: &InputValueDef ) -> ArbitraryResult<Argument>

Create an arbitrary Argument

pub fn arguments_definition(&mut self) -> ArbitraryResult<ArgumentsDef>

Create an arbitrary ArgumentsDef

impl<'a> DocumentBuilder<'a>

pub fn description(&mut self) -> ArbitraryResult<Description>

Create an arbitrary Description

impl<'a> DocumentBuilder<'a>

pub fn directives( &mut self, directive_location: DirectiveLocation ) -> ArbitraryResult<HashMap<Name, Directive>>

Create an arbitrary vector of Directive

pub fn directive( &mut self, directive_location: DirectiveLocation ) -> ArbitraryResult<Option<Directive>>

Create an arbitrary Directive given a directive location

pub fn directive_def(&mut self) -> ArbitraryResult<DirectiveDef>

Create an arbitrary DirectiveDef

pub fn directive_locations( &mut self ) -> ArbitraryResult<HashSet<DirectiveLocation>>

Create an arbitrary HashSet of DirectiveLocation

impl<'a> DocumentBuilder<'a>

pub fn enum_type_definition(&mut self) -> Result<EnumTypeDef>

Create an arbitrary EnumTypeDef

pub fn choose_enum(&mut self) -> Result<&EnumTypeDef>

Choose an arbitrary EnumTypeDef in existings (already created) enum definitions

pub fn arbitrary_variant<'b>( &mut self, enum_: &'b EnumTypeDef ) -> Result<&'b Name>

Create an arbitrary variant Name given an enum

pub fn enum_values_definition(&mut self) -> Result<HashSet<EnumValueDefinition>>

Create an arbitrary EnumValueDefinition

impl<'a> DocumentBuilder<'a>

pub fn fields_definition( &mut self, exclude: &[&Name] ) -> ArbitraryResult<Vec<FieldDef>>

Create an arbitrary list of FieldDef

pub fn field(&mut self, index: usize) -> ArbitraryResult<Field>

Create an arbitrary Field given an object type

impl<'a> DocumentBuilder<'a>

pub fn fragment_definition(&mut self) -> ArbitraryResult<FragmentDef>

Create an arbitrary FragmentDef

pub fn fragment_spread( &mut self, excludes: &mut Vec<Name> ) -> ArbitraryResult<Option<FragmentSpread>>

Create an arbitrary FragmentSpread, returns None if no fragment definition was previously created

pub fn inline_fragment(&mut self) -> ArbitraryResult<InlineFragment>

Create an arbitrary InlineFragment

pub fn type_condition(&mut self) -> ArbitraryResult<TypeCondition>

Create an arbitrary TypeCondition

impl<'a> DocumentBuilder<'a>

pub fn input_object_type_definition( &mut self ) -> ArbitraryResult<InputObjectTypeDef>

Create an arbitrary InputObjectTypeDef

impl<'a> DocumentBuilder<'a>

pub fn input_value(&mut self) -> ArbitraryResult<InputValue>

Create an arbitrary InputValue

pub fn input_value_for_type(&mut self, ty: &Ty) -> ArbitraryResult<InputValue>

pub fn input_values_def(&mut self) -> ArbitraryResult<Vec<InputValueDef>>

Create an arbitrary list of InputValueDef

pub fn input_value_def(&mut self) -> ArbitraryResult<InputValueDef>

Create an arbitrary InputValueDef

impl<'a> DocumentBuilder<'a>

pub fn interface_type_definition(&mut self) -> ArbitraryResult<InterfaceTypeDef>

Create an arbitrary InterfaceTypeDef

pub fn implements_interfaces(&mut self) -> ArbitraryResult<HashSet<Name>>

Create an arbitrary HashSet of implemented interfaces

impl<'a> DocumentBuilder<'a>

pub fn name(&mut self) -> ArbitraryResult<Name>

Create an arbitrary Name

pub fn type_name(&mut self) -> ArbitraryResult<Name>

Create an arbitrary type Name

pub fn name_with_index(&mut self, index: usize) -> ArbitraryResult<Name>

Create an arbitrary Name with an index included in the name (to avoid name conflict)

impl<'a> DocumentBuilder<'a>

pub fn object_type_definition(&mut self) -> ArbitraryResult<ObjectTypeDef>

Create an arbitrary ObjectTypeDef

impl<'a> DocumentBuilder<'a>

pub fn operation_definition(&mut self) -> ArbitraryResult<Option<OperationDef>>

Create an arbitrary OperationDef taking the last SchemaDef

impl<'a> DocumentBuilder<'a>

pub fn scalar_type_definition(&mut self) -> ArbitraryResult<ScalarTypeDef>

Create an arbitrary ScalarTypeDef

impl<'a> DocumentBuilder<'a>

pub fn schema_definition(&mut self) -> ArbitraryResult<SchemaDef>

Create an arbitrary SchemaDef

impl<'a> DocumentBuilder<'a>

pub fn selection_set(&mut self) -> ArbitraryResult<SelectionSet>

Create an arbitrary SelectionSet

pub fn selection( &mut self, index: usize, excludes: &mut Vec<Name> ) -> ArbitraryResult<Selection>

Create an arbitrary Selection

impl<'a> DocumentBuilder<'a>

pub fn ty(&mut self) -> ArbitraryResult<Ty>

Create an arbitrary Ty

pub fn choose_ty(&mut self, existing_types: &[Ty]) -> ArbitraryResult<Ty>

Choose an arbitrary existing Ty given a slice of existing types

pub fn choose_named_ty(&mut self, existing_types: &[Ty]) -> ArbitraryResult<Ty>

Choose an arbitrary existing named Ty given a slice of existing types

impl<'a> DocumentBuilder<'a>

pub fn union_type_definition(&mut self) -> ArbitraryResult<UnionTypeDef>

Create an arbitrary UnionTypeDef

impl<'a> DocumentBuilder<'a>

pub fn variable_definitions(&mut self) -> ArbitraryResult<Vec<VariableDef>>

Create an arbitrary list of VariableDef

pub fn variable_definition(&mut self) -> ArbitraryResult<VariableDef>

Create an arbitrary VariableDef

impl<'a> DocumentBuilder<'a>

pub fn new(u: &'a mut Unstructured<'a>) -> Result<Self>

Create an instance of DocumentBuilder

pub fn with_document( u: &'a mut Unstructured<'a>, document: Document ) -> Result<Self>

Create an instance of DocumentBuilder given a Document to be able to call methods on DocumentBuilder and generate valid entities like for example an operation

pub fn input_exhausted(&self) -> bool

Returns whether the provided Unstructured is now empty

pub fn finish(self) -> Document

Convert a DocumentBuilder into a GraphQL Document

Trait Implementations

impl<'a> Debug for DocumentBuilder<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.