temp

Author: BrynCooke

crates/apollo-smith/src/next/executable/executable_document.rs

@@ -0,0 +1,30 @@
+use crate::next::Unstructured;
+use apollo_compiler::executable::Fragment;
+use apollo_compiler::{ExecutableDocument, Node};
+use crate::next::schema::Selectable;
+
+pub(crate) trait ExecutableDocumentExt {
+    fn random_fragment(&self, u: &mut Unstructured) -> arbitrary::Result<&Node<Fragment>> {
+        let fragments = self.target().fragments.values().collect::<Vec<_>>();
+        Ok(fragments[u.choose_index(fragments.len())?])
+    }
+
+    fn random_fragment_of_type(
+        &self,
+        u: &mut Unstructured,
+        selectable: &impl Selectable
+    ) -> arbitrary::Result<Option<&Node<Fragment>>> {
+        let fragments = self.target().fragments.values().filter(|f|&f.selection_set.ty == selectable.name()).collect::<Vec<_>>();
+        if fragments.is_empty() {
+            return Ok(None)
+        }
+        Ok(Some(fragments[u.choose_index(fragments.len())?]))
+    }
+    fn target(&self) -> &ExecutableDocument;
+}
+
+impl ExecutableDocumentExt for ExecutableDocument {
+    fn target(&self) -> &ExecutableDocument {
+        &self
+    }
+}

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

@@ -0,0 +1 @@
+pub(crate) mod executable_document;

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

@@ -10,6 +10,7 @@ mod ast;
 mod mutations;
 mod schema;
 mod unstructured;
+mod executable;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {

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

@@ -1,4 +1,4 @@
-use crate::next::mutations::{ExecutableDocumentMutation, SchemaMutation};
+use crate::next::mutations::{ExecutableDocumentMutation};
 
 use crate::next::unstructured::Unstructured;
 use apollo_compiler::ast::{Definition, Document};

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

@@ -0,0 +1,26 @@
+use crate::next::mutations::{ExecutableDocumentMutation};
+
+use crate::next::unstructured::Unstructured;
+use apollo_compiler::ast::{Definition, Document};
+use apollo_compiler::{ExecutableDocument, Node, Schema};
+
+pub(crate) struct AddFragmentDefiniton;
+
+impl ExecutableDocumentMutation for AddFragmentDefiniton {
+    fn apply(
+        &self,
+        u: &mut Unstructured,
+        doc: &mut Document,
+        schema: &Schema,
+        executable_document: &ExecutableDocument,
+    ) -> arbitrary::Result<bool> {
+        doc.definitions
+            .push(Definition::FragmentDefinition(Node::new(
+                u.arbitrary_fragment_definition(schema, executable_document)?,
+            )));
+        Ok(true)
+    }
+    fn is_valid(&self) -> bool {
+        true
+    }
+}

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

@@ -1,4 +1,4 @@
-use crate::next::mutations::{ExecutableDocumentMutation, SchemaMutation};
+use crate::next::mutations::{ExecutableDocumentMutation};
 
 use crate::next::unstructured::Unstructured;
 use apollo_compiler::ast::{Definition, Document};

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

@@ -25,6 +25,7 @@ mod add_union_type_definition;
 mod remove_all_fields;
 mod remove_required_field;
 mod add_anonymous_operation_definition;
+mod add_fragment_definiton;
 
 pub(crate) trait SchemaMutation {
     /// Apply the mutation to the document

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

@@ -1,7 +1,9 @@
+use std::ops::Deref;
 use std::sync::OnceLock;
 use apollo_compiler::ast::{FieldDefinition, Name};
-use apollo_compiler::schema::{Component, ExtendedType, InterfaceType, ObjectType};
+use apollo_compiler::schema::{Component, ExtendedType, InterfaceType, ObjectType, UnionType};
 use indexmap::IndexMap;
+use apollo_compiler::Schema;
 use crate::next::Unstructured;
 
 pub(crate) mod extended_type;
@@ -71,8 +73,12 @@ macro_rules! field_access {
 field_access!(ObjectType);
 field_access!(InterfaceType);
 
-pub(crate) trait TypeHasFields {
+pub(crate) trait Selectable {
+
+    fn name(&self) -> &Name;
     fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>>;
+
+    fn random_specialization<'a>(&self, u: &mut Unstructured, schema: &'a Schema) -> arbitrary::Result<Option<&'a ExtendedType>>;
     fn random_field(&self, u: &mut Unstructured) -> arbitrary::Result<&Component<FieldDefinition>> {
         // Types always have at least one field
         let fields = self.fields().values().collect::<Vec<_>>();
@@ -81,25 +87,106 @@ pub(crate) trait TypeHasFields {
 
 }
 
-impl TypeHasFields for ObjectType {
+impl Selectable for ObjectType {
+    fn name(&self) -> &Name {
+        &self.name
+    }
+
+
+
     fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
         &self.fields
     }
+
+    fn random_specialization<'a>(&self, _u: &mut Unstructured, _schema: &'a Schema) -> arbitrary::Result<Option<&'a ExtendedType>> {
+        Ok(None)
+    }
 }
 
-impl TypeHasFields for InterfaceType {
+impl Selectable for &UnionType {
+    fn name(&self) -> &Name {
+        &self.name
+    }
+
+    fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
+        static EMPTY: OnceLock<IndexMap<Name, Component<FieldDefinition>>> = OnceLock::new();
+        &EMPTY.get_or_init(||Default::default())
+    }
+
+    fn random_specialization<'a>(&self, u: &mut Unstructured, schema: &'a Schema) -> arbitrary::Result<Option<&'a ExtendedType>> {
+        let members = self.members.iter().map(|name| schema.types.get(&name.name)).collect::<Vec<_>>();
+        if members.is_empty() {
+            Ok(None)
+        }
+        else {
+            Ok(members[u.choose_index(members.len())?])
+        }
+    }
+}
+
+impl Selectable for InterfaceType {
+    fn name(&self) -> &Name {
+        &self.name
+    }
+
     fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
         &self.fields
     }
+
+    fn random_specialization<'a>(&self, u: &mut Unstructured, schema: &'a Schema) -> arbitrary::Result<Option<&'a ExtendedType>> {
+        // An interface specialization is either an object or another interface that implements this interface
+        let implements = schema
+            .types
+            .values()
+            .filter(|ty| {
+                match ty {
+                    ExtendedType::Object(o) => o.implements_interfaces.contains(&self.name),
+                    ExtendedType::Interface(i) => i.implements_interfaces.contains(&self.name),
+                    _=> return false,
+                }
+            })
+            .collect::<Vec<_>>();
+        if implements.is_empty() {
+            Ok(None)
+        }
+        else {
+            Ok(Some(implements[u.choose_index(implements.len())?]))
+        }
+
+
+    }
 }
 
-impl TypeHasFields for ExtendedType {
+
+impl Selectable for ExtendedType {
+    fn name(&self) -> &Name {
+        match self {
+            ExtendedType::Scalar(scalar) => {&scalar.name}
+            ExtendedType::Object(object_type) => {&object_type.name}
+            ExtendedType::Interface(interface_type) => {&interface_type.name}
+            ExtendedType::Union(union_type) => {&union_type.name}
+            ExtendedType::Enum(enum_type) => {&enum_type.name}
+            ExtendedType::InputObject(input_object) => {&input_object.name}
+        }
+    }
+
+
+
     fn fields(&self) -> &IndexMap<Name, Component<FieldDefinition>> {
         static EMPTY: OnceLock<IndexMap<Name, Component<FieldDefinition>>> = OnceLock::new();
         match self {
-            ExtendedType::Object(t) => t.fields(),
-            ExtendedType::Interface(t) => t.fields(),
+            ExtendedType::Object(t) => &t.fields,
+            ExtendedType::Interface(t) => &t.fields,
             _ => &EMPTY.get_or_init(||Default::default()),
         }
     }
+
+    fn random_specialization<'a>(&self, u: &mut Unstructured, schema: &'a Schema) -> arbitrary::Result<Option<&'a ExtendedType>> {
+        match self {
+            ExtendedType::Object(object_type) => {object_type.deref().random_specialization(u, schema)}
+            ExtendedType::Interface(interface_type) => { interface_type.deref().random_specialization(u, schema)}
+            ExtendedType::Union(union_type) => { union_type.deref().random_specialization(u, schema)}
+            _ => Ok(None)
+        }
+    }
 }