How are fixtures closed?

[Stefanhg]

Hello,

I am working on fixing a bug in some internal tools we use to handle working with targets in test.
The tool itself interacts with different targets across multiple Python packages and helps user interact with the targets. The tool is a Pytest plugin that between each tests closes the target
Closing the targets works fine with pytest_runtest_teardown unless people use the targets in the teardown (which they do).
I resolved my issue initially by closing my targets in the pytest_runtest_setup but this looks confusing when reading the output of a test so that's not acceptable.

So my question is. How does PyTest "close"/exit fixtures and is there a more nicer way for me to do something after fixtures are closed?
I have been reading a bit in _pytest/fixtures.py but I could not find anything that could answer my questions.

Example of where i need to hook onto:

I have some targets that are fixtures. These fixtures has to be closed before I can then close the connection. This is something that has to be done across many tests that are separated into different repositories and therefore I cannot do it with a fixture.

I made an example of what I need but I am very unsure how helpful it is.

Conftest.

import pytest
class TargetManager:
    open_targets = []

target_manager = TargetManager()

def target_closing_function():
    """I want this function to be implemented somewhere"""
    target_manager.open_targets.clear()

# If implemented, both tests passes
# @pytest.hookimpl
# def pytest_runtest_setup():
#     target_closing_function()

Testcase

import pytest
from conftest import target_manager

@pytest.fixture
def my_fix_a():
    # "opens my target"
    target = "A"
    target_manager.open_targets.append(target)
    yield
    # Target A sends something and NOT closing here.
    # Since order of fixtures is very random, it has to be closed after all fixture
    assert len(target_manager.open_targets) == 1

@pytest.fixture
def verify_targets_closed():
    assert len(target_manager.open_targets) == 0

def test_a(verify_targets_closed, my_fix_a):
    pass

def test_b(verify_targets_closed, my_fix_a):
    pass

[RonnyPfannschmidt]

its not clear what you are asking for but it seems like you should use a fixture for your targets or outline the use case enough to avoid the XY-problem

[Stefanhg]

@RonnyPfannschmidt I updated the question. Unsure if this helps tho.
The simplified version. Need to do something after the fixtures are closed before next test starts. Where can i "hook onto" in PyTest?

I cannot use a fixture since we have a plugin that interacts with the targets. Ideally we should switch away from this structure we currently have and use a fixture for spawning the targets and then just have a yield + close routine in the fixture but it would be a MAJOR rewrite of everything and people at my company are not ready for this.

[Stefanhg]

I found something but it is also a bit hacky but it causes my tests to pass and fulfills the requirements set.

Creating a global variable, set it to true when last test and then do the teardown in logfinish hook:

conftest

import pytest

last_test = False
"""Set to True when last test is executed"""


class TargetManager:
    open_targets = []


target_manager = TargetManager()


def target_closing_function():
    """I want this function to be implemented somewhere"""
    target_manager.open_targets.clear()


def pytest_runtest_protocol(item, nextitem):
    if nextitem is None:
        global last_test
        last_test = True


@pytest.hookimpl()
def pytest_runtest_logfinish():
    if last_test is False:
        target_closing_function()

[RonnyPfannschmidt]

That's the job of session scope, please don't invent a broken hack for it

[Stefanhg]

But then it does not happen between each test? Only at the end of all tests

[RonnyPfannschmidt]

Then you need a support function scope fixture

[Stefanhg]

@RonnyPfannschmidt I am just unsure if this is possible using a fixture.
Since it is random when a fixture is "closed" it might cause the support fixture to be "closed" before the fixture my_fix_a.
Unless i am misunderstanding what you mean by:

support function scope fixture

I sadly can't have a fixture that my my_fix_a depend on because our code base is based on some old c**b I am working on deprecating. Since I am planning on deprecating this way of doing things I would actually go as far as saying the ugly hack might work for now. But I'm still just curious what kind of magic the experinced people could do!

[RonnyPfannschmidt]

In that case you might want to investigate using a autouse fixture to close late after non autouse fixtures

And leave open per test to first use

[Stefanhg]

I just tested with an autouse fixture recommended by @RonnyPfannschmidt and It is working! but it is still risky as if others then define an autouse fixture.
I think I will close the issue for now. There are two possible ways of doing it one is janky but is more safe and the other is more "correct to do" but comes with risks people need to be aware of.
Thank you for the support!