temp

Author: BrynCooke

crates/apollo-smith/src/next/README.md

@@ -0,0 +1,2 @@
+# Apollo-Smith Next
+The next folder ****

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

@@ -30,16 +30,30 @@ pub enum Error {
     },
 
     #[error("validation passed, but should have failed")]
-    ExpectedValidationFail { doc: Document, mutation: String },
+    SchemaExpectedValidationFail { doc: Document, mutation: String },
 
     #[error("the serialized AST did not round trip to an identical AST")]
     SerializationInconsistency { original: Document, new: Document },
 
     #[error("parse error")]
     Parse(WithErrors<Document>),
 
+    #[error("validation passed, but should have failed")]
+    ExecutableExpectedValidationFail {
+        schema: Valid<Schema>,
+        doc: Document,
+        mutation: String
+    },
+
     #[error("reparse error")]
-    Reparse {
+    SchemaReparse {
+        doc: Document,
+        errors: WithErrors<Document>,
+    },
+
+    #[error("reparse error")]
+    ExecutableReparse {
+        schema: Valid<Schema>,
         doc: Document,
         errors: WithErrors<Document>,
     },
@@ -67,12 +81,13 @@ pub fn generate_schema_document(u: &mut Unstructured) -> Result<Document, Error>
             continue;
         }
 
+
         // Now let's validate that the schema says it's OK
         match (mutation.is_valid(), new_doc.to_schema_validate()) {
             (true, Ok(new_schema)) => {
                 // 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::Reparse {
+                    .map_err(|e| Error::SchemaReparse {
                         doc: new_doc.clone(),
                         errors: e,
                     })?;
@@ -87,7 +102,6 @@ pub fn generate_schema_document(u: &mut Unstructured) -> Result<Document, Error>
 
                 // Let's try and create an executable document from the schema
                 generate_executable_document(u, &new_schema)?;
-
                 schema = new_schema.into_inner();
                 doc = new_doc;
                 continue;
@@ -99,7 +113,7 @@ pub fn generate_schema_document(u: &mut Unstructured) -> Result<Document, Error>
                 });
             }
             (false, Ok(_)) => {
-                return Err(Error::ExpectedValidationFail {
+                return Err(Error::SchemaExpectedValidationFail {
                     doc: new_doc,
                     mutation: mutation.type_name().to_string(),
                 });
@@ -119,7 +133,7 @@ pub(crate) fn generate_executable_document(
 ) -> Result<Document, Error> {
     let mut doc = Document::new();
     let mutations = mutations::executable_document_mutations();
-    for _ in 0..1000 {
+    for count 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))?;
@@ -133,12 +147,12 @@ pub(crate) fn generate_executable_document(
         }
 
         // Now let's validate that the schema says it's OK
-
         match (mutation.is_valid(), new_doc.to_executable_validate(schema)) {
             (true, Ok(_)) => {
                 // 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::Reparse {
+                    .map_err(|e| Error::ExecutableReparse {
+                        schema: schema.clone(),
                         doc: new_doc.clone(),
                         errors: e,
                     })?;
@@ -162,7 +176,7 @@ pub(crate) fn generate_executable_document(
                 });
             }
             (false, Ok(_)) => {
-                return Err(Error::ExpectedValidationFail {
+                return Err(Error::SchemaExpectedValidationFail {
                     doc: new_doc,
                     mutation: mutation.type_name().to_string(),
                 });

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

@@ -17,9 +17,9 @@ impl Mutation for AddOperationDefinition {
             .push(Definition::OperationDefinition(Node::new(
                 u.arbitrary_operation_definition(schema)?,
             )));
-        Ok(false)
+        Ok(true)
     }
     fn is_valid(&self) -> bool {
-        false
+        true
     }
 }

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

@@ -48,7 +48,7 @@ pub(crate) fn schema_mutations() -> Vec<Box<dyn Mutation>> {
         Box::new(AddInputObjectTypeDefinition),
         Box::new(AddUnionTypeDefinition),
         Box::new(AddInterfaceTypeDefinition),
-        Box::new(RemoveAllFields),
+        //Box::new(RemoveAllFields),
         Box::new(RemoveRequiredField),
     ]
 }

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

@@ -16,6 +16,8 @@ use crate::next::ast::directive_definition::DirectiveDefinitionIterExt;
 use crate::next::schema::extended_type::{ExtendedTypeExt, ExtendedTypeKind};
 use crate::next::schema::object_type::ObjectTypeExt;
 use crate::next::schema::schema::SchemaExt;
+use crate::next::schema::TypeHasFields;
+
 pub struct Unstructured<'a> {
     u: arbitrary::Unstructured<'a>,
     counter: usize,
@@ -447,8 +449,10 @@ impl Unstructured<'_> {
                 .sample_directives(self)?
                 .into_iter()
                 .with_location(DirectiveLocation::Field)
+                // skip and include are not allowed on operations
+                .filter(|d|d.name != "skip" && d.name != "include")
                 .try_collect(self, schema)?,
-            selection_set: self.arbitrary_vec(0, 5, |u| {
+            selection_set: self.arbitrary_vec(1, 5, |u| {
                 Ok(u.arbitrary_selection(schema, operation.deref())?)
             })?,
         })
@@ -484,7 +488,7 @@ impl Unstructured<'_> {
                 .into_iter()
                 .with_location(DirectiveLocation::InlineFragment)
                 .try_collect(self, schema)?,
-            selection_set: self.arbitrary_vec(0, 5, |u| Ok(u.arbitrary_selection(schema, ty)?))?,
+            selection_set: self.arbitrary_vec(1, 5, |u| Ok(u.arbitrary_selection(schema, ty)?))?,
         })
     }
 
@@ -502,22 +506,22 @@ impl Unstructured<'_> {
     fn arbitrary_selection(
         &mut self,
         schema: &Schema,
-        ty: &dyn super::schema::TypeHasFields,
+        ty: &dyn TypeHasFields,
     ) -> Result<Selection> {
         match self.choose_index(3) {
             Ok(0) => {
                 let field = ty.random_field(self)?;
                 let field_ty = schema.types.get(field.ty.inner_named_type()).expect("type must exist");
-                let selection_set = if field_ty.is_object() || field_ty.is_interface() {
-                    self.arbitrary_vec(0, 5, |u| {
+                let selection_set = if field_ty.is_scalar() {
+                    vec![]
+                } else {
+                    self.arbitrary_vec(1, 5, |u| {
                         Ok(u.arbitrary_selection(schema, field_ty)?)
                     })?
-                } else {
-                    vec![]
                 };
                 Ok(Selection::Field(Node::new(Field {
                     alias: self.arbitrary_optional(|u|Ok(u.unique_name()))?,
-                    name: self.unique_name(),
+                    name: field.name.clone(),
                     arguments: self.arbitrary_vec(0, 5, |u| {
                         Ok(Node::new(Argument {
                             name: u.unique_name(),

fuzz/fuzz_targets/parser_next.rs

@@ -20,7 +20,7 @@ fuzz_target!(|data: &[u8]| {
             Error::Parse(doc) => {
                 println!("{}\ndoc:\n{}\nerrors:\n{}", e, doc.to_string(), doc.errors);
             }
-            Error::ExpectedValidationFail { doc, mutation } => {
+            Error::SchemaExpectedValidationFail { doc, mutation } => {
                 println!("{}\nmutation:\n{}\ndoc:\n{}", e, mutation, doc.to_string());
             }
             Error::SerializationInconsistency { original, new } => {
@@ -39,27 +39,44 @@ fuzz_target!(|data: &[u8]| {
                     errors.errors
                 );
             }
-            Error::Reparse { doc, errors } => {
+            Error::SchemaReparse { doc, errors } => {
                 println!(
                     "{}\ndoc:\n{}\nerrors:\n{}",
                     e,
                     doc.to_string(),
                     errors.errors
                 );
             }
+
+            Error::ExecutableReparse {
+                schema,
+                doc,
+                errors,
+            } => {
+                println!(
+                    "{}\ndoc:\n{}\nschema:\n{}\nerrors:\n{}",
+                    e,
+                    doc.to_string(),
+                    schema.to_string(),
+                    errors.errors
+                );
+            }
             Error::ExecutableDocumentValidation {
                 doc,
                 schema,
                 errors,
             } => {
                 println!(
-                    "{}\nschena\n{}\ndoc:\n{}\nerrors:\n{}",
+                    "{}\ndoc\n{}\nschema:\n{}\nerrors:\n{}",
                     e,
-                    schema.to_string(),
                     doc.to_string(),
+                    schema.to_string(),
                     errors.errors
                 );
             }
+            Error::ExecutableExpectedValidationFail { schema, doc, mutation } => {
+                println!("{}\nmutation:\n{}\ndoc:\n{}\nschema\n{}", e, mutation, doc.to_string(), schema.to_string());
+            }
         }
         panic!("error detected: {}", e);
     }