Experimental: customizable validation

Closes #37

Author: jhgg

graphql/core/utils/type_info.py

@@ -22,16 +22,17 @@ def pop(lst):
 @six.add_metaclass(visitor_meta.VisitorMeta)
 class TypeInfo(object):
     __slots__ = '_schema', '_type_stack', '_parent_type_stack', '_input_type_stack', '_field_def_stack', '_directive', \
-                '_argument'
+                '_argument', '_get_field_def_fn'
 
-    def __init__(self, schema):
+    def __init__(self, schema, get_field_def_fn=get_field_def):
         self._schema = schema
         self._type_stack = []
         self._parent_type_stack = []
         self._input_type_stack = []
         self._field_def_stack = []
         self._directive = None
         self._argument = None
+        self._get_field_def_fn = get_field_def_fn
 
     def get_type(self):
         if self._type_stack:
@@ -76,7 +77,7 @@ def enter_Field(self, node):
         parent_type = self.get_parent_type()
         field_def = None
         if parent_type:
-            field_def = get_field_def(self._schema, parent_type, node)
+            field_def = self._get_field_def_fn(self._schema, parent_type, node)
         self._field_def_stack.append(field_def)
         self._type_stack.append(field_def and field_def.type)
 

graphql/core/validation/__init__.py

@@ -10,11 +10,11 @@ def validate(schema, ast, rules=specified_rules):
     assert schema, 'Must provide schema'
     assert ast, 'Must provide document'
     assert isinstance(schema, GraphQLSchema)
-    return visit_using_rules(schema, ast, rules)
+    type_info = TypeInfo(schema)
+    return visit_using_rules(schema, type_info, ast, rules)
 
 
-def visit_using_rules(schema, ast, rules):
-    type_info = TypeInfo(schema)
+def visit_using_rules(schema, type_info, ast, rules):
     context = ValidationContext(schema, ast, type_info)
     errors = []
     rules = [rule(context) for rule in rules]

tests/core_validation/test_validation.py

@@ -0,0 +1,53 @@
+from graphql.core import parse
+from graphql.core import validate
+from graphql.core.utils.type_info import TypeInfo
+from graphql.core.validation import visit_using_rules
+from graphql.core.validation.rules import specified_rules
+from utils import test_schema
+
+
+def expect_valid(schema, query_string):
+    errors = validate(schema, parse(query_string))
+    assert not errors
+
+
+def test_it_validates_queries():
+    expect_valid(test_schema, '''
+      query {
+        catOrDog {
+          ... on Cat {
+            furColor
+          }
+          ... on Dog {
+            isHousetrained
+          }
+        }
+      }
+    ''')
+
+
+def test_validates_using_a_custom_type_info():
+    type_info = TypeInfo(test_schema, lambda *_: None)
+
+    ast = parse('''
+      query {
+        catOrDog {
+          ... on Cat {
+            furColor
+          }
+          ... on Dog {
+            isHousetrained
+          }
+        }
+      }
+    ''')
+
+    errors = visit_using_rules(
+        test_schema,
+        type_info,
+        ast,
+        specified_rules
+    )
+
+    assert len(errors) == 1
+    assert errors[0].message == 'Cannot query field "catOrDog" on "QueryRoot".'

tests/core_validation/utils.py

@@ -44,10 +44,24 @@
         'surname': GraphQLArgument(GraphQLBoolean),
     }),
     'nickname': GraphQLField(GraphQLString),
+    'barkVolume': GraphQLField(GraphQLInt),
     'barks': GraphQLField(GraphQLBoolean),
     'doesKnowCommand': GraphQLField(GraphQLBoolean, {
         'dogCommand': GraphQLArgument(DogCommand)
-    })
+    }),
+    'isHousetrained': GraphQLField(
+        GraphQLBoolean,
+        args={
+            'atOtherHomes': GraphQLArgument(GraphQLBoolean, default_value=True)
+        }
+    ),
+    'isAtLocation': GraphQLField(
+        GraphQLBoolean,
+        args={
+            'x': GraphQLArgument(GraphQLInt),
+            'y': GraphQLArgument(GraphQLInt)
+        }
+    )
 }, interfaces=[Being, Pet], is_type_of=lambda: None)
 
 Cat = GraphQLObjectType('Cat', lambda: {
@@ -163,7 +177,7 @@
     'complicatedArgs': GraphQLField(ComplicatedArgs),
 })
 
-default_schema = GraphQLSchema(query=QueryRoot, directives=[
+test_schema = GraphQLSchema(query=QueryRoot, directives=[
     GraphQLDirective(name='operationOnly', on_operation=True),
     GraphQLIncludeDirective,
     GraphQLSkipDirective
@@ -202,11 +216,11 @@ def expect_invalid(schema, rules, query, expected_errors, sort_list=True):
 
 
 def expect_passes_rule(rule, query):
-    return expect_valid(default_schema, [rule], query)
+    return expect_valid(test_schema, [rule], query)
 
 
 def expect_fails_rule(rule, query, errors, sort_list=True):
-    return expect_invalid(default_schema, [rule], query, errors, sort_list)
+    return expect_invalid(test_schema, [rule], query, errors, sort_list)
 
 
 def expect_fails_rule_with_schema(schema, rule, query, errors, sort_list=True):