star

venv/lib/python3.9/site-packages/graphene/relay/tests/test_connection.py

@@ -0,0 +1,318 @@
+import re
+
+from pytest import raises
+
+from ...types import Argument, Field, Int, List, NonNull, ObjectType, Schema, String
+from ..connection import (
+    Connection,
+    ConnectionField,
+    PageInfo,
+    ConnectionOptions,
+    get_edge_class,
+)
+from ..node import Node
+
+
+class MyObject(ObjectType):
+    class Meta:
+        interfaces = [Node]
+
+    field = String()
+
+
+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)
+    assert isinstance(edge_field.type.of_type, List)
+    assert edge_field.type.of_type.of_type == MyObjectConnection.Edge
+
+    assert isinstance(pageinfo_field, Field)
+    assert isinstance(pageinfo_field.type, NonNull)
+    assert pageinfo_field.type.of_type == PageInfo
+
+
+def test_connection_inherit_abstracttype():
+    class BaseConnection:
+        extra = String()
+
+    class MyObjectConnection(BaseConnection, Connection):
+        class Meta:
+            node = MyObject
+
+    assert MyObjectConnection._meta.name == "MyObjectConnection"
+    fields = MyObjectConnection._meta.fields
+    assert list(fields) == ["page_info", "edges", "extra"]
+
+
+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)
+    assert isinstance(edge_field.type.of_type, List)
+    assert edge_field.type.of_type.of_type == MyObjectConnection.Edge
+
+    assert isinstance(pageinfo_field, Field)
+    assert isinstance(pageinfo_field.type, NonNull)
+    assert pageinfo_field.type.of_type == PageInfo
+
+    assert isinstance(nodes_field, Field)
+    assert isinstance(nodes_field.type, NonNull)
+    assert isinstance(nodes_field.type.of_type, List)
+    assert nodes_field.type.of_type.of_type == MyObject
+
+
+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)
+    assert isinstance(edge_field.type.of_type, List)
+    assert isinstance(edge_field.type.of_type.of_type, NonNull)
+
+    assert edge_field.type.of_type.of_type.of_type.__name__ == "MyObjectEdge"
+
+    # This page info is NonNull
+    assert isinstance(pageinfo_field, Field)
+    assert isinstance(edge_field.type, NonNull)
+    assert pageinfo_field.type.of_type == PageInfo
+
+
+def test_connection_name():
+    custom_name = "MyObjectCustomNameConnection"
+
+    class BaseConnection:
+        extra = String()
+
+    class MyObjectConnection(BaseConnection, Connection):
+        class Meta:
+            node = MyObject
+            name = custom_name
+
+    assert MyObjectConnection._meta.name == custom_name
+
+
+def test_edge():
+    class MyObjectConnection(Connection):
+        class Meta:
+            node = MyObject
+
+        class Edge:
+            other = String()
+
+    Edge = MyObjectConnection.Edge
+    assert Edge._meta.name == "MyObjectEdge"
+    edge_fields = Edge._meta.fields
+    assert list(edge_fields) == ["node", "cursor", "other"]
+
+    assert isinstance(edge_fields["node"], Field)
+    assert edge_fields["node"].type == MyObject
+
+    assert isinstance(edge_fields["other"], Field)
+    assert edge_fields["other"].type == String
+
+
+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"
+    edge_fields = Edge._meta.fields
+    assert list(edge_fields) == ["node", "cursor", "extra", "other"]
+
+    assert isinstance(edge_fields["node"], Field)
+    assert edge_fields["node"].type == MyObject
+
+    assert isinstance(edge_fields["other"], Field)
+    assert edge_fields["other"].type == String
+
+
+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)
+    assert edge_fields["node"].type.of_type == MyObject
+
+
+def test_pageinfo():
+    assert PageInfo._meta.name == "PageInfo"
+    fields = PageInfo._meta.fields
+    assert list(fields) == [
+        "has_next_page",
+        "has_previous_page",
+        "start_cursor",
+        "end_cursor",
+    ]
+
+
+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),
+    }
+
+
+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
+    )
+
+
+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),
+    }
+
+
+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)
+    executed = schema.execute("{ testConnection { edges { cursor } } }")
+    assert not executed.errors
+    assert executed.data == {"testConnection": {"edges": []}}
+
+
+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
+    assert isinstance(edges_field_type, NonNull)
+
+    edges_list_element_type = edges_field_type.of_type.of_type
+    assert isinstance(edges_list_element_type, NonNull)
+
+    node_field = edges_list_element_type.of_type._meta.fields["node"]
+    assert isinstance(node_field.type, NonNull)

venv/lib/python3.9/site-packages/graphene/relay/tests/test_connection_async.py

@@ -0,0 +1,121 @@
+from pytest import mark
+
+from graphql_relay.utils import base64
+
+from graphene.types import ObjectType, Schema, String
+from graphene.relay.connection import Connection, ConnectionField, PageInfo
+from graphene.relay.node import Node
+
+letter_chars = ["A", "B", "C", "D", "E"]
+
+
+class Letter(ObjectType):
+    class Meta:
+        interfaces = (Node,)
+
+    letter = String()
+
+
+class LetterConnection(Connection):
+    class Meta:
+        node = Letter
+
+
+class Query(ObjectType):
+    letters = ConnectionField(LetterConnection)
+    connection_letters = ConnectionField(LetterConnection)
+    async_letters = ConnectionField(LetterConnection)
+
+    node = Node.Field()
+
+    def resolve_letters(self, info, **args):
+        return list(letters.values())
+
+    async def resolve_async_letters(self, info, **args):
+        return list(letters.values())
+
+    def resolve_connection_letters(self, info, **args):
+        return LetterConnection(
+            page_info=PageInfo(has_next_page=True, has_previous_page=False),
+            edges=[
+                LetterConnection.Edge(node=Letter(id=0, letter="A"), cursor="a-cursor")
+            ],
+        )
+
+
+schema = Schema(Query)
+
+letters = {letter: Letter(id=i, letter=letter) for i, letter in enumerate(letter_chars)}
+
+
+def edges(selected_letters):
+    return [
+        {
+            "node": {"id": base64("Letter:%s" % letter.id), "letter": letter.letter},
+            "cursor": base64("arrayconnection:%s" % letter.id),
+        }
+        for letter in [letters[i] for i in selected_letters]
+    ]
+
+
+def cursor_for(ltr):
+    letter = letters[ltr]
+    return base64("arrayconnection:%s" % letter.id)
+
+
+def execute(args=""):
+    if args:
+        args = "(" + args + ")"
+
+    return schema.execute(
+        """
+    {
+        letters%s {
+            edges {
+                node {
+                    id
+                    letter
+                }
+                cursor
+            }
+            pageInfo {
+                hasPreviousPage
+                hasNextPage
+                startCursor
+                endCursor
+            }
+        }
+    }
+    """
+        % args
+    )
+
+
+@mark.asyncio
+async def test_connection_async():
+    result = await schema.execute_async(
+        """
+    {
+        asyncLetters(first:1) {
+            edges {
+                node {
+                    id
+                    letter
+                }
+            }
+            pageInfo {
+                hasPreviousPage
+                hasNextPage
+            }
+        }
+    }
+    """
+    )
+
+    assert not result.errors
+    assert result.data == {
+        "asyncLetters": {
+            "edges": [{"node": {"id": "TGV0dGVyOjA=", "letter": "A"}}],
+            "pageInfo": {"hasPreviousPage": False, "hasNextPage": True},
+        }
+    }

venv/lib/python3.9/site-packages/graphene/relay/tests/test_connection_query.py

@@ -0,0 +1,286 @@
+from pytest import mark
+
+from graphql_relay.utils import base64
+
+from ...types import ObjectType, Schema, String
+from ..connection import Connection, ConnectionField, PageInfo
+from ..node import Node
+
+letter_chars = ["A", "B", "C", "D", "E"]
+
+
+class Letter(ObjectType):
+    class Meta:
+        interfaces = (Node,)
+
+    letter = String()
+
+
+class LetterConnection(Connection):
+    class Meta:
+        node = Letter
+
+
+class Query(ObjectType):
+    letters = ConnectionField(LetterConnection)
+    connection_letters = ConnectionField(LetterConnection)
+    async_letters = ConnectionField(LetterConnection)
+
+    node = Node.Field()
+
+    def resolve_letters(self, info, **args):
+        return list(letters.values())
+
+    async def resolve_async_letters(self, info, **args):
+        return list(letters.values())
+
+    def resolve_connection_letters(self, info, **args):
+        return LetterConnection(
+            page_info=PageInfo(has_next_page=True, has_previous_page=False),
+            edges=[
+                LetterConnection.Edge(node=Letter(id=0, letter="A"), cursor="a-cursor")
+            ],
+        )
+
+
+schema = Schema(Query)
+
+letters = {letter: Letter(id=i, letter=letter) for i, letter in enumerate(letter_chars)}
+
+
+def edges(selected_letters):
+    return [
+        {
+            "node": {"id": base64("Letter:%s" % letter.id), "letter": letter.letter},
+            "cursor": base64("arrayconnection:%s" % letter.id),
+        }
+        for letter in [letters[i] for i in selected_letters]
+    ]
+
+
+def cursor_for(ltr):
+    letter = letters[ltr]
+    return base64("arrayconnection:%s" % letter.id)
+
+
+async def execute(args=""):
+    if args:
+        args = "(" + args + ")"
+    return await schema.execute_async(
+        """
+    {
+        letters%s {
+            edges {
+                node {
+                    id
+                    letter
+                }
+                cursor
+            }
+            pageInfo {
+                hasPreviousPage
+                hasNextPage
+                startCursor
+                endCursor
+            }
+        }
+    }
+    """
+        % args
+    )
+
+
+async def check(args, letters, has_previous_page=False, has_next_page=False):
+    result = await execute(args)
+    expected_edges = edges(letters)
+    expected_page_info = {
+        "hasPreviousPage": has_previous_page,
+        "hasNextPage": has_next_page,
+        "endCursor": expected_edges[-1]["cursor"] if expected_edges else None,
+        "startCursor": expected_edges[0]["cursor"] if expected_edges else None,
+    }
+
+    assert not result.errors
+    assert result.data == {
+        "letters": {"edges": expected_edges, "pageInfo": expected_page_info}
+    }
+
+
+@mark.asyncio
+async def test_returns_all_elements_without_filters():
+    await check("", "ABCDE")
+
+
+@mark.asyncio
+async def test_respects_a_smaller_first():
+    await check("first: 2", "AB", has_next_page=True)
+
+
+@mark.asyncio
+async def test_respects_an_overly_large_first():
+    await check("first: 10", "ABCDE")
+
+
+@mark.asyncio
+async def test_respects_a_smaller_last():
+    await check("last: 2", "DE", has_previous_page=True)
+
+
+@mark.asyncio
+async def test_respects_an_overly_large_last():
+    await check("last: 10", "ABCDE")
+
+
+@mark.asyncio
+async def test_respects_first_and_after():
+    await check(f'first: 2, after: "{cursor_for("B")}"', "CD", has_next_page=True)
+
+
+@mark.asyncio
+async def test_respects_first_and_after_with_long_first():
+    await check(f'first: 10, after: "{cursor_for("B")}"', "CDE")
+
+
+@mark.asyncio
+async def test_respects_last_and_before():
+    await check(f'last: 2, before: "{cursor_for("D")}"', "BC", has_previous_page=True)
+
+
+@mark.asyncio
+async def test_respects_last_and_before_with_long_last():
+    await check(f'last: 10, before: "{cursor_for("D")}"', "ABC")
+
+
+@mark.asyncio
+async def test_respects_first_and_after_and_before_too_few():
+    await check(
+        f'first: 2, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
+        "BC",
+        has_next_page=True,
+    )
+
+
+@mark.asyncio
+async def test_respects_first_and_after_and_before_too_many():
+    await check(
+        f'first: 4, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
+    )
+
+
+@mark.asyncio
+async def test_respects_first_and_after_and_before_exactly_right():
+    await check(
+        f'first: 3, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
+    )
+
+
+@mark.asyncio
+async def test_respects_last_and_after_and_before_too_few():
+    await check(
+        f'last: 2, after: "{cursor_for("A")}", before: "{cursor_for("E")}"',
+        "CD",
+        has_previous_page=True,
+    )
+
+
+@mark.asyncio
+async def test_respects_last_and_after_and_before_too_many():
+    await check(
+        f'last: 4, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
+    )
+
+
+@mark.asyncio
+async def test_respects_last_and_after_and_before_exactly_right():
+    await check(
+        f'last: 3, after: "{cursor_for("A")}", before: "{cursor_for("E")}"', "BCD"
+    )
+
+
+@mark.asyncio
+async def test_returns_no_elements_if_first_is_0():
+    await check("first: 0", "", has_next_page=True)
+
+
+@mark.asyncio
+async def test_returns_all_elements_if_cursors_are_invalid():
+    await check('before: "invalid" after: "invalid"', "ABCDE")
+
+
+@mark.asyncio
+async def test_returns_all_elements_if_cursors_are_on_the_outside():
+    await check(
+        f'before: "{base64("arrayconnection:%s" % 6)}" after: "{base64("arrayconnection:%s" % -1)}"',
+        "ABCDE",
+    )
+
+
+@mark.asyncio
+async def test_returns_no_elements_if_cursors_cross():
+    await check(
+        f'before: "{base64("arrayconnection:%s" % 2)}" after: "{base64("arrayconnection:%s" % 4)}"',
+        "",
+    )
+
+
+@mark.asyncio
+async def test_connection_type_nodes():
+    result = await schema.execute_async(
+        """
+    {
+        connectionLetters {
+            edges {
+                node {
+                    id
+                    letter
+                }
+                cursor
+            }
+            pageInfo {
+                hasPreviousPage
+                hasNextPage
+            }
+        }
+    }
+    """
+    )
+
+    assert not result.errors
+    assert result.data == {
+        "connectionLetters": {
+            "edges": [
+                {"node": {"id": "TGV0dGVyOjA=", "letter": "A"}, "cursor": "a-cursor"}
+            ],
+            "pageInfo": {"hasPreviousPage": False, "hasNextPage": True},
+        }
+    }
+
+
+@mark.asyncio
+async def test_connection_async():
+    result = await schema.execute_async(
+        """
+    {
+        asyncLetters(first:1) {
+            edges {
+                node {
+                    id
+                    letter
+                }
+            }
+            pageInfo {
+                hasPreviousPage
+                hasNextPage
+            }
+        }
+    }
+    """
+    )
+
+    assert not result.errors
+    assert result.data == {
+        "asyncLetters": {
+            "edges": [{"node": {"id": "TGV0dGVyOjA=", "letter": "A"}}],
+            "pageInfo": {"hasPreviousPage": False, "hasNextPage": True},
+        }
+    }

venv/lib/python3.9/site-packages/graphene/relay/tests/test_custom_global_id.py

@@ -0,0 +1,325 @@
+import re
+from uuid import uuid4
+
+from graphql import graphql_sync
+
+from ..id_type import BaseGlobalIDType, SimpleGlobalIDType, UUIDGlobalIDType
+from ..node import Node
+from ...types import Int, ObjectType, Schema, String
+
+
+class TestUUIDGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": uuid4(), "name": "First"},
+            {"id": uuid4(), "name": "Second"},
+            {"id": uuid4(), "name": "Third"},
+            {"id": uuid4(), "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = UUIDGlobalIDType
+
+        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])
+        self.graphql_schema = self.schema.graphql_schema
+
+    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))
+        types = [t for t, f in parsed]
+        fields = [f for t, f in parsed]
+        custom_node_interface = "interface CustomNode"
+        assert custom_node_interface in types
+        assert (
+            '"""The ID of the object"""\n  id: UUID!'
+            == fields[types.index(custom_node_interface)]
+        )
+        user_type = "type User implements CustomNode"
+        assert user_type in types
+        assert (
+            '"""The ID of the object"""\n  id: UUID!\n  name: String'
+            == fields[types.index(user_type)]
+        )
+
+    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"])},
+        )
+        assert not result.errors
+        assert result.data["user"]["id"] == str(self.user_list[0]["id"])
+        assert result.data["user"]["name"] == self.user_list[0]["name"]
+
+
+class TestSimpleGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": "my global primary key in clear 1", "name": "First"},
+            {"id": "my global primary key in clear 2", "name": "Second"},
+            {"id": "my global primary key in clear 3", "name": "Third"},
+            {"id": "my global primary key in clear 4", "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+        class CustomNode(Node):
+            class Meta:
+                global_id_type = SimpleGlobalIDType
+
+        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])
+        self.graphql_schema = self.schema.graphql_schema
+
+    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))
+        types = [t for t, f in parsed]
+        fields = [f for t, f in parsed]
+        custom_node_interface = "interface CustomNode"
+        assert custom_node_interface in types
+        assert (
+            '"""The ID of the object"""\n  id: ID!'
+            == fields[types.index(custom_node_interface)]
+        )
+        user_type = "type User implements CustomNode"
+        assert user_type in types
+        assert (
+            '"""The ID of the object"""\n  id: ID!\n  name: String'
+            == fields[types.index(user_type)]
+        )
+
+    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)
+        assert not result.errors
+        assert result.data["user"]["id"] == self.user_list[2]["id"]
+        assert result.data["user"]["name"] == self.user_list[2]["name"]
+
+
+class TestCustomGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": 1, "name": "First"},
+            {"id": 2, "name": "Second"},
+            {"id": 3, "name": "Third"},
+            {"id": 4, "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+        class CustomGlobalIDType(BaseGlobalIDType):
+            """
+            Global id that is simply and integer in clear.
+            """
+
+            graphene_type = Int
+
+            @classmethod
+            def resolve_global_id(cls, info, global_id):
+                _type = info.return_type.graphene_type._meta.name
+                return _type, global_id
+
+            @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])
+        self.graphql_schema = self.schema.graphql_schema
+
+    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))
+        types = [t for t, f in parsed]
+        fields = [f for t, f in parsed]
+        custom_node_interface = "interface CustomNode"
+        assert custom_node_interface in types
+        assert (
+            '"""The ID of the object"""\n  id: Int!'
+            == fields[types.index(custom_node_interface)]
+        )
+        user_type = "type User implements CustomNode"
+        assert user_type in types
+        assert (
+            '"""The ID of the object"""\n  id: Int!\n  name: String'
+            == fields[types.index(user_type)]
+        )
+
+    def test_get_by_id(self):
+        query = """query {
+            user(id: 2) {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert not result.errors
+        assert result.data["user"]["id"] == self.user_list[1]["id"]
+        assert result.data["user"]["name"] == self.user_list[1]["name"]
+
+
+class TestIncompleteCustomGlobalID:
+    def setup_method(self):
+        self.user_list = [
+            {"id": 1, "name": "First"},
+            {"id": 2, "name": "Second"},
+            {"id": 3, "name": "Third"},
+            {"id": 4, "name": "Fourth"},
+        ]
+        self.users = {user["id"]: user for user in self.user_list}
+
+    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])
+        self.graphql_schema = self.schema.graphql_schema
+
+        query = """query {
+            user(id: 2) {
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert not result.errors
+        assert result.data["user"]["name"] == self.user_list[1]["name"]
+
+        query = """query {
+            user(id: 2) {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert result.errors is not None
+        assert len(result.errors) == 1
+        assert result.errors[0].path == ["user", "id"]
+
+    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])
+        self.graphql_schema = self.schema.graphql_schema
+
+        query = """query {
+            user(id: 2) {
+                id
+                name
+            }
+        }"""
+        result = graphql_sync(self.graphql_schema, query)
+        assert result.errors is not None
+        assert len(result.errors) == 1
+        assert result.errors[0].path == ["user"]

venv/lib/python3.9/site-packages/graphene/relay/tests/test_global_id.py

@@ -0,0 +1,58 @@
+from graphql_relay import to_global_id
+
+from ...types import ID, NonNull, ObjectType, String
+from ...types.definitions import GrapheneObjectType
+from ..node import GlobalID, Node
+
+
+class CustomNode(Node):
+    class Meta:
+        name = "Node"
+
+
+class User(ObjectType):
+    class Meta:
+        interfaces = [CustomNode]
+
+    name = String()
+
+
+class Info:
+    def __init__(self, parent_type):
+        self.parent_type = GrapheneObjectType(
+            graphene_type=parent_type,
+            name=parent_type._meta.name,
+            description=parent_type._meta.description,
+            fields=None,
+            is_type_of=parent_type.is_type_of,
+            interfaces=None,
+        )
+
+
+def test_global_id_defaults_to_required_and_node():
+    gid = GlobalID()
+    assert isinstance(gid.type, NonNull)
+    assert gid.type.of_type == ID
+    assert gid.node == Node
+
+
+def test_global_id_allows_overriding_of_node_and_required():
+    gid = GlobalID(node=CustomNode, required=False)
+    assert gid.type == ID
+    assert gid.node == CustomNode
+
+
+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))
+    assert my_global_id == to_global_id(User._meta.name, my_id)
+
+
+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)
+    assert my_global_id == to_global_id(User._meta.name, my_id)

venv/lib/python3.9/site-packages/graphene/relay/tests/test_mutation.py

@@ -0,0 +1,206 @@
+from pytest import mark, raises
+
+from ...types import (
+    ID,
+    Argument,
+    Field,
+    InputField,
+    InputObjectType,
+    NonNull,
+    ObjectType,
+    Schema,
+)
+from ...types.scalars import String
+from ..mutation import ClientIDMutation
+
+
+class SharedFields:
+    shared = String()
+
+
+class MyNode(ObjectType):
+    # class Meta:
+    #     interfaces = (Node, )
+    id = ID()
+    name = String()
+
+
+class SaySomething(ClientIDMutation):
+    class Input:
+        what = String()
+
+    phrase = String()
+
+    @staticmethod
+    def mutate_and_get_payload(self, info, what, client_mutation_id=None):
+        return SaySomething(phrase=str(what))
+
+
+class FixedSaySomething:
+    __slots__ = ("phrase",)
+
+    def __init__(self, phrase):
+        self.phrase = phrase
+
+
+class SaySomethingFixed(ClientIDMutation):
+    class Input:
+        what = String()
+
+    phrase = String()
+
+    @staticmethod
+    def mutate_and_get_payload(self, info, what, client_mutation_id=None):
+        return FixedSaySomething(phrase=str(what))
+
+
+class SaySomethingAsync(ClientIDMutation):
+    class Input:
+        what = String()
+
+    phrase = String()
+
+    @staticmethod
+    async def mutate_and_get_payload(self, info, what, client_mutation_id=None):
+        return SaySomething(phrase=str(what))
+
+
+# MyEdge = MyNode.Connection.Edge
+class MyEdge(ObjectType):
+    node = Field(MyNode)
+    cursor = String()
+
+
+class OtherMutation(ClientIDMutation):
+    class Input(SharedFields):
+        additional_field = String()
+
+    name = String()
+    my_node_edge = Field(MyEdge)
+
+    @staticmethod
+    def mutate_and_get_payload(
+        self, info, shared="", additional_field="", client_mutation_id=None
+    ):
+        edge_type = MyEdge
+        return OtherMutation(
+            name=shared + additional_field,
+            my_node_edge=edge_type(cursor="1", node=MyNode(name="name")),
+        )
+
+
+class RootQuery(ObjectType):
+    something = String()
+
+
+class Mutation(ObjectType):
+    say = SaySomething.Field()
+    say_fixed = SaySomethingFixed.Field()
+    say_async = SaySomethingAsync.Field()
+    other = OtherMutation.Field()
+
+
+schema = Schema(query=RootQuery, mutation=Mutation)
+
+
+def test_no_mutate_and_get_payload():
+    with raises(AssertionError) as excinfo:
+
+        class MyMutation(ClientIDMutation):
+            pass
+
+    assert (
+        "MyMutation.mutate_and_get_payload method is required in a ClientIDMutation."
+        == str(excinfo.value)
+    )
+
+
+def test_mutation():
+    fields = SaySomething._meta.fields
+    assert list(fields) == ["phrase", "client_mutation_id"]
+    assert SaySomething._meta.name == "SaySomethingPayload"
+    assert isinstance(fields["phrase"], Field)
+    field = SaySomething.Field()
+    assert field.type == SaySomething
+    assert list(field.args) == ["input"]
+    assert isinstance(field.args["input"], Argument)
+    assert isinstance(field.args["input"].type, NonNull)
+    assert field.args["input"].type.of_type == SaySomething.Input
+    assert isinstance(fields["client_mutation_id"], Field)
+    assert fields["client_mutation_id"].name == "clientMutationId"
+    assert fields["client_mutation_id"].type == String
+
+
+def test_mutation_input():
+    Input = SaySomething.Input
+    assert issubclass(Input, InputObjectType)
+    fields = Input._meta.fields
+    assert list(fields) == ["what", "client_mutation_id"]
+    assert isinstance(fields["what"], InputField)
+    assert fields["what"].type == String
+    assert isinstance(fields["client_mutation_id"], InputField)
+    assert fields["client_mutation_id"].type == String
+
+
+def test_subclassed_mutation():
+    fields = OtherMutation._meta.fields
+    assert list(fields) == ["name", "my_node_edge", "client_mutation_id"]
+    assert isinstance(fields["name"], Field)
+    field = OtherMutation.Field()
+    assert field.type == OtherMutation
+    assert list(field.args) == ["input"]
+    assert isinstance(field.args["input"], Argument)
+    assert isinstance(field.args["input"].type, NonNull)
+    assert field.args["input"].type.of_type == OtherMutation.Input
+
+
+def test_subclassed_mutation_input():
+    Input = OtherMutation.Input
+    assert issubclass(Input, InputObjectType)
+    fields = Input._meta.fields
+    assert list(fields) == ["shared", "additional_field", "client_mutation_id"]
+    assert isinstance(fields["shared"], InputField)
+    assert fields["shared"].type == String
+    assert isinstance(fields["additional_field"], InputField)
+    assert fields["additional_field"].type == String
+    assert isinstance(fields["client_mutation_id"], InputField)
+    assert fields["client_mutation_id"].type == String
+
+
+def test_node_query():
+    executed = schema.execute(
+        'mutation a { say(input: {what:"hello", clientMutationId:"1"}) { phrase } }'
+    )
+    assert not executed.errors
+    assert executed.data == {"say": {"phrase": "hello"}}
+
+
+def test_node_query_fixed():
+    executed = schema.execute(
+        'mutation a { sayFixed(input: {what:"hello", clientMutationId:"1"}) { phrase } }'
+    )
+    assert "Cannot set client_mutation_id in the payload object" in str(
+        executed.errors[0]
+    )
+
+
+@mark.asyncio
+async def test_node_query_async():
+    executed = await schema.execute_async(
+        'mutation a { sayAsync(input: {what:"hello", clientMutationId:"1"}) { phrase } }'
+    )
+    assert not executed.errors
+    assert executed.data == {"sayAsync": {"phrase": "hello"}}
+
+
+def test_edge_query():
+    executed = schema.execute(
+        'mutation a { other(input: {clientMutationId:"1"}) { clientMutationId, myNodeEdge { cursor node { name }} } }'
+    )
+    assert not executed.errors
+    assert dict(executed.data) == {
+        "other": {
+            "clientMutationId": "1",
+            "myNodeEdge": {"cursor": "1", "node": {"name": "name"}},
+        }
+    }

venv/lib/python3.9/site-packages/graphene/relay/tests/test_mutation_async.py

@@ -0,0 +1,90 @@
+from pytest import mark
+
+from graphene.types import ID, Field, ObjectType, Schema
+from graphene.types.scalars import String
+from graphene.relay.mutation import ClientIDMutation
+from graphene.test import Client
+
+
+class SharedFields(object):
+    shared = String()
+
+
+class MyNode(ObjectType):
+    # class Meta:
+    #     interfaces = (Node, )
+    id = ID()
+    name = String()
+
+
+class SaySomethingAsync(ClientIDMutation):
+    class Input:
+        what = String()
+
+    phrase = String()
+
+    @staticmethod
+    async def mutate_and_get_payload(self, info, what, client_mutation_id=None):
+        return SaySomethingAsync(phrase=str(what))
+
+
+# MyEdge = MyNode.Connection.Edge
+class MyEdge(ObjectType):
+    node = Field(MyNode)
+    cursor = String()
+
+
+class OtherMutation(ClientIDMutation):
+    class Input(SharedFields):
+        additional_field = String()
+
+    name = String()
+    my_node_edge = Field(MyEdge)
+
+    @staticmethod
+    def mutate_and_get_payload(
+        self, info, shared="", additional_field="", client_mutation_id=None
+    ):
+        edge_type = MyEdge
+        return OtherMutation(
+            name=shared + additional_field,
+            my_node_edge=edge_type(cursor="1", node=MyNode(name="name")),
+        )
+
+
+class RootQuery(ObjectType):
+    something = String()
+
+
+class Mutation(ObjectType):
+    say_promise = SaySomethingAsync.Field()
+    other = OtherMutation.Field()
+
+
+schema = Schema(query=RootQuery, mutation=Mutation)
+client = Client(schema)
+
+
+@mark.asyncio
+async def test_node_query_promise():
+    executed = await client.execute_async(
+        'mutation a { sayPromise(input: {what:"hello", clientMutationId:"1"}) { phrase } }'
+    )
+    assert isinstance(executed, dict)
+    assert "errors" not in executed
+    assert executed["data"] == {"sayPromise": {"phrase": "hello"}}
+
+
+@mark.asyncio
+async def test_edge_query():
+    executed = await client.execute_async(
+        'mutation a { other(input: {clientMutationId:"1"}) { clientMutationId, myNodeEdge { cursor node { name }} } }'
+    )
+    assert isinstance(executed, dict)
+    assert "errors" not in executed
+    assert executed["data"] == {
+        "other": {
+            "clientMutationId": "1",
+            "myNodeEdge": {"cursor": "1", "node": {"name": "name"}},
+        }
+    }

venv/lib/python3.9/site-packages/graphene/relay/tests/test_node.py

@@ -0,0 +1,219 @@
+import re
+from textwrap import dedent
+
+from graphql_relay import to_global_id
+
+from ...types import ObjectType, Schema, String
+from ..node import Node, is_node
+
+
+class SharedNodeFields:
+    shared = String()
+    something_else = String()
+
+    def resolve_something_else(*_):
+        return "----"
+
+
+class MyNode(ObjectType):
+    class Meta:
+        interfaces = (Node,)
+
+    name = String()
+
+    @staticmethod
+    def get_node(info, id):
+        return MyNode(name=str(id))
+
+
+class MyOtherNode(SharedNodeFields, ObjectType):
+    extra_field = String()
+
+    class Meta:
+        interfaces = (Node,)
+
+    def resolve_extra_field(self, *_):
+        return "extra field info."
+
+    @staticmethod
+    def get_node(info, id):
+        return MyOtherNode(shared=str(id))
+
+
+class RootQuery(ObjectType):
+    first = String()
+    node = Node.Field()
+    only_node = Node.Field(MyNode)
+    only_node_lazy = Node.Field(lambda: MyNode)
+
+
+schema = Schema(query=RootQuery, types=[MyNode, MyOtherNode])
+
+
+def test_node_good():
+    assert "id" in MyNode._meta.fields
+    assert is_node(MyNode)
+    assert not is_node(object)
+    assert not is_node("node")
+
+
+def test_node_query():
+    executed = schema.execute(
+        '{ node(id:"%s") { ... on MyNode { name } } }' % Node.to_global_id("MyNode", 1)
+    )
+    assert not executed.errors
+    assert executed.data == {"node": {"name": "1"}}
+
+
+def test_subclassed_node_query():
+    executed = schema.execute(
+        '{ node(id:"%s") { ... on MyOtherNode { shared, extraField, somethingElse } } }'
+        % to_global_id("MyOtherNode", 1)
+    )
+    assert not executed.errors
+    assert executed.data == {
+        "node": {
+            "shared": "1",
+            "extraField": "extra field info.",
+            "somethingElse": "----",
+        }
+    }
+
+
+def test_node_requesting_non_node():
+    executed = schema.execute(
+        '{ node(id:"%s") { __typename } } ' % Node.to_global_id("RootQuery", 1)
+    )
+    assert executed.errors
+    assert re.match(
+        r"ObjectType .* does not implement the .* interface.",
+        executed.errors[0].message,
+    )
+    assert executed.data == {"node": None}
+
+
+def test_node_requesting_unknown_type():
+    executed = schema.execute(
+        '{ node(id:"%s") { __typename } } ' % Node.to_global_id("UnknownType", 1)
+    )
+    assert executed.errors
+    assert re.match(r"Relay Node .* not found in schema", executed.errors[0].message)
+    assert executed.data == {"node": None}
+
+
+def test_node_query_incorrect_id():
+    executed = schema.execute(
+        '{ node(id:"%s") { ... on MyNode { name } } }' % "something:2"
+    )
+    assert executed.errors
+    assert re.match(r"Unable to parse global ID .*", executed.errors[0].message)
+    assert executed.data == {"node": None}
+
+
+def test_node_field():
+    node_field = Node.Field()
+    assert node_field.type == Node
+    assert node_field.node_type == Node
+
+
+def test_node_field_custom():
+    node_field = Node.Field(MyNode)
+    assert node_field.type == MyNode
+    assert node_field.node_type == Node
+
+
+def test_node_field_args():
+    field_args = {
+        "name": "my_custom_name",
+        "description": "my_custom_description",
+        "deprecation_reason": "my_custom_deprecation_reason",
+    }
+    node_field = Node.Field(**field_args)
+    for field_arg, value in field_args.items():
+        assert getattr(node_field, field_arg) == value
+
+
+def test_node_field_only_type():
+    executed = schema.execute(
+        '{ onlyNode(id:"%s") { __typename, name } } ' % Node.to_global_id("MyNode", 1)
+    )
+    assert not executed.errors
+    assert executed.data == {"onlyNode": {"__typename": "MyNode", "name": "1"}}
+
+
+def test_node_field_only_type_wrong():
+    executed = schema.execute(
+        '{ onlyNode(id:"%s") { __typename, name } } '
+        % Node.to_global_id("MyOtherNode", 1)
+    )
+    assert len(executed.errors) == 1
+    assert str(executed.errors[0]).startswith("Must receive a MyNode id.")
+    assert executed.data == {"onlyNode": None}
+
+
+def test_node_field_only_lazy_type():
+    executed = schema.execute(
+        '{ onlyNodeLazy(id:"%s") { __typename, name } } '
+        % Node.to_global_id("MyNode", 1)
+    )
+    assert not executed.errors
+    assert executed.data == {"onlyNodeLazy": {"__typename": "MyNode", "name": "1"}}
+
+
+def test_node_field_only_lazy_type_wrong():
+    executed = schema.execute(
+        '{ onlyNodeLazy(id:"%s") { __typename, name } } '
+        % Node.to_global_id("MyOtherNode", 1)
+    )
+    assert len(executed.errors) == 1
+    assert str(executed.errors[0]).startswith("Must receive a MyNode id.")
+    assert executed.data == {"onlyNodeLazy": None}
+
+
+def test_str_schema():
+    assert (
+        str(schema).strip()
+        == dedent(
+            '''
+        schema {
+          query: RootQuery
+        }
+
+        type MyNode implements Node {
+          """The ID of the object"""
+          id: ID!
+          name: String
+        }
+
+        """An object with an ID"""
+        interface Node {
+          """The ID of the object"""
+          id: ID!
+        }
+
+        type MyOtherNode implements Node {
+          """The ID of the object"""
+          id: ID!
+          shared: String
+          somethingElse: String
+          extraField: String
+        }
+
+        type RootQuery {
+          first: String
+          node(
+            """The ID of the object"""
+            id: ID!
+          ): Node
+          onlyNode(
+            """The ID of the object"""
+            id: ID!
+          ): MyNode
+          onlyNodeLazy(
+            """The ID of the object"""
+            id: ID!
+          ): MyNode
+        }
+        '''
+        ).strip()
+    )

venv/lib/python3.9/site-packages/graphene/relay/tests/test_node_custom.py

@@ -0,0 +1,313 @@
+from textwrap import dedent
+
+from graphql import graphql_sync
+
+from ...types import Interface, ObjectType, Schema
+from ...types.scalars import Int, String
+from ..node import Node
+
+
+class CustomNode(Node):
+    class Meta:
+        name = "Node"
+
+    @staticmethod
+    def to_global_id(type_, id):
+        return id
+
+    @staticmethod
+    def get_node_from_global_id(info, id, only_type=None):
+        assert info.schema is graphql_schema
+        if id in user_data:
+            return user_data.get(id)
+        else:
+            return photo_data.get(id)
+
+
+class BasePhoto(Interface):
+    width = Int(description="The width of the photo in pixels")
+
+
+class User(ObjectType):
+    class Meta:
+        interfaces = [CustomNode]
+
+    name = String(description="The full name of the user")
+
+
+class Photo(ObjectType):
+    class Meta:
+        interfaces = [CustomNode, BasePhoto]
+
+
+user_data = {"1": User(id="1", name="John Doe"), "2": User(id="2", name="Jane Smith")}
+
+photo_data = {"3": Photo(id="3", width=300), "4": Photo(id="4", width=400)}
+
+
+class RootQuery(ObjectType):
+    node = CustomNode.Field()
+
+
+schema = Schema(query=RootQuery, types=[User, Photo])
+graphql_schema = schema.graphql_schema
+
+
+def test_str_schema_correct():
+    assert (
+        str(schema).strip()
+        == dedent(
+            '''
+        schema {
+          query: RootQuery
+        }
+
+        type User implements Node {
+          """The ID of the object"""
+          id: ID!
+
+          """The full name of the user"""
+          name: String
+        }
+
+        interface Node {
+          """The ID of the object"""
+          id: ID!
+        }
+
+        type Photo implements Node & BasePhoto {
+          """The ID of the object"""
+          id: ID!
+
+          """The width of the photo in pixels"""
+          width: Int
+        }
+
+        interface BasePhoto {
+          """The width of the photo in pixels"""
+          width: Int
+        }
+
+        type RootQuery {
+          node(
+            """The ID of the object"""
+            id: ID!
+          ): Node
+        }
+        '''
+        ).strip()
+    )
+
+
+def test_gets_the_correct_id_for_users():
+    query = """
+      {
+        node(id: "1") {
+          id
+        }
+      }
+    """
+    expected = {"node": {"id": "1"}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_gets_the_correct_id_for_photos():
+    query = """
+      {
+        node(id: "4") {
+          id
+        }
+      }
+    """
+    expected = {"node": {"id": "4"}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_gets_the_correct_name_for_users():
+    query = """
+      {
+        node(id: "1") {
+          id
+          ... on User {
+            name
+          }
+        }
+      }
+    """
+    expected = {"node": {"id": "1", "name": "John Doe"}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_gets_the_correct_width_for_photos():
+    query = """
+      {
+        node(id: "4") {
+          id
+          ... on Photo {
+            width
+          }
+        }
+      }
+    """
+    expected = {"node": {"id": "4", "width": 400}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_gets_the_correct_typename_for_users():
+    query = """
+      {
+        node(id: "1") {
+          id
+          __typename
+        }
+      }
+    """
+    expected = {"node": {"id": "1", "__typename": "User"}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_gets_the_correct_typename_for_photos():
+    query = """
+      {
+        node(id: "4") {
+          id
+          __typename
+        }
+      }
+    """
+    expected = {"node": {"id": "4", "__typename": "Photo"}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_ignores_photo_fragments_on_user():
+    query = """
+      {
+        node(id: "1") {
+          id
+          ... on Photo {
+            width
+          }
+        }
+      }
+    """
+    expected = {"node": {"id": "1"}}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_returns_null_for_bad_ids():
+    query = """
+      {
+        node(id: "5") {
+          id
+        }
+      }
+    """
+    expected = {"node": None}
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_have_correct_node_interface():
+    query = """
+      {
+        __type(name: "Node") {
+          name
+          kind
+          fields {
+            name
+            type {
+              kind
+              ofType {
+                name
+                kind
+              }
+            }
+          }
+        }
+      }
+    """
+    expected = {
+        "__type": {
+            "name": "Node",
+            "kind": "INTERFACE",
+            "fields": [
+                {
+                    "name": "id",
+                    "type": {
+                        "kind": "NON_NULL",
+                        "ofType": {"name": "ID", "kind": "SCALAR"},
+                    },
+                }
+            ],
+        }
+    }
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected
+
+
+def test_has_correct_node_root_field():
+    query = """
+      {
+        __schema {
+          queryType {
+            fields {
+              name
+              type {
+                name
+                kind
+              }
+              args {
+                name
+                type {
+                  kind
+                  ofType {
+                    name
+                    kind
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    """
+    expected = {
+        "__schema": {
+            "queryType": {
+                "fields": [
+                    {
+                        "name": "node",
+                        "type": {"name": "Node", "kind": "INTERFACE"},
+                        "args": [
+                            {
+                                "name": "id",
+                                "type": {
+                                    "kind": "NON_NULL",
+                                    "ofType": {"name": "ID", "kind": "SCALAR"},
+                                },
+                            }
+                        ],
+                    }
+                ]
+            }
+        }
+    }
+    result = graphql_sync(graphql_schema, query)
+    assert not result.errors
+    assert result.data == expected