Add typing to validation tests and refactoring

Replicates graphql/graphql-js@51eda7b

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
 
 The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.0.2. All parts of the API are covered by an extensive test suite of currently 1661
+14.0.2. All parts of the API are covered by an extensive test suite of currently 1662
 unit tests.
 
 

tests/validation/harness.py

@@ -1,4 +1,7 @@
-from graphql.language.parser import parse
+from typing import List, Optional, Type
+
+from graphql.error import GraphQLError
+from graphql.language import parse, print_ast
 from graphql.type import (
     GraphQLArgument,
     GraphQLBoolean,
@@ -25,6 +28,7 @@
     GraphQLIncludeDirective,
     GraphQLSkipDirective,
 )
+from graphql.validation import ValidationRule, SDLValidationRule
 from graphql.validation.validate import validate, validate_sdl
 
 Being = GraphQLInterfaceType(
@@ -227,11 +231,11 @@ def raise_type_error(message):
 InvalidScalar = GraphQLScalarType(
     name="Invalid",
     serialize=lambda value: value,
-    parse_literal=lambda node: raise_type_error(
-        f"Invalid scalar is always invalid: {node.value}"
+    parse_literal=lambda value_node: raise_type_error(
+        f"Invalid scalar is always invalid: {print_ast(value_node)}"
     ),
-    parse_value=lambda node: raise_type_error(
-        f"Invalid scalar is always invalid: {node}"
+    parse_value=lambda value: raise_type_error(
+        f"Invalid scalar is always invalid: {value!r}"
     ),
 )
 
@@ -289,34 +293,25 @@ def raise_type_error(message):
 )
 
 
-def expect_valid(schema, rule, query_string):
-    errors = validate(schema, parse(query_string), [rule])
-    assert errors == [], "Should validate"
-
-
-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):
-    expect_valid(test_schema, rule, query_string)
-
-
-def expect_fails_rule(rule, query_string, errors):
-    return expect_invalid(test_schema, rule, query_string, errors)
-
-
-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)
-
-
-def expect_sdl_errors_from_rule(rule, sdl_string, schema=None):
-    errors = validate_sdl(parse(sdl_string), schema, [rule])
-    return errors
+def assert_validation_errors(
+    rule: Type[ValidationRule],
+    query_str: str,
+    errors: List[GraphQLError],
+    schema: GraphQLSchema = test_schema,
+) -> List[GraphQLError]:
+    doc = parse(query_str)
+    returned_errors = validate(schema, doc, [rule])
+    assert returned_errors == errors
+    return returned_errors
+
+
+def assert_sdl_validation_errors(
+    rule: Type[SDLValidationRule],
+    sdl_str: str,
+    errors: List[GraphQLError],
+    schema: Optional[GraphQLSchema] = None,
+) -> List[GraphQLError]:
+    doc = parse(sdl_str)
+    returned_errors = validate_sdl(doc, schema, [rule])
+    assert returned_errors == errors
+    return returned_errors

tests/validation/test_executable_definitions.py

@@ -1,9 +1,15 @@
+from functools import partial
+
 from graphql.validation import ExecutableDefinitionsRule
 from graphql.validation.rules.executable_definitions import (
     non_executable_definitions_message,
 )
 
-from .harness import expect_fails_rule, expect_passes_rule
+from .harness import assert_validation_errors
+
+assert_errors = partial(assert_validation_errors, ExecutableDefinitionsRule)
+
+assert_valid = partial(assert_errors, errors=[])
 
 
 def non_executable_definition(def_name, line, column):
@@ -15,20 +21,18 @@ def non_executable_definition(def_name, line, column):
 
 def describe_validate_executable_definitions():
     def with_only_operation():
-        expect_passes_rule(
-            ExecutableDefinitionsRule,
+        assert_valid(
             """
             query Foo {
               dog {
                 name
               }
             }
-            """,
+            """
         )
 
     def with_operation_and_fragment():
-        expect_passes_rule(
-            ExecutableDefinitionsRule,
+        assert_valid(
             """
             query Foo {
               dog {
@@ -40,12 +44,11 @@ def with_operation_and_fragment():
             fragment Frag on Dog {
               name
             }
-            """,
+            """
         )
 
     def with_type_definition():
-        expect_fails_rule(
-            ExecutableDefinitionsRule,
+        assert_errors(
             """
             query Foo {
               dog {
@@ -68,8 +71,7 @@ def with_type_definition():
         )
 
     def with_schema_definition():
-        expect_fails_rule(
-            ExecutableDefinitionsRule,
+        assert_errors(
             """
             schema {
               query: Query

tests/validation/test_fields_on_correct_type.py

@@ -1,7 +1,13 @@
+from functools import partial
+
 from graphql.validation import FieldsOnCorrectTypeRule
 from graphql.validation.rules.fields_on_correct_type import undefined_field_message
 
-from .harness import expect_fails_rule, expect_passes_rule
+from .harness import assert_validation_errors
+
+assert_errors = partial(assert_validation_errors, FieldsOnCorrectTypeRule)
+
+assert_valid = partial(assert_errors, errors=[])
 
 
 def undefined_field(field, type_, suggested_types, suggested_fields, line, column):
@@ -15,71 +21,64 @@ def undefined_field(field, type_, suggested_types, suggested_fields, line, colum
 
 def describe_validate_fields_on_correct_type():
     def object_field_selection():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment objectFieldSelection on Dog {
               __typename
               name
             }
-            """,
+            """
         )
 
     def aliased_object_field_selection():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment aliasedObjectFieldSelection on Dog {
               tn : __typename
               otherName : name
             }
-            """,
+            """
         )
 
     def interface_field_selection():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment interfaceFieldSelection on Pet {
               __typename
               name
             }
-            """,
+            """
         )
 
     def aliased_interface_field_selection():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment interfaceFieldSelection on Pet {
               otherName : name
             }
-            """,
+            """
         )
 
     def lying_alias_selection():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment lyingAliasSelection on Dog {
               name : nickname
             }
-            """,
+            """
         )
 
     def ignores_fields_on_unknown_type():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment unknownSelection on UnknownType {
               unknownField
             }
-            """,
+            """
         )
 
     def reports_errors_when_type_is_known_again():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment typeKnownAgain on Pet {
               unknown_pet_field {
@@ -96,8 +95,7 @@ def reports_errors_when_type_is_known_again():
         )
 
     def field_not_defined_on_fragment():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment fieldNotDefined on Dog {
               meowVolume
@@ -107,8 +105,7 @@ def field_not_defined_on_fragment():
         )
 
     def ignores_deeply_unknown_field():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment deepFieldNotDefined on Dog {
               unknown_field {
@@ -120,10 +117,9 @@ def ignores_deeply_unknown_field():
         )
 
     def sub_field_not_defined():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
-              fragment subFieldNotDefined on Human {
+            fragment subFieldNotDefined on Human {
               pets {
                 unknown_field
               }
@@ -133,8 +129,7 @@ def sub_field_not_defined():
         )
 
     def field_not_defined_on_inline_fragment():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment fieldNotDefined on Pet {
               ... on Dog {
@@ -146,8 +141,7 @@ def field_not_defined_on_inline_fragment():
         )
 
     def aliased_field_target_not_defined():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment aliasedFieldTargetNotDefined on Dog {
               volume : mooVolume
@@ -157,8 +151,7 @@ def aliased_field_target_not_defined():
         )
 
     def aliased_lying_field_target_not_defined():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment aliasedLyingFieldTargetNotDefined on Dog {
               barkVolume : kawVolume
@@ -168,8 +161,7 @@ def aliased_lying_field_target_not_defined():
         )
 
     def not_defined_on_interface():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment notDefinedOnInterface on Pet {
               tailLength
@@ -179,8 +171,7 @@ def not_defined_on_interface():
         )
 
     def defined_on_implementors_but_not_on_interface():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment definedOnImplementorsButNotInterface on Pet {
               nickname
@@ -190,18 +181,16 @@ def defined_on_implementors_but_not_on_interface():
         )
 
     def meta_field_selection_on_union():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment directFieldSelectionOnUnion on CatOrDog {
               __typename
             }
-            """,
+            """
         )
 
     def direct_field_selection_on_union():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
             fragment directFieldSelectionOnUnion on CatOrDog {
               directField
@@ -211,8 +200,7 @@ def direct_field_selection_on_union():
         )
 
     def defined_on_implementors_queried_on_union():
-        expect_fails_rule(
-            FieldsOnCorrectTypeRule,
+        assert_errors(
             """
               fragment definedOnImplementorsQueriedOnUnion on CatOrDog {
               name
@@ -231,8 +219,7 @@ def defined_on_implementors_queried_on_union():
         )
 
     def valid_field_in_inline_fragment():
-        expect_passes_rule(
-            FieldsOnCorrectTypeRule,
+        assert_valid(
             """
             fragment objectFieldSelection on Pet {
               ... on Dog {
@@ -242,7 +229,7 @@ def valid_field_in_inline_fragment():
                 name
               }
             }
-            """,
+            """
         )