Introduction

In unittest.IsolatedAsyncioTestCase, the usual way to run background work is asyncio.create_task, followed by explicit cleanup or awaiting before the test ends. The important part is not just starting the task. The important part is making ownership clear so the test does not leak tasks, swallow exceptions, or finish while background work is still running.

Use asyncio.create_task

Inside an async test method, the standard primitive is asyncio.create_task:

1import asyncio
2import unittest
3
4class BackgroundTaskTests(unittest.IsolatedAsyncioTestCase):
5    async def test_worker(self):
6        async def worker():
7            await asyncio.sleep(0.01)
8            return 42
9
10        task = asyncio.create_task(worker())
11        result = await task
12        self.assertEqual(result, 42)

This is the normal pattern because the test is already running inside an event loop managed by IsolatedAsyncioTestCase.

Background Task Means You Still Need Cleanup

If the task is meant to keep running in the background while the test does something else, store it and cancel or await it explicitly before the test ends.

1import asyncio
2import contextlib
3import unittest
4
5class BackgroundTaskTests(unittest.IsolatedAsyncioTestCase):
6    async def test_background_loop(self):
7        events = []
8
9        async def background():
10            try:
11                while True:
12                    events.append("tick")
13                    await asyncio.sleep(0.01)
14            except asyncio.CancelledError:
15                raise
16
17        task = asyncio.create_task(background())
18
19        await asyncio.sleep(0.03)
20        self.assertTrue(events)
21
22        task.cancel()
23        with contextlib.suppress(asyncio.CancelledError):
24            await task

That final await matters because cancellation is asynchronous too.

addAsyncCleanup Makes Ownership Cleaner

A nice pattern is to register cleanup right after the task is created.

1import asyncio
2import contextlib
3import unittest
4
5class BackgroundTaskTests(unittest.IsolatedAsyncioTestCase):
6    async def asyncSetUp(self):
7        self.tasks = []
8
9    async def _cancel_task(self, task):
10        task.cancel()
11        with contextlib.suppress(asyncio.CancelledError):
12            await task
13
14    async def test_service(self):
15        async def worker():
16            await asyncio.sleep(1)
17
18        task = asyncio.create_task(worker())
19        self.tasks.append(task)
20        self.addAsyncCleanup(self._cancel_task, task)

This keeps task cleanup close to task creation and prevents orphaned tasks if an assertion fails partway through the test.

Let the Test Stay Deterministic

A background task is only useful if the test can still coordinate with it predictably. Use events, queues, or short awaits to synchronize instead of hoping the task "probably ran" by the time the assertion executes.

1import asyncio
2import unittest
3
4class EventTests(unittest.IsolatedAsyncioTestCase):
5    async def test_background_signal(self):
6        event = asyncio.Event()
7
8        async def worker():
9            await asyncio.sleep(0.01)
10            event.set()
11
12        task = asyncio.create_task(worker())
13        await event.wait()
14        await task
15        self.assertTrue(event.is_set())

This is more reliable than arbitrary long sleeps.

This is also why short-lived helper coroutines are often easier to test than free-running background loops. The less open-ended the task lifetime is, the easier it is to prove in the test that startup, progress, and shutdown all happened in the intended order.

That ownership model also makes failures easier to debug. When every background task has an explicit cleanup path, exceptions surface near the responsible test instead of leaking into shutdown warnings later.

Common Pitfalls

The biggest mistake is creating a task and never awaiting or cancelling it. That can leak work into the end of the test and produce confusing warnings or hidden exceptions.

Another issue is assuming create_task alone makes the test robust. It only schedules the coroutine. You still need explicit synchronization if the assertion depends on the task having reached a certain state.

People also often use large sleep values instead of proper coordination primitives such as Event or Queue. That makes tests slower and less deterministic.

Finally, remember that exceptions inside background tasks can be missed if you never await the task. If the result matters, await it or check it explicitly during cleanup.

Summary

• In IsolatedAsyncioTestCase, the standard way to start background work is asyncio.create_task.
• Always await or cancel background tasks before the test ends.
• 'addAsyncCleanup is a clean way to register task teardown.'
• Use Event, Queue, or other coordination primitives instead of guessing with sleeps.
• Task creation is only half the job; deterministic cleanup and synchronization are what make async tests reliable.