back to OpenHands summary

OpenHands: graphene

Pytest Summary for test graphene

status	count
failed	229
passed	83
total	312
collected	312

Failed pytests:

test_connection.py::test_connection

test_connection.py::test_connection

def test_connection():
        class MyObjectConnection(Connection):
            extra = String()

            class Meta:
                node = MyObject

            class Edge:
                other = String()

        assert MyObjectConnection._meta.name == "MyObjectConnection"
        fields = MyObjectConnection._meta.fields
        assert list(fields) == ["page_info", "edges", "extra"]
        edge_field = fields["edges"]
        pageinfo_field = fields["page_info"]

        assert isinstance(edge_field, Field)
>       assert isinstance(edge_field.type, NonNull)
E       AttributeError: 'Field' object has no attribute 'type'

graphene/relay/tests/test_connection.py:40: AttributeError

test_connection.py::test_connection_extra_abstract_fields

test_connection.py::test_connection_extra_abstract_fields

def test_connection_extra_abstract_fields():
        class ConnectionWithNodes(Connection):
            class Meta:
                abstract = True

            @classmethod
            def __init_subclass_with_meta__(cls, node=None, name=None, **options):
                _meta = ConnectionOptions(cls)

                _meta.fields = {
                    "nodes": Field(
                        NonNull(List(node)),
                        description="Contains all the nodes in this connection.",
                    ),
                }

                return super(ConnectionWithNodes, cls).__init_subclass_with_meta__(
                    node=node, name=name, _meta=_meta, **options
                )

        class MyObjectConnection(ConnectionWithNodes):
            class Meta:
                node = MyObject

            class Edge:
                other = String()

        assert MyObjectConnection._meta.name == "MyObjectConnection"
        fields = MyObjectConnection._meta.fields
        assert list(fields) == ["nodes", "page_info", "edges"]
        edge_field = fields["edges"]
        pageinfo_field = fields["page_info"]
        nodes_field = fields["nodes"]

        assert isinstance(edge_field, Field)
>       assert isinstance(edge_field.type, NonNull)
E       AttributeError: 'Field' object has no attribute 'type'

graphene/relay/tests/test_connection.py:97: AttributeError

test_connection.py::test_connection_override_fields

test_connection.py::test_connection_override_fields

def test_connection_override_fields():
        class ConnectionWithNodes(Connection):
            class Meta:
                abstract = True

            @classmethod
            def __init_subclass_with_meta__(cls, node=None, name=None, **options):
                _meta = ConnectionOptions(cls)
                base_name = (
                    re.sub("Connection$", "", name or cls.__name__) or node._meta.name
                )

                edge_class = get_edge_class(cls, node, base_name)

                _meta.fields = {
                    "page_info": Field(
                        NonNull(
                            PageInfo,
                            name="pageInfo",
                            required=True,
                            description="Pagination data for this connection.",
                        )
                    ),
                    "edges": Field(
                        NonNull(List(NonNull(edge_class))),
                        description="Contains the nodes in this connection.",
                    ),
                }

                return super(ConnectionWithNodes, cls).__init_subclass_with_meta__(
                    node=node, name=name, _meta=_meta, **options
                )

        class MyObjectConnection(ConnectionWithNodes):
            class Meta:
                node = MyObject

        assert MyObjectConnection._meta.name == "MyObjectConnection"
        fields = MyObjectConnection._meta.fields
        assert list(fields) == ["page_info", "edges"]
        edge_field = fields["edges"]
        pageinfo_field = fields["page_info"]

        assert isinstance(edge_field, Field)
>       assert isinstance(edge_field.type, NonNull)
E       AttributeError: 'Field' object has no attribute 'type'

graphene/relay/tests/test_connection.py:155: AttributeError

test_connection.py::test_edge

test_connection.py::test_edge

def test_edge():
        class MyObjectConnection(Connection):
            class Meta:
                node = MyObject

            class Edge:
                other = String()

        Edge = MyObjectConnection.Edge
>       assert Edge._meta.name == "MyObjectEdge"
E       AssertionError: assert 'EdgeBase' == 'MyObjectEdge'
E         
E         - MyObjectEdge
E         + EdgeBase

graphene/relay/tests/test_connection.py:190: AssertionError

test_connection.py::test_edge_with_bases

test_connection.py::test_edge_with_bases

def test_edge_with_bases():
        class BaseEdge:
            extra = String()

        class MyObjectConnection(Connection):
            class Meta:
                node = MyObject

            class Edge(BaseEdge):
                other = String()

        Edge = MyObjectConnection.Edge
>       assert Edge._meta.name == "MyObjectEdge"
E       AssertionError: assert 'EdgeBase' == 'MyObjectEdge'
E         
E         - MyObjectEdge
E         + EdgeBase

graphene/relay/tests/test_connection.py:213: AssertionError

test_connection.py::test_edge_with_nonnull_node

test_connection.py::test_edge_with_nonnull_node

def test_edge_with_nonnull_node():
        class MyObjectConnection(Connection):
            class Meta:
                node = NonNull(MyObject)

        edge_fields = MyObjectConnection.Edge._meta.fields
        assert isinstance(edge_fields["node"], Field)
>       assert isinstance(edge_fields["node"].type, NonNull)
E       AttributeError: 'Field' object has no attribute 'type'

graphene/relay/tests/test_connection.py:231: AttributeError

test_connection.py::test_connectionfield

test_connection.py::test_connectionfield

def test_connectionfield():
        class MyObjectConnection(Connection):
            class Meta:
                node = MyObject

        field = ConnectionField(MyObjectConnection)
>       assert field.args == {
            "before": Argument(String),
            "after": Argument(String),
            "first": Argument(Int),
            "last": Argument(Int),
        }
E       AssertionError: assert [] == {'after': }
E         
E         Use -v to get more diff

graphene/relay/tests/test_connection.py:252: AssertionError

test_connection.py::test_connectionfield_node_deprecated

test_connection.py::test_connectionfield_node_deprecated

def test_connectionfield_node_deprecated():
        field = ConnectionField(MyObject)
        with raises(Exception) as exc_info:
            field.type

>       assert "ConnectionFields now need a explicit ConnectionType for Nodes." in str(
            exc_info.value
        )
E       assert 'ConnectionFields now need a explicit ConnectionType for Nodes.' in "'IterableConnectionField' object has no attribute 'type'"
E        +  where "'IterableConnectionField' object has no attribute 'type'" = str(AttributeError("'IterableConnectionField' object has no attribute 'type'"))
E        +    where AttributeError("'IterableConnectionField' object has no attribute 'type'") = .value

graphene/relay/tests/test_connection.py:265: AssertionError

test_connection.py::test_connectionfield_custom_args

test_connection.py::test_connectionfield_custom_args

def test_connectionfield_custom_args():
        class MyObjectConnection(Connection):
            class Meta:
                node = MyObject

        field = ConnectionField(
            MyObjectConnection, before=String(required=True), extra=String()
        )
>       assert field.args == {
            "before": Argument(NonNull(String)),
            "after": Argument(String),
            "first": Argument(Int),
            "last": Argument(Int),
            "extra": Argument(String),
        }
E       AssertionError: assert [] == {'after': , ...}
E         
E         Use -v to get more diff

graphene/relay/tests/test_connection.py:278: AssertionError

test_connection.py::test_connectionfield_required

test_connection.py::test_connectionfield_required

def test_connectionfield_required():
        class MyObjectConnection(Connection):
            class Meta:
                node = MyObject

        class Query(ObjectType):
            test_connection = ConnectionField(MyObjectConnection, required=True)

            def resolve_test_connection(root, info, **args):
                return []

>       schema = Schema(query=Query)

graphene/relay/tests/test_connection.py:298: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_connection.py::test_connectionfield_strict_types

test_connection.py::test_connectionfield_strict_types

def test_connectionfield_strict_types():
        class MyObjectConnection(Connection):
            class Meta:
                node = MyObject
                strict_types = True

        connection_field = ConnectionField(MyObjectConnection)
>       edges_field_type = connection_field.type._meta.fields["edges"].type
E       AttributeError: 'IterableConnectionField' object has no attribute 'type'

graphene/relay/tests/test_connection.py:311: AttributeError

test_custom_global_id.py::TestUUIDGlobalID::test_str_schema_correct

test_custom_global_id.py::TestUUIDGlobalID::test_str_schema_correct

self = 

    def test_str_schema_correct(self):
        """
        Check that the schema has the expected and custom node interface and user type and that they both use UUIDs
        """
>       parsed = re.findall(r"(.+) \{\n\s*([\w\W]*?)\n\}", str(self.schema))
E       AttributeError: 'TestUUIDGlobalID' object has no attribute 'schema'

graphene/relay/tests/test_custom_global_id.py:45: AttributeError

test_custom_global_id.py::TestUUIDGlobalID::test_get_by_id

test_custom_global_id.py::TestUUIDGlobalID::test_get_by_id

self = 

    def test_get_by_id(self):
        query = """query userById($id: UUID!) {
            user(id: $id) {
                id
                name
            }
        }"""
        # UUID need to be converted to string for serialization
        result = graphql_sync(
>           self.graphql_schema,
            query,
            variable_values={"id": str(self.user_list[0]["id"])},
        )
E       AttributeError: 'TestUUIDGlobalID' object has no attribute 'graphql_schema'

graphene/relay/tests/test_custom_global_id.py:70: AttributeError

test_custom_global_id.py::TestSimpleGlobalID::test_str_schema_correct

test_custom_global_id.py::TestSimpleGlobalID::test_str_schema_correct

self = 

    def test_str_schema_correct(self):
        """
        Check that the schema has the expected and custom node interface and user type and that they both use UUIDs
        """
>       parsed = re.findall(r"(.+) \{\n\s*([\w\W]*?)\n\}", str(self.schema))
E       AttributeError: 'TestSimpleGlobalID' object has no attribute 'schema'

graphene/relay/tests/test_custom_global_id.py:113: AttributeError

test_custom_global_id.py::TestSimpleGlobalID::test_get_by_id

test_custom_global_id.py::TestSimpleGlobalID::test_get_by_id

self = 

    def test_get_by_id(self):
        query = """query {
            user(id: "my global primary key in clear 3") {
                id
                name
            }
        }"""
>       result = graphql_sync(self.graphql_schema, query)
E       AttributeError: 'TestSimpleGlobalID' object has no attribute 'graphql_schema'

graphene/relay/tests/test_custom_global_id.py:136: AttributeError

test_custom_global_id.py::TestCustomGlobalID::test_str_schema_correct

test_custom_global_id.py::TestCustomGlobalID::test_str_schema_correct

self = 

    def test_str_schema_correct(self):
        """
        Check that the schema has the expected and custom node interface and user type and that they both use UUIDs
        """
>       parsed = re.findall(r"(.+) \{\n\s*([\w\W]*?)\n\}", str(self.schema))
E       AttributeError: 'TestCustomGlobalID' object has no attribute 'schema'

graphene/relay/tests/test_custom_global_id.py:192: AttributeError

test_custom_global_id.py::TestCustomGlobalID::test_get_by_id

test_custom_global_id.py::TestCustomGlobalID::test_get_by_id

self = 

    def test_get_by_id(self):
        query = """query {
            user(id: 2) {
                id
                name
            }
        }"""
>       result = graphql_sync(self.graphql_schema, query)
E       AttributeError: 'TestCustomGlobalID' object has no attribute 'graphql_schema'

graphene/relay/tests/test_custom_global_id.py:215: AttributeError

test_custom_global_id.py::TestIncompleteCustomGlobalID::test_must_define_to_global_id

test_custom_global_id.py::TestIncompleteCustomGlobalID::test_must_define_to_global_id

self = 

    def test_must_define_to_global_id(self):
        """
        Test that if the `to_global_id` method is not defined, we can query the object, but we can't request its ID.
        """

        class CustomGlobalIDType(BaseGlobalIDType):
            graphene_type = Int

            @classmethod
            def resolve_global_id(cls, info, global_id):
                _type = info.return_type.graphene_type._meta.name
                return _type, global_id

        class CustomNode(Node):
            class Meta:
                global_id_type = CustomGlobalIDType

        class User(ObjectType):
            class Meta:
                interfaces = [CustomNode]

            name = String()

            @classmethod
            def get_node(cls, _type, _id):
                return self.users[_id]

        class RootQuery(ObjectType):
            user = CustomNode.Field(User)

>       self.schema = Schema(query=RootQuery, types=[User])

graphene/relay/tests/test_custom_global_id.py:261: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None
types = [>], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_custom_global_id.py::TestIncompleteCustomGlobalID::test_must_define_resolve_global_id

test_custom_global_id.py::TestIncompleteCustomGlobalID::test_must_define_resolve_global_id

self = 

    def test_must_define_resolve_global_id(self):
        """
        Test that if the `resolve_global_id` method is not defined, we can't query the object by ID.
        """

        class CustomGlobalIDType(BaseGlobalIDType):
            graphene_type = Int

            @classmethod
            def to_global_id(cls, _type, _id):
                return _id

        class CustomNode(Node):
            class Meta:
                global_id_type = CustomGlobalIDType

        class User(ObjectType):
            class Meta:
                interfaces = [CustomNode]

            name = String()

            @classmethod
            def get_node(cls, _type, _id):
                return self.users[_id]

        class RootQuery(ObjectType):
            user = CustomNode.Field(User)

>       self.schema = Schema(query=RootQuery, types=[User])

graphene/relay/tests/test_custom_global_id.py:313: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None
types = [>], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_global_id.py::test_global_id_defaults_to_required_and_node

test_global_id.py::test_global_id_defaults_to_required_and_node

def test_global_id_defaults_to_required_and_node():
        gid = GlobalID()
>       assert isinstance(gid.type, NonNull)
E       AttributeError: 'GlobalID' object has no attribute 'type'

graphene/relay/tests/test_global_id.py:34: AttributeError

test_global_id.py::test_global_id_allows_overriding_of_node_and_required

test_global_id.py::test_global_id_allows_overriding_of_node_and_required

def test_global_id_allows_overriding_of_node_and_required():
        gid = GlobalID(node=CustomNode, required=False)
>       assert gid.type == ID
E       AttributeError: 'GlobalID' object has no attribute 'type'

graphene/relay/tests/test_global_id.py:41: AttributeError

test_global_id.py::test_global_id_defaults_to_info_parent_type

test_global_id.py::test_global_id_defaults_to_info_parent_type

def test_global_id_defaults_to_info_parent_type():
        my_id = "1"
        gid = GlobalID()
        id_resolver = gid.wrap_resolve(lambda *_: my_id)
>       my_global_id = id_resolver(None, Info(User))
E       TypeError: 'NoneType' object is not callable

graphene/relay/tests/test_global_id.py:49: TypeError

test_global_id.py::test_global_id_allows_setting_customer_parent_type

test_global_id.py::test_global_id_allows_setting_customer_parent_type

def test_global_id_allows_setting_customer_parent_type():
        my_id = "1"
        gid = GlobalID(parent_type=User)
        id_resolver = gid.wrap_resolve(lambda *_: my_id)
>       my_global_id = id_resolver(None, None)
E       TypeError: 'NoneType' object is not callable

graphene/relay/tests/test_global_id.py:57: TypeError

test_1293.py::test_schema_printable_with_default_datetime_value

test_1293.py::test_schema_printable_with_default_datetime_value

def test_schema_printable_with_default_datetime_value():
>       schema = graphene.Schema(query=Query, mutation=Mutations)

graphene/tests/issues/test_1293.py:39: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = >
subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[Date-"2022-02-02"]

test_1419.py::test_parse_literal_with_variables[Date-"2022-02-02"]

input_type = >
input_value = '"2022-02-02"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[GenericScalar-"foo"]

test_1419.py::test_parse_literal_with_variables[GenericScalar-"foo"]

input_type = >
input_value = '"foo"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[Int-1]

test_1419.py::test_parse_literal_with_variables[Int-1]

input_type = >, input_value = '1'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[BigInt-12345678901234567890]

test_1419.py::test_parse_literal_with_variables[BigInt-12345678901234567890]

input_type = >
input_value = '12345678901234567890'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[Float-1.1]

test_1419.py::test_parse_literal_with_variables[Float-1.1]

input_type = >, input_value = '1.1'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[String-"foo"]

test_1419.py::test_parse_literal_with_variables[String-"foo"]

input_type = >, input_value = '"foo"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[Boolean-true]

test_1419.py::test_parse_literal_with_variables[Boolean-true]

input_type = >, input_value = 'true'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[ID-1]

test_1419.py::test_parse_literal_with_variables[ID-1]

input_type = >, input_value = '1'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[DateTime-"2022-02-02T11:11:11"]

test_1419.py::test_parse_literal_with_variables[DateTime-"2022-02-02T11:11:11"]

input_type = >
input_value = '"2022-02-02T11:11:11"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[UUID-"cbebbc62-758e-4f75-a890-bc73b5017d81"]

test_1419.py::test_parse_literal_with_variables[UUID-"cbebbc62-758e-4f75-a890-bc73b5017d81"]

input_type = >
input_value = '"cbebbc62-758e-4f75-a890-bc73b5017d81"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[Decimal-"1.1"]

test_1419.py::test_parse_literal_with_variables[Decimal-"1.1"]

input_type = >
input_value = '"1.1"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[JSONString-"{\"key\":\"foo\",\"value\":\"bar\"}"]

test_1419.py::test_parse_literal_with_variables[JSONString-"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"]

input_type = >
input_value = '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_1419.py::test_parse_literal_with_variables[Base64-"Q2hlbG8gd29ycmxkCg=="]

test_1419.py::test_parse_literal_with_variables[Base64-"Q2hlbG8gd29ycmxkCg=="]

input_type = >
input_value = '"Q2hlbG8gd29ycmxkCg=="'

    @pytest.mark.parametrize(
        "input_type,input_value",
        [
            (Date, '"2022-02-02"'),
            (GenericScalar, '"foo"'),
            (Int, "1"),
            (BigInt, "12345678901234567890"),
            (Float, "1.1"),
            (String, '"foo"'),
            (Boolean, "true"),
            (ID, "1"),
            (DateTime, '"2022-02-02T11:11:11"'),
            (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
            (Decimal, '"1.1"'),
            (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
            (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
        ],
    )
    def test_parse_literal_with_variables(input_type, input_value):
        # input_b needs to be evaluated as literal while the variable dict for
        # input_a is passed along.

        class Query(ObjectType):
            generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())

            def resolve_generic(self, info, input_a=None, input_b=None):
                return input

>       schema = Schema(query=Query)

graphene/tests/issues/test_1419.py:42: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_313.py::test_create_post

test_313.py::test_create_post

def test_create_post():
        query_string = """
        mutation {
          createPost(text: "Try this out") {
            result {
              __typename
            }
          }
        }
        """

>       schema = graphene.Schema(query=Query, mutation=Mutations)

graphene/tests/issues/test_313.py:53: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = >
subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_356.py::test_issue

test_356.py::test_issue

def test_issue():
        class Query(graphene.ObjectType):
            things = relay.ConnectionField(MyUnion)

        with raises(Exception) as exc_info:
            graphene.Schema(query=Query)

>       assert str(exc_info.value) == (
            "Query fields cannot be resolved."
            " IterableConnectionField type has to be a subclass of Connection."
            ' Received "MyUnion".'
        )
E       assert "'TypeMap' ob...te 'add_type'" == 'Query fields...ed "MyUnion".'
E         
E         - Query fields cannot be resolved. IterableConnectionField type has to be a subclass of Connection. Received "MyUnion".
E         + 'TypeMap' object has no attribute 'add_type'

graphene/tests/issues/test_356.py:29: AssertionError

test_490.py::test_issue

test_490.py::test_issue

def test_issue():
        query_string = """
        query myQuery {
          someField(from: "Oh")
        }
        """

>       schema = graphene.Schema(query=Query)

graphene/tests/issues/test_490.py:20: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_720.py::test_issue

test_720.py::test_issue

def test_issue():
        query_string = """
        query myQuery {
          myField(input: {x: 1})
        }
        """

>       schema = graphene.Schema(query=Query)

graphene/tests/issues/test_720.py:41: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_argument.py::test_argument

test_argument.py::test_argument

def test_argument():
        arg = Argument(String, default_value="a", description="desc", name="b")
>       assert arg.type == String
E       AttributeError: 'Argument' object has no attribute 'type'

graphene/types/tests/test_argument.py:14: AttributeError

test_argument.py::test_argument_comparasion

test_argument.py::test_argument_comparasion

def test_argument_comparasion():
        arg1 = Argument(
            String,
            name="Hey",
            description="Desc",
            default_value="default",
            deprecation_reason="deprecated",
        )
        arg2 = Argument(
            String,
            name="Hey",
            description="Desc",
            default_value="default",
            deprecation_reason="deprecated",
        )

>       assert arg1 == arg2

graphene/types/tests/test_argument.py:36: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = 
other = 

    def __eq__(self, other):
>       return isinstance(other, Argument) and (self.name == other.name and self.type == other.type and (self.default_value == other.default_value) and (self.description == other.description) and (self.deprecation_reason == other.deprecation_reason))
E       AttributeError: 'Argument' object has no attribute 'type'

graphene/types/argument.py:77: AttributeError

test_argument.py::test_argument_required

test_argument.py::test_argument_required

def test_argument_required():
        arg = Argument(String, required=True)
>       assert arg.type == NonNull(String)
E       AttributeError: 'Argument' object has no attribute 'type'

graphene/types/tests/test_argument.py:42: AttributeError

test_argument.py::test_to_arguments

test_argument.py::test_to_arguments

def test_to_arguments():
        args = {"arg_string": Argument(String), "unmounted_arg": String(required=True)}

        my_args = to_arguments(args)
>       assert my_args == {
            "arg_string": Argument(String),
            "unmounted_arg": Argument(String, required=True),
        }
E       AssertionError: assert [] == {'arg_string'...7fe41c721010>}
E         
E         Use -v to get more diff

graphene/types/tests/test_argument.py:49: AssertionError

test_argument.py::test_to_arguments_deprecated

test_argument.py::test_to_arguments_deprecated

def test_to_arguments_deprecated():
        args = {"unmounted_arg": String(required=False, deprecation_reason="deprecated")}

        my_args = to_arguments(args)
>       assert my_args == {
            "unmounted_arg": Argument(
                String, required=False, deprecation_reason="deprecated"
            ),
        }
E       AssertionError: assert [] == {'unmounted_a...7fe41c55cc50>}
E         
E         Use -v to get more diff

graphene/types/tests/test_argument.py:59: AssertionError

test_argument.py::test_to_arguments_required_deprecated

test_argument.py::test_to_arguments_required_deprecated

def test_to_arguments_required_deprecated():
        args = {
            "unmounted_arg": String(
                required=True, name="arg", deprecation_reason="deprecated"
            )
        }

>       with raises(AssertionError) as exc_info:
E       Failed: DID NOT RAISE 

graphene/types/tests/test_argument.py:73: Failed

test_argument.py::test_to_arguments_raises_if_field

test_argument.py::test_to_arguments_raises_if_field

def test_to_arguments_raises_if_field():
        args = {"arg_string": Field(String)}

        with raises(ValueError) as exc_info:
            to_arguments(args)

>       assert str(exc_info.value) == (
            "Expected arg_string to be Argument, but received Field. Try using "
            "Argument(String)."
        )
E       assert "Unknown argu...field.Field'>" == 'Expected arg...ment(String).'
E         
E         - Expected arg_string to be Argument, but received Field. Try using Argument(String).
E         + Unknown argument "arg_string" of type 

graphene/types/tests/test_argument.py:85: AssertionError

test_argument.py::test_to_arguments_raises_if_inputfield

test_argument.py::test_to_arguments_raises_if_inputfield

def test_to_arguments_raises_if_inputfield():
        args = {"arg_string": InputField(String)}

        with raises(ValueError) as exc_info:
            to_arguments(args)

>       assert str(exc_info.value) == (
            "Expected arg_string to be Argument, but received InputField. Try "
            "using Argument(String)."
        )
E       assert "Unknown argu....InputField'>" == 'Expected arg...ment(String).'
E         
E         - Expected arg_string to be Argument, but received InputField. Try using Argument(String).
E         + Unknown argument "arg_string" of type 

graphene/types/tests/test_argument.py:97: AssertionError

test_argument.py::test_argument_with_lazy_type

test_argument.py::test_argument_with_lazy_type

def test_argument_with_lazy_type():
        MyType = object()
        arg = Argument(lambda: MyType)
>       assert arg.type == MyType
E       AttributeError: 'Argument' object has no attribute 'type'

graphene/types/tests/test_argument.py:106: AttributeError

test_argument.py::test_argument_with_lazy_partial_type

test_argument.py::test_argument_with_lazy_partial_type

def test_argument_with_lazy_partial_type():
        MyType = object()
        arg = Argument(partial(lambda: MyType))
>       assert arg.type == MyType
E       AttributeError: 'Argument' object has no attribute 'type'

graphene/types/tests/test_argument.py:112: AttributeError

test_base.py::test_basetype_create

test_base.py::test_basetype_create

def test_basetype_create():
>       MyBaseType = CustomType.create_type("MyBaseType")
E       AttributeError: type object 'CustomType' has no attribute 'create_type'

graphene/types/tests/test_base.py:51: AttributeError

test_base.py::test_basetype_create_extra

test_base.py::test_basetype_create_extra

def test_basetype_create_extra():
>       MyBaseType = CustomType.create_type("MyBaseType", name="Base", description="Desc")
E       AttributeError: type object 'CustomType' has no attribute 'create_type'

graphene/types/tests/test_base.py:59: AttributeError

test_definition.py::test_defines_a_query_only_schema

test_definition.py::test_defines_a_query_only_schema

def test_defines_a_query_only_schema():
>       blog_schema = Schema(Query)

graphene/types/tests/test_definition.py:73: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_defines_a_mutation_schema

test_definition.py::test_defines_a_mutation_schema

def test_defines_a_mutation_schema():
>       blog_schema = Schema(Query, mutation=Mutation)

graphene/types/tests/test_definition.py:100: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = >
subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_defines_a_subscription_schema

test_definition.py::test_defines_a_subscription_schema

def test_defines_a_subscription_schema():
>       blog_schema = Schema(Query, subscription=Subscription)

graphene/types/tests/test_definition.py:111: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None
subscription = >
types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_includes_nested_input_objects_in_the_map

test_definition.py::test_includes_nested_input_objects_in_the_map

def test_includes_nested_input_objects_in_the_map():
        class NestedInputObject(InputObjectType):
            value = String()

        class SomeInputObject(InputObjectType):
            nested = InputField(NestedInputObject)

        class SomeMutation(Mutation):
            mutate_something = Field(Article, input=Argument(SomeInputObject))

        class SomeSubscription(Mutation):
            subscribe_to_something = Field(Article, input=Argument(SomeInputObject))

>       schema = Schema(query=Query, mutation=SomeMutation, subscription=SomeSubscription)

graphene/types/tests/test_definition.py:134: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = >
subscription = >
types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_includes_interfaces_thunk_subtypes_in_the_type_map

test_definition.py::test_includes_interfaces_thunk_subtypes_in_the_type_map

def test_includes_interfaces_thunk_subtypes_in_the_type_map():
        class SomeInterface(Interface):
            f = Int()

        class SomeSubtype(ObjectType):
            class Meta:
                interfaces = (SomeInterface,)

        class Query(ObjectType):
            iface = Field(lambda: SomeInterface)

>       schema = Schema(query=Query, types=[SomeSubtype])

graphene/types/tests/test_definition.py:151: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None
types = [>]
auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_includes_types_in_union

test_definition.py::test_includes_types_in_union

def test_includes_types_in_union():
        class SomeType(ObjectType):
            a = String()

        class OtherType(ObjectType):
            b = String()

        class MyUnion(Union):
            class Meta:
                types = (SomeType, OtherType)

        class Query(ObjectType):
            union = Field(MyUnion)

>       schema = Schema(query=Query)

graphene/types/tests/test_definition.py:171: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_maps_enum

test_definition.py::test_maps_enum

def test_maps_enum():
        class SomeType(ObjectType):
            a = String()

        class OtherType(ObjectType):
            b = String()

        class MyUnion(Union):
            class Meta:
                types = (SomeType, OtherType)

        class Query(ObjectType):
            union = Field(MyUnion)

>       schema = Schema(query=Query)

graphene/types/tests/test_definition.py:192: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_includes_interfaces_subtypes_in_the_type_map

test_definition.py::test_includes_interfaces_subtypes_in_the_type_map

def test_includes_interfaces_subtypes_in_the_type_map():
        class SomeInterface(Interface):
            f = Int()

        class SomeSubtype(ObjectType):
            class Meta:
                interfaces = (SomeInterface,)

        class Query(ObjectType):
            iface = Field(SomeInterface)

>       schema = Schema(query=Query, types=[SomeSubtype])

graphene/types/tests/test_definition.py:210: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None
types = [>]
auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_definition.py::test_stringifies_simple_types

test_definition.py::test_stringifies_simple_types

def test_stringifies_simple_types():
        assert str(Int) == "Int"
        assert str(Article) == "Article"
        assert str(MyInterface) == "MyInterface"
        assert str(MyUnion) == "MyUnion"
        assert str(MyEnum) == "MyEnum"
        assert str(MyInputObjectType) == "MyInputObjectType"
>       assert str(NonNull(Int)) == "Int!"

graphene/types/tests/test_definition.py:223: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = 

    def __str__(self):
>       return f'{self.of_type}!'
E       AttributeError: 'NonNull' object has no attribute 'of_type'

graphene/types/structures.py:81: AttributeError

test_definition.py::test_does_not_mutate_passed_field_definitions

test_definition.py::test_does_not_mutate_passed_field_definitions

def test_does_not_mutate_passed_field_definitions():
        class CommonFields:
            field1 = String()
            field2 = String(id=String())

        class TestObject1(CommonFields, ObjectType):
            pass

        class TestObject2(CommonFields, ObjectType):
            pass

>       assert TestObject1._meta.fields == TestObject2._meta.fields
E       AssertionError: assert {'field1': } == {'field1': }
E         
E         Differing items:
E         {'field1': } != {'field1': }
E         {'field2': } != {'field2': }
E         Use -v to get more diff

graphene/types/tests/test_definition.py:305: AssertionError

test_definition.py::test_graphene_graphql_type_can_be_copied

test_definition.py::test_graphene_graphql_type_can_be_copied

def test_graphene_graphql_type_can_be_copied():
        class Query(ObjectType):
            field = String()

            def resolve_field(self, info):
                return ""

>       schema = Schema(query=Query)

graphene/types/tests/test_definition.py:327: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/schema.py:90: in __init__
    type_map = TypeMap(query, mutation, subscription, types, auto_camelcase=auto_camelcase)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {}, query = >
mutation = None, subscription = None, types = [], auto_camelcase = True

    def __init__(self, query=None, mutation=None, subscription=None, types=None, auto_camelcase=True):
        assert_valid_root_type(query)
        assert_valid_root_type(mutation)
        assert_valid_root_type(subscription)
        if types is None:
            types = []
        for type_ in types:
            assert is_graphene_type(type_)
        self.auto_camelcase = auto_camelcase
>       create_graphql_type = self.add_type
E       AttributeError: 'TypeMap' object has no attribute 'add_type'

graphene/types/schema.py:50: AttributeError

test_dynamic.py::test_dynamic

test_dynamic.py::test_dynamic

def test_dynamic():
        dynamic = Dynamic(lambda: String)
>       assert dynamic.get_type() == String
E       AttributeError: 'Dynamic' object has no attribute 'get_type'

graphene/types/tests/test_dynamic.py:10: AttributeError

test_dynamic.py::test_nonnull

test_dynamic.py::test_nonnull

def test_nonnull():
        dynamic = Dynamic(lambda: NonNull(String))
>       assert dynamic.get_type().of_type == String
E       AttributeError: 'Dynamic' object has no attribute 'get_type'

graphene/types/tests/test_dynamic.py:16: AttributeError

test_dynamic.py::test_list

test_dynamic.py::test_list

def test_list():
        dynamic = Dynamic(lambda: List(String))
>       assert dynamic.get_type().of_type == String
E       AttributeError: 'Dynamic' object has no attribute 'get_type'

graphene/types/tests/test_dynamic.py:22: AttributeError

test_dynamic.py::test_list_non_null

test_dynamic.py::test_list_non_null

def test_list_non_null():
        dynamic = Dynamic(lambda: List(NonNull(String)))
>       assert dynamic.get_type().of_type.of_type == String
E       AttributeError: 'Dynamic' object has no attribute 'get_type'

graphene/types/tests/test_dynamic.py:28: AttributeError

test_dynamic.py::test_partial

test_dynamic.py::test_partial

def test_partial():
        def __type(_type):
            return _type

        dynamic = Dynamic(partial(__type, String))
>       assert dynamic.get_type() == String
E       AttributeError: 'Dynamic' object has no attribute 'get_type'

graphene/types/tests/test_dynamic.py:37: AttributeError

test_enum.py::test_enum_from_python3_enum_uses_default_builtin_doc

test_enum.py::test_enum_from_python3_enum_uses_default_builtin_doc

def test_enum_from_python3_enum_uses_default_builtin_doc():
        RGB = Enum("RGB", "RED,GREEN,BLUE")
>       assert RGB._meta.description == "An enumeration."
E       AssertionError: assert None == 'An enumeration.'
E        +  where None = .description
E        +    where  = >._meta

graphene/types/tests/test_enum.py:80: AssertionError

test_enum.py::test_enum_from_builtin_enum_accepts_lambda_description

test_enum.py::test_enum_from_builtin_enum_accepts_lambda_description

def test_enum_from_builtin_enum_accepts_lambda_description():
        def custom_description(value):
            if not value:
                return "StarWars Episodes"

            return "New Hope Episode" if value == Episode.NEWHOPE else "Other"

        def custom_deprecation_reason(value):
            return "meh" if value == Episode.NEWHOPE else None

        PyEpisode = PyEnum("PyEpisode", "NEWHOPE,EMPIRE,JEDI")
        Episode = Enum.from_enum(
            PyEpisode,
            description=custom_description,
            deprecation_reason=custom_deprecation_reason,
        )

>       class Query(ObjectType):

graphene/types/tests/test_enum.py:100: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = 
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'PyEpisode' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_enum_from_python3_enum_uses_enum_doc

test_enum.py::test_enum_from_python3_enum_uses_enum_doc

def test_enum_from_python3_enum_uses_enum_doc():
        from enum import Enum as PyEnum

        class Color(PyEnum):
            """This is the description"""

            RED = 1
            GREEN = 2
            BLUE = 3

        RGB = Enum.from_enum(Color)
        assert RGB._meta.enum == Color
>       assert RGB._meta.description == "This is the description"
E       AssertionError: assert None == 'This is the description'
E        +  where None = .description
E        +    where  = >._meta

graphene/types/tests/test_enum.py:130: AssertionError

test_enum.py::test_enum_value_as_unmounted_field

test_enum.py::test_enum_value_as_unmounted_field

def test_enum_value_as_unmounted_field():
        class RGB(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

        unmounted = RGB()
        unmounted_field = unmounted.Field()
>       assert isinstance(unmounted_field, Field)
E       assert False
E        +  where False = isinstance(None, Field)

graphene/types/tests/test_enum.py:156: AssertionError

test_enum.py::test_enum_value_as_unmounted_inputfield

test_enum.py::test_enum_value_as_unmounted_inputfield

def test_enum_value_as_unmounted_inputfield():
        class RGB(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

        unmounted = RGB()
        unmounted_field = unmounted.InputField()
>       assert isinstance(unmounted_field, InputField)
E       assert False
E        +  where False = isinstance(None, InputField)

graphene/types/tests/test_enum.py:168: AssertionError

test_enum.py::test_enum_value_as_unmounted_argument

test_enum.py::test_enum_value_as_unmounted_argument

def test_enum_value_as_unmounted_argument():
        class RGB(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

        unmounted = RGB()
        unmounted_field = unmounted.Argument()
>       assert isinstance(unmounted_field, Argument)
E       assert False
E        +  where False = isinstance(None, Argument)

graphene/types/tests/test_enum.py:180: AssertionError

test_enum.py::test_enum_can_be_initialized

test_enum.py::test_enum_can_be_initialized

def test_enum_can_be_initialized():
        class RGB(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

>       assert RGB.get(1) == RGB.RED
E       AttributeError: type object 'RGB' has no attribute 'get'

graphene/types/tests/test_enum.py:201: AttributeError

test_enum.py::test_enum_to_enum_comparison_should_differ

test_enum.py::test_enum_to_enum_comparison_should_differ

def test_enum_to_enum_comparison_should_differ():
        class RGB1(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

        class RGB2(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

>       assert RGB1.RED != RGB2.RED
E       AssertionError: assert  != 
E        +  where  = >.RED
E        +  and    = >.RED

graphene/types/tests/test_enum.py:228: AssertionError

test_enum.py::test_enum_types

test_enum.py::test_enum_types

def test_enum_types():
        from enum import Enum as PyEnum

        class Color(PyEnum):
            """Primary colors"""

            RED = 1
            YELLOW = 2
            BLUE = 3

        GColor = Enum.from_enum(Color)

>       class Query(ObjectType):

graphene/types/tests/test_enum.py:261: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = 
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'Color' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_enum_resolver

test_enum.py::test_enum_resolver

def test_enum_resolver():
        from enum import Enum as PyEnum

        class Color(PyEnum):
            RED = 1
            GREEN = 2
            BLUE = 3

        GColor = Enum.from_enum(Color)

>       class Query(ObjectType):

graphene/types/tests/test_enum.py:298: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = 
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'Color' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_enum_resolver_compat

test_enum.py::test_enum_resolver_compat

def test_enum_resolver_compat():
        from enum import Enum as PyEnum

        class Color(PyEnum):
            RED = 1
            GREEN = 2
            BLUE = 3

        GColor = Enum.from_enum(Color)

>       class Query(ObjectType):

graphene/types/tests/test_enum.py:322: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = 
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'Color' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_enum_with_name

test_enum.py::test_enum_with_name

def test_enum_with_name():
        from enum import Enum as PyEnum

        class Color(PyEnum):
            RED = 1
            YELLOW = 2
            BLUE = 3

        GColor = Enum.from_enum(Color, description="original colors")
>       UniqueGColor = Enum.from_enum(
            Color, name="UniqueColor", description="unique colors"
        )
E       TypeError: Enum.from_enum() got an unexpected keyword argument 'name'

graphene/types/tests/test_enum.py:355: TypeError

test_enum.py::test_enum_resolver_invalid

test_enum.py::test_enum_resolver_invalid

def test_enum_resolver_invalid():
        from enum import Enum as PyEnum

        class Color(PyEnum):
            RED = 1
            GREEN = 2
            BLUE = 3

        GColor = Enum.from_enum(Color)

>       class Query(ObjectType):

graphene/types/tests/test_enum.py:402: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = 
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'Color' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_field_enum_argument

test_enum.py::test_field_enum_argument

def test_field_enum_argument():
        class Color(Enum):
            RED = 1
            GREEN = 2
            BLUE = 3

>       class Brick(ObjectType):

graphene/types/tests/test_enum.py:421: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = .Color object at 0x7fe41c6483d0>
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'Color' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_mutation_enum_input

test_enum.py::test_mutation_enum_input

def test_mutation_enum_input():
        class RGB(Enum):
            """Available colors"""

            RED = 1
            GREEN = 2
            BLUE = 3

        color_input = None

>       class CreatePaint(Mutation):

graphene/types/tests/test_enum.py:460: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/mutation.py:75: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = .RGB object at 0x7fe41c4dd450>
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'RGB' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_mutation_enum_input_type

test_enum.py::test_mutation_enum_input_type

def test_mutation_enum_input_type():
        class RGB(Enum):
            """Available colors"""

            RED = 1
            GREEN = 2
            BLUE = 3

>       class ColorInput(InputObjectType):

graphene/types/tests/test_enum.py:500: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/inputobjecttype.py:80: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=InputField))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = .RGB object at 0x7fe41c4079d0>
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'RGB' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_enum.py::test_hashable_enum

test_enum.py::test_hashable_enum

def test_hashable_enum():
        class RGB(Enum):
            """Available colors"""

            RED = 1
            GREEN = 2
            BLUE = 3

        color_map = {RGB.RED: "a", RGB.BLUE: "b", 1: "c"}

>       assert color_map[RGB.RED] == "a"
E       AssertionError: assert 'c' == 'a'
E         
E         - a
E         + c

graphene/types/tests/test_enum.py:548: AssertionError

test_enum.py::test_enum_description_member_not_interpreted_as_property

test_enum.py::test_enum_description_member_not_interpreted_as_property

def test_enum_description_member_not_interpreted_as_property():
        class RGB(Enum):
            """Description"""

            red = "red"
            green = "green"
            blue = "blue"
            description = "description"
            deprecation_reason = "deprecation_reason"

>       class Query(ObjectType):

graphene/types/tests/test_enum.py:596: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
graphene/types/objecttype.py:23: in __new__
    base_cls = super().__new__(cls, name_, (InterObjectType,) + bases, namespace, **options)
graphene/utils/subclass_with_meta.py:37: in __init_subclass__
    super_class.__init_subclass_with_meta__(**options)
graphene/types/objecttype.py:113: in __init_subclass_with_meta__
    fields.update(yank_fields_from_attrs(base.__dict__, _as=Field))
graphene/types/utils.py:43: in yank_fields_from_attrs
    fields.append((key, get_field_as(value, _as)))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

value = .RGB object at 0x7fe41c77c350>
_as = 

    def get_field_as(value, _as=None):
        """
        Get type mounted
        """
        if isinstance(value, MountedType):
            return value
        elif isinstance(value, UnmountedType):
>           return value.mount(_as)
E           AttributeError: 'RGB' object has no attribute 'mount'

graphene/types/utils.py:32: AttributeError

test_field.py::test_field_basic

test_field.py::test_field_basic

def test_field_basic():
        MyType = object()
        args = {"my arg": Argument(True)}

        def resolver():
            return None

        deprecation_reason = "Deprecated now"
        description = "My Field"
        my_default = "something"
        field = Field(
            MyType,
            name="name",
            args=args,
            resolver=resolver,
            description=description,
            deprecation_reason=deprecation_reason,
            default_value=my_default,
        )
        assert field.name == "name"
>       assert field.args == args
E       AssertionError: assert [] == {'my arg': }
E         
E         Use -v to get more diff

graphene/types/tests/test_field.py:40: AssertionError

test_field.py::test_field_required

test_field.py::test_field_required

def test_field_required():
        MyType = object()
        field = Field(MyType, required=True)
>       assert isinstance(field.type, NonNull)
E       AttributeError: 'Field' object has no attribute 'type'

graphene/types/tests/test_field.py:50: AttributeError

test_field.py::test_field_source

test_field.py::test_field_source

def test_field_source():
        MyType = object()
>       field = Field(MyType, source="value")

graphene/types/tests/test_field.py:65: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = 
type_ =