def check_selection_node():
assert not is_selection_node(Node())
assert not is_selection_node(DocumentNode())
assert is_selection_node(SelectionNode())
assert is_selection_node(FieldNode())
assert is_selection_node(InlineFragmentNode())
assert not is_selection_node(SelectionSetNode())
def check_value_node():
assert not is_value_node(Node())
assert not is_value_node(DocumentNode())
assert is_value_node(ValueNode())
assert is_value_node(IntValueNode())
assert is_value_node(ObjectValueNode())
assert not is_value_node(TypeNode())
def check_type_extension_node():
assert not is_type_extension_node(Node())
assert not is_type_extension_node(DocumentNode())
assert is_type_extension_node(TypeExtensionNode())
assert not is_type_extension_node(ScalarTypeDefinitionNode())
assert is_type_extension_node(ScalarTypeExtensionNode())
assert not is_type_extension_node(DefinitionNode())
assert not is_type_extension_node(TypeNode())
def check_type_system_extension_node():
assert not is_type_system_extension_node(Node())
assert not is_type_system_extension_node(DocumentNode())
assert is_type_system_extension_node(SchemaExtensionNode())
assert is_type_system_extension_node(TypeExtensionNode())
assert not is_type_system_extension_node(TypeSystemDefinitionNode())
assert not is_type_system_extension_node(DefinitionNode())
assert not is_type_system_extension_node(TypeNode())
def check_type_definition_node():
assert not is_type_definition_node(Node())
assert not is_type_definition_node(DocumentNode())
assert is_type_definition_node(TypeDefinitionNode())
assert is_type_definition_node(ScalarTypeDefinitionNode())
assert not is_type_definition_node(TypeSystemDefinitionNode())
assert not is_type_definition_node(DefinitionNode())
assert not is_type_definition_node(TypeNode())
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)))
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 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 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) on FIELD | SCALAR
""")
extended_twice_schema = extend_schema(extended_schema, ast)
query = extended_twice_schema.get_type("Query")
some_scalar = extended_twice_schema.get_type("SomeScalar")
some_enum = extended_twice_schema.get_type("SomeEnum")
some_union = extended_twice_schema.get_type("SomeUnion")
some_input = extended_twice_schema.get_type("SomeInput")
some_interface = extended_twice_schema.get_type("SomeInterface")
test_input = extended_twice_schema.get_type("TestInput")
test_enum = extended_twice_schema.get_type("TestEnum")
test_union = extended_twice_schema.get_type("TestUnion")
test_interface = extended_twice_schema.get_type("TestInterface")
test_type = extended_twice_schema.get_type("TestType")
test_directive = extended_twice_schema.get_directive("test")
assert len(query.extension_ast_nodes) == 2
assert len(some_scalar.extension_ast_nodes) == 2
assert len(some_enum.extension_ast_nodes) == 2
assert len(some_union.extension_ast_nodes) == 2
assert len(some_input.extension_ast_nodes) == 2
assert len(some_interface.extension_ast_nodes) == 2
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
restored_extension_ast = DocumentNode(definitions=[
*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,
test_input.ast_node,
test_enum.ast_node,
test_union.ast_node,
test_interface.ast_node,
test_type.ast_node,
test_directive.ast_node,
])
assert print_schema(extend_schema(
test_schema,
restored_extension_ast)) == print_schema(extended_twice_schema)
new_field = query.fields["newField"]
assert print_ast(
new_field.ast_node) == "newField(testArg: TestInput): TestEnum"
assert print_ast(
new_field.args["testArg"].ast_node) == "testArg: TestInput"
assert (print_ast(query.fields["oneMoreNewField"].ast_node) ==
"oneMoreNewField: TestUnion")
assert print_ast(some_enum.values["NEW_VALUE"].ast_node) == "NEW_VALUE"
assert (print_ast(some_enum.values["ONE_MORE_NEW_VALUE"].ast_node) ==
"ONE_MORE_NEW_VALUE")
assert print_ast(
some_input.fields["newField"].ast_node) == "newField: String"
assert (print_ast(some_input.fields["oneMoreNewField"].ast_node) ==
"oneMoreNewField: String")
assert (print_ast(
some_interface.fields["newField"].ast_node) == "newField: String")
assert (print_ast(some_interface.fields["oneMoreNewField"].ast_node) ==
"oneMoreNewField: String")
assert (print_ast(test_input.fields["testInputField"].ast_node) ==
"testInputField: TestEnum")
assert print_ast(
test_enum.values["TEST_VALUE"].ast_node) == "TEST_VALUE"
assert (print_ast(test_interface.fields["interfaceField"].ast_node) ==
"interfaceField: String")
assert (print_ast(test_type.fields["interfaceField"].ast_node) ==
"interfaceField: String")
assert print_ast(test_directive.args["arg"].ast_node) == "arg: Int"
def print_extension_nodes(obj: TypeWithExtensionAstNodes) -> str:
assert obj is not None and obj.extension_ast_nodes is not None
return print_ast(DocumentNode(definitions=obj.extension_ast_nodes))
def check_type_node():
assert not is_type_node(Node())
assert not is_type_node(DocumentNode())
assert not is_type_node(ValueNode())
assert is_type_node(TypeNode())
assert is_type_node(NonNullTypeNode())
def check_exectuable_definition_node():
assert not is_executable_definition_node(Node())
assert not is_executable_definition_node(DocumentNode())
assert not is_executable_definition_node(DefinitionNode())
assert is_executable_definition_node(ExecutableDefinitionNode())
assert not is_executable_definition_node(TypeSystemDefinitionNode())
def correctly_assign_ast_nodes():
schema_ast = parse(
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_ast_schema(schema_ast)
query = schema.get_type('Query')
query = cast(GraphQLObjectType, query)
test_input = schema.get_type('TestInput')
test_input = cast(GraphQLInputObjectType, test_input)
test_enum = schema.get_type('TestEnum')
test_enum = cast(GraphQLEnumType, test_enum)
test_union = schema.get_type('TestUnion')
test_interface = schema.get_type('TestInterface')
test_interface = cast(GraphQLInterfaceType, test_interface)
test_type = schema.get_type('TestType')
test_scalar = schema.get_type('TestScalar')
test_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) == print_ast(schema_ast)
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')
assert print_ast(
test_enum.values['TEST_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 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) on FIELD | SCALAR
""")
extended_twice_schema = extend_schema(extended_schema, ast)
query = extended_twice_schema.get_type('Query')
some_scalar = extended_twice_schema.get_type('SomeScalar')
some_enum = extended_twice_schema.get_type('SomeEnum')
some_union = extended_twice_schema.get_type('SomeUnion')
some_input = extended_twice_schema.get_type('SomeInput')
some_interface = extended_twice_schema.get_type('SomeInterface')
test_input = extended_twice_schema.get_type('TestInput')
test_enum = extended_twice_schema.get_type('TestEnum')
test_union = extended_twice_schema.get_type('TestUnion')
test_interface = extended_twice_schema.get_type('TestInterface')
test_type = extended_twice_schema.get_type('TestType')
test_directive = extended_twice_schema.get_directive('test')
assert len(query.extension_ast_nodes) == 2
assert len(some_scalar.extension_ast_nodes) == 2
assert len(some_enum.extension_ast_nodes) == 2
assert len(some_union.extension_ast_nodes) == 2
assert len(some_input.extension_ast_nodes) == 2
assert len(some_interface.extension_ast_nodes) == 2
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
restored_extension_ast = DocumentNode(
definitions=[
*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,
test_input.ast_node,
test_enum.ast_node,
test_union.ast_node,
test_interface.ast_node,
test_type.ast_node,
test_directive.ast_node])
assert print_schema(
extend_schema(test_schema, restored_extension_ast)
) == print_schema(extended_twice_schema)
new_field = query.fields['newField']
assert print_ast(
new_field.ast_node) == 'newField(testArg: TestInput): TestEnum'
assert print_ast(
new_field.args['testArg'].ast_node) == 'testArg: TestInput'
assert print_ast(
query.fields['oneMoreNewField'].ast_node
) == 'oneMoreNewField: TestUnion'
assert print_ast(some_enum.values['NEW_VALUE'].ast_node) == 'NEW_VALUE'
assert print_ast(some_enum.values[
'ONE_MORE_NEW_VALUE'].ast_node) == 'ONE_MORE_NEW_VALUE'
assert print_ast(some_input.fields[
'newField'].ast_node) == 'newField: String'
assert print_ast(some_input.fields[
'oneMoreNewField'].ast_node) == 'oneMoreNewField: String'
assert print_ast(some_interface.fields[
'newField'].ast_node) == 'newField: String'
assert print_ast(some_interface.fields[
'oneMoreNewField'].ast_node) == 'oneMoreNewField: String'
assert print_ast(
test_input.fields['testInputField'].ast_node
) == 'testInputField: TestEnum'
assert print_ast(
test_enum.values['TEST_VALUE'].ast_node) == 'TEST_VALUE'
assert print_ast(
test_interface.fields['interfaceField'].ast_node
) == 'interfaceField: String'
assert print_ast(
test_type.fields['interfaceField'].ast_node
) == 'interfaceField: String'
assert print_ast(test_directive.args['arg'].ast_node) == 'arg: Int'
def match_order_of_default_types_and_directives():
schema = GraphQLSchema()
sdl_schema = build_ast_schema(DocumentNode(definitions=[]))
assert sdl_schema.directives == schema.directives
assert sdl_schema.type_map == schema.type_map
def correctly_assign_ast_nodes():
schema_ast = parse(
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_ast_schema(schema_ast)
query = schema.get_type("Query")
query = cast(GraphQLObjectType, query)
test_input = schema.get_type("TestInput")
test_input = cast(GraphQLInputObjectType, test_input)
test_enum = schema.get_type("TestEnum")
test_enum = cast(GraphQLEnumType, test_enum)
test_union = schema.get_type("TestUnion")
test_interface = schema.get_type("TestInterface")
test_interface = cast(GraphQLInterfaceType, test_interface)
test_type = schema.get_type("TestType")
test_scalar = schema.get_type("TestScalar")
test_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) == print_ast(schema_ast)
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")
assert print_ast(
test_enum.values["TEST_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"
