Pytest hook in runtest protocol

[tcpdcp22]

Hello.

I use pytest 8.2.2

Could you please explain:

1. How can you get information about the status of the completed test in hooks pytest_runtest_call or pytest_runtest_teardown?
   if i write

@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_call(item):
    outcome = yield
    res = outcome.get_result()

@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_teardown(item, nextitem):
    outcome = yield
    res = outcome.get_result()

in 'res' I don't see the test status, why? After all, logically, these hooks call the next tests or a teardown for a test and already know about the result of the completed test.

2. Why in hook 1 when filtering by call.when param at the 'teardown' stage do I see the status of my test as 'failed' although it passed? And at the 'call' stage - the test is marked as 'passed'

@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item, call):
    outcome = yield
    report = outcome.get_result()
    # if call.when == 'call':
    if call.when == 'teardown':
        item.res = report.outcome

3. In native realisation I see that code, why and how work return(yield)?

@hookimpl(wrapper=True)
    def pytest_runtest_teardown(self, item: Item) -> Generator[None, None, None]:
        with self.item_capture("teardown", item):
            return (yield)

[portyu9]

Hi @tcpdcp22

The important distinction is between running a test phase and creating the report for that phase.

Pytest executes three phases:

setup
call
teardown

and each phase receives its own TestReport.

pytest_runtest_call() executes the test body. Its return value is not the test's pass/fail report, so wrapping it does not give you a TestReport through the hook result.

If you need the result, use:

pytest_runtest_makereport

For current-style pluggy wrappers:

import pytest


@pytest.hookimpl(wrapper=True)
def pytest_runtest_makereport(item, call):
    report = yield

    if report.when == "call":
        if report.passed:
            print("test passed")
        elif report.failed:
            print("test failed")
        elif report.skipped:
            print("test skipped")

    return report

For the older hookwrapper=True form, the pattern is:

@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item, call):
    outcome = yield
    report = outcome.get_result()

    if report.when == "call":
        print(report.outcome)

That also explains why you can see:

call: passed
teardown: failed

Those are not contradictory.

For example:

@pytest.fixture
def resource():
    yield

    raise RuntimeError("cleanup failed")


def test_example(resource):
    assert True

The test body succeeds:

report.when == "call"
report.passed == True

but fixture cleanup fails later:

report.when == "teardown"
report.failed == True

Pytest therefore reports the overall test run with a teardown error even though the actual test function passed.

Finally, code such as:

return (yield)

in a wrapper simply forwards the result produced by the wrapped hook implementation unchanged.

So if your objective is to inspect pass/fail/skip state, pytest_runtest_makereport is the appropriate hook; don't try to derive that status from the return value of pytest_runtest_call, pytest_runtest_setup, or pytest_runtest_teardown.

Please mark this answer as accepted if it helped, thank you.