Get the list of tests for the module-scope fixture

[dimaqq]

Today, we advise our library users to set up a fixture that looks like this:

@pytest.fixture(scope='module')
def foo_service(request: pytest.FixtureRequest):
        name = "foo"
        start_service(name)

        yield name

        if request.session.testsfailed:
            log = get_service_logs(name)
            print(log)

        stop_service(name)

Which is fine, except it's imprecise.

The logs are dumped when any test in the session, not current module has failed.
(I'm also unclear about tests that errored out, e.g. some other fixture raised, rather than failed).

Ideally, the module-scoped fixture could get something like request or module_request argument that allows it to interrogate the tests for which this very instance of the fixture was set up.

Is there a way to do this?

Would this be a good feature for pytest itself?

[RonnyPfannschmidt]

Unfortunately its not safety possible at the moment

A approximation woul be a pair of fixtures where the function scoped facade reports each test to the module scoped one

[dimaqq]

This could be worked on...
I'll try to find time to whip up a demo next week!

[Labeeb2339]

The pair-fixture approximation mentioned above is the safe pattern. request.session.testsfailed is global (and includes setup/teardown errors), so a module-scoped fixture cannot use it to identify only its own tests. Put a function-scoped facade in front of the module-scoped service and let the report hook update the service state:

import pytest

service_key = pytest.StashKey[object]()

@pytest.hookimpl(wrapper=True, tryfirst=True)
def pytest_runtest_makereport(item, call):
    report = yield
    service = item.stash.get(service_key, None)
    if service is not None and report.failed:
        service.saw_problem = True
    return report

@pytest.fixture(scope="module")
def foo_service():
    service = start_service("foo")
    service.saw_problem = False
    yield service
    if service.saw_problem:
        print(get_service_logs("foo"))
    stop_service("foo")

@pytest.fixture
def foo(foo_service, request):
    request.node.stash[service_key] = foo_service
    return foo_service

Have tests (and fixtures whose setup should count) depend on foo, not directly on foo_service; making foo the first dependency ensures the service is registered before later setup can fail. report.failed covers call failures and setup/teardown errors, and the module fixture sees the accumulated flag only after all of its tests have finished. If starting the module-scoped service itself fails, that is a module setup error before there is a usable service from which to collect logs.