Cancel remaining type resolvers on exceptions

Author: Cito

src/graphql/execution/execute.py

@@ -2105,25 +2105,39 @@ def default_type_resolver(
     # Otherwise, test each possible type.
     possible_types = info.schema.get_possible_types(abstract_type)
     is_awaitable = info.is_awaitable
-    awaitable_is_type_of_results: list[Awaitable] = []
-    append_awaitable_results = awaitable_is_type_of_results.append
+    awaitable_is_type_of_results: list[Awaitable[bool]] = []
+    append_awaitable_result = awaitable_is_type_of_results.append
     awaitable_types: list[GraphQLObjectType] = []
-    append_awaitable_types = awaitable_types.append
+    append_awaitable_type = awaitable_types.append
 
     for type_ in possible_types:
         if type_.is_type_of:
             is_type_of_result = type_.is_type_of(value, info)
 
             if is_awaitable(is_type_of_result):
-                append_awaitable_results(cast("Awaitable", is_type_of_result))
-                append_awaitable_types(type_)
+                append_awaitable_result(cast("Awaitable[bool]", is_type_of_result))
+                append_awaitable_type(type_)
             elif is_type_of_result:
                 return type_.name
 
     if awaitable_is_type_of_results:
         # noinspection PyShadowingNames
         async def get_type() -> str | None:
-            is_type_of_results = await gather(*awaitable_is_type_of_results)
+            tasks = [
+                create_task(result)  # type: ignore[arg-type]
+                for result in awaitable_is_type_of_results
+            ]
+
+            try:
+                is_type_of_results = await gather(*tasks)
+            except Exception:
+                # Cancel unfinished tasks before raising the exception
+                for task in tasks:
+                    if not task.done():
+                        task.cancel()
+                await gather(*tasks, return_exceptions=True)
+                raise
+
             for is_type_of_result, type_ in zip(is_type_of_results, awaitable_types):
                 if is_type_of_result:
                     return type_.name

tests/execution/test_parallel.py

@@ -336,3 +336,84 @@ async def resolve_iterator(*args):
             await barrier.wait()
             await asyncio.sleep(0)
             assert not completed
+
+        @pytest.mark.asyncio
+        async def cancel_type_resolver():
+            FooType = GraphQLInterfaceType("Foo", {"foo": GraphQLField(GraphQLString)})
+
+            barrier = Barrier(3)
+            completed = False
+
+            async def is_type_of_bar(*_args):
+                raise RuntimeError("Oops")
+
+            BarType = GraphQLObjectType(
+                "Bar",
+                {
+                    "foo": GraphQLField(GraphQLString),
+                },
+                interfaces=[FooType],
+                is_type_of=is_type_of_bar,
+            )
+
+            async def is_type_of_baz(*_args):
+                nonlocal completed
+                await barrier.wait()
+                completed = True  # pragma: no cover
+
+            BazType = GraphQLObjectType(
+                "Baz",
+                {
+                    "foo": GraphQLField(GraphQLString),
+                },
+                interfaces=[FooType],
+                is_type_of=is_type_of_baz,
+            )
+
+            schema = GraphQLSchema(
+                GraphQLObjectType(
+                    "Query",
+                    {
+                        "foo": GraphQLField(
+                            GraphQLList(FooType),
+                            resolve=lambda *_args: [
+                                {"foo": "bar"},
+                                {"foo": "baz"},
+                            ],
+                        )
+                    },
+                ),
+                types=[BarType, BazType],
+            )
+
+            ast = parse(
+                """
+                {
+                foo {
+                    foo
+                    ... on Bar { foobar }
+                    ... on Baz { foobaz }
+                }
+                }
+                """
+            )
+
+            # raises TimeoutError if not parallel
+            awaitable_result = execute(schema, ast)
+            assert isinstance(awaitable_result, Awaitable)
+            result = await asyncio.wait_for(awaitable_result, 1)
+
+            assert result == (
+                {"foo": [None, None]},
+                [
+                    {"message": "Oops", "locations": [(3, 17)], "path": ["foo", 0]},
+                    {"message": "Oops", "locations": [(3, 17)], "path": ["foo", 1]},
+                ],
+            )
+
+            assert not completed
+
+            # Unblock succeed() and check that it does not complete
+            await barrier.wait()
+            await asyncio.sleep(0)
+            assert not completed