Reconciling pytest fixture injection with app's own service dependency injection system

[ianjosephwilson]

I have a web app that has a service registry/container that maps an interface to factory that is cached after construction, depending on the scope. In a way it is similar to pytest fixtures themselves. When I'm writing tests I want to load those services alongside fixtures. Or really just "auto" make the fixtures.

What is a good way to do that? I think maybe just hard coding all the fixtures is the easiest way (after writing this up). It always seems like it would be repetitive but it would probably be write once use until the actual service(s) changed.

Some options I've tried:

0. just hard code 1 fixture for every service (even if there are 100+ of them)
1. inject them into globals() via some module level code in conftest.py
   • globals()[service_fixture_name] = service_fixture_func in conftest.py
2. wrap each actual test in decorator that inspects it and builds a new function that does the injection of both pytest fixtures and app services
   • 2a. Maybe use pytest_generate_tests to parameterize in the app service fixtures?

Option 0

# psuedo code example
from app.protocols import IServiceA

@pytest.fixture
def app_container():
    # build this however we build it in the app itself
    return app_container_instance

@pytest.fixture
def service_a(app_container):
    # bypass pytest fixture resolution and load this and its dependencies from the app container 
    service_a_api = app_container.get(IServiceA):
    return service_a_api

@pytest.fixture
def fixture_b(): # normal pytest fixture
    return 'b'

def test_abc(service_a, fixture_b):
    assert service_a.add_to_a(fixture_b, "c") == "abc"

Edited: Try to fix formatting.

[sgoel2be24-cyber]

Option 1 is actually a legitimate, well-behaved way to do this — pytest discovers fixtures by scanning the conftest module's attributes, so it doesn't care whether a fixture was written by hand or assigned in a loop. The trick is to generate them through a small factory and give each one an explicit name=, so you don't hit Python's late-binding closure bug and the fixtures show up properly in pytest --fixtures:

# conftest.py
import pytest
from app.container import build_container
from app.protocols import IServiceA, IServiceB  # ...

# fixture name -> interface; could also be derived from the registry itself
SERVICES = {
    "service_a": IServiceA,
    "service_b": IServiceB,
}

@pytest.fixture
def app_container():
    container = build_container()  # however the app builds it
    yield container
    container.close()               # if it has teardown


def _make_service_fixture(name, iface):
    @pytest.fixture(name=name)
    def _fixture(app_container):
        return app_container.get(iface)
    _fixture.__doc__ = f"{iface.__name__} resolved from the app container."
    return _fixture


for _name, _iface in SERVICES.items():
    globals()[_name] = _make_service_fixture(_name, _iface)

Tests then look exactly like your Option 0 example — def test_abc(service_a, fixture_b): ... — and you can freely mix app services with normal fixtures. Because every service fixture depends on the same app_container fixture, services resolved within one test share the container's cache, so service_b's internal IServiceA is the same instance as the service_a the test receives.

A few things that make this nicer in practice:

• Scopes: if your container scopes map to pytest scopes, pass scope= through the factory (@pytest.fixture(name=name, scope=scope)) and have a container fixture per scope (e.g. a session-scoped root container and a function-scoped child/request container). Just remember a fixture can only depend on fixtures of the same or wider scope.
• Overriding in tests: since these are real fixtures, you can override any one of them in a test module or nested conftest.py with a hand-written @pytest.fixture def service_a(): return FakeServiceA() — that's the big advantage over Option 2.
• Deriving the names: if the registry is introspectable, build SERVICES from it (e.g. snake_case(iface.__name__.removeprefix("I"))) so new services get fixtures automatically.

I'd avoid Option 2 (wrapping tests / pytest_generate_tests): parametrization is meant for producing multiple test cases, and a decorator that rewrites signatures fights pytest's introspection, so you lose --fixtures, overriding, and good error messages.

[Michael-WhiteCapData]

One caveat about overriding these fixtures: replacing the pytest fixture for service A does not replace the container's binding for A. If service B resolves A through app_container.get(...), B still receives the container's instance, even when the test receives a fake from the overridden fixture.

To use the fake inside B too, configure the replacement in a fresh container before resolving either service. Already constructed dependent services can retain the original instance even if A's binding and cache entry are later replaced. Alternatively, construct B in a fixture that explicitly depends on the pytest fixture for A.

I verified these cases with a minimal cached factory container and pytest. The specific override and cache APIs will depend on your container implementation.