Implement KnownArgumentNames validation rule

Author: dittos

graphql/core/validation/rules.py

@@ -1,7 +1,7 @@
 from ..utils import type_from_ast
 from ..error import GraphQLError
 from ..type.definition import is_composite_type, is_input_type, is_leaf_type
-from ..language.ast import OperationDefinition
+from ..language import ast
 from ..language.visitor import Visitor
 from ..language.printer import print_ast
 
@@ -39,7 +39,7 @@ def __init__(self, context):
     def enter_Document(self, node, *args):
         n = 0
         for definition in node.definitions:
-            if isinstance(definition, OperationDefinition):
+            if isinstance(definition, ast.OperationDefinition):
                 n += 1
         self._op_count = n
 
@@ -180,7 +180,44 @@ class KnownDirectives(ValidationRule):
 
 
 class KnownArgumentNames(ValidationRule):
-    pass
+    def enter_Argument(self, node, key, parent, path, ancestors):
+        argument_of = ancestors[-1]
+        if isinstance(argument_of, ast.Field):
+            field_def = self.context.get_field_def()
+            if field_def:
+                field_arg_def = None
+                for arg in field_def.args:
+                    if arg.name == node.name.value:
+                        field_arg_def = arg
+                        break
+                if not field_arg_def:
+                    parent_type = self.context.get_parent_type()
+                    assert parent_type
+                    return GraphQLError(
+                        self.message(node.name.value, field_def.name, parent_type.name),
+                        [node]
+                    )
+        elif isinstance(argument_of, ast.Directive):
+            directive = self.context.get_directive()
+            if directive:
+                directive_arg_def = None
+                for arg in directive.args:
+                    if arg.name == node.name.value:
+                        directive_arg_def = arg
+                        break
+                if not directive_arg_def:
+                    return GraphQLError(
+                        self.directive_message(node.name.value, directive.name),
+                        [node]
+                    )
+
+    @staticmethod
+    def message(arg_name, field_name, type):
+        return 'Unknown argument "{}" on field "{}" of type "{}".'.format(arg_name, field_name, type)
+
+    @staticmethod
+    def directive_message(arg_name, directive_name):
+        return 'Unknown argument "{}" on directive "@{}".'.format(arg_name, directive_name)
 
 
 class UniqueArgumentNames(ValidationRule):

tests/core_validation/test_known_argument_names.py

@@ -1,5 +1,3 @@
-import pytest
-
 from graphql.core.language.location import SourceLocation
 from graphql.core.validation.rules import KnownArgumentNames
 from utils import expect_passes_rule, expect_fails_rule
@@ -14,7 +12,7 @@ def unknown_arg(arg_name, field_name, type_name, line, column):
 
 def unknown_directive_arg(arg_name, directive_name, line, column):
     return {
-        'message': KnownArgumentNames.unknown_directive_message(
+        'message': KnownArgumentNames.directive_message(
             arg_name, directive_name),
         'locations': [SourceLocation(line, column)]
     }
@@ -85,10 +83,6 @@ def test_directive_args_are_known():
     ''')
 
 
-@pytest.mark.skipif(not hasattr(KnownArgumentNames,
-                                "unknown_directive_message"),
-                    reason=("KnownDirectives.unknown_directive_message not "
-                            "yet implemented"))
 def test_undirective_args_are_invalid():
     expect_fails_rule(KnownArgumentNames, '''
       {
@@ -97,8 +91,6 @@ def test_undirective_args_are_invalid():
     ''', [unknown_directive_arg('unless', 'skip', 3, 19)])
 
 
-@pytest.mark.skipif(not hasattr(KnownArgumentNames, "message"),
-                    reason="KnownArgumentNames.message not yet implemented")
 def test_invalid_arg_name():
     expect_fails_rule(KnownArgumentNames, '''
       fragment invalidArgName on Dog {
@@ -107,8 +99,6 @@ def test_invalid_arg_name():
     ''', [unknown_arg('unknown', 'doesKnowCommand', 'Dog', 3, 25)])
 
 
-@pytest.mark.skipif(not hasattr(KnownArgumentNames, "message"),
-                    reason="KnownArgumentNames.message not yet implemented")
 def test_unknown_args_amongst_known_args():
     expect_fails_rule(KnownArgumentNames, '''
       fragment oneGoodArgOneInvalidArg on Dog {
@@ -118,8 +108,6 @@ def test_unknown_args_amongst_known_args():
           unknown_arg('unknown', 'doesKnowCommand', 'Dog', 3, 55)])
 
 
-@pytest.mark.skipif(not hasattr(KnownArgumentNames, "message"),
-                    reason="KnownArgumentNames.message not yet implemented")
 def test_unknown_args_deeply():
     expect_fails_rule(KnownArgumentNames, '''
       {

tests/core_validation/utils.py

@@ -73,6 +73,7 @@
     'human': GraphQLField(Human, {
         'id': GraphQLArgument(GraphQLID),
     }),
+    'dog': GraphQLField(Dog),
     'pet': GraphQLField(Pet),
     'catOrDog': GraphQLField(CatOrDog),
     'complicatedArgs': GraphQLField(ComplicatedArgs),