def extends_without_altering_original_schema():
     extended_schema = extend_test_schema("""
         extend type Query {
          newField: String
         }
         """)
     assert extend_schema != test_schema
     assert "newField" in print_schema(extended_schema)
     assert "newField" not in print_schema(test_schema)
 def test_get_schema_with_macros_original_schema_unchanged(self) -> None:
     empty_macro_registry = get_empty_test_macro_registry()
     original_printed_schema = print_schema(
         self.macro_registry.schema_without_macros)
     printed_schema_with_0_macros = print_schema(
         get_schema_with_macros(empty_macro_registry))
     printed_schema_afterwards = print_schema(
         self.macro_registry.schema_without_macros)
     self.assertEqual(original_printed_schema, printed_schema_afterwards)
     self.assertEqual(original_printed_schema, printed_schema_with_0_macros)
예제 #3
0
def expect_schema_changes(schema: GraphQLSchema,
                          extended_schema: GraphQLSchema,
                          expected: str) -> None:
    schema_definitions = {
        print_ast(node)
        for node in parse(print_schema(schema)).definitions
    }
    assert ("\n\n".join(schema_def for schema_def in (
        print_ast(node)
        for node in parse(print_schema(extended_schema)).definitions)
                        if schema_def not in schema_definitions) == expected)
예제 #4
0
        def legacy_support_for_interfaces_with_null_as_interfaces_field():
            introspection = introspection_from_schema(dummy_schema)
            some_interface_introspection = next(
                type_ for type_ in introspection["__schema"]["types"]
                if type_["name"] == "SomeInterface")

            assert some_interface_introspection["interfaces"] == []
            some_interface_introspection["interfaces"] = None

            client_schema = build_client_schema(introspection)
            assert print_schema(client_schema) == print_schema(dummy_schema)
예제 #5
0
def print_schema_changes(schema: GraphQLSchema,
                         extended_schema: GraphQLSchema) -> str:
    schema_definitions = [
        print_ast(definition)
        for definition in parse(print_schema(schema)).definitions
    ]
    ast = parse(print_schema(extended_schema))
    return print_ast(
        DocumentNode(definitions=FrozenList(
            node for node in ast.definitions
            if print_ast(node) not in schema_definitions)))
예제 #6
0
    def may_extend_mutations_and_subscriptions():
        mutation_schema = build_schema(
            """
            type Query {
              queryField: String
            }

            type Mutation {
              mutationField: String
            }

            type Subscription {
              subscriptionField: String
            }
            """
        )
        ast = parse(
            """
            extend type Query {
              newQueryField: Int
            }

            extend type Mutation {
              newMutationField: Int
            }

            extend type Subscription {
              newSubscriptionField: Int
            }
            """
        )
        original_print = print_schema(mutation_schema)
        extended_schema = extend_schema(mutation_schema, ast)
        assert extended_schema != mutation_schema
        assert print_schema(mutation_schema) == original_print
        assert print_schema(extended_schema) == dedent(
            """
            type Query {
              queryField: String
              newQueryField: Int
            }

            type Mutation {
              mutationField: String
              newMutationField: Int
            }

            type Subscription {
              subscriptionField: String
              newSubscriptionField: Int
            }
            """
        )
예제 #7
0
    def may_extend_mutations_and_subscriptions():
        mutationSchema = GraphQLSchema(
            query=GraphQLObjectType(
                name="Query", fields=lambda: {"queryField": GraphQLField(GraphQLString)}
            ),
            mutation=GraphQLObjectType(
                name="Mutation",
                fields=lambda: {"mutationField": GraphQLField(GraphQLString)},
            ),
            subscription=GraphQLObjectType(
                name="Subscription",
                fields=lambda: {"subscriptionField": GraphQLField(GraphQLString)},
            ),
        )

        ast = parse(
            """
            extend type Query {
              newQueryField: Int
            }

            extend type Mutation {
              newMutationField: Int
            }

            extend type Subscription {
              newSubscriptionField: Int
            }
            """
        )
        original_print = print_schema(mutationSchema)
        extended_schema = extend_schema(mutationSchema, ast)
        assert extended_schema != mutationSchema
        assert print_schema(mutationSchema) == original_print
        assert print_schema(extended_schema) == dedent(
            """
            type Mutation {
              mutationField: String
              newMutationField: Int
            }

            type Query {
              queryField: String
              newQueryField: Int
            }

            type Subscription {
              subscriptionField: String
              newSubscriptionField: Int
            }
            """
        )
예제 #8
0
def test_default_conversion_type_name():
    assert (
        print_schema(graphql_schema(query=[b]))
        == """\
type Query {
  b: B!
}

type B {
  a: Int!
}
"""
    )
    assert serialization_schema(B, all_refs=True) == {
        "$ref": "#/$defs/B",
        "$defs": {
            "B": {"$ref": "#/$defs/A"},
            "A": {
                "type": "object",
                "properties": {"a": {"type": "integer"}},
                "required": ["a"],
                "additionalProperties": False,
            },
        },
        "$schema": "http://json-schema.org/draft/2019-09/schema#",
    }
    assert serialization_schema(B) == {
        "type": "object",
        "properties": {"a": {"type": "integer"}},
        "required": ["a"],
        "additionalProperties": False,
        "$schema": "http://json-schema.org/draft/2019-09/schema#",
    }
예제 #9
0
def print_test_schema_changes(extended_schema):
    ast = parse(print_schema(extended_schema))
    ast.definitions = [
        node for node in ast.definitions
        if print_ast(node) not in test_schema_definitions
    ]
    return print_ast(ast)
예제 #10
0
        def _get_directives_in_string_form(directives):
            """Return a set of directives in their string form, from the native directive type."""
            fake_query_type = GraphQLObjectType(
                "Query", fields={"foo": GraphQLField(GraphQLString)}
            )
            fake_schema = GraphQLSchema(fake_query_type, directives=directives)

            # Split schema on double line breaks where the following character is not a space.
            # It is not possible to simply split on double line breaks because print_schema puts a
            # double line break between GraphQLArguments. The not space character is retained and
            # reattached to the rest of the line.
            split_schema_lines = [
                line.strip() for line in re.split("\n\n([^ ])", print_schema(fake_schema))
            ]

            # Reattach the delimiter's character to the rest of the line. The first line does
            # not have a separated character from regular expression splitting.
            schema_lines = [split_schema_lines[0]] + [
                delimiter_character + line
                for delimiter_character, line in zip(
                    split_schema_lines[1::2], split_schema_lines[2::2]
                )
            ]

            return {line for line in schema_lines if line.startswith("directive")}
예제 #11
0
    def can_deep_copy_a_schema():
        source = """
            schema {
              query: Farm
              mutation: Work
            }

            type Cow {
              id: ID!
              name: String
              moos: Boolean
            }

            type Pig {
              id: ID!
              name: String
              oink: Boolean
            }

            union Animal = Cow | Pig

            enum Food {
              CORN
              FRUIT
            }

            input Feed {
              amount: Float
              type: Food
            }

            type Farm {
              animals: [Animal!]!
            }

            type Work {
              feed(feed: Feed): Boolean
            }
        """
        schema = build_schema(source)
        schema_copy = deepcopy(schema)

        for name in ("Cow", "Pig", "Animal", "Food", "Feed", "Farm", "Work"):
            assert schema.get_type(name) is not schema_copy.get_type(name)

        assert print_schema(lexicographic_sort_schema(schema)) == print_schema(
            lexicographic_sort_schema(schema_copy))
예제 #12
0
def dump_schema(connection, schema, out_file):
    """Dump the GraphQL Schema to stdout or file"""
    from nebulo.gql.sqla_to_gql import sqla_models_to_graphql_schema
    from nebulo.sql.reflection.manager import reflect_sqla_models

    engine = create_engine(connection)
    sqla_models, sql_functions = reflect_sqla_models(engine, schema=schema)
    schema = sqla_models_to_graphql_schema(sqla_models, sql_functions)
    schema_str = print_schema(schema)
    click.echo(schema_str, file=out_file)
예제 #13
0
def cycle_sdl(sdl: str) -> str:
    """Full cycle test.

    This function does a full cycle of going from a string with the contents of the SDL,
    parsed in a schema AST, materializing that schema AST into an in-memory
    GraphQLSchema, and then finally printing that GraphQL into the SDÖ.
    """
    ast = parse(sdl)
    schema = build_ast_schema(ast)
    return print_schema(schema)
예제 #14
0
async def test_subscription(alias, conversion, error_handler, resolver):
    if alias is not None:
        sub_name = alias
    elif resolver is not None:
        sub_name = resolver.__name__
    else:
        sub_name = events.__name__
    if (alias, conversion, error_handler, resolver) == (None, None, Undefined,
                                                        None):
        sub_op = events
    else:
        sub_op = Subscription(events,
                              alias,
                              conversion,
                              None,
                              error_handler,
                              resolver=resolver)
    schema = graphql_schema(query=[hello],
                            subscription=[sub_op],
                            types=[Event])
    sub_field = sub_name
    if resolver is not None:
        sub_field += "(dummy: Boolean)"
    sub_field += f": {'String' if conversion else 'Event'}"
    if error_handler is Undefined:
        sub_field += "!"
    schema_str = """\
type Event {
  name: String!
}

type Query {
  hello: String!
}

type Subscription {
  %s
}
"""
    assert print_schema(schema) == schema_str % sub_field
    sub_query = sub_name
    if conversion is None:
        sub_query += "{name}"
    subscription = await graphql.subscribe(
        schema, graphql.parse("subscription {%s}" % sub_query))
    result = EVENTS
    if resolver:
        result = [s.capitalize() for s in result]
    if not conversion:
        result = [{"name": s} for s in result]
    assert [ev.data async for ev in subscription] == [{
        sub_name: r
    } for r in result]
예제 #15
0
def test_annotated_schema():
    assert (deserialization_schema(A) == serialization_schema(A) == {
        "$schema": "http://json-schema.org/draft/2019-09/schema#",
        "type": "object",
        "properties": {
            "a": {
                "type": "integer",
                "maximum": 10,
                "minimum": 0,
                "description": "field description",
            }
        },
        "required": ["a"],
        "additionalProperties": False,
    })
    assert (deserialization_schema(A, all_refs=True) == serialization_schema(
        A, all_refs=True) == {
            "$schema": "http://json-schema.org/draft/2019-09/schema#",
            "$ref": "#/$defs/A",
            "$defs": {
                "A": {
                    "additionalProperties": False,
                    "properties": {
                        "a": {
                            "$ref": "#/$defs/someInt",
                            "description": "field description",
                            "minimum": 0,
                        }
                    },
                    "required": ["a"],
                    "type": "object",
                },
                "someInt": {
                    "description": "type description",
                    "maximum": 10,
                    "type": "integer",
                },
            },
        })
    assert (print_schema(graphql_schema(query=[a])) == '''\
type Query {
  a: A!
}

type A {
  """field description"""
  a: someInt!
}

"""type description"""
scalar someInt
''')
예제 #16
0
    def builds_a_schema_without_the_query_type():
        sdl = dedent("""
            type Query {
              foo: String
            }
            """)

        schema = build_schema(sdl)
        introspection = introspection_from_schema(schema)
        del introspection["__schema"]["queryType"]

        client_schema = build_client_schema(introspection)
        assert client_schema.query_type is None
        assert print_schema(client_schema) == sdl
예제 #17
0
def cycle_introspection(sdl_string):
    """Test that the client side introspection gives the same result.

    This function does a full cycle of going from a string with the contents of the SDL,
    build in-memory GraphQLSchema from it, produce a client-side representation of the
    schema by using "build_client_schema" and then finally printing that that schema
    into the SDL.
    """
    server_schema = build_schema(sdl_string)
    initial_introspection = introspection_from_schema(server_schema)
    client_schema = build_client_schema(initial_introspection)
    # If the client then runs the introspection query against the client-side schema,
    # it should get a result identical to what was returned by the server
    second_introspection = introspection_from_schema(client_schema)
    assert initial_introspection == second_introspection
    return print_schema(client_schema)
예제 #18
0
    def builds_a_schema_without_directives():
        sdl = dedent("""
            type Query {
              foo: String
            }
            """)

        schema = build_schema(sdl)
        introspection = introspection_from_schema(schema)
        del introspection["__schema"]["directives"]

        client_schema = build_client_schema(introspection)

        assert schema.directives
        assert client_schema.directives == []
        assert print_schema(client_schema) == sdl
예제 #19
0
    def test_meta_fields_from_constant(self) -> None:
        fields = schema.EXTENDED_META_FIELD_DEFINITIONS.copy()
        fields.update(
            OrderedDict((
                ("foo", GraphQLField(GraphQLString)),
                ("bar", GraphQLField(GraphQLInt)),
            )))
        graphql_type = GraphQLObjectType("MyType", fields)
        custom_schema = GraphQLSchema(graphql_type,
                                      directives=schema.DIRECTIVES)

        # Ensure that stringifying and parsing this schema works just fine.
        printed_schema = print_schema(custom_schema)
        expected_type_definition = """\
type MyType {
    _x_count: Int
    foo: String
    bar: Int
}""".replace("    ", "  ")  # 2 space indentation instead of 4 spaces
        self.assertIn(expected_type_definition, printed_schema)
예제 #20
0
def cycle_introspection(sdl_string):
    """Test that the client side introspection gives the same result.

    This function does a full cycle of going from a string with the contents of the SDL,
    build in-memory GraphQLSchema from it, produce a client-side representation of the
    schema by using "build_client_schema" and then return that schema printed as SDL.
    """
    options = dict(specified_by_url=True, directive_is_repeatable=True)

    server_schema = build_schema(sdl_string)
    initial_introspection = introspection_from_schema(server_schema, **options)
    client_schema = build_client_schema(initial_introspection)
    # If the client then runs the introspection query against the client-side schema,
    # it should get a result identical to what was returned by the server
    second_introspection = introspection_from_schema(client_schema, **options)

    # If the client then runs the introspection query against the client-side
    # schema, it should get a result identical to what was returned by the server.
    assert initial_introspection == second_introspection
    return print_schema(client_schema)
예제 #21
0
def test_resolver_default_parameter_not_serializable(tp, default):
    def resolver(arg=default) -> bool:
        return arg is default

    resolver.__annotations__["arg"] = tp
    # wraps in order to trigger the bug of get_type_hints with None default value
    resolver2 = wraps(resolver)(lambda arg=default: resolver(arg))
    schema = graphql_schema(query=[resolver2])
    assert (
        print_schema(schema)
        == """\
type Query {
  resolver(arg: Int): Boolean!
}
"""
    )
    assert (
        graphql_sync(schema, "{resolver}").data
        == graphql_sync(schema, "{resolver(arg: null)}").data
        == {"resolver": True}
    )
예제 #22
0
def test_resolver_position():
    assert serialization_schema(B) == {
        "type": "object",
        "properties": {
            "a": {
                "type": "integer"
            },
            "b": {
                "type": "integer"
            },
            "c": {
                "type": "integer"
            },
            "d": {
                "type": "integer"
            },
            "e": {
                "type": "integer"
            },
        },
        "required": ["a", "b", "c", "d", "e"],
        "additionalProperties": False,
        "$schema": "http://json-schema.org/draft/2019-09/schema#",
    }
    assert (print_schema(graphql_schema(query=[query])) == """\
type Query {
  query: B!
}

type B {
  a: Int!
  b: Int!
  c: Int!
  d: Int!
  e: Int!
}
""")
예제 #23
0
    def define_sample_schema():
        BlogImage = GraphQLObjectType(
            "Image",
            {
                "url": GraphQLField(GraphQLString),
                "width": GraphQLField(GraphQLInt),
                "height": GraphQLField(GraphQLInt),
            },
        )

        BlogAuthor = GraphQLObjectType(
            "Author",
            lambda: {
                "id":
                GraphQLField(GraphQLString),
                "name":
                GraphQLField(GraphQLString),
                "pic":
                GraphQLField(
                    BlogImage,
                    args={
                        "width": GraphQLArgument(GraphQLInt),
                        "height": GraphQLArgument(GraphQLInt),
                    },
                ),
                "recentArticle":
                GraphQLField(BlogArticle),
            },
        )

        BlogArticle = GraphQLObjectType(
            "Article",
            lambda: {
                "id": GraphQLField(GraphQLString),
                "isPublished": GraphQLField(GraphQLBoolean),
                "author": GraphQLField(BlogAuthor),
                "title": GraphQLField(GraphQLString),
                "body": GraphQLField(GraphQLString),
            },
        )

        BlogQuery = GraphQLObjectType(
            "Query",
            {
                "article":
                GraphQLField(BlogArticle,
                             args={"id": GraphQLArgument(GraphQLString)}),
                "feed":
                GraphQLField(GraphQLList(BlogArticle)),
            },
        )

        BlogMutation = GraphQLObjectType(
            "Mutation", {"writeArticle": GraphQLField(BlogArticle)})

        BlogSubscription = GraphQLObjectType(
            "Subscription",
            {
                "articleSubscribe":
                GraphQLField(args={"id": GraphQLArgument(GraphQLString)},
                             type_=BlogArticle)
            },
        )

        schema = GraphQLSchema(BlogQuery, BlogMutation, BlogSubscription)

        assert print_schema(schema) == dedent("""
            type Article {
              id: String
              isPublished: Boolean
              author: Author
              title: String
              body: String
            }

            type Author {
              id: String
              name: String
              pic(width: Int, height: Int): Image
              recentArticle: Article
            }

            type Image {
              url: String
              width: Int
              height: Int
            }

            type Mutation {
              writeArticle: Article
            }

            type Query {
              article(id: String): Article
              feed: [Article]
            }

            type Subscription {
              articleSubscribe(id: String): Article
            }
            """)
예제 #24
0
    def define_sample_schema():
        BlogImage = GraphQLObjectType(
            "Image",
            {
                "url": GraphQLField(GraphQLString),
                "width": GraphQLField(GraphQLInt),
                "height": GraphQLField(GraphQLInt),
            },
        )

        BlogArticle: GraphQLObjectType

        BlogAuthor = GraphQLObjectType(
            "Author",
            lambda: {
                "id":
                GraphQLField(GraphQLString),
                "name":
                GraphQLField(GraphQLString),
                "pic":
                GraphQLField(
                    BlogImage,
                    args={
                        "width": GraphQLArgument(GraphQLInt),
                        "height": GraphQLArgument(GraphQLInt),
                    },
                ),
                "recentArticle":
                GraphQLField(BlogArticle),
            },
        )

        BlogArticle = GraphQLObjectType(
            "Article",
            lambda: {
                "id": GraphQLField(GraphQLString),
                "isPublished": GraphQLField(GraphQLBoolean),
                "author": GraphQLField(BlogAuthor),
                "title": GraphQLField(GraphQLString),
                "body": GraphQLField(GraphQLString),
            },
        )

        BlogQuery = GraphQLObjectType(
            "Query",
            {
                "article":
                GraphQLField(BlogArticle,
                             args={"id": GraphQLArgument(GraphQLString)}),
                "feed":
                GraphQLField(GraphQLList(BlogArticle)),
            },
        )

        BlogMutation = GraphQLObjectType(
            "Mutation", {"writeArticle": GraphQLField(BlogArticle)})

        BlogSubscription = GraphQLObjectType(
            "Subscription",
            {
                "articleSubscribe":
                GraphQLField(args={"id": GraphQLArgument(GraphQLString)},
                             type_=BlogArticle)
            },
        )

        schema = GraphQLSchema(BlogQuery, BlogMutation, BlogSubscription)

        kwargs = schema.to_kwargs()
        types = kwargs.pop("types")
        assert types == list(schema.type_map.values())
        assert kwargs == {
            "query": BlogQuery,
            "mutation": BlogMutation,
            "subscription": BlogSubscription,
            "directives": None,
            "ast_node": None,
            "extensions": None,
            "extension_ast_nodes": None,
            "assume_valid": False,
        }

        assert print_schema(schema) == dedent("""
            type Article {
              id: String
              isPublished: Boolean
              author: Author
              title: String
              body: String
            }

            type Author {
              id: String
              name: String
              pic(width: Int, height: Int): Image
              recentArticle: Article
            }

            type Image {
              url: String
              width: Int
              height: Int
            }

            type Mutation {
              writeArticle: Article
            }

            type Query {
              article(id: String): Article
              feed: [Article]
            }

            type Subscription {
              articleSubscribe(id: String): Article
            }
            """)
def extend_test_schema(sdl, **options) -> GraphQLSchema:
    original_print = print_schema(test_schema)
    ast = parse(sdl)
    extended_schema = extend_schema(test_schema, ast, **options)
    assert print_schema(test_schema) == original_print
    return extended_schema
    def correctly_assigns_ast_nodes_to_new_and_extended_types():
        extended_schema = extend_test_schema("""
            extend type Query {
              newField(testArg: TestInput): TestEnum
            }

            extend scalar SomeScalar @foo

            extend enum SomeEnum {
              NEW_VALUE
            }

            extend union SomeUnion = Bar

            extend input SomeInput {
              newField: String
            }

            extend interface SomeInterface {
              newField: String
            }

            enum TestEnum {
              TEST_VALUE
            }

            input TestInput {
              testInputField: TestEnum
            }
            """)
        ast = parse("""
            extend type Query {
              oneMoreNewField: TestUnion
            }

            extend scalar SomeScalar @test

            extend enum SomeEnum {
              ONE_MORE_NEW_VALUE
            }

            extend union SomeUnion = TestType

            extend input SomeInput {
              oneMoreNewField: String
            }

            extend interface SomeInterface {
              oneMoreNewField: String
            }

            union TestUnion = TestType

            interface TestInterface {
              interfaceField: String
            }

            type TestType implements TestInterface {
              interfaceField: String
            }

            directive @test(arg: Int) repeatable on FIELD | SCALAR
            """)
        extended_twice_schema = extend_schema(extended_schema, ast)

        query = assert_object_type(extended_twice_schema.get_type("Query"))
        some_enum = assert_enum_type(
            extended_twice_schema.get_type("SomeEnum"))
        some_union = assert_union_type(
            extended_twice_schema.get_type("SomeUnion"))
        some_scalar = assert_scalar_type(
            extended_twice_schema.get_type("SomeScalar"))
        some_input = assert_input_object_type(
            extended_twice_schema.get_type("SomeInput"))
        some_interface = assert_interface_type(
            extended_twice_schema.get_type("SomeInterface"))

        test_input = assert_input_object_type(
            extended_twice_schema.get_type("TestInput"))
        test_enum = assert_enum_type(
            extended_twice_schema.get_type("TestEnum"))
        test_union = assert_union_type(
            extended_twice_schema.get_type("TestUnion"))
        test_type = assert_object_type(
            extended_twice_schema.get_type("TestType"))
        test_interface = assert_interface_type(
            extended_twice_schema.get_type("TestInterface"))
        test_directive = assert_directive(
            extended_twice_schema.get_directive("test"))

        assert test_type.extension_ast_nodes is None
        assert test_enum.extension_ast_nodes is None
        assert test_union.extension_ast_nodes is None
        assert test_input.extension_ast_nodes is None
        assert test_interface.extension_ast_nodes is None

        assert query.extension_ast_nodes
        assert len(query.extension_ast_nodes) == 2
        assert some_scalar.extension_ast_nodes
        assert len(some_scalar.extension_ast_nodes) == 2
        assert some_enum.extension_ast_nodes
        assert len(some_enum.extension_ast_nodes) == 2
        assert some_union.extension_ast_nodes
        assert len(some_union.extension_ast_nodes) == 2
        assert some_input.extension_ast_nodes
        assert len(some_input.extension_ast_nodes) == 2
        assert some_interface.extension_ast_nodes
        assert len(some_interface.extension_ast_nodes) == 2

        definitions: List[Optional[TypeSystemDefinitionNode]] = [
            test_input.ast_node,
            test_enum.ast_node,
            test_union.ast_node,
            test_interface.ast_node,
            test_type.ast_node,
            test_directive.ast_node,
        ]
        extensions: List[Optional[FrozenList[TypeSystemDefinitionNode]]] = [
            query.extension_ast_nodes,
            some_scalar.extension_ast_nodes,
            some_enum.extension_ast_nodes,
            some_union.extension_ast_nodes,
            some_input.extension_ast_nodes,
            some_interface.extension_ast_nodes,
        ]
        for extension_ast_nodes in extensions:
            if extension_ast_nodes:
                definitions.extend(extension_ast_nodes)
        restored_extension_ast = DocumentNode(definitions=definitions)

        assert print_schema(extend_schema(
            test_schema,
            restored_extension_ast)) == print_schema(extended_twice_schema)

        new_field = query.fields["newField"]
        assert print_ast_node(
            new_field) == "newField(testArg: TestInput): TestEnum"
        assert print_ast_node(
            new_field.args["testArg"]) == "testArg: TestInput"
        assert (print_ast_node(
            query.fields["oneMoreNewField"]) == "oneMoreNewField: TestUnion")

        new_value = some_enum.values["NEW_VALUE"]
        assert some_enum
        assert print_ast_node(new_value) == "NEW_VALUE"

        one_more_new_value = some_enum.values["ONE_MORE_NEW_VALUE"]
        assert one_more_new_value
        assert print_ast_node(one_more_new_value) == "ONE_MORE_NEW_VALUE"
        assert print_ast_node(
            some_input.fields["newField"]) == "newField: String"
        assert (print_ast_node(
            some_input.fields["oneMoreNewField"]) == "oneMoreNewField: String")
        assert print_ast_node(
            some_interface.fields["newField"]) == "newField: String"
        assert (print_ast_node(some_interface.fields["oneMoreNewField"]) ==
                "oneMoreNewField: String")

        assert (print_ast_node(
            test_input.fields["testInputField"]) == "testInputField: TestEnum")

        test_value = test_enum.values["TEST_VALUE"]
        assert test_value
        assert print_ast_node(test_value) == "TEST_VALUE"

        assert (print_ast_node(test_interface.fields["interfaceField"]) ==
                "interfaceField: String")
        assert (print_ast_node(
            test_type.fields["interfaceField"]) == "interfaceField: String")
        assert print_ast_node(test_directive.args["arg"]) == "arg: Int"
      someEnum: SomeEnum
      someInterface(id: ID!): SomeInterface
      someInput(input: SomeInput): String
    }
    """)


def extend_test_schema(sdl, **options) -> GraphQLSchema:
    original_print = print_schema(test_schema)
    ast = parse(sdl)
    extended_schema = extend_schema(test_schema, ast, **options)
    assert print_schema(test_schema) == original_print
    return extended_schema


test_schema_ast = parse(print_schema(test_schema))
test_schema_definitions = [
    print_ast(node) for node in test_schema_ast.definitions
]


def print_test_schema_changes(extended_schema):
    ast = parse(print_schema(extended_schema))
    ast.definitions = FrozenList(
        node for node in ast.definitions
        if print_ast(node) not in test_schema_definitions)
    return print_ast(ast)


TypeWithAstNode = Union[GraphQLArgument, GraphQLEnumValue, GraphQLField,
                        GraphQLInputField, GraphQLNamedType, GraphQLSchema, ]
예제 #28
0
}

type Bar {
  field: String!
}

input FooInput {
  bar: BarInput
  baz: Int
}

input BarInput {
  field: String!
}
"""
assert print_schema(schema) == schema_str

query_str = """
{
    query(foo: {bar: {field: "value"}}) {
        bar {
            field
        }
        baz
    }
}
"""
assert graphql_sync(schema, query_str).data == {
    "query": {"bar": {"field": "value"}, "baz": None}
}
예제 #29
0
def print_for_test(schema: GraphQLSchema) -> str:
    schema_text = print_schema(schema)
    # keep print_schema and build_schema in sync
    assert print_schema(build_schema(schema_text)) == schema_text
    return schema_text
def expect_printed_schema(schema: GraphQLSchema) -> str:
    schema_text = print_schema(schema)
    # keep print_schema and build_schema in sync
    assert print_schema(build_schema(schema_text)) == schema_text
    return schema_text