25 Mar 09:44

bcdc049

pytest-asyncio 0.18.3

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

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.

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.

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.

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.

Assets 4

03 Mar 11:53

github-actions

v0.18.2

929608e

pytest-asyncio 0.18.2

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.
...

Assets 4

10 Feb 13:01

github-actions

v0.18.1

34436cd

pytest-asyncio 0.18.1

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](https://gi...

Assets 4

07 Feb 11:59

github-actions

v0.18.0

07e9922

pytest-asyncio 0.18.0

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](https://github.com/p...

Assets 4

17 Jan 15:35

github-actions

v0.17.2

4353327

pytest-asyncio 0.17.2

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](https://github.com/...

Assets 4

16 Jan 21:09

github-actions

v0.17.1

8ed5687

pytest-asyncio 0.17.1

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](https://...

Assets 4

13 Jan 11:09

github-actions

v0.17.0

2e2d5d2

pytest-asyncio 0.17.0

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-1...

Assets 4

13 Jan 10:47

github-actions

v0.17.0a6

90436c9

pytest-asyncio 0.17.0a6 Pre-release

Pre-release

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-...

Assets 4

13 Jan 09:59

github-actions

v0.17.0a4

141937b

pytest-asyncio 0.17.0a4 Pre-release

Pre-release

pytest-asyncio: pytest support for asyncio

.. image:: https://img.shields.io/pypi/v/pytest-asyncio.svg
:target: https://pypi.python.org/pypi/pytest-asyncio
.. image:: https://github.com/pytest-dev/pytest-asyncio/workflows/CI/badge.svg
:target: https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI
.. image:: https://codecov.io/gh/pytest-dev/pytest-asyncio/branch/master/graph/badge.svg
:target: https://codecov.io/gh/pytest-dev/pytest-asyncio
.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio.svg
:target: https://github.com/pytest-dev/pytest-asyncio
:alt: Supported Python versions
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
:target: https://github.com/ambv/black

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.

.. code-block:: python

@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_.

.. _pytest-tornado: https://github.com/eugeniy/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:

.. code-block:: bash

$ 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 <https://docs.pytest.org/en/latest/reference/customize.html>_:

.. code-block:: ini

pytest.ini

[pytest]
asyncio_mode = auto

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

.. code-block:: bash

$ 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.

.. code-block:: python

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.

.. code-block:: python

@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.

.. code-block:: python

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``.

.. code-block:: python3

    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.

.. code-block:: python

    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.


.. |pytestmark| replace:: ``pytestmark``
.. _pytestmark: http://doc.pytest.org/en/latest/example/markers.html#marking-whole-classes-or-modules

Note about unittest
-------------------

Test classes subclassing the standard `unittest <https://docs.python.org/3/library/unittest.html>`__ library are not supported, users
are recommended to use `unitest.IsolatedAsyncioTestCase <https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase>`__
or an async framework such as `asynctest <https://asynctest.readthedocs.io/en/latest>`__.

Changelog
---------
0.17.0 (UNRELEASED)
~~~~~~~~~~~~~~~~~~~
- `pytest-asyncio` no longer alters existing event loop policies. `#168 <https://github.com/pytest-dev/pytest-asyncio/issues/168>`_, `#188 <https://github.com/pytest-dev/pytest-asyncio/issues/168>`_
- Drop support for Python 3.6
- Fixed an issue when pytest-asyncio was used in combination with `flaky` or inherited asynchronous Hypothesis tests. `#178 <https://github.com/pytest-dev/pytest-asyncio/issues/178>`_ `#231 <https://github.com/pytest-dev/pytest-asyncio/issues/231>`_
- Added `flaky <https://pypi.org/project/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 <https://github.com/pytest-dev/pytest-asyncio/issues/99>`_
- Added the plugin modes: *strict*, *auto*, and *legacy*. See `documentation <https://github.com/pytest-dev/pytest-asyncio#modes>`_ for details. `#125 <https://github.com/pytest-dev/pytest-asyncio/issues/125>`_
- Correctly process ``KeyboardInterrupt`` during async fixture setup phase `#219 <https://github.com/pytest-de...

Assets 4

13 Jan 09:37

github-actions

v0.17.0a3

696cf7d

pytest-asyncio 0.17.0a3 Pre-release

Pre-release

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.

.. code-block:: python

@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_.

.. _pytest-tornado: https://github.com/eugeniy/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:

.. code-block:: bash

$ 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 <https://docs.pytest.org/en/latest/reference/customize.html>_:

.. code-block:: ini

pytest.ini

[pytest]
asyncio_mode = auto

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

.. code-block:: bash

$ 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.

.. code-block:: python

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.

.. code-block:: python

@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.

.. code-block:: python

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``.

.. code-block:: python3

    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.

.. code-block:: python

    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.


.. |pytestmark| replace:: ``pytestmark``
.. _pytestmark: http://doc.pytest.org/en/latest/example/markers.html#marking-whole-classes-or-modules

Note about unittest
-------------------

Test classes subclassing the standard `unittest <https://docs.python.org/3/library/unittest.html>`__ library are not supported, users
are recommended to use `unitest.IsolatedAsyncioTestCase <https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase>`__
or an async framework such as `asynctest <https://asynctest.readthedocs.io/en/latest>`__.

Changelog
---------
0.17.0 (UNRELEASED)
~~~~~~~~~~~~~~~~~~~
- `pytest-asyncio` no longer alters existing event loop policies. `#168 <https://github.com/pytest-dev/pytest-asyncio/issues/168>`_, `#188 <https://github.com/pytest-dev/pytest-asyncio/issues/168>`_
- Drop support for Python 3.6
- Fixed an issue when pytest-asyncio was used in combination with `flaky` or inherited asynchronous Hypothesis tests. `#178 <https://github.com/pytest-dev/pytest-asyncio/issues/178>`_ `#231 <https://github.com/pytest-dev/pytest-asyncio/issues/231>`_
- Added `flaky <https://pypi.org/project/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 <https://github.com/pytest-dev/pytest-asyncio/issues/99>`_
- Added the plugin modes: *strict*, *auto*, and *legacy*. See `documentation <https://github.com/pytest-dev/pytest-asyncio#modes>`_ for details. `#125 <https://github.com/pytest-dev/pytest-asyncio/issues/125>`_
- Correctly process ``KeyboardInterrupt`` during async fixture setup phase `#219 <https://github.com/pytest-de...

Assets 2

Releases: pytest-dev/pytest-asyncio

pytest-asyncio 0.18.3

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

Features

Installation

Modes

Auto mode

Strict mode

Legacy mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

pytest.mark.asyncio

Note about unittest

Contributing

pytest-asyncio 0.18.2

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

Features

Installation

Modes

Auto mode

Strict mode

Legacy mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

pytest.mark.asyncio

Note about unittest

Changelog

0.18.2 (22-03-03)

0.18.1 (22-02-10)

0.18.0 (22-02-07)

0.17.2 (22-01-17)

0.17.1 (22-01-16)

pytest-asyncio 0.18.1

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

Features

Installation

Modes

Auto mode

Strict mode

Legacy mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

pytest.mark.asyncio

Note about unittest

Changelog

0.18.1 (22-02-10)

0.18.0 (22-02-07)

0.17.2 (22-01-17)

0.17.1 (22-01-16)

pytest-asyncio 0.18.0

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

Features

Installation

Modes

Auto mode

Strict mode

Legacy mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

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`

`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`

`pytest.mark.asyncio`

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`