def object_type_definition(self, tree: Tree) -> GraphQLObjectType:
     # TODO: Add directives
     description = None
     ast_node = None  # TODO: Should we discard it or keep it ?
     name = None
     interfaces = None
     fields = None
     for child in tree.children:
         if child.type == 'description':
             description = child.value
         elif child.type == 'TYPE':
             ast_node = child
         elif child.type == 'IDENT':
             name = String(str(child.value), ast_node=child)
         elif child.type == 'interfaces':
             interfaces = child.value
         elif child.type == 'fields':
             fields = child.value
         elif child.type == 'discard':
             pass
         else:
             raise UnexpectedASTNode(
                 "Unexpected AST node `{}`, type `{}`".format(
                     child, child.__class__.__name__))
     return GraphQLObjectType(
         name=name,
         fields=fields,
         interfaces=interfaces,
         description=description,
     )
 def object_type_definition(self, tree: Tree) -> GraphQLObjectType:
     # TODO: Add directives
     description = None
     name = None
     interfaces = None
     fields = None
     for child in tree.children:
         if child.type == "description":
             description = child.value
         elif child.type == "IDENT":
             name = child.value
         elif child.type == "interfaces":
             interfaces = child.value
         elif child.type == "fields":
             fields = child.value
         elif child.type == "discard" or child.type == "TYPE":
             pass
         else:
             raise UnexpectedASTNode(
                 "Unexpected AST node `{}`, type `{}`".format(
                     child, child.__class__.__name__))
     return GraphQLObjectType(
         name=name,
         fields=fields,
         interfaces=interfaces,
         description=description,
         schema=self._schema,
     )
Example #3
0
def parse_object_type_definition(
    object_type_definition_node: "ObjectTypeDefinitionNode",
    schema: "GraphQLSchema",
) -> Optional["GraphQLObjectType"]:
    """
    Computes an AST object type definition node into a GraphQLObjectType
    instance.
    :param object_type_definition_node: AST object type definition node to
    treat
    :param schema: the GraphQLSchema instance linked to the engine
    :type object_type_definition_node: ObjectTypeDefinitionNode
    :type schema: GraphQLSchema
    :return: the GraphQLObjectType instance
    :rtype: Optional[GraphQLObjectType]
    """
    if not object_type_definition_node:
        return None

    object_type = GraphQLObjectType(
        name=parse_name(object_type_definition_node.name, schema),
        description=parse_name(object_type_definition_node.description,
                               schema),
        interfaces=parse_implements_interfaces(
            object_type_definition_node.interfaces, schema),
        fields=parse_fields_definition(object_type_definition_node.fields,
                                       schema),
        directives=object_type_definition_node.directives,
    )
    schema.add_type_definition(object_type)
    return object_type
Example #4
0
def test_graphql_object_init(mocked_resolver_factory):
    obj = GraphQLObjectType(
        name="Name",
        fields=OrderedDict([
            ("test", GraphQLField(name="arg", gql_type="Int")),
            ("another", GraphQLField(name="arg", gql_type="String")),
        ]),
        interfaces=["First", "Second"],
        description="description",
    )

    assert obj.name == "Name"
    assert obj.find_field("test") == GraphQLField(name="arg", gql_type="Int")
    assert obj.find_field("another") == GraphQLField(name="arg",
                                                     gql_type="String")
    assert obj.interfaces_names == ["First", "Second"]
    assert obj.description == "description"
Example #5
0
def test_graphql_object_repr():
    obj = GraphQLObjectType(name="Name",
                            fields=OrderedDict([
                                ("test",
                                 GraphQLField(name="arg", gql_type="Int")),
                                ("another",
                                 GraphQLField(name="arg", gql_type="String")),
                            ]),
                            interfaces=["First", "Second"],
                            description="description")

    assert obj.__repr__() == "GraphQLObjectType(" \
                             "name='Name', " \
                             "fields=OrderedDict([" \
                                "('test', GraphQLField(name='arg', " \
                                    "gql_type='Int', arguments=OrderedDict(), " \
                                    "resolver=None, description=None)), " \
                                "('another', GraphQLField(name='arg', " \
                                    "gql_type='String', arguments=OrderedDict(), " \
                                    "resolver=None, description=None))]), " \
                             "interfaces=['First', 'Second'], " \
                             "description='description')"
    assert obj == eval(repr(obj))
Example #6
0
async def test_build_schema(monkeypatch, clean_registry):
    from tartiflette.resolver.factory import ResolverExecutorFactory
    from tartiflette.engine import _import_builtins

    resolver_excutor = Mock()
    monkeypatch.setattr(
        ResolverExecutorFactory,
        "get_resolver_executor",
        Mock(return_value=resolver_excutor),
    )

    from tartiflette.schema.bakery import SchemaBakery
    from tartiflette.types.argument import GraphQLArgument
    from tartiflette.types.field import GraphQLField
    from tartiflette.types.input_object import GraphQLInputObjectType
    from tartiflette.types.interface import GraphQLInterfaceType
    from tartiflette.types.list import GraphQLList
    from tartiflette.types.non_null import GraphQLNonNull
    from tartiflette.types.object import GraphQLObjectType
    from tartiflette.types.union import GraphQLUnionType

    schema_sdl = """
    schema @enable_cache {
        query: RootQuery
        mutation: RootMutation
        subscription: RootSubscription
    }

    union Group = Foo | Bar | Baz

    interface Something {
        oneField: [Int]
        anotherField: [String]
        aLastOne: [[Date!]]!
    }

    input UserInfo {
        name: String
        dateOfBirth: [Date]
        graphQLFan: Boolean!
    }

    # directive @partner(goo: Anything) on ENUM_VALUE

    \"\"\"
    This is a docstring for the Test Object Type.
    \"\"\"
    type Test implements Unknown & Empty{
        \"\"\"
        This is a field description :D
        \"\"\"
        field(input: InputObject): String!
        anotherField: [Int]
        fieldWithDefaultValueArg(test: String = "default"): ID
        simpleField: Date
    }
    """
    _, schema_sdl = await _import_builtins([], schema_sdl, "G")
    _, schema_E = await _import_builtins([], "", "E")
    clean_registry.register_sdl("G", schema_sdl)
    clean_registry.register_sdl("E", schema_E)
    generated_schema = SchemaBakery._preheat("G")
    expected_schema = SchemaBakery._preheat("E")
    expected_schema.query_type = "RootQuery"
    expected_schema.mutation_type = "RootMutation"
    expected_schema.subscription_type = "RootSubscription"

    expected_schema.add_definition(
        GraphQLUnionType(name="Group", gql_types=["Foo", "Bar", "Baz"]))
    expected_schema.add_definition(
        GraphQLInterfaceType(
            name="Something",
            fields=OrderedDict(
                oneField=GraphQLField(name="oneField",
                                      gql_type=GraphQLList(gql_type="Int")),
                anotherField=GraphQLField(
                    name="anotherField",
                    gql_type=GraphQLList(gql_type="String"),
                ),
                aLastOne=GraphQLField(
                    name="aLastOne",
                    gql_type=GraphQLNonNull(gql_type=GraphQLList(
                        gql_type=GraphQLList(gql_type=GraphQLNonNull(
                            gql_type="Date")))),
                ),
            ),
        ))
    expected_schema.add_definition(
        GraphQLInputObjectType(
            name="UserInfo",
            fields=OrderedDict([
                ("name", GraphQLArgument(name="name", gql_type="String")),
                (
                    "dateOfBirth",
                    GraphQLArgument(
                        name="dateOfBirth",
                        gql_type=GraphQLList(gql_type="Date"),
                    ),
                ),
                (
                    "graphQLFan",
                    GraphQLArgument(
                        name="graphQLFan",
                        gql_type=GraphQLNonNull(gql_type="Boolean"),
                    ),
                ),
            ]),
        ))
    expected_schema.add_definition(
        GraphQLObjectType(
            name="Test",
            fields=OrderedDict([
                (
                    "field",
                    GraphQLField(
                        name="field",
                        gql_type=GraphQLNonNull(gql_type="String"),
                        arguments=OrderedDict(input=GraphQLArgument(
                            name="input", gql_type="InputObject")),
                    ),
                ),
                (
                    "anotherField",
                    GraphQLField(
                        name="anotherField",
                        gql_type=GraphQLList(gql_type="Int"),
                    ),
                ),
                (
                    "fieldWithDefaultValueArg",
                    GraphQLField(
                        name="fieldWithDefaultValueArg",
                        gql_type="ID",
                        arguments=OrderedDict(test=GraphQLArgument(
                            name="test",
                            gql_type="String",
                            default_value="default",
                        )),
                    ),
                ),
                (
                    "simpleField",
                    GraphQLField(name="simpleField", gql_type="Date"),
                ),
            ]),
            interfaces=["Unknown", "Empty"],
        ))

    assert 5 < len(generated_schema._gql_types)
    assert len(expected_schema._gql_types) == len(generated_schema._gql_types)

    monkeypatch.undo()
Example #7
0
def test_build_schema():
    schema_sdl = """
    schema @enable_cache {
        query: RootQuery
        mutation: RootMutation
        subscription: RootSubscription
    }
    
    scalar Date
    
    union Group = Foo | Bar | Baz
    
    interface Something {
        oneField: [Int]
        anotherField: [String]
        aLastOne: [[Date!]]!
    }
    
    input UserInfo {
        name: String
        dateOfBirth: [Date]
        graphQLFan: Boolean!
    }
    
    # directive @partner(goo: Anything) on ENUM_VALUE
    
    \"\"\"
    This is a docstring for the Test Object Type.
    \"\"\"
    type Test implements Unknown & Empty @enable_cache {
        \"\"\"
        This is a field description :D
        \"\"\"
        field(input: InputObject): String! @deprecated(reason: "Useless field")
        anotherField: [Int] @something(
            lst: ["about" "stuff"]
            obj: {some: [4, 8, 16], complex: {about: 19.4}, another: EnumVal}
        )
        fieldWithDefaultValueArg(test: String = "default"): ID
        simpleField: Date
    }
    """

    generated_schema = build_graphql_schema_from_sdl(schema_sdl,
                                                     schema=GraphQLSchema())

    expected_schema = GraphQLSchema()
    expected_schema.query_type = "RootQuery"
    expected_schema.mutation_type = "RootMutation"
    expected_schema.subscription_type = "RootSubscription"

    expected_schema.add_definition(GraphQLScalarType(name="Date"))
    expected_schema.add_definition(GraphQLUnionType(name="Group", gql_types=[
        "Foo",
        "Bar",
        "Baz",
    ]))
    expected_schema.add_definition(GraphQLInterfaceType(name="Something", fields=OrderedDict(
        oneField=GraphQLField(name="oneField", gql_type=GraphQLList(gql_type="Int")),
        anotherField=GraphQLField(name="anotherField", gql_type=GraphQLList(gql_type="String")),
        aLastOne=GraphQLField(name="aLastOne", gql_type=GraphQLNonNull(gql_type=GraphQLList(gql_type=GraphQLList(gql_type=GraphQLNonNull(gql_type="Date"))))),
    )))
    expected_schema.add_definition(GraphQLInputObjectType(name="UserInfo", fields=OrderedDict([
        ('name', GraphQLArgument(name="name", gql_type="String")),
        ('dateOfBirth', GraphQLArgument(name="dateOfBirth", gql_type=GraphQLList(gql_type="Date"))),
        ('graphQLFan', GraphQLArgument(name="graphQLFan", gql_type=GraphQLNonNull(gql_type="Boolean"))),
    ])))
    expected_schema.add_definition(GraphQLObjectType(name="Test", fields=OrderedDict([
        ('field', GraphQLField(name="field", gql_type=GraphQLNonNull(gql_type="String"), arguments=OrderedDict(
            input=GraphQLArgument(name="input", gql_type="InputObject"),
        ))),
        ('anotherField', GraphQLField(name="anotherField", gql_type=GraphQLList(gql_type="Int"))),
        ('fieldWithDefaultValueArg', GraphQLField(name="fieldWithDefaultValueArg", gql_type="ID", arguments=OrderedDict(
            test=GraphQLArgument(name="test", gql_type="String", default_value="default"),
        ))),
        ('simpleField', GraphQLField(name="simpleField", gql_type="Date")),
    ]),
                                                               interfaces=[
                                                                   "Unknown",
                                                                   "Empty",
                                                               ]))

    assert expected_schema == generated_schema
    assert len(generated_schema._gql_types) > 5
    assert len(generated_schema._gql_types) == len(expected_schema._gql_types)
    # Only the default types should be in the schema
    assert len(DefaultGraphQLSchema._gql_types) == 5
Example #8
0
def test_graphql_object_eq():
    obj = GraphQLObjectType(name="Name",
                            fields=OrderedDict([
                                ("test",
                                 GraphQLField(name="arg", gql_type="Int")),
                                ("another",
                                 GraphQLField(name="arg", gql_type="String")),
                            ]),
                            interfaces=["First", "Second"],
                            description="description")

    ## Same
    assert obj == obj
    assert obj == GraphQLObjectType(name="Name",
                                    fields=OrderedDict([
                                        ("test",
                                         GraphQLField(name="arg",
                                                      gql_type="Int")),
                                        ("another",
                                         GraphQLField(name="arg",
                                                      gql_type="String")),
                                    ]),
                                    interfaces=["First", "Second"],
                                    description="description")
    # Currently we ignore the description in comparing
    assert obj == GraphQLObjectType(name="Name",
                                    fields=OrderedDict([
                                        ("test",
                                         GraphQLField(name="arg",
                                                      gql_type="Int")),
                                        ("another",
                                         GraphQLField(name="arg",
                                                      gql_type="String")),
                                    ]),
                                    interfaces=["First", "Second"])

    ## Different
    assert obj != GraphQLObjectType(
        name="Name",
        fields=OrderedDict([
            ("another", GraphQLField(name="arg", gql_type="String")),
            ("test", GraphQLField(name="arg", gql_type="Int")),
            # We reversed the fields
        ]),
        interfaces=["First", "Second"])
    assert obj != GraphQLObjectType(
        name="Name",
        fields=OrderedDict([
            ("test", GraphQLField(name="arg", gql_type="Int")),
            ("another", GraphQLField(name="arg", gql_type="String")),
        ]),
        interfaces=[
            "Second"
            "First",
            # We reversed the interface fields
        ],
        description="description")
    assert obj != GraphQLObjectType(
        name="Name", fields=OrderedDict(), interfaces=["First", "Second"])
    assert obj != GraphQLObjectType(
        name="Name",
        fields=OrderedDict([
            ("test", GraphQLField(name="arg", gql_type="Int")),
            ("another", GraphQLField(name="arg", gql_type="String")),
        ]),
        interfaces=[])
    assert obj != GraphQLObjectType(
        name="OtherName",
        fields=OrderedDict([
            ("test", GraphQLField(name="arg", gql_type="Int")),
            ("another", GraphQLField(name="arg", gql_type="String")),
        ]),
        interfaces=["First", "Second"],
        description="description")
     ],
 ),
 (
     """
     type Car implements Vehicle {
         modelName: String
         speedInKmh: Float
     }
     """,
     [
         Tree('type_definition', [
             GraphQLObjectType(
                 name="Car",
                 fields=OrderedDict([
                     ("modelName",
                      GraphQLField(name="modelName", gql_type="String")),
                     ("speedInKmh",
                      GraphQLField(name="speedInKmh", gql_type="Float")),
                 ]),
                 interfaces=["Vehicle"]),
         ])
     ],
 ),
 (
     """
     schema {
         query: RootQuery
         mutation: RootMutation
         subscription: RootSubscription
     }
     """,