Remove expected warnings from tests more reliably

Author: Cito

tests/execution/test_subscribe.py

@@ -33,6 +33,7 @@
     GraphQLString,
 )
 
+from ..fixtures import cleanup
 from ..utils.assert_equal_awaitables_or_values import assert_equal_awaitables_or_values
 
 
@@ -405,6 +406,9 @@ async def async_fn(obj, info):
         assert is_awaitable(result)
         assert await result == expected_result
 
+        del result
+        cleanup()
+
     @mark.asyncio
     async def resolves_to_an_error_for_subscription_resolver_errors():
         expected_result = (

tests/execution/test_sync.py

@@ -1,4 +1,3 @@
-from gc import collect
 from inspect import isawaitable
 
 from pytest import mark, raises
@@ -9,6 +8,8 @@
 from graphql.type import GraphQLField, GraphQLObjectType, GraphQLSchema, GraphQLString
 from graphql.validation import validate
 
+from ..fixtures import cleanup
+
 
 def describe_execute_synchronously_when_possible():
     def _resolve_sync(root_value, _info):
@@ -91,6 +92,8 @@ async def throws_if_encountering_async_execution_with_check_sync():
                 )
             msg = str(exc_info.value)
             assert msg == "GraphQL execution failed to complete synchronously."
+            del exc_info
+            cleanup()
 
         @mark.asyncio
         @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
@@ -108,9 +111,8 @@ async def throws_if_encountering_async_operation_without_check_sync():
                     }
                 ],
             )
-            # garbage collect coroutine in order to not postpone the warning
             del result
-            collect()
+            cleanup()
 
         @mark.asyncio
         @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
@@ -129,6 +131,8 @@ async def throws_if_encountering_async_iterable_execution_with_check_sync():
                 )
             msg = str(exc_info.value)
             assert msg == "GraphQL execution failed to complete synchronously."
+            del exc_info
+            cleanup()
 
         @mark.asyncio
         @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
@@ -145,6 +149,8 @@ async def throws_if_encountering_async_iterable_execution_without_check_sync():
                 execute_sync(schema, document=parse(doc), root_value="rootValue")
             msg = str(exc_info.value)
             assert msg == "GraphQL execution failed to complete synchronously."
+            del exc_info
+            cleanup()
 
     def describe_graphql_sync():
         def reports_errors_raised_during_schema_validation():
@@ -192,6 +198,8 @@ async def throws_if_encountering_async_operation_with_check_sync():
                 graphql_sync(schema, doc, "rootValue", check_sync=True)
             msg = str(exc_info.value)
             assert msg == "GraphQL execution failed to complete synchronously."
+            del exc_info
+            cleanup()
 
         @mark.asyncio
         @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
@@ -209,6 +217,5 @@ async def throws_if_encountering_async_operation_without_check_sync():
                     }
                 ],
             )
-            # garbage collect coroutine in order to not postpone the warning
             del result
-            collect()
+            cleanup()

tests/fixtures/__init__.py

@@ -1,18 +1,29 @@
 """Fixtures for graphql tests"""
 import json
+from gc import collect
 from os.path import dirname, join
 
 from pytest import fixture
 
 
 __all__ = [
+    "cleanup",
     "kitchen_sink_query",
     "kitchen_sink_sdl",
     "big_schema_sdl",
     "big_schema_introspection_result",
 ]
 
 
+def cleanup(rounds=5):
+    """Run garbage collector.
+
+    This can be used to remove coroutines that were not awaited after running tests.
+    """
+    for _generation in range(rounds):
+        collect()
+
+
 def read_graphql(name):
     path = join(dirname(__file__), name + ".graphql")
     return open(path, encoding="utf-8").read()

tests/pyutils/test_is_awaitable.py

@@ -61,49 +61,59 @@ def some_generator():
         assert not is_awaitable(some_generator())
 
     def declines_a_coroutine_function():
-        async def some_coroutine():
+        async def some_async_function():
             return True  # pragma: no cover
 
-        assert not isawaitable(some_coroutine)
-        assert not is_awaitable(some_coroutine)
+        assert not isawaitable(some_async_function)
+        assert not is_awaitable(some_async_function)
 
     @mark.asyncio
-    @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
     async def recognizes_a_coroutine_object():
-        async def some_coroutine():
-            return False  # pragma: no cover
+        async def some_async_function():
+            return True
+
+        some_coroutine = some_async_function()
+
+        assert isawaitable(some_coroutine)
+        assert is_awaitable(some_coroutine)
 
-        assert isawaitable(some_coroutine())
-        assert is_awaitable(some_coroutine())
+        assert await some_coroutine is True
 
     @mark.filterwarnings("ignore::Warning")  # Deprecation and Runtime warnings
     @mark.skipif(
         python_version >= (3, 11),
         reason="Generator-based coroutines not supported any more since Python 3.11",
     )
-    def recognizes_an_old_style_coroutine():  # pragma: no cover
+    async def recognizes_an_old_style_coroutine():  # pragma: no cover
         @asyncio.coroutine  # type: ignore
-        def some_old_style_coroutine():
-            yield False  # pragma: no cover
+        def some_function():
+            yield True
 
-        assert is_awaitable(some_old_style_coroutine())
-        assert is_awaitable(some_old_style_coroutine())
+        some_old_style_coroutine = some_function()
+        assert is_awaitable(some_old_style_coroutine)
+        assert is_awaitable(some_old_style_coroutine)
 
     @mark.asyncio
-    @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
     async def recognizes_a_future_object():
-        async def some_coroutine():
-            return False  # pragma: no cover
+        async def some_async_function():
+            return True
 
-        some_future = asyncio.ensure_future(some_coroutine())
+        some_coroutine = some_async_function()
+        some_future = asyncio.ensure_future(some_coroutine)
 
         assert is_awaitable(some_future)
         assert is_awaitable(some_future)
 
-    @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
-    def declines_an_async_generator():
-        async def some_async_generator():
-            yield True  # pragma: no cover
+        assert await some_future is True
+
+    @mark.asyncio
+    async def declines_an_async_generator():
+        async def some_async_generator_function():
+            yield True
+
+        some_async_generator = some_async_generator_function()
+
+        assert not isawaitable(some_async_generator)
+        assert not is_awaitable(some_async_generator)
 
-        assert not isawaitable(some_async_generator())
-        assert not is_awaitable(some_async_generator())
+        assert await some_async_generator.__anext__() is True

tests/utils/test_assert_equal_awaitables_or_values.py

@@ -38,13 +38,17 @@ async def test_value(value):
             )
 
     @mark.asyncio
-    @mark.filterwarnings("ignore:.* was never awaited:RuntimeWarning")
     async def throws_when_given_mixture_of_equal_values_and_awaitables():
         async def test_value():
             return {"test": "test"}
 
+        value1 = await test_value()
+        value2 = test_value()
+
         with raises(
             AssertionError,
             match=r"Received an invalid mixture of promises and values\.",
         ):
-            await assert_equal_awaitables_or_values(await test_value(), test_value())
+            await assert_equal_awaitables_or_values(value1, value2)
+
+        assert await value2 == value1