Repeated use of fixtures in pytest

Question

I am learning pytest, particularly its fixtures which are different from the xUnit setUp() and tearDown() paradigm. Say I have the following test:

import pytest


@pytest.fixture()
def foo():
    return 'foo'


@pytest.fixture()
def bar():
    return 'bar'


@pytest.fixture()
def baz():
    return 'baz'


@pytest.fixture()
def foobar(foo, bar):
    return foo + bar


@pytest.fixture()
def foobaz(foo, baz):
    return foo + baz


def test(foobar, foobaz):
    print('test')
    print(foobar)
    print(foobaz)

In this example, the foo() fixture is used twice, once by foobar() and again by foobaz(). If I reuse the same fixture multiple times for a single test, is the fixture function called once and its result cached? Or is it called each time that it is used? In my contrived example, the returned value is static, so there is no problems. I can imagine many situations where the returned value is more dynamic and I need to guarantee that I have the exact same instance everywhere it is used.

Answer 1

pytest fixture's life could be controlled with scope argument. There are basically four scopes function, class, module, session. The default scope is function which is the one your fixtures are using.

In the case of function scope, the fixture would be called for each test function on which the fixture is used.

A class scoped fixture is called once per test class through out the test cycle and so is module scoped fixture (once per test module).

A session scoped fixture is called once per test session.

More reading and examples for different scopes is available fixtures and fixture function

Answer 2

A fixture is only called when it is used and it will be only called once based on the scope.

If the scope is session then it will only be called one for the whole execution. In your case since you have not specified the scope, it assumed function.

So below would be the execution order

foo
bar
foo + bar
baz
foo + baz

As you can see baz only called when foo + baz method was requested.

• If you remove both the parameters from your test function. Nothing will be called even once.
• If you remove foobaz then baz and foobaz will never be called
• If you insert another function test2(foobar, foobaz), then whole cycle will be repeated as the scope of fixture is per/function