Per-use fixture scope

I often find myself needing 2 results from a function-scoped fixture for the same test run.

To do this today, I need a factory:

@pytest.fixture
def foo_factory(a, b, c, d_factory):
    def _foo():
        d = d_factory()
        # Use a, b, c, and d to make foo.
        return foo
    return _foo


@pytest.fixture
def bar(foo_factory):
    foo = foo_factory()
    # Use foo to make some_bar.
    return some_bar


@pytest.fixture
def baz(bar, foo_factory):
    foo = foo_factory()
    # Use foo and bar to make some_baz.
    return some_baz


def test_baz(baz):
    assert baz.whatever

Alternatively, I can invoke foo directly (like a regular function), but then everything foo accepts (i.e. a, b, c, d) must be defined in the calling scope which is unscalable.

If there was, say, a 'call' scope, this could be replaced with:

@pytest.fixture(scope='call')
def foo(a, b, c, d):  # d would also be call-scoped.
    # Use a, b, c, and d to make some_foo.
    return some_foo


# A function-scoped fixture would not be able to depend on a call-scoped fixture.
@pytest.fixture(scope='call')
def bar(foo):
    # Use foo to make some_bar.
    return some_bar


@pytest.fixture(scope='call')
def baz(foo, bar):
    # Use foo and bar to make some_baz.
    return some_baz


def test_baz(baz):
    assert baz.whatever

• Note that bar and baz get distinct foos.

In other words, this is a feature request for a fixture scope that behaves just like regular function invocations, but you don’t have to do the invocation, pytest does it for you (which keeps the calling scope uncluttered).

[asottile]

Duplicate of #456 I believe, if not feel free to reopen (let’s consolidate discussion on this there)

[nicoddemus]

Ref: #2703