temp

Author: BrynCooke

crates/apollo-smith/src/next/mod.rs

@@ -132,23 +132,24 @@ pub(crate) fn generate_executable_document(
     schema: &Valid<Schema>,
 ) -> Result<Document, Error> {
     let mut doc = Document::new();
+    let mut executable_document = doc.to_executable(schema).expect("initial document must be valid");
     let mutations = mutations::executable_document_mutations();
-    for count in 0..1000 {
+    for _ in 0..1000 {
         if u.len() == 0 {
             // We ran out of data abort. This is not an error
             return Err(Error::Arbitrary(arbitrary::Error::NotEnoughData))?;
         }
         let mutation = u.choose(&mutations)?;
         let mut new_doc = doc.clone();
         // First let's modify the document.
-        if !mutation.apply(u, &mut new_doc, &schema)? {
+        if !mutation.apply(u, &mut new_doc, &schema, &executable_document)? {
             // The mutation didn't apply, let's try another one
             continue;
         }
 
         // Now let's validate that the schema says it's OK
         match (mutation.is_valid(), new_doc.to_executable_validate(schema)) {
-            (true, Ok(_)) => {
+            (true, Ok(new_executable_document)) => {
                 // Let's reparse the document to check that it can be parsed
                 let reparsed = Document::parse(new_doc.to_string(), PathBuf::from("synthetic"))
                     .map_err(|e| Error::ExecutableReparse {
@@ -166,6 +167,7 @@ pub(crate) fn generate_executable_document(
                 }
 
                 doc = new_doc;
+                executable_document = new_executable_document.into_inner();
                 continue;
             }
             (true, Err(e)) => {

crates/apollo-smith/src/next/mutations/add_anonymous_operation_definition.rs

@@ -0,0 +1,30 @@
+use crate::next::mutations::{ExecutableDocumentMutation, SchemaMutation};
+
+use crate::next::unstructured::Unstructured;
+use apollo_compiler::ast::{Definition, Document};
+use apollo_compiler::{ExecutableDocument, Node, Schema};
+
+pub(crate) struct AddAnonymousOperationDefinition;
+
+impl ExecutableDocumentMutation for AddAnonymousOperationDefinition {
+    fn apply(
+        &self,
+        u: &mut Unstructured,
+        doc: &mut Document,
+        schema: &Schema,
+        executable_document: &ExecutableDocument,
+    ) -> arbitrary::Result<bool> {
+        if !executable_document.named_operations.is_empty() || executable_document.anonymous_operation.is_some() {
+            // We already have an operation, so we can't add an anonymous one
+            return Ok(false);
+        }
+        doc.definitions
+            .push(Definition::OperationDefinition(Node::new(
+                u.arbitrary_operation_definition(schema, executable_document, None)?,
+            )));
+        Ok(true)
+    }
+    fn is_valid(&self) -> bool {
+        true
+    }
+}

crates/apollo-smith/src/next/mutations/add_directive_definition.rs

@@ -1,11 +1,11 @@
 use apollo_compiler::ast::{Definition, Document};
 use apollo_compiler::{Node, Schema};
 
-use crate::next::mutations::Mutation;
+use crate::next::mutations::SchemaMutation;
 use crate::next::unstructured::Unstructured;
 
 pub(crate) struct AddDirectiveDefinition;
-impl Mutation for AddDirectiveDefinition {
+impl SchemaMutation for AddDirectiveDefinition {
     fn apply(
         &self,
         u: &mut Unstructured,

crates/apollo-smith/src/next/mutations/add_enum_type_definition.rs

@@ -1,11 +1,11 @@
 use apollo_compiler::ast::{Definition, Document};
 use apollo_compiler::{Node, Schema};
 
-use crate::next::mutations::Mutation;
+use crate::next::mutations::SchemaMutation;
 use crate::next::unstructured::Unstructured;
 
 pub(crate) struct AddEnumTypeDefinition;
-impl Mutation for AddEnumTypeDefinition {
+impl SchemaMutation for AddEnumTypeDefinition {
     fn apply(
         &self,
         u: &mut Unstructured,

crates/apollo-smith/src/next/mutations/add_input_object_type_definition.rs

@@ -1,11 +1,11 @@
 use apollo_compiler::ast::{Definition, Document};
 use apollo_compiler::{Node, Schema};
 
-use crate::next::mutations::Mutation;
+use crate::next::mutations::SchemaMutation;
 use crate::next::unstructured::Unstructured;
 
 pub(crate) struct AddInputObjectTypeDefinition;
-impl Mutation for AddInputObjectTypeDefinition {
+impl SchemaMutation for AddInputObjectTypeDefinition {
     fn apply(
         &self,
         u: &mut Unstructured,

crates/apollo-smith/src/next/mutations/add_interface_type_definition.rs

@@ -1,11 +1,11 @@
 use apollo_compiler::ast::{Definition, Document};
 use apollo_compiler::{Node, Schema};
 
-use crate::next::mutations::Mutation;
+use crate::next::mutations::SchemaMutation;
 use crate::next::unstructured::Unstructured;
 
 pub(crate) struct AddInterfaceTypeDefinition;
-impl Mutation for AddInterfaceTypeDefinition {
+impl SchemaMutation for AddInterfaceTypeDefinition {
     fn apply(
         &self,
         u: &mut Unstructured,

crates/apollo-smith/src/next/mutations/add_named_operation_definition.rs

@@ -0,0 +1,31 @@
+use crate::next::mutations::{ExecutableDocumentMutation, SchemaMutation};
+
+use crate::next::unstructured::Unstructured;
+use apollo_compiler::ast::{Definition, Document};
+use apollo_compiler::{ExecutableDocument, Node, Schema};
+
+pub(crate) struct AddNamedOperationDefinition;
+
+impl ExecutableDocumentMutation for AddNamedOperationDefinition {
+    fn apply(
+        &self,
+        u: &mut Unstructured,
+        doc: &mut Document,
+        schema: &Schema,
+        executable_document: &ExecutableDocument,
+    ) -> arbitrary::Result<bool> {
+        if executable_document.anonymous_operation.is_some() {
+            // We already have an anonymous operation, so we can't add a named one
+            return Ok(false);
+        }
+        let name = u.unique_name();
+        doc.definitions
+            .push(Definition::OperationDefinition(Node::new(
+                u.arbitrary_operation_definition(schema, executable_document, Some(name))?,
+            )));
+        Ok(true)
+    }
+    fn is_valid(&self) -> bool {
+        true
+    }
+}

crates/apollo-smith/src/next/mutations/add_object_type_definition.rs

@@ -1,11 +1,11 @@
 use apollo_compiler::ast::{Definition, Document};
 use apollo_compiler::{Node, Schema};
 
-use crate::next::mutations::Mutation;
+use crate::next::mutations::SchemaMutation;
 use crate::next::unstructured::Unstructured;
 
 pub(crate) struct AddObjectTypeDefinition;
-impl Mutation for AddObjectTypeDefinition {
+impl SchemaMutation for AddObjectTypeDefinition {
     fn apply(
         &self,
         u: &mut Unstructured,

crates/apollo-smith/src/next/mutations/add_operation_definition.rs

@@ -1,11 +1,11 @@
 use apollo_compiler::ast::{Definition, Document};
 use apollo_compiler::{Node, Schema};
 
-use crate::next::mutations::Mutation;
+use crate::next::mutations::SchemaMutation;
 use crate::next::unstructured::Unstructured;
 
 pub(crate) struct AddSchemaDefiniton;
-impl Mutation for AddSchemaDefiniton {
+impl SchemaMutation for AddSchemaDefiniton {
     fn apply(
         &self,
         u: &mut Unstructured,