Temp

Author: BrynCooke

crates/apollo-smith/src/next/ast/document.rs

@@ -1,28 +1,15 @@
-use std::collections::HashSet;
-
-use arbitrary::Result;
-
 use paste::paste;
 
 use apollo_compiler::ast::{
-    Definition, DirectiveDefinition, DirectiveLocation, Document, EnumTypeDefinition,
-    EnumTypeExtension, EnumValueDefinition, FieldDefinition, FragmentDefinition,
-    InputObjectTypeDefinition, InputObjectTypeExtension, InputValueDefinition,
-    InterfaceTypeDefinition, InterfaceTypeExtension, Name, ObjectTypeDefinition,
-    ObjectTypeExtension, OperationDefinition, OperationType, ScalarTypeDefinition,
-    ScalarTypeExtension, SchemaDefinition, SchemaExtension, Type, UnionTypeDefinition,
-    UnionTypeExtension, Value,
+    Definition, DirectiveDefinition, Document, EnumTypeDefinition, EnumTypeExtension,
+    FragmentDefinition, InputObjectTypeDefinition, InputObjectTypeExtension,
+    InterfaceTypeDefinition, InterfaceTypeExtension, ObjectTypeDefinition, ObjectTypeExtension,
+    OperationDefinition, ScalarTypeDefinition, ScalarTypeExtension, SchemaDefinition,
+    SchemaExtension, UnionTypeDefinition, UnionTypeExtension,
 };
-use apollo_compiler::executable::DirectiveList;
-use apollo_compiler::schema::ExtendedType;
-use apollo_compiler::{Node, NodeStr, Schema};
-
-use crate::next::ast::definition::{DefinitionExt, DefinitionKind};
-use crate::next::schema::extended_type::{ExtendedTypeExt, ExtendedTypeKind};
-use crate::next::unstructured::{Unstructured, UnstructuredExt, UnstructuredOption};
+use apollo_compiler::Node;
 
-use super::super::schema::schema::SchemaExt;
-use super::directive_definition::DirectiveDefinitionIterExt;
+use crate::next::unstructured::Unstructured;
 
 /// Macro to create accessors for definitions
 macro_rules! access {

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

@@ -73,14 +73,15 @@ pub enum Error {
 
 pub fn generate_schema_document(input: &[u8]) -> Result<Document, Error> {
     let mut u = Unstructured::new(input);
-    println!("starting");
     let mut doc = Document::parse(
         "type Query { me: String }".to_string(),
         PathBuf::from("synthetic"),
     )
     .map_err(Error::Parse)?; // Start with a minimal schema
-    println!("parsed initial");
     let mutations = mutations::all_mutations();
+    for mutation in &mutations {
+        println!("mutation {}", mutation.type_name());
+    }
     let mut schema = doc.to_schema().expect("initial schema must be valid");
     for n in 0..1000 {
         println!("iteration: {}", n);
@@ -93,8 +94,6 @@ pub fn generate_schema_document(input: &[u8]) -> Result<Document, Error> {
         Document::parse(doc.to_string(), PathBuf::from("synthetic")).map_err(Error::Parse)?;
         // Now let's validate that the schema says it's OK
 
-        println!("{}", doc.to_string());
-
         match (mutation.is_valid(), doc.to_schema_validate()) {
             (true, Ok(new_schema)) => {
                 schema = new_schema.into_inner();
@@ -107,7 +106,7 @@ pub fn generate_schema_document(input: &[u8]) -> Result<Document, Error> {
                 return Err(Error::ExpectedValidationFail(doc));
             }
             (false, Err(_)) => {
-                // Validation was expected to fail, we can't continue
+                // Validation was expected to fail, we can't continue as we mutated the doc
                 return Ok(doc);
             }
         }
@@ -130,7 +129,7 @@ mod test {
 
     #[test]
     fn test() {
-        let input = b"293ur928jff029jf0293f";
+        let input = b"293ur928jff029jf0293ff20983nr0v243ucm8unr4pv938uavtnpb98aun34vtr98aun23vr892auna98r3unv298ua43arp9vu32a3p538umq2v4098cutrnfavwynr9ha28pbz9vuwrA29P38AU[R09UMA2[0893U5NC9A8P3NRV";
         match generate_schema_document(input) {
             Ok(_) => {}
             Err(e) => {

crates/apollo-smith/src/next/test.graphql

@@ -160,7 +160,7 @@ impl Unstructured<'_> {
                 .into_iter()
                 .with_location(DirectiveLocation::Object)
                 .try_collect(self, schema)?,
-            fields: self.arbitrary_vec(0, 5, |u| {
+            fields: self.arbitrary_vec(1, 5, |u| {
                 Ok(Node::new(u.arbitrary_field_definition(
                     schema,
                     DirectiveLocation::FieldDefinition,

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

@@ -1,6 +1,6 @@
 #![no_main]
 use apollo_parser::Parser;
-use apollo_rs_fuzz::{fuzz_document, generate_valid_document, log_gql_doc};
+use apollo_rs_fuzz::{generate_valid_document, log_gql_doc};
 use libfuzzer_sys::arbitrary::Unstructured;
 use libfuzzer_sys::fuzz_target;
 use log::debug;
@@ -9,33 +9,7 @@ use std::panic;
 fuzz_target!(|data: &[u8]| {
     let _ = env_logger::try_init();
 
-    let parser = panic::catch_unwind(|| Parser::new(&doc_generated));
-
-    let parser = match parser {
-        Err(err) => {
-            panic!("error {err:?}");
-        }
-        Ok(p) => p,
-    };
-    debug!("======= DOCUMENT =======");
-    debug!("{}", doc_generated);
-    debug!("========================");
-
-    let tree = parser.parse();
-    // early return if the parser detected an error
-    let mut should_panic = false;
-    if tree.errors().len() > 0 {
-        should_panic = true;
-        let errors = tree
-            .errors()
-            .map(|err| err.message())
-            .collect::<Vec<&str>>()
-            .join("\n");
-        debug!("Parser errors ========== \n{:?}", errors);
-        debug!("========================");
-        log_gql_doc(&doc_generated, &errors);
-    }
-    if should_panic {
-        panic!("error detected");
+    if let Err(e) = apollo_rs_fuzz::generate_schema_document(data) {
+        log::info!("error: {:?}", e);
     }
 });

fuzz/fuzz_targets/parser_next.rs

@@ -13,6 +13,15 @@ pub fn generate_valid_document(input: &[u8]) -> Result<String> {
     Ok(document.into())
 }
 
+pub fn generate_schema_document(
+    input: &[u8],
+) -> std::result::Result<(), apollo_smith::next::Error> {
+    drop(env_logger::try_init());
+
+    apollo_smith::next::generate_schema_document(input)?;
+    Ok(())
+}
+
 /// Log the error and the document generated for these errors
 /// Save it into files
 pub fn log_gql_doc(gql_doc: &str, errors: &str) {