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) -> Result<Vec<Argument>>

Create an arbitrary vector of Argument

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

Create an arbitrary vector of Argument given ArgumentsDef

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

Create an arbitrary Argument

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

Create an arbitrary Argument

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

Create an arbitrary ArgumentsDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary Description

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary vector of Directive

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

Create an arbitrary Directive given a directive location

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

Create an arbitrary DirectiveDef

pub fn directive_locations(&mut self) -> Result<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]) -> Result<Vec<FieldDef>>

Create an arbitrary list of FieldDef

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

Create an arbitrary Field given an object type

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary FragmentDef

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

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

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

Create an arbitrary InlineFragment

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

Create an arbitrary TypeCondition

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary InputObjectTypeDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary InputValue

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

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

Create an arbitrary list of InputValueDef

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

Create an arbitrary InputValueDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary InterfaceTypeDef

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

Create an arbitrary HashSet of implemented interfaces

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary Name

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

Create an arbitrary type Name

pub fn name_with_index(&mut self, index: usize) -> Result<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) -> Result<ObjectTypeDef>

Create an arbitrary ObjectTypeDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary OperationDef taking the last SchemaDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary ScalarTypeDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary SchemaDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary SelectionSet

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

Create an arbitrary Selection

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary Ty

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

Choose an arbitrary existing Ty given a slice of existing types

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

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

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary UnionTypeDef

impl<'a> DocumentBuilder<'a>

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

Create an arbitrary list of VariableDef

pub fn variable_definition(&mut self) -> Result<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 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.