switch async testing tool to anyio, since pytest-asyncio seems flaky

Author: amirreza8002

pyproject.toml

@@ -57,6 +57,7 @@ brotli = [
 
 [dependency-groups]
 dev = [
+    "anyio>=4.9.0",
     "black>=25.1.0",
     "coverage>=7.8.0",
     "django-cmd>=2.6",
@@ -66,7 +67,6 @@ dev = [
     "mypy>=1.15.0",
     "pre-commit>=4.2.0",
     "pytest>=8.3.5",
-    "pytest-asyncio>=0.26.0",
     "pytest-django>=4.11.1",
     "pytest-mock>=3.14.0",
     "pytest-subtests>=0.14.1",
@@ -104,8 +104,6 @@ ignore_missing_settings = true
 
 [tool.pytest.ini_options]
 DJANGO_SETTINGS_MODULE = "tests.settings.sqlite"
-asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "session"
 
 [tool.coverage.run]
 plugins = ["django_coverage_plugin"]

tests/conftest.py

@@ -3,7 +3,6 @@
 from typing import cast
 
 import pytest
-import pytest_asyncio
 from pytest_django.fixtures import SettingsWrapper
 
 from asgiref.compatibility import iscoroutinefunction
@@ -12,10 +11,13 @@
 from django_valkey.base import BaseValkeyCache
 from django_valkey.cache import ValkeyCache
 
+
+pytestmark = pytest.mark.anyio
+
 # for some reason `isawaitable` doesn't work here
 if iscoroutinefunction(default_cache.clear):
 
-    @pytest_asyncio.fixture(loop_scope="session")
+    @pytest.fixture(scope="function")
     async def cache():
         yield default_cache
         await default_cache.aclear()

tests/tests_async/conftest.py

@@ -0,0 +1,11 @@
+import pytest
+
+
+@pytest.fixture(scope="session")
+def anyio_backend():
+    return "asyncio"
+
+
+@pytest.fixture(scope="session", autouse=True)
+async def keepalive(anyio_backend):
+    pass

tests/tests_async/test_backend.py

@@ -8,7 +8,6 @@
 from unittest.mock import patch, AsyncMock
 
 import pytest
-import pytest_asyncio
 from pytest_django.fixtures import SettingsWrapper
 from pytest_mock import MockerFixture
 
@@ -22,7 +21,10 @@
 from django_valkey.serializers.msgpack import MSGPackSerializer
 
 
-@pytest_asyncio.fixture(loop_scope="session")
+pytestmark = pytest.mark.anyio
+
+
+@pytest.fixture
 async def patch_itersize_setting() -> Iterable[None]:
     del caches["default"]
     with override_settings(DJANGO_VALKEY_SCAN_ITERSIZE=30):
@@ -31,7 +33,6 @@ async def patch_itersize_setting() -> Iterable[None]:
     del caches["default"]
 
 
-@pytest.mark.asyncio(loop_scope="session")
 class TestAsyncDjangoValkeyCache:
     async def test_set_int(self, cache: AsyncValkeyCache):
         if isinstance(cache.client, AsyncHerdClient):

tests/tests_async/test_cache_options.py

@@ -4,7 +4,6 @@
 from typing import cast
 
 import pytest
-import pytest_asyncio
 from pytest import LogCaptureFixture
 from pytest_django.fixtures import SettingsWrapper
 
@@ -15,6 +14,9 @@
 from django_valkey.async_cache.cache import AsyncValkeyCache
 from django_valkey.async_cache.client import AsyncHerdClient, AsyncDefaultClient
 
+
+pytestmark = pytest.mark.anyio
+
 methods_with_no_parameters = {"clear", "close"}
 
 methods_with_one_required_parameters = {
@@ -75,9 +77,8 @@
 }
 
 
-@pytest.mark.asyncio(loop_scope="session")
 class TestDjangoValkeyOmitException:
-    @pytest_asyncio.fixture
+    @pytest.fixture
     async def conf_cache(self, settings: SettingsWrapper):
         caches_settings = copy.deepcopy(settings.CACHES)
         # NOTE: this files raises RuntimeWarning because `conn.close` was not awaited,
@@ -86,7 +87,7 @@ async def conf_cache(self, settings: SettingsWrapper):
         settings.CACHES = caches_settings
         return caches_settings
 
-    @pytest_asyncio.fixture
+    @pytest.fixture
     async def conf_cache_to_ignore_exception(
         self, settings: SettingsWrapper, conf_cache
     ):
@@ -95,7 +96,7 @@ async def conf_cache_to_ignore_exception(
         settings.DJANGO_VALKEY_IGNORE_EXCEPTIONS = True
         settings.DJANGO_VALKEY_LOG_IGNORE_EXCEPTIONS = True
 
-    @pytest_asyncio.fixture
+    @pytest.fixture
     async def ignore_exceptions_cache(
         self, conf_cache_to_ignore_exception
     ) -> AsyncValkeyCache:
@@ -213,7 +214,7 @@ async def test_error_raised_when_ignore_is_not_set(self, conf_cache):
             await cache.get("key")
 
 
-@pytest_asyncio.fixture
+@pytest.fixture
 async def key_prefix_cache(
     cache: AsyncValkeyCache, settings: SettingsWrapper
 ) -> Iterable[AsyncValkeyCache]:
@@ -223,14 +224,13 @@ async def key_prefix_cache(
     yield cache
 
 
-@pytest_asyncio.fixture
+@pytest.fixture
 async def with_prefix_cache() -> Iterable[AsyncValkeyCache]:
     with_prefix = cast(AsyncValkeyCache, caches["with_prefix"])
     yield with_prefix
     await with_prefix.clear()
 
 
-@pytest.mark.asyncio(loop_scope="session")
 class TestDjangoValkeyCacheEscapePrefix:
     async def test_delete_pattern(
         self, key_prefix_cache: AsyncValkeyCache, with_prefix_cache: AsyncValkeyCache
@@ -261,7 +261,6 @@ async def test_keys(
         assert "b" not in keys
 
 
-@pytest.mark.asyncio(loop_scope="session")
 async def test_custom_key_function(cache: AsyncValkeyCache, settings: SettingsWrapper):
     caches_setting = copy.deepcopy(settings.CACHES)
     caches_setting["default"]["KEY_FUNCTION"] = "tests.test_cache_options.make_key"

tests/tests_async/test_client.py

@@ -2,7 +2,6 @@
 from unittest.mock import AsyncMock
 
 import pytest
-import pytest_asyncio
 from pytest_django.fixtures import SettingsWrapper
 from pytest_mock import MockerFixture
 
@@ -11,16 +10,17 @@
 from django_valkey.async_cache.cache import AsyncValkeyCache
 from django_valkey.async_cache.client import AsyncDefaultClient
 
+pytestmark = pytest.mark.anyio
 
-@pytest_asyncio.fixture
+
+@pytest.fixture
 async def cache_client(cache: AsyncValkeyCache) -> Iterable[AsyncDefaultClient]:
     client = cache.client
     await client.aset("TestClientClose", 0)
     yield client
     await client.adelete("TestClientClose")
 
 
-@pytest.mark.asyncio(loop_scope="session")
 class TestClientClose:
     async def test_close_client_disconnect_default(
         self, cache_client: AsyncDefaultClient, mocker: MockerFixture

tests/tests_async/test_connection_factory.py

@@ -6,7 +6,9 @@
 from django_valkey.async_cache import pool
 
 
-@pytest.mark.asyncio
+pytestmark = pytest.mark.anyio
+
+
 async def test_connection_factory_redefine_from_opts():
     cf = sync_pool.get_connection_factory(
         options={
@@ -30,7 +32,6 @@ async def test_connection_factory_redefine_from_opts():
         ),
     ],
 )
-@pytest.mark.asyncio
 async def test_connection_factory_opts(conn_factory: str, expected):
     cf = sync_pool.get_connection_factory(
         path=None,
@@ -55,7 +56,6 @@ async def test_connection_factory_opts(conn_factory: str, expected):
         ),
     ],
 )
-@pytest.mark.asyncio
 async def test_connection_factory_path(conn_factory: str, expected):
     cf = sync_pool.get_connection_factory(
         path=conn_factory,
@@ -66,7 +66,6 @@ async def test_connection_factory_path(conn_factory: str, expected):
     assert isinstance(cf, expected)
 
 
-@pytest.mark.asyncio
 async def test_connection_factory_no_sentinels():
     with pytest.raises(ImproperlyConfigured):
         sync_pool.get_connection_factory(

tests/tests_async/test_connection_string.py

@@ -2,6 +2,8 @@
 
 from django_valkey import pool
 
+pytestmark = pytest.mark.anyio
+
 
 @pytest.mark.parametrize(
     "connection_string",
@@ -11,7 +13,6 @@
         "valkeys://localhost:3333?db=2",
     ],
 )
-@pytest.mark.asyncio
 async def test_connection_strings(connection_string: str):
     cf = pool.get_connection_factory(
         options={

tests/tests_async/test_requests.py

@@ -1,9 +1,13 @@
 import pytest
 
 from django.core import signals
-from django.core.cache import cache, close_caches
+from django.core.cache import close_caches
 
 from django_valkey.base import close_async_caches
+from django_valkey.async_cache.cache import AsyncValkeyCache
+
+
+pytestmark = pytest.mark.anyio
 
 
 class TestWithOldSignal:
@@ -15,7 +19,11 @@ def setup(self):
         signals.request_finished.disconnect(close_caches)
         signals.request_finished.connect(close_async_caches)
 
-    @pytest.mark.asyncio(loop_scope="session")
+    def test_old_receiver_is_registered_and_new_receiver_unregistered(self, setup):
+        sync_receivers, async_receivers = signals.request_finished._live_receivers(None)
+        assert close_caches in sync_receivers
+        assert close_async_caches not in async_receivers
+
     async def test_warning_output_when_request_finished(self, async_client):
         with pytest.warns(
             RuntimeWarning,
@@ -28,7 +36,6 @@ async def test_warning_output_when_request_finished(self, async_client):
             == "coroutine 'AsyncBackendCommands.close' was never awaited"
         )
 
-    @pytest.mark.asyncio(loop_scope="session")
     async def test_manually_await_signal(self, recwarn):
         await signals.request_finished.asend(self.__class__)
         assert len(recwarn) == 1
@@ -38,24 +45,27 @@ async def test_manually_await_signal(self, recwarn):
             == "coroutine 'AsyncBackendCommands.close' was never awaited"
         )
 
-    def test_manually_call_signal(self, recwarn):
-        signals.request_finished.send(self.__class__)
-        assert len(recwarn) == 1
+    # for some reason if i make this function sync, it can't get the log
+    async def test_manually_call_signal(self):
+        with pytest.warns(
+            RuntimeWarning,
+            match="coroutine 'AsyncBackendCommands.close' was never awaited",
+        ) as record:
+            signals.request_finished.send(self.__class__)
+        assert len(record) == 1
 
         assert (
-            str(recwarn[0].message)
+            str(record[0].message)
             == "coroutine 'AsyncBackendCommands.close' was never awaited"
         )
 
 
 class TestWithNewSignal:
-    @pytest.mark.asyncio(loop_scope="session")
     async def test_warning_output_when_request_finished(self, async_client, recwarn):
         await async_client.get("/async/")
 
         assert len(recwarn) == 0
 
-    @pytest.mark.asyncio(loop_scope="session")
     async def test_manually_await_signal(self, recwarn):
         await signals.request_finished.asend(self.__class__)
         assert len(recwarn) == 0
@@ -69,9 +79,8 @@ def test_receiver_is_registered_and_old_receiver_unregistered(self):
         assert close_async_caches in async_receivers
         assert close_caches not in sync_receivers
 
-    @pytest.mark.asyncio(loop_scope="session")
     async def test_close_is_called_by_signal(self, mocker):
-        close_spy = mocker.spy(cache, "close")
+        close_spy = mocker.spy(AsyncValkeyCache, "close")
         await signals.request_finished.asend(self.__class__)
         assert close_spy.await_count == 1
         assert close_spy.call_count == 1