Accessing variables defined in pytest

[baileythegreen]

I was looking into how to access variables defined in pytest for some tests I'm writing. I found this answer, which shows what seems to be a concise, builtin way to do so, and started using this:

def pytest_configure():
    pytest.testspath = Path(__file__).parents[0]
    pytest.fixturepath = pytest.testspath / "fixtures"

which allows these to be accessed in other test files as pytest.fixturepath.

However, in looking at some existing tests that I did not write, I saw that something to the same end was already done in at least one place:

@pytest.fixture
def path_fixtures_base():
    """Base path to fixture data folders."""
    return FIXTUREPATH

Which way should be preferred/retained?

My thought is that we should change to the former, because it lends itself to devs/users being able to quickly see what variables they can access using the pytest.<variable_name> syntax, rather than needing to search for them¹, and it is a bit more concise.

Are there reasons why maintaining the latter would be better, aside from the need to change some existing code?

Footnotes

1. If I hadn't happened to be looking for an example of something else, I still wouldn't know the latter example was in conftest.py. ↩

[widdowquinn]

Further down the same StackOverflow issue there is this comment:

I wouldn't mess with global variables. Just define your fixture to return a value and use that fixture in your tests: Similar to what @milo posted but a lot simpler.

and this is closer to my view. It's essentially what I did.

(There are, to be clear, two relevant global variables still involved in conftest.py: TESTSPATH and FIXTUREPATH. This is because they may be reused within conftest.py, for a number of reasons, but their scope is limited to conftest.py and they are not exposed through pytest AFAIK.)

Both your/SO suggestion and the current solution are intended to achieve the same goal: to make a specified path available for tests. Moreover, the path needs to be obtained "live" on the executing system. My preference is to retain existing behaviour.

• I think that the fixture mechanism is expected to provide this kind of variable, with pytest - it's the pytesty way to do this: the "global variable" fixture values specifically required for a test are declared in that test function template, where they are explicitly enumerated as the fixtures relevant for the test, and this is self-documenting. Riding on the back of the pytest namespace is not as clear.
• The pytest_configure() function as written in that SO comment just adds new attributes to the pytest namespace. There are no checks for overwriting that namespace, and there is no distinction between parts of the namespace that were declared by you and those that are are part of the pytest package, obscuring the intent of the variable/fixture to some extent. I'd consider this to be a risky approach with potential unknown side-effects if a pytest attribute was accidentally overwritten.
• Defining path_fixtures_base as a fixture allows us to document the code readily with docstrings, hooking into Python's help(). The SO solution adds an ad hoc attribute to the namespace with no documentation other than the attribute name.
• There is syntactic consistency within the current conftest.py in that fixtures representing specific paths adopt Hungarian notation, starting with path to indicate that they are paths. This could be adopted in the SO-suggested approach, but if you changed the way we share the fixture directory path, you should really change all such variables. That is extra, unnecessary, work.