def correctly_extend_object_type():
object_sdl = dedent("""
type SomeObject implements Foo {
first: String
}
extend type SomeObject implements Bar {
second: Int
}
extend type SomeObject implements Baz {
third: Float
}
""")
schema = build_schema(object_sdl + dedent("""
interface Foo
interface Bar
interface Baz
"""))
some_object = assert_object_type(schema.get_type("SomeObject"))
assert print_type(some_object) + "\n" == dedent("""
type SomeObject implements Foo & Bar & Baz {
first: String
second: Int
third: Float
}
""")
assert print_all_ast_nodes(some_object) == object_sdl
def extends_objects_by_adding_new_fields():
extended_schema = extend_test_schema("""
extend type Foo {
newField: String
}
""")
assert print_test_schema_changes(extended_schema) == dedent("""
type Foo implements SomeInterface {
name: String
some: SomeInterface
tree: [Foo]!
newField: String
}
""")
foo_type = assert_object_type(extended_schema.get_type("Foo"))
query_type = assert_object_type(extended_schema.get_type("Query"))
assert query_type.fields["foo"].type == foo_type
def correctly_extend_object_type():
schema = build_schema(
"""
type SomeObject implements Foo {
first: String
}
extend type SomeObject implements Bar {
second: Int
}
extend type SomeObject implements Baz {
third: Float
}
interface Foo
interface Bar
interface Baz
"""
)
some_object = assert_object_type(schema.get_type("SomeObject"))
assert print_type(some_object) == dedent(
"""
type SomeObject implements Foo & Bar & Baz {
first: String
second: Int
third: Float
}
"""
)
expect_ast_node(
some_object,
dedent(
"""
type SomeObject implements Foo {
first: String
}
"""
),
)
expect_extension_ast_nodes(
some_object,
dedent(
"""
extend type SomeObject implements Bar {
second: Int
}
extend type SomeObject implements Baz {
third: Float
}
"""
),
)
def extends_objects_with_deprecated_fields():
extended_schema = extend_test_schema("""
extend type Foo {
deprecatedField: String @deprecated(reason: "not used anymore")
}
""")
foo_type = assert_object_type(extended_schema.get_type("Foo"))
deprecated_field_def = foo_type.fields["deprecatedField"]
assert deprecated_field_def.is_deprecated is True
assert deprecated_field_def.deprecation_reason == "not used anymore"
def adds_multiple_new_root_types_via_schema_extension():
schema = build_schema("type Query")
extend_ast = parse("""
extend schema {
mutation: Mutation
subscription: Subscription
}
type Mutation
type Subscription
""")
extended_schema = extend_schema(schema, extend_ast)
mutation_type = assert_object_type(extended_schema.mutation_type)
assert mutation_type.name == "Mutation"
subscription_type = assert_object_type(
extended_schema.subscription_type)
assert subscription_type.name == "Subscription"
def can_describe_the_extended_fields():
extended_schema = extend_test_schema("""
extend type Query {
"New field description."
newField: String
}
""")
query_type = assert_object_type(extended_schema.get_type("Query"))
assert query_type.fields[
"newField"].description == "New field description."
def extends_unions_by_adding_new_types():
extended_schema = extend_test_schema("""
extend union SomeUnion = Bar
""")
assert print_test_schema_changes(extended_schema) == dedent("""
union SomeUnion = Foo | Biz | Bar
""")
some_union_type = extended_schema.get_type("SomeUnion")
query_type = assert_object_type(extended_schema.get_type("Query"))
union_field = query_type.fields["someUnion"]
assert union_field.type == some_union_type
def allows_to_reference_introspection_types():
schema = build_schema("""
type Query {
introspectionField: __EnumValue
}
""")
query_type = assert_object_type(schema.get_type("Query"))
__EnumValue = introspection_types["__EnumValue"]
assert query_type.fields["introspectionField"].type is __EnumValue
assert schema.get_type(
"__EnumValue") is introspection_types["__EnumValue"]
def extends_objects_with_deprecated_fields():
schema = build_schema("type SomeObject")
extend_ast = parse("""
extend type SomeObject {
deprecatedField: String @deprecated(reason: "not used anymore")
}
""")
extended_schema = extend_schema(schema, extend_ast)
some_type = assert_object_type(extended_schema.get_type("SomeObject"))
deprecated_field = some_type.fields["deprecatedField"]
assert deprecated_field.deprecation_reason == "not used anymore"
def one_line_prints_a_short_description():
description = "This field is awesome"
output = print_single_field_schema(
GraphQLField(GraphQLString, description=description))
assert output == dedent('''
type Query {
"""This field is awesome"""
singleField: String
}
''')
schema = build_schema(output)
recreated_root = assert_object_type(schema.type_map["Query"])
recreated_field = recreated_root.fields["singleField"]
assert recreated_field.description == description
def adds_new_root_types_via_schema_extension():
schema = build_schema("""
type Query
type MutationRoot
""")
extension_sdl = dedent("""
extend schema {
mutation: MutationRoot
}
""")
extended_schema = extend_schema(schema, parse(extension_sdl))
mutation_type = assert_object_type(extended_schema.mutation_type)
assert mutation_type.name == "MutationRoot"
assert print_extension_nodes(extended_schema) == extension_sdl
def preserves_leading_spaces_when_printing_a_description():
description = ' This field is "awesome"'
output = print_single_field_schema(
GraphQLField(GraphQLString, description=description))
assert output == dedent('''
type Query {
""" This field is "awesome"
"""
singleField: String
}
''')
schema = build_schema(output)
recreated_root = assert_object_type(schema.type_map["Query"])
recreated_field = recreated_root.fields["singleField"]
assert recreated_field.description == description
def does_not_one_line_print_a_description_that_ends_with_a_quote():
description = 'This field is "awesome"'
output = print_single_field_schema(
GraphQLField(GraphQLString, description=description))
assert output == dedent('''
type Query {
"""
This field is "awesome"
"""
singleField: String
}
''')
schema = build_schema(output)
recreated_root = assert_object_type(schema.type_map["Query"])
recreated_field = recreated_root.fields["singleField"]
assert recreated_field.description == description
def adds_schema_definition_missing_in_the_original_schema():
schema = build_schema("""
directive @foo on SCHEMA
type Foo
""")
assert schema.query_type is None
extension_sdl = dedent("""
schema @foo {
query: Foo
}
""")
extended_schema = extend_schema(schema, parse(extension_sdl))
query_type = assert_object_type(extended_schema.query_type)
assert query_type.name == "Foo"
assert print_ast_node(extended_schema) + "\n" == extension_sdl
def extends_enums_by_adding_new_values():
extended_schema = extend_test_schema("""
extend enum SomeEnum {
NEW_ENUM
}
""")
assert print_test_schema_changes(extended_schema) == dedent("""
enum SomeEnum {
ONE
TWO
NEW_ENUM
}
""")
some_enum_type = extended_schema.get_type("SomeEnum")
query_type = assert_object_type(extended_schema.get_type("Query"))
enum_field = query_type.fields["someEnum"]
assert enum_field.type == some_enum_type
def extends_inputs_by_adding_new_fields():
extended_schema = extend_test_schema("""
extend input SomeInput {
newField: String
}
""")
assert print_test_schema_changes(extended_schema) == dedent("""
input SomeInput {
fooArg: String
newField: String
}
""")
some_input_type = extended_schema.get_type("SomeInput")
query_type = assert_object_type(extended_schema.get_type("Query"))
input_field = query_type.fields["someInput"]
assert input_field.args["input"].type == some_input_type
foo_directive = assert_directive(extended_schema.get_directive("foo"))
assert foo_directive.args["input"].type == some_input_type
def builds_types_with_deprecated_fields_and_values():
schema = GraphQLSchema()
extend_ast = parse("""
type SomeObject {
deprecatedField: String @deprecated(reason: "not used anymore")
}
enum SomeEnum {
DEPRECATED_VALUE @deprecated(reason: "do not use")
}
""")
extended_schema = extend_schema(schema, extend_ast)
some_type = assert_object_type(extended_schema.get_type("SomeObject"))
deprecated_field = some_type.fields["deprecatedField"]
assert deprecated_field.deprecation_reason == "not used anymore"
some_enum = assert_enum_type(extended_schema.get_type("SomeEnum"))
deprecated_enum = some_enum.values["DEPRECATED_VALUE"]
assert deprecated_enum.deprecation_reason == "do not use"
def supports_deprecated_directive():
sdl = dedent(
"""
enum MyEnum {
VALUE
OLD_VALUE @deprecated
OTHER_VALUE @deprecated(reason: "Terrible reasons")
}
type Query {
field1: String @deprecated
field2: Int @deprecated(reason: "Because I said so")
enum: MyEnum
}
"""
)
assert cycle_sdl(sdl) == sdl
schema = build_schema(sdl)
my_enum = assert_enum_type(schema.get_type("MyEnum"))
value = my_enum.values["VALUE"]
assert value.is_deprecated is False
old_value = my_enum.values["OLD_VALUE"]
assert old_value.is_deprecated is True
assert old_value.deprecation_reason == "No longer supported"
other_value = my_enum.values["OTHER_VALUE"]
assert other_value.is_deprecated is True
assert other_value.deprecation_reason == "Terrible reasons"
root_fields = assert_object_type(schema.get_type("Query")).fields
field1 = root_fields["field1"]
assert field1.is_deprecated is True
assert field1.deprecation_reason == "No longer supported"
field2 = root_fields["field2"]
assert field2.is_deprecated is True
assert field2.deprecation_reason == "Because I said so"
def builds_types_with_deprecated_fields_and_values():
extended_schema = extend_test_schema("""
type TypeWithDeprecatedField {
newDeprecatedField: String @deprecated(reason: "not used anymore")
}
enum EnumWithDeprecatedValue {
DEPRECATED @deprecated(reason: "do not use")
}
""")
deprecated_field_def = assert_object_type(
extended_schema.get_type(
"TypeWithDeprecatedField")).fields["newDeprecatedField"]
assert deprecated_field_def.is_deprecated is True
assert deprecated_field_def.deprecation_reason == "not used anymore"
deprecated_enum_def = assert_enum_type(
extended_schema.get_type(
"EnumWithDeprecatedValue")).values["DEPRECATED"]
assert deprecated_enum_def.is_deprecated is True
assert deprecated_enum_def.deprecation_reason == "do not use"
def correctly_assigns_ast_nodes_to_new_and_extended_types():
schema = build_schema("""
type Query
scalar SomeScalar
enum SomeEnum
union SomeUnion
input SomeInput
type SomeObject
interface SomeInterface
directive @foo on SCALAR
""")
first_extension_ast = parse("""
extend type Query {
newField(testArg: TestInput): TestEnum
}
extend scalar SomeScalar @foo
extend enum SomeEnum {
NEW_VALUE
}
extend union SomeUnion = SomeObject
extend input SomeInput {
newField: String
}
extend interface SomeInterface {
newField: String
}
enum TestEnum {
TEST_VALUE
}
input TestInput {
testInputField: TestEnum
}
""")
extended_schema = extend_schema(schema, first_extension_ast)
second_extension_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,
second_extension_ast)
extend_in_one_go_schema = extend_schema(
schema, concat_ast([first_extension_ast, second_extension_ast]))
assert print_schema(extend_in_one_go_schema) == print_schema(
extended_twice_schema)
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
assert {
test_input.ast_node,
test_enum.ast_node,
test_union.ast_node,
test_interface.ast_node,
test_type.ast_node,
test_directive.ast_node,
*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,
} == {
*first_extension_ast.definitions, *second_extension_ast.definitions
}
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 print_ast_node(new_value) == "NEW_VALUE"
one_more_new_value = some_enum.values["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 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"
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"
def returns_true_for_object_type():
assert is_object_type(ObjectType) is True
assert_object_type(ObjectType)
def supports_deprecated_directive():
sdl = dedent(
"""
enum MyEnum {
VALUE
OLD_VALUE @deprecated
OTHER_VALUE @deprecated(reason: "Terrible reasons")
}
input MyInput {
oldInput: String @deprecated
otherInput: String @deprecated(reason: "Use newInput")
newInput: String
}
type Query {
field1: String @deprecated
field2: Int @deprecated(reason: "Because I said so")
enum: MyEnum
field3(oldArg: String @deprecated, arg: String): String
field4(oldArg: String @deprecated(reason: "Why not?"), arg: String): String
field5(arg: MyInput): String
}
""" # noqa: E501
)
assert cycle_sdl(sdl) == sdl
schema = build_schema(sdl)
my_enum = assert_enum_type(schema.get_type("MyEnum"))
value = my_enum.values["VALUE"]
assert value.deprecation_reason is None
old_value = my_enum.values["OLD_VALUE"]
assert old_value.deprecation_reason == "No longer supported"
other_value = my_enum.values["OTHER_VALUE"]
assert other_value.deprecation_reason == "Terrible reasons"
root_fields = assert_object_type(schema.get_type("Query")).fields
field1 = root_fields["field1"]
assert field1.deprecation_reason == "No longer supported"
field2 = root_fields["field2"]
assert field2.deprecation_reason == "Because I said so"
input_fields = assert_input_object_type(schema.get_type("MyInput")).fields
new_input = input_fields["newInput"]
assert new_input.deprecation_reason is None
old_input = input_fields["oldInput"]
assert old_input.deprecation_reason == "No longer supported"
other_input = input_fields["otherInput"]
assert other_input.deprecation_reason == "Use newInput"
field3_old_arg = root_fields["field3"].args["oldArg"]
assert field3_old_arg.deprecation_reason == "No longer supported"
field4_old_arg = root_fields["field4"].args["oldArg"]
assert field4_old_arg.deprecation_reason == "Why not?"
def correctly_assign_ast_nodes():
sdl = dedent("""
schema {
query: Query
}
type Query {
testField(testArg: TestInput): TestUnion
}
input TestInput {
testInputField: TestEnum
}
enum TestEnum {
TEST_VALUE
}
union TestUnion = TestType
interface TestInterface {
interfaceField: String
}
type TestType implements TestInterface {
interfaceField: String
}
scalar TestScalar
directive @test(arg: TestScalar) on FIELD
""")
schema = build_schema(sdl)
query = assert_object_type(schema.get_type("Query"))
test_input = assert_input_object_type(schema.get_type("TestInput"))
test_enum = assert_enum_type(schema.get_type("TestEnum"))
test_union = assert_union_type(schema.get_type("TestUnion"))
test_interface = assert_interface_type(
schema.get_type("TestInterface"))
test_type = assert_object_type(schema.get_type("TestType"))
test_scalar = assert_scalar_type(schema.get_type("TestScalar"))
test_directive = assert_directive(schema.get_directive("test"))
restored_schema_ast = DocumentNode(definitions=[
schema.ast_node,
query.ast_node,
test_input.ast_node,
test_enum.ast_node,
test_union.ast_node,
test_interface.ast_node,
test_type.ast_node,
test_scalar.ast_node,
test_directive.ast_node,
])
assert print_ast(restored_schema_ast) == sdl
test_field = query.fields["testField"]
assert print_ast(test_field.ast_node) == (
"testField(testArg: TestInput): TestUnion")
assert print_ast(
test_field.args["testArg"].ast_node) == "testArg: TestInput"
assert print_ast(test_input.fields["testInputField"].ast_node) == (
"testInputField: TestEnum")
test_enum_value = test_enum.values["TEST_VALUE"]
assert test_enum_value
assert print_ast(test_enum_value.ast_node) == "TEST_VALUE"
assert print_ast(test_interface.fields["interfaceField"].ast_node) == (
"interfaceField: String")
assert print_ast(
test_directive.args["arg"].ast_node) == "arg: TestScalar"
def returns_false_for_wrapped_object_type():
assert is_object_type(GraphQLList(ObjectType)) is False
with raises(TypeError):
assert_object_type(GraphQLList(ObjectType))
def correctly_assign_ast_nodes():
sdl = dedent(
"""
schema {
query: Query
}
type Query {
testField(testArg: TestInput): TestUnion
}
input TestInput {
testInputField: TestEnum
}
enum TestEnum {
TEST_VALUE
}
union TestUnion = TestType
interface TestInterface {
interfaceField: String
}
type TestType implements TestInterface {
interfaceField: String
}
scalar TestScalar
directive @test(arg: TestScalar) on FIELD
"""
)
ast = parse(sdl, no_location=True)
schema = build_ast_schema(ast)
query = assert_object_type(schema.get_type("Query"))
test_input = assert_input_object_type(schema.get_type("TestInput"))
test_enum = assert_enum_type(schema.get_type("TestEnum"))
test_union = assert_union_type(schema.get_type("TestUnion"))
test_interface = assert_interface_type(schema.get_type("TestInterface"))
test_type = assert_object_type(schema.get_type("TestType"))
test_scalar = assert_scalar_type(schema.get_type("TestScalar"))
test_directive = assert_directive(schema.get_directive("test"))
assert (
schema.ast_node,
query.ast_node,
test_input.ast_node,
test_enum.ast_node,
test_union.ast_node,
test_interface.ast_node,
test_type.ast_node,
test_scalar.ast_node,
test_directive.ast_node,
) == ast.definitions
test_field = query.fields["testField"]
expect_ast_node(test_field, "testField(testArg: TestInput): TestUnion")
expect_ast_node(test_field.args["testArg"], "testArg: TestInput")
expect_ast_node(test_input.fields["testInputField"], "testInputField: TestEnum")
test_enum_value = test_enum.values["TEST_VALUE"]
expect_ast_node(test_enum_value, "TEST_VALUE")
expect_ast_node(
test_interface.fields["interfaceField"], "interfaceField: String"
)
expect_ast_node(test_directive.args["arg"], "arg: TestScalar")
