Async Testing

Modes, Markers, and Event Loops

Plain pytest cannot await coroutines — without a plugin, async tests are skipped with "async def functions are not natively supported". pytest-asyncio wraps each async test in an event loop.

# pyproject.toml
[tool.pytest.ini_options]
asyncio_mode = "auto"        # no markers needed; "strict" (default) requires them

In strict mode every coroutine test carries the marker:

import pytest

@pytest.mark.asyncio
async def test_fetch(client):
    resp = await client.get("/health")
    assert resp.status == 200

By default each test gets a function-scoped loop, created and closed around it — anything bound to one loop (clients, locks) must not leak into the next test. Unmarked async tests in strict mode are silently skipped, which is the most common "my tests never ran" bug.

Async Fixtures and Composition

Async fixtures need the plugin’s decorator in strict/standard mode so they are awaited on the right loop:

import pytest_asyncio

@pytest_asyncio.fixture
async def db_url(tmp_path):
    server = await start_db(tmp_path)     # awaited setup
    yield f"sqlite+aiosqlite:///{server}"
    await server.stop()                   # awaited teardown

@pytest_asyncio.fixture(loop_scope="session")
async def app_client():
    async with AsyncClient(app=app) as c:
        yield c

loop_scope (matching the test’s @pytest.mark.asyncio(loop_scope="session")) lets fixtures and tests share one loop across a module or session — necessary when a background task or connection pool must survive multiple tests. Keep the scope change deliberate: a session loop widens the blast radius of leaked tasks.

Pitfalls and Interview Angles

• Coroutine never awaited. Creating a task and forgetting await/asyncio.gather yields a RuntimeWarning and a test that asserts nothing; enable filterwarnings = error to convert warnings into failures.
• Loop mismatch. Binding an object on loop A and awaiting it on loop B raises "attached to a different loop" — scopes must match across fixture and test.
• Order dependence. asyncio.create_task work continues until the loop closes; cancel or await tasks in teardown so tests stay isolated.
• Timeouts. Pair with pytest-timeout so a hung await fails fast instead of stalling CI.

Interview angle: explain the loop lifecycle pytest-asyncio manages (create → run test → run teardown → close), why asyncio.run per test is the default isolation strategy, and how you would test code that assumes a long-lived loop.