added UniqueFragmentNames

Author: dotansimha

src/ast/ext.rs

@@ -231,3 +231,9 @@ impl AstNodeWithName for query::OperationDefinition {
         }
     }
 }
+
+impl AstNodeWithName for query::FragmentDefinition {
+    fn node_name(&self) -> Option<String> {
+        Some(self.name.clone())
+    }
+}

src/validation/rules/defaults.rs

@@ -3,7 +3,7 @@ use crate::validation::validate::ValidationPlan;
 use super::{
     FieldsOnCorrectType, FragmentsOnCompositeTypes, KnownFragmentNamesRule, KnownTypeNames,
     LeafFieldSelections, LoneAnonymousOperation, NoUnusedFragments, OverlappingFieldsCanBeMerged,
-    SingleFieldSubscriptions, UniqueOperationNames, VariablesAreInputTypes,
+    SingleFieldSubscriptions, UniqueFragmentNames, UniqueOperationNames, VariablesAreInputTypes,
 };
 
 pub fn default_rules_validation_plan() -> ValidationPlan {
@@ -18,6 +18,7 @@ pub fn default_rules_validation_plan() -> ValidationPlan {
     plan.add_rule(Box::new(NoUnusedFragments {}));
     plan.add_rule(Box::new(LeafFieldSelections {}));
     plan.add_rule(Box::new(UniqueOperationNames {}));
+    plan.add_rule(Box::new(UniqueFragmentNames {}));
     plan.add_rule(Box::new(SingleFieldSubscriptions {}));
     plan.add_rule(Box::new(VariablesAreInputTypes {}));
 

src/validation/rules/mod.rs

@@ -10,6 +10,7 @@ pub mod overlapping_fields_can_be_merged;
 /// Utilities validating GraphQL documents/operations
 pub mod rule;
 pub mod single_field_subscriptions;
+pub mod unique_fragment_names;
 pub mod unique_operation_names;
 pub mod variables_are_input_types;
 
@@ -24,5 +25,6 @@ pub use self::no_unused_fragments::*;
 pub use self::overlapping_fields_can_be_merged::*;
 pub use self::rule::*;
 pub use self::single_field_subscriptions::*;
+pub use self::unique_fragment_names::*;
 pub use self::unique_operation_names::*;
 pub use self::variables_are_input_types::*;

src/validation/rules/unique_fragment_names.rs

@@ -0,0 +1,206 @@
+use std::collections::HashMap;
+
+use super::ValidationRule;
+use crate::ast::AstNodeWithName;
+use crate::static_graphql::query::*;
+use crate::validation::utils::ValidationError;
+use crate::{ast::QueryVisitor, validation::utils::ValidationContext};
+
+/// Unique fragment names
+///
+/// A GraphQL document is only valid if all defined fragments have unique names.
+///
+/// See https://spec.graphql.org/draft/#sec-Fragment-Name-Uniqueness
+pub struct UniqueFragmentNames;
+
+impl QueryVisitor<FoundFragments> for UniqueFragmentNames {
+    fn enter_fragment_definition(
+        &self,
+        node: &FragmentDefinition,
+        visitor_context: &mut FoundFragments,
+    ) {
+        if let Some(name) = node.node_name() {
+            visitor_context.store_finding(&name);
+        }
+    }
+}
+
+struct FoundFragments {
+    findings_counter: HashMap<String, i32>,
+}
+
+impl FoundFragments {
+    fn new() -> Self {
+        Self {
+            findings_counter: HashMap::new(),
+        }
+    }
+
+    fn store_finding(&mut self, name: &String) {
+        let value = *self.findings_counter.entry(name.clone()).or_insert(0);
+        self.findings_counter.insert(name.clone(), value + 1);
+    }
+}
+
+impl ValidationRule for UniqueFragmentNames {
+    fn validate<'a>(&self, ctx: &ValidationContext) -> Vec<ValidationError> {
+        let mut found_fragments = FoundFragments::new();
+        self.visit_document(&ctx.operation.clone(), &mut found_fragments);
+
+        found_fragments
+            .findings_counter
+            .into_iter()
+            .filter(|(_key, value)| *value > 1)
+            .map(|(key, _value)| ValidationError {
+                message: format!("There can be only one fragment named \"{}\".", key),
+                locations: vec![],
+            })
+            .collect()
+    }
+}
+
+#[test]
+fn no_fragments() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "{
+          field
+        }",
+        &mut plan,
+    );
+
+    assert_eq!(get_messages(&errors).len(), 0);
+}
+
+#[test]
+fn one_fragment() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "{
+          ...fragA
+        }
+        fragment fragA on Type {
+          field
+        }",
+        &mut plan,
+    );
+
+    assert_eq!(get_messages(&errors).len(), 0);
+}
+
+#[test]
+fn many_fragment() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "{
+          ...fragA
+          ...fragB
+          ...fragC
+        }
+        fragment fragA on Type {
+          fieldA
+        }
+        fragment fragB on Type {
+          fieldB
+        }
+        fragment fragC on Type {
+          fieldC
+        }",
+        &mut plan,
+    );
+
+    assert_eq!(get_messages(&errors).len(), 0);
+}
+
+#[test]
+fn inline_fragments_are_always_unique() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "{
+          ...on Type {
+            fieldA
+          }
+          ...on Type {
+            fieldB
+          }
+        }",
+        &mut plan,
+    );
+
+    assert_eq!(get_messages(&errors).len(), 0);
+}
+
+#[test]
+fn fragment_and_operation_named_the_same() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "query Foo {
+          ...Foo
+        }
+        fragment Foo on Type {
+          field
+        }",
+        &mut plan,
+    );
+
+    assert_eq!(get_messages(&errors).len(), 0);
+}
+
+#[test]
+fn fragments_named_the_same() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "{
+          ...fragA
+        }
+        fragment fragA on Type {
+          fieldA
+        }
+        fragment fragA on Type {
+          fieldB
+        }",
+        &mut plan,
+    );
+
+    let messages = get_messages(&errors);
+    assert_eq!(messages.len(), 1);
+    assert_eq!(
+        messages,
+        vec!["There can be only one fragment named \"fragA\"."]
+    );
+}
+
+#[test]
+fn fragments_named_the_same_without_being_referenced() {
+    use crate::validation::test_utils::*;
+
+    let mut plan = create_plan_from_rule(Box::new(UniqueFragmentNames {}));
+    let errors = test_operation_without_schema(
+        "fragment fragA on Type {
+          fieldA
+        }
+        fragment fragA on Type {
+          fieldB
+        }",
+        &mut plan,
+    );
+
+    let messages = get_messages(&errors);
+    assert_eq!(messages.len(), 1);
+    assert_eq!(
+        messages,
+        vec!["There can be only one fragment named \"fragA\"."]
+    );
+}