Update dependency pytest-asyncio to v0.23.6

Open renovate[bot] opened this issue 7 months ago • 0 comments

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
pytest-asyncio (changelog)	`0.17.2` -> `0.23.6`

Release Notes

pytest-dev/pytest-asyncio (pytest-asyncio)

`v0.23.6`

Compare Source

`v0.23.5`: pytest-asyncio 0.23.5

Compare Source

0.23.5 (2024-02-09)

Declare compatibility with pytest 8 #737
Fix typing errors with recent versions of mypy #769
Prevent DeprecationWarning about internal use of asyncio.get_event_loop() from affecting test cases #757

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

`v0.23.4`: pytest-asyncio 0.23.4

Compare Source

0.23.4 (2024-01-28)

pytest-asyncio no longer imports additional, unrelated packages during test collection #729
Addresses further issues that caused an internal pytest error during test collection
Declares incompatibility with pytest 8 #737

`v0.23.3`: pytest-asyncio 0.23.3

Compare Source

0.23.3 (2024-01-01)

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 #706
Fixes various bugs that caused an internal pytest error during test collection #711 #713 #719

Known issues

`v0.23.2`: pytest-asyncio 0.23.2

Compare Source

0.23.2 (2023-12-04)

Fixes a bug that caused an internal pytest error when collecting .txt files #703

`v0.23.1`: pytest-asyncio 0.23.1

Compare Source

0.23.1 (2023-12-03)

Fixes a bug that caused an internal pytest error when using module-level skips #701

`v0.23.0`: pytest-asyncio 0.23.0

Compare Source

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
Introduces pytest_asyncio.is_async_test which returns whether a test item is managed by pytest-asyncio #376
Removes and pytest-trio, mypy, and flaky from the test dependencies #620, #674, #678

`v0.22.0`: pytest-asyncio 0.22.0 (yanked)

Compare Source

This release deprecated event loop overrides, but didn't provide adequate replacement functionality for all relevant use cases. As such, the release was yanked from PyPI.

0.22.0 (2023-10-31)

Class-scoped and module-scoped event loops can be requested via the asyncio_event_loop mark. #620
Deprecate redefinition of the event_loop fixture. #587 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
Remove support for Python 3.7
Declare support for Python 3.12

`v0.21.1`: pytest-asyncio 0.21.1

Compare Source

0.21.1 (2023-07-12)

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.

`v0.21.0`: pytest-asyncio 0.21.0

Compare Source

0.21.0 (23-03-19)

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.

`v0.20.3`: pytest-asyncio 0.20.3

Compare Source

title: 'pytest-asyncio'

pytest-asyncio is a pytest plugin. It facilitates testing of code that uses the asyncio 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:

@&#8203;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 library are not supported. Users are advised to use unittest.IsolatedAsyncioTestCase or an async framework such as asynctest.

pytest-asyncio is available under the Apache License 2.0.

Installation

To install pytest-asyncio, simply:

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

`v0.20.2`: pytest-asyncio 0.20.2

Compare Source

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

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

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

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

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

Features

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

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

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

Modes

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

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


### pytest.ini
[pytest]
asyncio_mode = auto

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

$ pytest tests --asyncio-mode=strict

Auto mode

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

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

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

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

Strict mode

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

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

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

Fixtures

`event_loop`

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

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

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

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

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

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

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

`unused_tcp_port`

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

`unused_tcp_port_factory`

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

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

`unused_udp_port` and `unused_udp_port_factory`

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

Async fixtures

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

import pytest_asyncio

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

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

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

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

Markers

`pytest.mark.asyncio`

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

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

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

import asyncio

import pytest

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

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

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

Note about unittest

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

Contributing

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

`v0.20.1`: pytest-asyncio 0.20.1

Compare Source

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

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

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

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

Features

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

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

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

Modes

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

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


### pytest.ini
[pytest]
asyncio_mode = auto

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

$ pytest tests --asyncio-mode=strict

Auto mode

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

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

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

Strict mode

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

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

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

Fixtures

`event_loop`

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

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

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

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

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

`unused_tcp_port`

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

`unused_tcp_port_factory`

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

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

`unused_udp_port` and `unused_udp_port_factory`

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

Async fixtures

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

import pytest_asyncio

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

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

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

Markers

`pytest.mark.asyncio`

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

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

import asyncio

import pytest

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

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

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

Note about unittest

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

Contributing

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

`v0.20.0`: pytest-asyncio 0.20.0

Compare Source

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

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

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

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

Features

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

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

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

Modes

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

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


### pytest.ini
[pytest]
asyncio_mode = auto

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

$ pytest tests --asyncio-mode=strict

Auto mode

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

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

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

Strict mode

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

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

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

Fixtures

`event_loop`

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

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

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

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

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

`unused_tcp_port`

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

`unused_tcp_port_factory`

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

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

`unused_udp_port` and `unused_udp_port_factory`

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

Async fixtures

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

import pytest_asyncio

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

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

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

Markers

`pytest.mark.asyncio`

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

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

import asyncio

import pytest

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

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

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

Note about unittest

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

Contributing

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

`v0.19.0`: pytest-asyncio 0.19.0

Compare Source

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

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

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

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

Features

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

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

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

Modes

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

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


### pytest.ini
[pytest]
asyncio_mode = auto

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

$ pytest tests --asyncio-mode=strict

Auto mode

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

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

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

Strict mode

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

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

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

Legacy mode

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

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

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

Fixtures

`event_loop`

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

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

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

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

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

`unused_tcp_port`

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

`unused_tcp_port_factory`

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

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

`unused_udp_port` and `unused_udp_port_factory`

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

Async fixtures

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

import pytest_asyncio

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

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

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

Markers

`pytest.mark.asyncio`

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

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

import asyncio

import pytest

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

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

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

Note about unittest

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

Contributing

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

`v0.18.3`: pytest-asyncio 0.18.3

Compare Source

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

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

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

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

Features

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

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

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

Modes

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

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


### pytest.ini
[pytest]
asyncio_mode = auto

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

$ pytest tests --asyncio-mode=strict

Auto mode

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

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

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

Strict mode

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

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

Legacy mode

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

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

In future, the default will be changed.

Fixtures

`event_loop`

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

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

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

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

@&#8203;pytest.fixture
def event_loop():
    loop = MyCustomLoop()
    yield loop
    loop.close()

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

`unused_tcp_port`

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

`unused_tcp_port_factory`

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

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

`unused_udp_port` and `unused_udp_port_factory`

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

Async fixtures

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

import pytest_asyncio

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

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

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

Markers

`pytest.mark.asyncio`

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

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

import asyncio

import pytest

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

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

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

Note about unittest

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

Contributing

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

`v0.18.2`: pytest-asyncio 0.18.2

Compare Source

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

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

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

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

Features

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

Installation

To install pytest-asyncio, simply:

$ pip install pytest-asyncio

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

Modes

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

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


### pytest.ini
[pytest]
asyncio_mode = auto

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

$ pytest tests --asyncio-mode=strict

Auto mode

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

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

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

Strict mode

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

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

Legacy mode

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

In future, the default will be changed.

Fixtures

`event_loop`

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

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

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

@&#8203;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 i

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

[ ] If you want to rebase/retry this PR, check this box

This PR has been generated by Mend Renovate. View repository job log here.

Nov 13 '23 03:11 renovate[bot]

aiohttp-aiofiles-tutorial aiohttp-aiofiles-tutorial copied to clipboard

Update dependency pytest-asyncio to v0.23.6

Release Notes

v0.23.6

v0.23.5: pytest-asyncio 0.23.5

0.23.5 (2024-02-09)

Known issues

v0.23.4: pytest-asyncio 0.23.4

0.23.4 (2024-01-28)

v0.23.3: pytest-asyncio 0.23.3

0.23.3 (2024-01-01)

Known issues

v0.23.2: pytest-asyncio 0.23.2

0.23.2 (2023-12-04)

v0.23.1: pytest-asyncio 0.23.1

0.23.1 (2023-12-03)

v0.23.0: pytest-asyncio 0.23.0

v0.22.0: pytest-asyncio 0.22.0 (yanked)

0.22.0 (2023-10-31)

v0.21.1: pytest-asyncio 0.21.1

0.21.1 (2023-07-12)

v0.21.0: pytest-asyncio 0.21.0

0.21.0 (23-03-19)

v0.20.3: pytest-asyncio 0.20.3

title: 'pytest-asyncio'

Installation

Contributing

v0.20.2: pytest-asyncio 0.20.2

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

Features

Installation

Modes

Auto mode

Strict mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

pytest.mark.asyncio

Note about unittest

Contributing

v0.20.1: pytest-asyncio 0.20.1

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

Features

Installation

Modes

Auto mode

Strict mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

pytest.mark.asyncio

Note about unittest

Contributing

v0.20.0: pytest-asyncio 0.20.0

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

Features

Installation

Modes

Auto mode

Strict mode

Fixtures

event_loop

unused_tcp_port

unused_tcp_port_factory

unused_udp_port and unused_udp_port_factory

Async fixtures

Markers

pytest.mark.asyncio

Note about unittest

Contributing

v0.19.0: pytest-asyncio 0.19.0

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

aiohttp-aiofiles-tutorial
aiohttp-aiofiles-tutorial copied to clipboard

`v0.23.6`

`v0.23.5`: pytest-asyncio 0.23.5

`v0.23.4`: pytest-asyncio 0.23.4

`v0.23.3`: pytest-asyncio 0.23.3

`v0.23.2`: pytest-asyncio 0.23.2

`v0.23.1`: pytest-asyncio 0.23.1

`v0.23.0`: pytest-asyncio 0.23.0

`v0.22.0`: pytest-asyncio 0.22.0 (yanked)

`v0.21.1`: pytest-asyncio 0.21.1

`v0.21.0`: pytest-asyncio 0.21.0

`v0.20.3`: pytest-asyncio 0.20.3

`v0.20.2`: pytest-asyncio 0.20.2

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`v0.20.1`: pytest-asyncio 0.20.1

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`v0.20.0`: pytest-asyncio 0.20.0

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`v0.19.0`: pytest-asyncio 0.19.0

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`v0.18.3`: pytest-asyncio 0.18.3

`event_loop`

`unused_tcp_port`

`unused_tcp_port_factory`

`unused_udp_port` and `unused_udp_port_factory`

`pytest.mark.asyncio`

`v0.18.2`: pytest-asyncio 0.18.2

`event_loop`