Merge remote-tracking branch 'dittos/master'

Author: jhgg

graphql/core/validation/rules.py

@@ -148,7 +148,22 @@ def message(field_name, type):
 
 
 class UniqueFragmentNames(ValidationRule):
-    pass
+    def __init__(self, context):
+        super(UniqueFragmentNames, self).__init__(context)
+        self.known_fragment_names = {}
+
+    def enter_FragmentDefinition(self, node, *args):
+        fragment_name = node.name.value
+        if fragment_name in self.known_fragment_names:
+            return GraphQLError(
+                self.duplicate_fragment_name_message(fragment_name),
+                [self.known_fragment_names[fragment_name], node.name]
+            )
+        self.known_fragment_names[fragment_name] = node.name
+
+    @staticmethod
+    def duplicate_fragment_name_message(field):
+        return 'There can only be one fragment named {}'.format(field)
 
 
 class KnownFragmentNames(ValidationRule):
@@ -256,7 +271,28 @@ def directive_message(arg_name, directive_name):
 
 
 class UniqueArgumentNames(ValidationRule):
-    pass
+    def __init__(self, context):
+        super(UniqueArgumentNames, self).__init__(context)
+        self.known_arg_names = {}
+
+    def enter_Field(self, node, *args):
+        self.known_arg_names = {}
+
+    def enter_Directive(self, node, key, parent, path, ancestors):
+        self.known_arg_names = {}
+
+    def enter_Argument(self, node, *args):
+        arg_name = node.name.value
+        if arg_name in self.known_arg_names:
+            return GraphQLError(
+                self.duplicate_arg_message(arg_name),
+                [self.known_arg_names[arg_name], node.name]
+            )
+        self.known_arg_names[arg_name] = node.name
+
+    @staticmethod
+    def duplicate_arg_message(field):
+        return 'There can only be one argument named {}'.format(field)
 
 
 class ArgumentsOfCorrectType(ValidationRule):

tests/core_validation/test_unique_argument_names.py

@@ -0,0 +1,113 @@
+from graphql.core.language.location import SourceLocation
+from graphql.core.validation.rules import UniqueArgumentNames
+from utils import expect_passes_rule, expect_fails_rule
+
+
+def duplicate_arg(arg_name, l1, c1, l2, c2):
+    return {
+        'message': UniqueArgumentNames.duplicate_arg_message(arg_name),
+        'locations': [SourceLocation(l1, c1), SourceLocation(l2, c2)]
+    }
+
+
+def test_no_arguments_on_field():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        field
+      }
+    ''')
+
+
+def test_no_arguments_on_directive():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        field
+      }
+    ''')
+
+
+def test_argument_on_field():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        field(arg: "value")
+      }
+    ''')
+
+
+def test_argument_on_directive():
+    expect_passes_rule(UniqueArgumentNames, '''
+       {
+        field @directive(arg: "value")
+      }
+    ''')
+
+def test_same_field_two_arguments():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        one: field(arg: "value")
+        two: field(arg: "value")
+      }
+    ''')
+
+def test_same_argument_on_field_and_directive():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        field(arg: "value") @directive(arg: "value")
+      }
+    ''')
+def test_same_argument_two_directives():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        field @directive1(arg: "value") @directive2(arg: "value")
+      }
+    ''')
+
+def test_multiple_field_arguments():
+    expect_passes_rule(UniqueArgumentNames, '''
+      {
+        field(arg1: "value", arg2: "value", arg3: "value")
+      }
+    ''')
+
+def test_multiple_directive_arguments():
+  expect_passes_rule(UniqueArgumentNames, '''
+    {
+      field @directive(arg1: "value", arg2: "value", arg3: "value")
+    }
+  ''')
+
+def test_duplicate_field_arguments():
+  expect_fails_rule(UniqueArgumentNames, '''
+    {
+      field(arg1: "value", arg1: "value")
+    }
+  ''', [duplicate_arg('arg1', 3, 13, 3, 28)]
+  )
+
+def test_many_duplicate_field_arguments():
+  expect_fails_rule(UniqueArgumentNames, '''
+    {
+      field(arg1: "value", arg1: "value", arg1: "value")
+    }
+  ''', [
+    duplicate_arg('arg1', 3, 13, 3, 28),
+    duplicate_arg('arg1', 3, 13, 3, 43)
+  ])
+
+def test_duplicate_directive_arguments():
+  expect_fails_rule(UniqueArgumentNames, '''
+    {
+      field @directive(arg1: "value", arg1: "value")
+    }
+  ''', [duplicate_arg('arg1', 3, 24, 3, 39)]
+  )
+
+def test_many_duplicate_directive_arguments():
+  expect_fails_rule(UniqueArgumentNames, '''
+    {
+      field @directive(arg1: "value", arg1: "value", arg1: "value")
+    }
+  ''',[
+      duplicate_arg('arg1', 3, 24, 3, 39),
+      duplicate_arg('arg1', 3, 24, 3, 54)
+  ])

tests/core_validation/test_unique_fragment_names.py

@@ -0,0 +1,95 @@
+from graphql.core.language.location import SourceLocation
+from graphql.core.validation.rules import UniqueFragmentNames
+from utils import expect_passes_rule, expect_fails_rule
+
+
+def duplicate_fragment(fragment_name, l1, c1, l2, c2):
+    return {
+        'message': UniqueFragmentNames.duplicate_fragment_name_message(fragment_name),
+        'locations': [SourceLocation(l1, c1), SourceLocation(l2, c2)]
+    }
+
+
+def test_no_fragments():
+    expect_passes_rule(UniqueFragmentNames, '''
+      {
+        field
+      }
+    ''')
+
+def test_one_fragment():
+    expect_passes_rule(UniqueFragmentNames, '''
+      {
+        ...fragA
+      }
+      fragment fragA on Type {
+        field
+      }
+    ''')
+
+def test_many_fragments():
+    expect_passes_rule(UniqueFragmentNames, '''
+      {
+        ...fragA
+        ...fragB
+        ...fragC
+      }
+      fragment fragA on Type {
+        fieldA
+      }
+      fragment fragB on Type {
+        fieldB
+      }
+      fragment fragC on Type {
+        fieldC
+      }
+    ''')
+
+def test_inline_fragments():
+    expect_passes_rule(UniqueFragmentNames, '''
+      {
+        ...on Type {
+          fieldA
+        }
+        ...on Type {
+          fieldB
+        }
+      }
+    ''')
+
+def test_fragment_operation_same_name():
+    expect_passes_rule(UniqueFragmentNames, '''
+      query Foo {
+        ...Foo
+      }
+      fragment Foo on Type {
+        field
+      }
+    ''')
+
+def test_fragments_same_name():
+    expect_fails_rule(UniqueFragmentNames, '''
+        {
+          ...fragA
+        }
+        fragment fragA on Type {
+          fieldA
+        }
+        fragment fragA on Type {
+          fieldB
+        }
+    ''', [duplicate_fragment('fragA', 5, 18, 8, 18)]
+    )
+
+def test_fragments_same_name_no_ref():
+    expect_fails_rule(UniqueFragmentNames, '''
+        fragment fragA on Type {
+          fieldA
+        }
+        fragment fragA on Type {
+          fieldB
+        }
+      ''', [
+        duplicate_fragment('fragA', 2, 18, 5, 18)
+      ]
+    )