Fixup: add Experimental note to variable-directive tests

Replicates graphql/graphql-js@1ac0bf8

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 
 The current version 1.0.0rc2 of GraphQL-core-next is up-to-date with GraphQL.js
 version 14.0.0rc2. All parts of the API are covered by an extensive test
-suite of currently 1551 unit tests.
+suite of currently 1552 unit tests.
 
 
 ## Documentation

tests/language/test_parser.py

@@ -82,7 +82,7 @@ def parses_constant_default_values():
           'query Foo($x: Complex = { a: { b: [ $var ] } }) { field }',
           'Unexpected $', (1, 37))
 
-    def parses_variable_definition_directives():
+    def experimental_parses_variable_definition_directives():
         parse('query Foo($x: Boolean = false @bar) { field }',
               experimental_variable_definition_directives=True)
 

tests/language/test_printer.py

@@ -40,16 +40,25 @@ def correctly_prints_mutation_operation_without_name():
 
     def correctly_prints_query_operation_with_artifacts():
         query_ast_with_artifacts = parse(
-            'query ($foo: TestType) @testDirective { id, name }',
-            experimental_variable_definition_directives=True)
+            'query ($foo: TestType) @testDirective { id, name }')
         assert print_ast(query_ast_with_artifacts) == dedent("""
             query ($foo: TestType) @testDirective {
               id
               name
             }
             """)
 
-    def correcty_prints_query_operation_with_variable_directive():
+    def correctly_prints_mutation_operation_with_artifacts():
+        mutation_ast_with_artifacts = parse(
+            'mutation ($foo: TestType) @testDirective { id, name }')
+        assert print_ast(mutation_ast_with_artifacts) == dedent("""
+            mutation ($foo: TestType) @testDirective {
+              id
+              name
+            }
+            """)
+
+    def experimental_prints_query_with_variable_directives():
         query_ast_with_variable_directive = parse(
             'query ($foo: TestType = {a: 123}'
             ' @testDirective(if: true) @test) { id }',
@@ -60,13 +69,15 @@ def correcty_prints_query_operation_with_variable_directive():
             }
             """)
 
-    def correctly_prints_mutation_operation_with_artifacts():
-        mutation_ast_with_artifacts = parse(
-            'mutation ($foo: TestType) @testDirective { id, name }')
-        assert print_ast(mutation_ast_with_artifacts) == dedent("""
-            mutation ($foo: TestType) @testDirective {
+    def experimental_prints_fragment_with_variable_directives():
+        query_ast_with_variable_directive = parse(
+            'fragment Foo($foo: TestType @test) on TestType'
+            ' @testDirective { id }',
+            experimental_fragment_variables=True,
+            experimental_variable_definition_directives=True)
+        assert print_ast(query_ast_with_variable_directive) == dedent("""
+            fragment Foo($foo: TestType @test) on TestType @testDirective {
               id
-              name
             }
             """)
 

tests/validation/harness.py

@@ -203,24 +203,24 @@ def raise_type_error(message):
     types=[Cat, Dog, Human, Alien])
 
 
-def expect_valid(schema, rule, query_string):
-    errors = validate(schema, parse(query_string), [rule])
+def expect_valid(schema, rule, query_string, **options):
+    errors = validate(schema, parse(query_string, **options), [rule])
     assert errors == [], 'Should validate'
 
 
-def expect_invalid(schema, rule, query_string, expected_errors):
-    errors = validate(schema, parse(query_string), [rule])
+def expect_invalid(schema, rule, query_string, expected_errors, **options):
+    errors = validate(schema, parse(query_string, **options), [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_passes_rule(rule, query_string, **options):
+    expect_valid(test_schema, rule, query_string, **options)
 
 
-def expect_fails_rule(rule, query_string, errors):
-    return expect_invalid(test_schema, rule, query_string, errors)
+def expect_fails_rule(rule, query_string, errors, **options):
+    return expect_invalid(test_schema, rule, query_string, errors, **options)
 
 
 def expect_passes_rule_with_schema(schema, rule, query_string):

tests/validation/test_known_directives.py

@@ -1,15 +1,12 @@
 from functools import partial
 
-from graphql.language import parse
 from graphql.utilities import build_schema
-from graphql.validation import validate, KnownDirectivesRule
+from graphql.validation import KnownDirectivesRule
 from graphql.validation.rules.known_directives import (
     unknown_directive_message, misplaced_directive_message)
 
 from .harness import (
-    expect_fails_rule, expect_passes_rule, expect_sdl_errors_from_rule,
-    test_schema)
-
+    expect_fails_rule, expect_passes_rule, expect_sdl_errors_from_rule)
 
 expect_sdl_errors = partial(
     expect_sdl_errors_from_rule, KnownDirectivesRule)
@@ -112,17 +109,12 @@ def with_well_placed_directives():
             }
             """)
 
-    def with_well_placed_variable_definition_directives():
-        # Need to parse with experimental flag
-        query_string = """
+    def experimental_with_well_placed_variable_definition_directive():
+        expect_passes_rule(KnownDirectivesRule, """
             query Foo($var: Boolean @onVariableDefinition) {
               name
             }
-            """
-        errors = validate(test_schema, parse(
-            query_string, experimental_variable_definition_directives=True),
-            [KnownDirectivesRule])
-        assert errors == [], 'Should validate'
+            """, experimental_variable_definition_directives=True)
 
     def with_misplaced_directives():
         expect_fails_rule(KnownDirectivesRule, """
@@ -141,20 +133,14 @@ def with_misplaced_directives():
             misplaced_directive('onQuery', 'mutation', 7, 26),
         ])
 
-    def with_misplaced_variable_definition_directives():
-        # Need to parse with experimental flag
-        query_string = """
+    def experimental_with_misplaced_variable_definition_directive():
+        expect_fails_rule(KnownDirectivesRule, """
             query Foo($var: Boolean @onField) {
               name
             }
-            """
-        errors = validate(test_schema, parse(
-            query_string, experimental_variable_definition_directives=True),
-            [KnownDirectivesRule])
-        expected_errors = [
-            misplaced_directive('onField', 'variable definition', 2, 37)]
-        assert len(errors) >= 1, 'Should not validate'
-        assert errors == expected_errors
+            """, [
+            misplaced_directive('onField', 'variable definition', 2, 37)],
+            experimental_variable_definition_directives=True)
 
     def describe_within_sdl():
 

tests/validation/test_unique_directives_per_location.py

@@ -7,7 +7,6 @@
 from .harness import (
     expect_fails_rule, expect_passes_rule, expect_sdl_errors_from_rule)
 
-
 expect_sdl_errors = partial(
     expect_sdl_errors_from_rule, UniqueDirectivesPerLocationRule)