Move customization tests for to a separate module

Author: Cito

tests/execution/test_customize.py

@@ -1,8 +1,19 @@
-from graphql.execution import ExecutionContext, execute
+from pytest import mark
+
+from graphql.execution import ExecutionContext, MapAsyncIterator, execute, subscribe
 from graphql.language import parse
 from graphql.type import GraphQLField, GraphQLObjectType, GraphQLSchema, GraphQLString
 
 
+try:
+    anext
+except NameError:  # pragma: no cover (Python < 3.10)
+    # noinspection PyShadowingBuiltins
+    async def anext(iterator):
+        """Return the next item from an async iterator."""
+        return await iterator.__anext__()
+
+
 def describe_customize_execution():
     def uses_a_custom_field_resolver():
         query = parse("{ foo }")
@@ -39,3 +50,73 @@ def execute_field(self, parent_type, source, field_nodes, path):
             {"foo": "barbar"},
             None,
         )
+
+
+def describe_customize_subscription():
+    @mark.asyncio
+    async def uses_a_custom_subscribe_field_resolver():
+        schema = GraphQLSchema(
+            query=GraphQLObjectType("Query", {"foo": GraphQLField(GraphQLString)}),
+            subscription=GraphQLObjectType(
+                "Subscription", {"foo": GraphQLField(GraphQLString)}
+            ),
+        )
+
+        class Root:
+            @staticmethod
+            async def custom_foo():
+                yield {"foo": "FooValue"}
+
+        subscription = await subscribe(
+            schema,
+            document=parse("subscription { foo }"),
+            root_value=Root(),
+            subscribe_field_resolver=lambda root, _info: root.custom_foo(),
+        )
+        assert isinstance(subscription, MapAsyncIterator)
+
+        assert await anext(subscription) == (
+            {"foo": "FooValue"},
+            None,
+        )
+
+        await subscription.aclose()
+
+    @mark.asyncio
+    async def uses_a_custom_execution_context_class():
+        class TestExecutionContext(ExecutionContext):
+            def build_resolve_info(self, *args, **kwargs):
+                resolve_info = super().build_resolve_info(*args, **kwargs)
+                resolve_info.context["foo"] = "bar"
+                return resolve_info
+
+        async def generate_foo(_obj, info):
+            yield info.context["foo"]
+
+        def resolve_foo(message, _info):
+            return message
+
+        schema = GraphQLSchema(
+            query=GraphQLObjectType("Query", {"foo": GraphQLField(GraphQLString)}),
+            subscription=GraphQLObjectType(
+                "Subscription",
+                {
+                    "foo": GraphQLField(
+                        GraphQLString,
+                        resolve=resolve_foo,
+                        subscribe=generate_foo,
+                    )
+                },
+            ),
+        )
+
+        document = parse("subscription { foo }")
+        subscription = await subscribe(
+            schema,
+            document,
+            context_value={},
+            execution_context_class=TestExecutionContext,
+        )
+        assert isinstance(subscription, MapAsyncIterator)
+
+        assert await anext(subscription) == ({"foo": "bar"}, None)

tests/execution/test_subscribe.py

@@ -3,12 +3,7 @@
 
 from pytest import mark, raises
 
-from graphql.execution import (
-    ExecutionContext,
-    MapAsyncIterator,
-    create_source_event_stream,
-    subscribe,
-)
+from graphql.execution import MapAsyncIterator, create_source_event_stream, subscribe
 from graphql.language import parse
 from graphql.pyutils import SimplePubSub
 from graphql.type import (
@@ -214,35 +209,6 @@ async def foo_generator(_obj, _info):
 
         await subscription.aclose()
 
-    @mark.asyncio
-    async def uses_a_custom_default_subscribe_field_resolver():
-        schema = GraphQLSchema(
-            query=DummyQueryType,
-            subscription=GraphQLObjectType(
-                "Subscription", {"foo": GraphQLField(GraphQLString)}
-            ),
-        )
-
-        class Root:
-            @staticmethod
-            async def custom_foo():
-                yield {"foo": "FooValue"}
-
-        subscription = await subscribe(
-            schema,
-            document=parse("subscription { foo }"),
-            root_value=Root(),
-            subscribe_field_resolver=lambda root, _info: root.custom_foo(),
-        )
-        assert isinstance(subscription, MapAsyncIterator)
-
-        assert await anext(subscription) == (
-            {"foo": "FooValue"},
-            None,
-        )
-
-        await subscription.aclose()
-
     @mark.asyncio
     async def should_only_resolve_the_first_field_of_invalid_multi_field():
         did_resolve = {"foo": False, "bar": False}
@@ -897,42 +863,3 @@ def resolve_message(message, _info):
         assert isinstance(subscription, MapAsyncIterator)
 
         assert await anext(subscription) == ({"newMessage": "Hello"}, None)
-
-    @mark.asyncio
-    async def should_work_with_custom_execution_contexts():
-        class CustomExecutionContext(ExecutionContext):
-            def build_resolve_info(self, *args, **kwargs):
-                resolve_info = super().build_resolve_info(*args, **kwargs)
-                resolve_info.context["foo"] = "bar"
-                return resolve_info
-
-        async def generate_messages(_obj, info):
-            yield info.context["foo"]
-
-        def resolve_message(message, _info):
-            return message
-
-        schema = GraphQLSchema(
-            query=QueryType,
-            subscription=GraphQLObjectType(
-                "Subscription",
-                {
-                    "newMessage": GraphQLField(
-                        GraphQLString,
-                        resolve=resolve_message,
-                        subscribe=generate_messages,
-                    )
-                },
-            ),
-        )
-
-        document = parse("subscription { newMessage }")
-        subscription = await subscribe(
-            schema,
-            document,
-            context_value={},
-            execution_context_class=CustomExecutionContext,
-        )
-        assert isinstance(subscription, MapAsyncIterator)
-
-        assert await anext(subscription) == ({"newMessage": "bar"}, None)