Changelog
### 0.23.6
```
- Fix compatibility with pytest 8.2 [800](https://github.com/pytest-dev/pytest-asyncio/pull/800)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see [706](https://github.com/pytest-dev/pytest-asyncio/issues/706)). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
```
### 0.23.5
```
- Declare compatibility with pytest 8 [737](https://github.com/pytest-dev/pytest-asyncio/issues/737)
- Fix typing errors with recent versions of mypy [769](https://github.com/pytest-dev/pytest-asyncio/issues/769)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see [706](https://github.com/pytest-dev/pytest-asyncio/issues/706)). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
```
### 0.23.4
```
- pytest-asyncio no longer imports additional, unrelated packages during test collection [729](https://github.com/pytest-dev/pytest-asyncio/issues/729)
Known issues
As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see [706](https://github.com/pytest-dev/pytest-asyncio/issues/706)). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved.
```
### 0.23.3
```
- Fixes a bug that caused event loops to be closed prematurely when using async generator fixtures with class scope or wider in a function-scoped test [708](https://github.com/pytest-dev/pytest-asyncio/issues/708)
- Fixes a bug that caused an internal pytest error when using unittest.SkipTest in a module [711](https://github.com/pytest-dev/pytest-asyncio/issues/711)
```
### 0.23.2
```
- Fixes a bug that caused an internal pytest error when collecting .txt files [703](https://github.com/pytest-dev/pytest-asyncio/issues/703)
```
### 0.23.1
```
- Fixes a bug that caused an internal pytest error when using module-level skips [701](https://github.com/pytest-dev/pytest-asyncio/issues/701)
```
### 0.23.0
```
This release is backwards-compatible with v0.21.
Changes are non-breaking, unless you upgrade from v0.22.
* BREAKING: The _asyncio_event_loop_ mark has been removed. Event loops with class, module, package, and session scopes can be requested via the _scope_ keyword argument to the _asyncio_ mark.
* Introduces the _event_loop_policy_ fixture which allows testing with non-default or multiple event loops [662](https://github.com/pytest-dev/pytest-asyncio/pull/662)
* Removes pytest-trio from the test dependencies [620](https://github.com/pytest-dev/pytest-asyncio/pull/620)
```
### 0.22.0
```
* Class-scoped and module-scoped event loops can be requested
via the _asyncio_event_loop_ mark. [620](https://github.com/pytest-dev/pytest-asyncio/pull/620)
* Deprecate redefinition of the _event_loop_ fixture. [587](https://github.com/pytest-dev/pytest-asyncio/issues/531)
Users requiring a class-scoped or module-scoped asyncio event loop for their tests
should mark the corresponding class or module with _asyncio_event_loop_.
* Test items based on asynchronous generators always exit with _xfail_ status and emit a warning during the collection phase. This behavior is consistent with synchronous yield tests. [642](https://github.com/pytest-dev/pytest-asyncio/issues/642)
* Remove support for Python 3.7
* Declare support for Python 3.12
```
### 0.21.1
```
* Output a proper error message when an invalid `asyncio_mode` is selected.
* Extend warning message about unclosed event loops with additional possible cause.
531
* Previously, some tests reported "skipped" or "xfailed" as a result. Now all tests report a "success" result.
```
### 0.21.0
```
* Drop compatibility with pytest 6.1. Pytest-asyncio now depends on pytest 7.0 or newer.
* pytest-asyncio cleans up any stale event loops when setting up and tearing down the
event_loop fixture. This behavior has been deprecated and pytest-asyncio emits a
DeprecationWarning when tearing down the event_loop fixture and current event loop
has not been closed.
```
### 0.20.3
```
---
title: 'pytest-asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](https://github.com/ambv/black)
pytest-asyncio is a
[pytest](https://docs.pytest.org/en/latest/contents.html) plugin. It
facilitates testing of code that uses the
[asyncio](https://docs.python.org/3/library/asyncio.html) library.
Specifically, pytest-asyncio provides support for coroutines as test
functions. This allows users to *await* code inside their tests. For
example, the following code is executed as a test item by pytest:
{.python}
pytest.mark.asyncio
async def test_some_asyncio_code():
res = await library.do_something()
assert b"expected result" == res
Note that test classes subclassing the standard
[unittest](https://docs.python.org/3/library/unittest.html) library are
not supported. Users are advised to use
[unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase)
or an async framework such as
[asynctest](https://asynctest.readthedocs.io/en/latest).
pytest-asyncio is available under the [Apache License
2.0](https://github.com/pytest-dev/pytest-asyncio/blob/master/LICENSE).
Installation
============
To install pytest-asyncio, simply:
{.bash}
$ pip install pytest-asyncio
This is enough for pytest to pick up pytest-asyncio.
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.
```
### 0.20.2
```
---
title: 'pytest-asyncio: pytest support for asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](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.
{.sourceCode .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](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]{.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:
{.sourceCode .bash}
$ 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](https://docs.pytest.org/en/latest/reference/customize.html):
{.sourceCode .ini}
pytest.ini
[pytest]
asyncio_mode = auto
The value can be overridden by command-line option for `pytest`
invocation:
{.sourceCode .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; 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](https://docs.python.org/3/library/asyncio-eventloop.html#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.
{.sourceCode .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
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:
{.sourceCode .python}
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.
{.sourceCode .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`.
{.sourceCode .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* 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.
{.sourceCode .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.
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
[unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase)
or an async framework such as
[asynctest](https://asynctest.readthedocs.io/en/latest).
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.
```
### 0.20.1
```
---
title: 'pytest-asyncio: pytest support for asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](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.
{.sourceCode .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](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]{.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:
{.sourceCode .bash}
$ 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](https://docs.pytest.org/en/latest/reference/customize.html):
{.sourceCode .ini}
pytest.ini
[pytest]
asyncio_mode = auto
The value can be overridden by command-line option for `pytest`
invocation:
{.sourceCode .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; 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](https://docs.python.org/3/library/asyncio-eventloop.html#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.
{.sourceCode .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
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:
{.sourceCode .python}
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.
{.sourceCode .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`.
{.sourceCode .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* 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.
{.sourceCode .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.
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
[unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase)
or an async framework such as
[asynctest](https://asynctest.readthedocs.io/en/latest).
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.
```
### 0.20.0
```
---
title: 'pytest-asyncio: pytest support for asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](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.
{.sourceCode .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](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]{.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:
{.sourceCode .bash}
$ 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](https://docs.pytest.org/en/latest/reference/customize.html):
{.sourceCode .ini}
pytest.ini
[pytest]
asyncio_mode = auto
The value can be overridden by command-line option for `pytest`
invocation:
{.sourceCode .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; 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](https://docs.python.org/3/library/asyncio-eventloop.html#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.
{.sourceCode .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
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:
{.sourceCode .python}
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.
{.sourceCode .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`.
{.sourceCode .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* 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.
{.sourceCode .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.
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
[unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase)
or an async framework such as
[asynctest](https://asynctest.readthedocs.io/en/latest).
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.
```
### 0.19.0
```
---
title: 'pytest-asyncio: pytest support for asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](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.
{.sourceCode .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](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]{.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:
{.sourceCode .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*. 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](https://docs.pytest.org/en/latest/reference/customize.html):
{.sourceCode .ini}
pytest.ini
[pytest]
asyncio_mode = auto
The value can be overridden by command-line option for `pytest`
invocation:
{.sourceCode .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; 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.
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`
------------
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](https://docs.python.org/3/library/asyncio-eventloop.html#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.
{.sourceCode .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
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:
{.sourceCode .python}
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.
{.sourceCode .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`.
{.sourceCode .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.
{.sourceCode .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.
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
[unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase)
or an async framework such as
[asynctest](https://asynctest.readthedocs.io/en/latest).
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.
```
### 0.18.3
```
---
title: 'pytest-asyncio: pytest support for asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](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.
{.sourceCode .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](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]{.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:
{.sourceCode .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):
{.sourceCode .ini}
pytest.ini
[pytest]
asyncio_mode = auto
The value can be overridden by command-line option for `pytest`
invocation:
{.sourceCode .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; 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.
{.sourceCode .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.
{.sourceCode .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.
{.sourceCode .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`.
{.sourceCode .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.
{.sourceCode .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.
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).
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.
```
### 0.18.2
```
-----------------
- Fix asyncio auto mode not marking static methods.
[\295](https://github.com/pytest-dev/pytest-asyncio/issues/295)
- Fix a compatibility issue with Hypothesis 6.39.0.
[\302](https://github.com/pytest-dev/pytest-asyncio/issues/302)
```
### 0.18.1
```
-----------------
- Fixes a regression that prevented async fixtures from working in
synchronous tests.
[\286](https://github.com/pytest-dev/pytest-asyncio/issues/286)
```
### 0.18.0
```
-----------------
- Raise a warning if \pytest.mark.asyncio is applied to non-async
function.
[\275](https://github.com/pytest-dev/pytest-asyncio/issues/275)
- Support parametrized `event_loop` fixture.
[\278](https://github.com/pytest-dev/pytest-asyncio/issues/278)
```
### 0.17.2
```
-----------------
- Require `typing-extensions` on Python\<3.8 only.
[\269](https://github.com/pytest-dev/pytest-asyncio/issues/269)
- Fix a regression in tests collection introduced by 0.17.1, the
plugin works fine with non-python tests again.
[\267](https://github.com/pytest-dev/pytest-asyncio/issues/267)
```
### 0.17.1
```
-----------------
- Fixes a bug that prevents async Hypothesis tests from working
without explicit `asyncio` marker when `--asyncio-mode=auto` is set.
[\258](https://github.com/pytest-dev/pytest-asyncio/issues/258)
- Fixed a bug that closes the default event loop if the loop doesn\'t
exist
[\257](https://github.com/pytest-dev/pytest-asyncio/issues/257)
- Added type annotations.
[\198](https://github.com/pytest-dev/pytest-asyncio/issues/198)
- Show asyncio mode in pytest report headers.
[\266](https://github.com/pytest-dev/pytest-asyncio/issues/266)
- Relax `asyncio_mode` type definition; it allows to support pytest
6.1+.
[\262](https://github.com/pytest-dev/pytest-asyncio/issues/262)
```
### 0.17.0
```
~~~~~~~~~~~~~~~~~~~
- `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-dev/pytest-asyncio/issues/219>`_
```
### 0.17.0a6
```
---
title: 'pytest-asyncio: pytest support for asyncio'
---
[](https://pypi.python.org/pypi/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI)
[](https://codecov.io/gh/pytest-dev/pytest-asyncio)
[](https://github.com/pytest-dev/pytest-asyncio)
[](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.
{.sourceCode .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](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]{.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:
{.sourceCode .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):
{.sourceCode .ini}
pytest.ini
[pytest]
asyncio_mode = auto
The value can be overriden by command-line option for `pytest`
invocation:
{.sourceCode .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.
{.sourceCode .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.
{.sourceCode .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.
{.sourceCode .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`.
{.sourceCode .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.
{.sourceCode .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.
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.0a4
```
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 co
pyup-bot
commented
5 months ago
This PR updates pytest-asyncio from 0.14.0 to 0.23.6.
Changelog
### 0.23.6 ``` - Fix compatibility with pytest 8.2 [800](https://github.com/pytest-dev/pytest-asyncio/pull/800) Known issues As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see [706](https://github.com/pytest-dev/pytest-asyncio/issues/706)). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved. ``` ### 0.23.5 ``` - Declare compatibility with pytest 8 [737](https://github.com/pytest-dev/pytest-asyncio/issues/737) - Fix typing errors with recent versions of mypy [769](https://github.com/pytest-dev/pytest-asyncio/issues/769) Known issues As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see [706](https://github.com/pytest-dev/pytest-asyncio/issues/706)). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved. ``` ### 0.23.4 ``` - pytest-asyncio no longer imports additional, unrelated packages during test collection [729](https://github.com/pytest-dev/pytest-asyncio/issues/729) Known issues As of v0.23, pytest-asyncio attaches an asyncio event loop to each item of the test suite (i.e. session, packages, modules, classes, functions) and allows tests to be run in those loops when marked accordingly. Pytest-asyncio currently assumes that async fixture scope is correlated with the new event loop scope. This prevents fixtures from being evaluated independently from the event loop scope and breaks some existing test suites (see [706](https://github.com/pytest-dev/pytest-asyncio/issues/706)). For example, a test suite may require all fixtures and tests to run in the same event loop, but have async fixtures that are set up and torn down for each module. If you're affected by this issue, please continue using the v0.21 release, until it is resolved. ``` ### 0.23.3 ``` - Fixes a bug that caused event loops to be closed prematurely when using async generator fixtures with class scope or wider in a function-scoped test [708](https://github.com/pytest-dev/pytest-asyncio/issues/708) - Fixes a bug that caused an internal pytest error when using unittest.SkipTest in a module [711](https://github.com/pytest-dev/pytest-asyncio/issues/711) ``` ### 0.23.2 ``` - Fixes a bug that caused an internal pytest error when collecting .txt files [703](https://github.com/pytest-dev/pytest-asyncio/issues/703) ``` ### 0.23.1 ``` - Fixes a bug that caused an internal pytest error when using module-level skips [701](https://github.com/pytest-dev/pytest-asyncio/issues/701) ``` ### 0.23.0 ``` This release is backwards-compatible with v0.21. Changes are non-breaking, unless you upgrade from v0.22. * BREAKING: The _asyncio_event_loop_ mark has been removed. Event loops with class, module, package, and session scopes can be requested via the _scope_ keyword argument to the _asyncio_ mark. * Introduces the _event_loop_policy_ fixture which allows testing with non-default or multiple event loops [662](https://github.com/pytest-dev/pytest-asyncio/pull/662) * Removes pytest-trio from the test dependencies [620](https://github.com/pytest-dev/pytest-asyncio/pull/620) ``` ### 0.22.0 ``` * Class-scoped and module-scoped event loops can be requested via the _asyncio_event_loop_ mark. [620](https://github.com/pytest-dev/pytest-asyncio/pull/620) * Deprecate redefinition of the _event_loop_ fixture. [587](https://github.com/pytest-dev/pytest-asyncio/issues/531) Users requiring a class-scoped or module-scoped asyncio event loop for their tests should mark the corresponding class or module with _asyncio_event_loop_. * Test items based on asynchronous generators always exit with _xfail_ status and emit a warning during the collection phase. This behavior is consistent with synchronous yield tests. [642](https://github.com/pytest-dev/pytest-asyncio/issues/642) * Remove support for Python 3.7 * Declare support for Python 3.12 ``` ### 0.21.1 ``` * Output a proper error message when an invalid `asyncio_mode` is selected. * Extend warning message about unclosed event loops with additional possible cause. 531 * Previously, some tests reported "skipped" or "xfailed" as a result. Now all tests report a "success" result. ``` ### 0.21.0 ``` * Drop compatibility with pytest 6.1. Pytest-asyncio now depends on pytest 7.0 or newer. * pytest-asyncio cleans up any stale event loops when setting up and tearing down the event_loop fixture. This behavior has been deprecated and pytest-asyncio emits a DeprecationWarning when tearing down the event_loop fixture and current event loop has not been closed. ``` ### 0.20.3 ``` --- title: 'pytest-asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](https://github.com/ambv/black) pytest-asyncio is a [pytest](https://docs.pytest.org/en/latest/contents.html) plugin. It facilitates testing of code that uses the [asyncio](https://docs.python.org/3/library/asyncio.html) library. Specifically, pytest-asyncio provides support for coroutines as test functions. This allows users to *await* code inside their tests. For example, the following code is executed as a test item by pytest: {.python} pytest.mark.asyncio async def test_some_asyncio_code(): res = await library.do_something() assert b"expected result" == res Note that test classes subclassing the standard [unittest](https://docs.python.org/3/library/unittest.html) library are not supported. Users are advised to use [unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase) or an async framework such as [asynctest](https://asynctest.readthedocs.io/en/latest). pytest-asyncio is available under the [Apache License 2.0](https://github.com/pytest-dev/pytest-asyncio/blob/master/LICENSE). Installation ============ To install pytest-asyncio, simply: {.bash} $ pip install pytest-asyncio This is enough for pytest to pick up pytest-asyncio. 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. ``` ### 0.20.2 ``` --- title: 'pytest-asyncio: pytest support for asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](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. {.sourceCode .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](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]{.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: {.sourceCode .bash} $ 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](https://docs.pytest.org/en/latest/reference/customize.html): {.sourceCode .ini} pytest.ini [pytest] asyncio_mode = auto The value can be overridden by command-line option for `pytest` invocation: {.sourceCode .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; 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](https://docs.python.org/3/library/asyncio-eventloop.html#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. {.sourceCode .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 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: {.sourceCode .python} 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. {.sourceCode .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`. {.sourceCode .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* 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. {.sourceCode .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. 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 [unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase) or an async framework such as [asynctest](https://asynctest.readthedocs.io/en/latest). 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. ``` ### 0.20.1 ``` --- title: 'pytest-asyncio: pytest support for asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](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. {.sourceCode .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](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]{.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: {.sourceCode .bash} $ 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](https://docs.pytest.org/en/latest/reference/customize.html): {.sourceCode .ini} pytest.ini [pytest] asyncio_mode = auto The value can be overridden by command-line option for `pytest` invocation: {.sourceCode .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; 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](https://docs.python.org/3/library/asyncio-eventloop.html#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. {.sourceCode .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 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: {.sourceCode .python} 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. {.sourceCode .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`. {.sourceCode .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* 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. {.sourceCode .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. 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 [unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase) or an async framework such as [asynctest](https://asynctest.readthedocs.io/en/latest). 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. ``` ### 0.20.0 ``` --- title: 'pytest-asyncio: pytest support for asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](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. {.sourceCode .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](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]{.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: {.sourceCode .bash} $ 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](https://docs.pytest.org/en/latest/reference/customize.html): {.sourceCode .ini} pytest.ini [pytest] asyncio_mode = auto The value can be overridden by command-line option for `pytest` invocation: {.sourceCode .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; 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](https://docs.python.org/3/library/asyncio-eventloop.html#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. {.sourceCode .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 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: {.sourceCode .python} 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. {.sourceCode .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`. {.sourceCode .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* 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. {.sourceCode .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. 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 [unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase) or an async framework such as [asynctest](https://asynctest.readthedocs.io/en/latest). 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. ``` ### 0.19.0 ``` --- title: 'pytest-asyncio: pytest support for asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](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. {.sourceCode .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](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]{.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: {.sourceCode .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*. 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](https://docs.pytest.org/en/latest/reference/customize.html): {.sourceCode .ini} pytest.ini [pytest] asyncio_mode = auto The value can be overridden by command-line option for `pytest` invocation: {.sourceCode .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; 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. 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` ------------ 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](https://docs.python.org/3/library/asyncio-eventloop.html#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. {.sourceCode .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 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: {.sourceCode .python} 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. {.sourceCode .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`. {.sourceCode .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. {.sourceCode .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. 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 [unittest.IsolatedAsyncioTestCase](https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase) or an async framework such as [asynctest](https://asynctest.readthedocs.io/en/latest). 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. ``` ### 0.18.3 ``` --- title: 'pytest-asyncio: pytest support for asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](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. {.sourceCode .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](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]{.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: {.sourceCode .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): {.sourceCode .ini} pytest.ini [pytest] asyncio_mode = auto The value can be overridden by command-line option for `pytest` invocation: {.sourceCode .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; 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. {.sourceCode .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. {.sourceCode .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. {.sourceCode .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`. {.sourceCode .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. {.sourceCode .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. 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). 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. ``` ### 0.18.2 ``` ----------------- - Fix asyncio auto mode not marking static methods. [\295](https://github.com/pytest-dev/pytest-asyncio/issues/295) - Fix a compatibility issue with Hypothesis 6.39.0. [\302](https://github.com/pytest-dev/pytest-asyncio/issues/302) ``` ### 0.18.1 ``` ----------------- - Fixes a regression that prevented async fixtures from working in synchronous tests. [\286](https://github.com/pytest-dev/pytest-asyncio/issues/286) ``` ### 0.18.0 ``` ----------------- - Raise a warning if \pytest.mark.asyncio is applied to non-async function. [\275](https://github.com/pytest-dev/pytest-asyncio/issues/275) - Support parametrized `event_loop` fixture. [\278](https://github.com/pytest-dev/pytest-asyncio/issues/278) ``` ### 0.17.2 ``` ----------------- - Require `typing-extensions` on Python\<3.8 only. [\269](https://github.com/pytest-dev/pytest-asyncio/issues/269) - Fix a regression in tests collection introduced by 0.17.1, the plugin works fine with non-python tests again. [\267](https://github.com/pytest-dev/pytest-asyncio/issues/267) ``` ### 0.17.1 ``` ----------------- - Fixes a bug that prevents async Hypothesis tests from working without explicit `asyncio` marker when `--asyncio-mode=auto` is set. [\258](https://github.com/pytest-dev/pytest-asyncio/issues/258) - Fixed a bug that closes the default event loop if the loop doesn\'t exist [\257](https://github.com/pytest-dev/pytest-asyncio/issues/257) - Added type annotations. [\198](https://github.com/pytest-dev/pytest-asyncio/issues/198) - Show asyncio mode in pytest report headers. [\266](https://github.com/pytest-dev/pytest-asyncio/issues/266) - Relax `asyncio_mode` type definition; it allows to support pytest 6.1+. [\262](https://github.com/pytest-dev/pytest-asyncio/issues/262) ``` ### 0.17.0 ``` ~~~~~~~~~~~~~~~~~~~ - `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-dev/pytest-asyncio/issues/219>`_ ``` ### 0.17.0a6 ``` --- title: 'pytest-asyncio: pytest support for asyncio' --- [](https://pypi.python.org/pypi/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI) [](https://codecov.io/gh/pytest-dev/pytest-asyncio) [](https://github.com/pytest-dev/pytest-asyncio) [](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. {.sourceCode .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](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]{.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: {.sourceCode .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): {.sourceCode .ini} pytest.ini [pytest] asyncio_mode = auto The value can be overriden by command-line option for `pytest` invocation: {.sourceCode .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. {.sourceCode .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. {.sourceCode .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. {.sourceCode .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`. {.sourceCode .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. {.sourceCode .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. 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.0a4 ``` 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 co