Improve typings for validation functions

Replicates graphql/graphql-js@b101bf6

Author: Cito

graphql/validation/rules/__init__.py

@@ -1,10 +1,12 @@
 """graphql.validation.rules package"""
 
+from typing import Type
+
 from ...error import GraphQLError
 from ...language.visitor import Visitor
 from ..validation_context import ValidationContext
 
-__all__ = ['ValidationRule']
+__all__ = ['ValidationRule', 'RuleType']
 
 
 class ValidationRule(Visitor):
@@ -14,3 +16,6 @@ def __init__(self, context: ValidationContext) -> None:
 
     def report_error(self, error: GraphQLError):
         self.context.report_error(error)
+
+
+RuleType = Type[ValidationRule]

graphql/validation/specified_rules.py

@@ -1,6 +1,6 @@
-from typing import List, Type
+from typing import List
 
-from .rules import ValidationRule
+from .rules import RuleType
 
 # Spec Section: "Executable Definitions"
 from .rules.executable_definitions import ExecutableDefinitionsRule
@@ -90,7 +90,7 @@
 # The order of the rules in this list has been adjusted to lead to the
 # most clear output when encountering multiple validation errors.
 
-specified_rules: List[Type[ValidationRule]] = [
+specified_rules: List[RuleType] = [
     ExecutableDefinitionsRule,
     UniqueOperationNamesRule,
     LoneAnonymousOperationRule,

graphql/validation/validate.py

@@ -1,17 +1,15 @@
-from typing import List, Sequence, Type
+from typing import List, Sequence
 
 from ..error import GraphQLError
 from ..language import DocumentNode, ParallelVisitor, TypeInfoVisitor, visit
 from ..type import GraphQLSchema, assert_valid_schema
 from ..utilities import TypeInfo
-from .rules import ValidationRule
+from .rules import RuleType
 from .specified_rules import specified_rules
 from .validation_context import ValidationContext
 
 __all__ = ['validate']
 
-RuleType = Type[ValidationRule]
-
 
 def validate(schema: GraphQLSchema, document_ast: DocumentNode,
              rules: Sequence[RuleType]=None,

tests/validation/harness.py

@@ -232,29 +232,29 @@ def raise_type_error(message):
     types=[Cat, Dog, Human, Alien])
 
 
-def expect_valid(schema, rules, query_string):
-    errors = validate(schema, parse(query_string), rules)
+def expect_valid(schema, rule, query_string):
+    errors = validate(schema, parse(query_string), [rule])
     assert errors == [], 'Should validate'
 
 
-def expect_invalid(schema, rules, query_string, expected_errors):
-    errors = validate(schema, parse(query_string), rules)
+def expect_invalid(schema, rule, query_string, expected_errors):
+    errors = validate(schema, parse(query_string), [rule])
     assert errors, 'Should not validate'
     assert errors == expected_errors
     return errors
 
 
 def expect_passes_rule(rule, query_string):
-    return expect_valid(test_schema, [rule], query_string)
+    return expect_valid(test_schema, rule, query_string)
 
 
 def expect_fails_rule(rule, query_string, errors):
-    return expect_invalid(test_schema, [rule], query_string, errors)
+    return expect_invalid(test_schema, rule, query_string, errors)
 
 
-def expect_fails_rule_with_schema(schema, rule, query_string, errors):
-    return expect_invalid(schema, [rule], query_string, errors)
+def expect_passes_rule_with_schema(schema, rule, query_string):
+    return expect_valid(schema, rule, query_string)
 
 
-def expect_passes_rule_with_schema(schema, rule, query_string):
-    return expect_valid(schema, [rule], query_string)
+def expect_fails_rule_with_schema(schema, rule, query_string, errors):
+    return expect_invalid(schema, rule, query_string, errors)