0.20.211 Nov 2022

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

asyncio code is usually written in the form of coroutines, which makes it slightly more difficult to test using normal testing tools. pytest-asyncio provides useful fixtures and markers to make testing easier.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Pytest-asyncio provides two modes: auto and strict with strict mode being the default.

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

This mode requires the simplest tests and fixtures configuration and is recommended for default usage unless the same project and its test suite should execute tests from different async frameworks, e.g. asyncio and trio. In this case, auto-handling can break tests designed for other framework; please use strict mode instead.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

This mode is used by default for the sake of project inter-compatibility.

Fixtures

`event_loop`

Creates a new asyncio event loop based on the current event loop policy. The new loop is available as the return value of this fixture or via asyncio.get_running_loop. The event loop is closed when the fixture scope ends. The fixture scope defaults to function scope.

Note that just using the event_loop fixture won't make your test function a coroutine. You'll need to interact with the event loop directly, using methods like event_loop.run_until_complete. See the pytest.mark.asyncio marker for treating test functions like coroutines.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

The event_loop fixture can be overridden in any of the standard pytest locations, e.g. directly in the test file, or in conftest.py. This allows redefining the fixture scope, for example:

@pytest.fixture(scope="session")
def event_loop():
    policy = asyncio.get_event_loop_policy()
    loop = policy.new_event_loop()
    yield loop
    loop.close()

If you need to change the type of the event loop, prefer setting a custom event loop policy over redefining the event_loop fixture.

If the pytest.mark.asyncio marker is applied to a test function, the event_loop fixture will be requested automatically by the test function.

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

All scopes are supported, but if you use a non-function scope you will need to redefine the event_loop fixture to have the same or broader scope. Async fixtures need the event loop, and so must have the same or narrower scope than the event_loop fixture.

auto mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

In order to make your test code a little more concise, the pytest pytestmark_ feature can be used to mark entire modules or classes with this marker. Only test coroutines will be affected (by default, coroutines prefixed by test_), so, for example, fixtures are safe to define.

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unittest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Fixes an issue with async fixtures that are defined as methods on a test class not being rebound to the actual test instance. #197

Replaced usage of deprecated @pytest.mark.tryfirst with @pytest.hookimpl(tryfirst=True) #438

Open source →

0.20.121 Oct 2022

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Pytest-asyncio provides two modes: auto and strict with strict mode being the default.

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

This mode is used by default for the sake of project inter-compatibility.

Fixtures

`event_loop`

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

The event_loop fixture can be overridden in any of the standard pytest locations, e.g. directly in the test file, or in conftest.py. This allows redefining the fixture scope, for example:

@pytest.fixture(scope="session")
def event_loop():
    policy = asyncio.get_event_loop_policy()
    loop = policy.new_event_loop()
    yield loop
    loop.close()

If you need to change the type of the event loop, prefer setting a custom event loop policy over redefining the event_loop fixture.

If the pytest.mark.asyncio marker is applied to a test function, the event_loop fixture will be requested automatically by the test function.

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unittest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Fixes an issue that warned about using an old version of pytest, even though the most recent version was installed. #430

Open source →

0.20.021 Oct 2022

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Pytest-asyncio provides two modes: auto and strict with strict mode being the default.

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

This mode is used by default for the sake of project inter-compatibility.

Fixtures

`event_loop`

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

The event_loop fixture can be overridden in any of the standard pytest locations, e.g. directly in the test file, or in conftest.py. This allows redefining the fixture scope, for example:

@pytest.fixture(scope="session")
def event_loop():
    policy = asyncio.get_event_loop_policy()
    loop = policy.new_event_loop()
    yield loop
    loop.close()

If you need to change the type of the event loop, prefer setting a custom event loop policy over redefining the event_loop fixture.

If the pytest.mark.asyncio marker is applied to a test function, the event_loop fixture will be requested automatically by the test function.

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unittest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

BREAKING: Removed legacy mode. If you’re upgrading from v0.19 and you haven’t configured asyncio_mode = legacy , you can upgrade without taking any additional action. If you’re upgrading from an earlier version or you have explicitly enabled legacy mode, you need to switch to auto or strict mode before upgrading to this version.

Deprecate use of pytest v6.

Fixed an issue which prevented fixture setup from being cached. #404

Open source →

0.19.015 Jul 2022Deprecated

Deprecation warnings are emitted with suggestion to either switching to auto mode or using strict mode with @pytest_asyncio.fixture decorators.

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy. Starting from pytest-asyncio>=0.19 the strict mode is the default.

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

This mode is used by default for the sake of project inter-compatibility.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

Deprecation warnings are emitted with suggestion to either switching to auto mode or using strict mode with @pytest_asyncio.fixture decorators.

The default was changed to strict in pytest-asyncio>=0.19.

Fixtures

`event_loop`

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

The event_loop fixture can be overridden in any of the standard pytest locations, e.g. directly in the test file, or in conftest.py. This allows redefining the fixture scope, for example:

@pytest.fixture(scope="session")
def event_loop():
    policy = asyncio.get_event_loop_policy()
    loop = policy.new_event_loop()
    yield loop
    loop.close()

If you need to change the type of the event loop, prefer setting a custom event loop policy over redefining the event_loop fixture.

If the pytest.mark.asyncio marker is applied to a test function, the event_loop fixture will be requested automatically by the test function.

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unittest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

BREAKING: The default asyncio_mode is now strict . #293

Removes setup.py since all relevant configuration is present setup.cfg . Users requiring an editable installation of pytest-asyncio need to use pip v21.1 or newer. #283

Declare support for Python 3.11.

Open source →

0.18.325 Mar 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode or using strict mode with @pytest_asyncio.fixture decorators.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

This fixture can be easily overridden in any of the standard pytest locations (e.g. directly in the test file, or in conftest.py) to use a non-default event loop. This will take effect even if you're using the pytest.mark.asyncio marker and not the event_loop fixture directly.

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

If the pytest.mark.asyncio marker is applied, a pytest hook will ensure the produced loop is set as the default global loop. Fixtures depending on the event_loop fixture can expect the policy to be properly modified when they run.

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Adds pytest-trio to the test dependencies

Fixes a bug that caused pytest-asyncio to try to set up async pytest_trio fixtures in strict mode. #298

Open source →

0.18.23 Mar 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.18.2 (22-03-03)

Fix asyncio auto mode not marking static methods. #295
Fix a compatibility issue with Hypothesis 6.39.0. #302

0.18.1 (22-02-10)

Fixes a regression that prevented async fixtures from working in synchronous tests. #286

0.18.0 (22-02-07)

Raise a warning if @pytest.mark.asyncio is applied to non-async function. #275
Support parametrized event_loop fixture. #278

0.17.2 (22-01-17)

Require typing-extensions on Python<3.8 only. #269
Fix a regression in tests collection introduced by 0.17.1, the plugin works fine with non-python tests again. #267

0.17.1 (22-01-16)

Fixes a bug that prevents async Hypothesis tests from working without explicit asyncio marker when --asyncio-mode=auto is set. #258
Fixed a bug that closes the default event loop if the loop doesn't exist #257
Added type annotations. #198
Show asyncio mode in pytest report headers. #266
Relax asyncio_mode type definition; it allows to support pytest 6.1+. #262

0.17.0 (22-01-13)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Fix asyncio auto mode not marking static methods. #295

Fix a compatibility issue with Hypothesis 6.39.0. #302

Open source →

0.18.110 Feb 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overridden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.18.1 (22-02-10)

Fixes a regression that prevented async fixtures from working in synchronous tests. #286

0.18.0 (22-02-07)

Raise a warning if @pytest.mark.asyncio is applied to non-async function. #275
Support parametrized event_loop fixture. #278

0.17.2 (22-01-17)

Require typing-extensions on Python<3.8 only. #269
Fix a regression in tests collection introduced by 0.17.1, the plugin works fine with non-python tests again. #267

0.17.1 (22-01-16)

Fixes a bug that prevents async Hypothesis tests from working without explicit asyncio marker when --asyncio-mode=auto is set. #258
Fixed a bug that closes the default event loop if the loop doesn't exist #257
Added type annotations. #198
Show asyncio mode in pytest report headers. #266
Relax asyncio_mode type definition; it allows to support pytest 6.1+. #262

0.17.0 (22-01-13)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Fixes a regression that prevented async fixtures from working in synchronous tests. #286

Open source →

0.18.07 Feb 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.18.0 (22-02-07)

Raise a warning if @pytest.mark.asyncio is applied to non-async function. #275
Support parametrized event_loop fixture. #278

0.17.2 (22-01-17)

Require typing-extensions on Python<3.8 only. #269
Fix a regression in tests collection introduced by 0.17.1, the plugin works fine with non-python tests again. #267

0.17.1 (22-01-16)

Fixes a bug that prevents async Hypothesis tests from working without explicit asyncio marker when --asyncio-mode=auto is set. #258
Fixed a bug that closes the default event loop if the loop doesn't exist #257
Added type annotations. #198
Show asyncio mode in pytest report headers. #266
Relax asyncio_mode type definition; it allows to support pytest 6.1+. #262

0.17.0 (22-01-13)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Raise a warning if @pytest.mark.asyncio is applied to non-async function. #275

Support parametrized event_loop fixture. #278

Open source →

0.17.217 Jan 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.17.2 (22-01-17)

Require typing-extensions on Python<3.8 only. #269
Fix a regression in tests collection introduced by 0.17.1, the plugin works fine with non-python tests again. #267

0.17.1 (22-01-16)

Fixes a bug that prevents async Hypothesis tests from working without explicit asyncio marker when --asyncio-mode=auto is set. #258
Fixed a bug that closes the default event loop if the loop doesn't exist #257
Added type annotations. #198
Show asyncio mode in pytest report headers. #266
Relax asyncio_mode type definition; it allows to support pytest 6.1+. #262

0.17.0 (22-01-13)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Require typing-extensions on Python<3.8 only. #269

Fix a regression in tests collection introduced by 0.17.1, the plugin works fine with non-python tests again. #267

Open source →

0.17.116 Jan 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.17.1 (22-01-16)

Fixes a bug that prevents async Hypothesis tests from working without explicit asyncio marker when --asyncio-mode=auto is set. #258
Fixed a bug that closes the default event loop if the loop doesn't exist #257
Added type annotations. #198
Show asyncio mode in pytest report headers. #266
Relax asyncio_mode type definition; it allows to support pytest 6.1+. #262

0.17.0 (22-01-13)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

Fixes a bug that prevents async Hypothesis tests from working without explicit asyncio marker when --asyncio-mode=auto is set. #258

Fixed a bug that closes the default event loop if the loop doesn’t exist #257

Added type annotations. #198

Show asyncio mode in pytest report headers. #266

Relax asyncio_mode type definition; it allows to support pytest 6.1+. #262

Open source →

0.17.013 Jan 2022Deprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.17.0 (22-01-13)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

Additional notes3 sources agree

pytest-asyncio no longer alters existing event loop policies. #168 , #188

Drop support for Python 3.6

Fixed an issue when pytest-asyncio was used in combination with flaky or inherited asynchronous Hypothesis tests. #178 #231

Added flaky to test dependencies

Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99

Added the plugin modes: strict , auto , and legacy . See documentation for details. #125

Correctly process KeyboardInterrupt during async fixture setup phase #219

Open source →

0.17.0a613 Jan 2022pre-releaseDeprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

title: 'pytest-asyncio: pytest support for asyncio'

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for [async def]{.title-ref} fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

`event_loop`

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

`unused_tcp_port`

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

`unused_tcp_port_factory`

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

`unused_udp_port` and `unused_udp_port_factory`

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

`pytest.mark.asyncio`

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.17.0 (UNRELEASED)

[pytest-asyncio]{.title-ref} no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with [flaky]{.title-ref} or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. [#62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>]{.title-ref}

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

0.17.0a413 Jan 2022pre-releaseDeprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

pytest-asyncio: pytest support for asyncio

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for async def fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

This mode requires the simplest tests and fixtures configuration and is recommended for default usage unless the same project and its test suite should execute tests from different async frameworks, e.g. asyncio and trio. In this case, auto-handling can break tests designed for other framework; plase use strict mode instead.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode or using strict mode with @pytest_asyncio.fixture decorators.

In future, the default will be changed.

Fixtures

event_loop

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Note that just using the event_loop fixture won't make your test function a coroutine. You'll need to interact with the event loop directly, using methods like event_loop.run_until_complete. See the pytest.mark.asyncio marker for treating test functions like coroutines.

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

This fixture can be easily overridden in any of the standard pytest locations (e.g. directly in the test file, or in conftest.py) to use a non-default event loop. This will take effect even if you're using the pytest.mark.asyncio marker and not the event_loop fixture directly.

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

If the pytest.mark.asyncio marker is applied, a pytest hook will ensure the produced loop is set as the default global loop. Fixtures depending on the event_loop fixture can expect the policy to be properly modified when they run.

unused_tcp_port

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

unused_tcp_port_factory

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

unused_udp_port and unused_udp_port_factory

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

All scopes are supported, but if you use a non-function scope you will need to redefine the event_loop fixture to have the same or broader scope. Async fixtures need the event loop, and so must have the same or narrower scope than the event_loop fixture.

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

pytest.mark.asyncio

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

In order to make your test code a little more concise, the pytest pytestmark feature can be used to mark entire modules or classes with this marker. Only test coroutines will be affected (by default, coroutines prefixed by test_), so, for example, fixtures are safe to define.

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.17.0 (UNRELEASED)

pytest-asyncio no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with flaky or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. #62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

0.17.0a313 Jan 2022pre-releaseDeprecated

This mode is used by default for the sake of backward compatibility, deprecation warnings are emitted with suggestion to either switching to auto mode…

pytest-asyncio: pytest support for asyncio

pytest-asyncio is an Apache2 licensed library, written in Python, for testing asyncio code with pytest.

@pytest.mark.asyncio
async def test_some_asyncio_code():
    res = await library.do_something()
    assert b"expected result" == res

pytest-asyncio has been strongly influenced by pytest-tornado.

Features

fixtures for creating and injecting versions of the asyncio event loop
fixtures for injecting unused tcp/udp ports
pytest markers for treating tests as asyncio coroutines
easy testing with non-default event loops
support for async def fixtures and async generator fixtures
support auto mode to handle all async fixtures and tests automatically by asyncio; provide strict mode if a test suite should work with different async frameworks simultaneously, e.g. asyncio and trio.

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.

Modes

Starting from pytest-asyncio>=0.17, three modes are provided: auto, strict and legacy (default).

The mode can be set by asyncio_mode configuration option in configuration file:

# pytest.ini
[pytest]
asyncio_mode = auto

The value can be overriden by command-line option for pytest invocation:

$ pytest tests --asyncio-mode=strict

Auto mode

When the mode is auto, all discovered async tests are considered asyncio-driven even if they have no @pytest.mark.asyncio marker.

All async fixtures are considered asyncio-driven as well, even if they are decorated with a regular @pytest.fixture decorator instead of dedicated @pytest_asyncio.fixture counterpart.

asyncio-driven means that tests and fixtures are executed by pytest-asyncio plugin.

This mode requires the simplest tests and fixtures configuration and is recommended for default usage unless the same project and its test suite should execute tests from different async frameworks, e.g. asyncio and trio. In this case, auto-handling can break tests designed for other framework; plase use strict mode instead.

Strict mode

Strict mode enforces @pytest.mark.asyncio and @pytest_asyncio.fixture usage. Without these markers, tests and fixtures are not considered as asyncio-driven, other pytest plugin can handle them.

Please use this mode if multiple async frameworks should be combined in the same test suite.

Legacy mode

This mode follows rules used by pytest-asyncio<0.17: tests are not auto-marked but fixtures are.

In future, the default will be changed.

Fixtures

event_loop

Creates and injects a new instance of the default asyncio event loop. By default, the loop will be closed at the end of the test (i.e. the default fixture scope is function).

Simply using this fixture will not set the generated event loop as the default asyncio event loop, or change the asyncio event loop policy in any way. Use pytest.mark.asyncio for this purpose.

def test_http_client(event_loop):
    url = "http://httpbin.org/get"
    resp = event_loop.run_until_complete(http_client(url))
    assert b"HTTP/1.1 200 OK" in resp

@pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

unused_tcp_port

Finds and yields a single unused TCP port on the localhost interface. Useful for binding temporary test servers.

unused_tcp_port_factory

A callable which returns a different unused TCP port each invocation. Useful when several unused TCP ports are required in a test.

def a_test(unused_tcp_port_factory):
    port1, port2 = unused_tcp_port_factory(), unused_tcp_port_factory()
    ...

unused_udp_port and unused_udp_port_factory

Work just like their TCP counterparts but return unused UDP ports.

Async fixtures

Asynchronous fixtures are defined just like ordinary pytest fixtures, except they should be decorated with @pytest_asyncio.fixture.

import pytest_asyncio


@pytest_asyncio.fixture
async def async_gen_fixture():
    await asyncio.sleep(0.1)
    yield "a value"


@pytest_asyncio.fixture(scope="module")
async def async_fixture():
    return await asyncio.sleep(0.1)

auto and legacy mode automatically converts async fixtures declared with the standard @pytest.fixture decorator to asyncio-driven versions.

Markers

pytest.mark.asyncio

Mark your test coroutine with this marker and pytest will execute it as an asyncio task using the event loop provided by the event_loop fixture. See the introductory section for an example.

The event loop used can be overridden by overriding the event_loop fixture (see above).

import asyncio

import pytest

# All test coroutines will be treated as marked.
pytestmark = pytest.mark.asyncio


async def test_example(event_loop):
    """No marker!"""
    await asyncio.sleep(0, loop=event_loop)

In auto mode, the pytest.mark.asyncio marker can be omitted, the marker is added automatically to async test functions.

Note about unittest

Test classes subclassing the standard unittest library are not supported, users are recommended to use unitest.IsolatedAsyncioTestCase or an async framework such as asynctest.

Changelog

0.17.0 (UNRELEASED)

pytest-asyncio no longer alters existing event loop policies. #168, #188
Drop support for Python 3.6
Fixed an issue when pytest-asyncio was used in combination with flaky or inherited asynchronous Hypothesis tests. #178 #231
Added flaky to test dependencies
Added unused_udp_port and unused_udp_port_factory fixtures (similar to unused_tcp_port and unused_tcp_port_factory counterparts. #99
Added the plugin modes: strict, auto, and legacy. See documentation for details. #125
Correctly process KeyboardInterrupt during async fixture setup phase #219

0.16.0 (2021-10-16)

Add support for Python 3.10

0.15.1 (2021-04-22)

Hotfix for errors while closing event loops while replacing them. #209 #210

0.15.0 (2021-04-19)

Add support for Python 3.9
Abandon support for Python 3.5. If you still require support for Python 3.5, please use pytest-asyncio v0.14 or earlier.
Set unused_tcp_port_factory fixture scope to 'session'. #163
Properly close event loops when replacing them. #208

0.14.0 (2020-06-24)

Fix #162, and event_loop fixture behavior now is coherent on all scopes. #164

0.12.0 (2020-05-04)

Run the event loop fixture as soon as possible. This helps with fixtures that have an implicit dependency on the event loop. #156

0.11.0 (2020-04-20)

Test on 3.8, drop 3.3 and 3.4. Stick to 0.10 for these versions. #152
Use the new Pytest 5.4.0 Function API. We therefore depend on pytest >= 5.4.0. #142
Better pytest.skip support. #126

0.10.0 (2019-01-08)

pytest-asyncio integrates with Hypothesis to support @given on async test functions using asyncio. #102
Pytest 4.1 support. #105

0.9.0 (2018-07-28)

Python 3.7 support.
Remove event_loop_process_pool fixture and pytest.mark.asyncio_process_pool marker (see https://bugs.python.org/issue34075 for deprecation and removal details)

0.8.0 (2017-09-23)

Improve integration with other packages (like aiohttp) with more careful event loop handling. #64

0.7.0 (2017-09-08)

Python versions pre-3.6 can use the async_generator library for async fixtures. #62 <https://github.com/pytest-dev/pytest-asyncio/pull/62>

0.6.0 (2017-05-28)

Support for Python versions pre-3.5 has been dropped.
pytestmark now works on both module and class level.
The forbid_global_loop parameter has been removed.
Support for async and async gen fixtures has been added. #45
The deprecation warning regarding asyncio.async() has been fixed. #51

0.5.0 (2016-09-07)

Introduced a changelog. #31
The event_loop fixture is again responsible for closing itself. This makes the fixture slightly harder to correctly override, but enables other fixtures to depend on it correctly. #30
Deal with the event loop policy by wrapping a special pytest hook, pytest_fixture_setup. This allows setting the policy before fixtures dependent on the event_loop fixture run, thus allowing them to take advantage of the forbid_global_loop parameter. As a consequence of this, we now depend on pytest 3.0. #29

0.4.1 (2016-06-01)

Fix a bug preventing the propagation of exceptions from the plugin. #25

0.4.0 (2016-05-30)

Make event_loop fixtures simpler to override by closing them in the plugin, instead of directly in the fixture. #21
Introduce the forbid_global_loop parameter. #21

0.3.0 (2015-12-19)

Support for Python 3.5 async/await syntax. #17

0.2.0 (2015-08-01)

unused_tcp_port_factory fixture. #10

0.1.1 (2015-04-23)

Initial release.

Contributing

Contributions are very welcome. Tests can be run with tox, please ensure the coverage at least stays the same before you submit a pull request.

Open source →

pytest-asyncio

Release timeline

Releases

1.4.0 - 2026-05-26

Deprecated

Added

Changed

Fixed

Notes for Downstream Packagers

1.4.0a2 - 2026-05-02

Deprecated

Added

Changed

Fixed

Notes for Downstream Packagers

1.4.0a1 - 2026-04-15

Added

Changed

Notes for Downstream Packagers

1.4.0a0 - 2026-03-25

Added

Changed

1.3.0 - 2025-11-10

Removed

Added

Notes for Downstream Packagers

1.2.0 - 2025-09-12

Added

Fixed

Notes for Downstream Packagers

v1.1.1 - 2025-09-12

Notes for Downstream Packagers

v1.1.1 - 2025-09-12

Notes for Downstream Packagers

Added

Fixed

Notes for Downstream Packagers

1.1.0a1 - 2025-06-30

Added

Fixed

Notes for Downstream Packagers

1.0.0 - 2025-05-26

Removed

Added

Changed

Fixed

Notes for Downstream Packagers

1.0.0a1 - 2025-05-09

Removed

Added

Changed

0.25.0 (2024-12-13)

0.24.0 (2024-08-22)

0.24.0 (UNRELEASED)

0.24.0 (UNRELEASED)

0.23.8 (2024-07-17)

Known issues

0.23.7 (2024-05-19)

Known issues

0.23.6 (2024-03-19)

Known issues

0.23.5 (2024-02-09)

Known issues

0.23.5 (2024-02-09)

Known issues

0.23.5 (UNRELEASED)

Known issues

0.23.4 (2024-01-28)

Known issues 

0.23.4 (UNRELEASED)

Known issues

0.23.4 (UNRELEASED)

Known issues

0.23.4 (UNRELEASED)

Known issues

0.23.3 (2024-01-01)

Known issues

0.23.3 (UNRELEASED)

0.23.2 (2023-12-04)

0.23.1 (2023-12-03)

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`