Defines a fixture that is automatically invoked by pytest for every test within the fixture's defined scope (function, class, or module).

Indicates that the decorated function is a fixture that should be implicitly applied to all relevant tests, communicating an implicit setup/teardown requirement.

When you need to establish state (e.g., database connection, mock objects, temporary directory) that must be available to every test in a module, class, or function without each test having to request the fixture explicitly.

Inside a pytest test module, a conftest.py file, or within a test class or function where the fixture is defined.

@pytest.fixture(autouse=True)\ndef <fixture_name>():\n <setup>\n yield\n <teardown>

@pytest.fixture(autouse=True) decorator applied to a function definition.

fixture_name: valid Python identifier; function_body: indented block containing setup code, optional yield, and teardown code.

• yield
• fixture
• test
• module
• class
• function
• monkeypatch
• tmp_path
• database
• mock

• Using scope='module'
• 'function'
• or 'class' instead of autouse=True to control fixture lifetime
• using autouse=False (default) to require explicit fixture request
• using params for parametrized fixtures.

Forgetting to include a yield or cleanup block, causing resources to persist across tests and leading to state leakage. Applying autouse=True to a heavyweight fixture (e.g., starting a Docker container) that runs for every test, unnecessarily slowing the test suite. Placing an autouse fixture in a narrow scope (e.g., inside a function) unintentionally limiting its effect and causing inconsistent test behavior. Assuming autouse fixtures execute in a specific order without declaring dependencies, which can produce fragile test ordering. Using autouse=True for fixtures that should be explicit, making test dependencies implicit and harder to understand.

@pytest.fixture without autouse – requires explicit request in test functions, making dependencies visible. @pytest.fixture(scope='module') – controls fixture lifetime to module scope without automatic use. unittest.TestCase.setUp – xUnit‑style setup method that runs before each test method but requires class inheritance. pytest.fixture(params=…) – parametrized fixture that runs multiple times per test, unlike a simple autouse fixture.

Coming from unittest: may expect setUp to run automatically for each test; in pytest, autouse fixtures provide similar behavior but must be defined explicitly and can be scoped differently. Coming from JUnit: may assume automatic dependency injection of fields; in pytest, autouse fixtures must be returned or yielded to be usable by tests. Coming from Node.js/Jest: may use beforeEach hooks that run for every test; autouse fixtures offer comparable functionality but are scoped to where they are defined. Coming from Ruby/RSpec: may use before(:each) blocks; autouse fixtures are the pytest equivalent but require explicit definition.

• pytest fixtures
• pytest fixture scopes
• pytest autouse fixtures
• pytest fixture parametrization

Avoid using autouse=True for fixtures that should be explicit, as it hides dependencies and makes tests harder to understand; heavyweight setup (e.g., starting external services) executed for every test can significantly slow the test suite—consider narrower scope or lazy initialization; autouse fixtures only affect tests defined within their scope (function, class, module) and do not apply to sibling or parent modules unless placed in an appropriate conftest.py.

Enables automatic setup and teardown of test state, reducing boilerplate and ensuring consistent preconditions across tests, which improves test reliability and maintainability.

An autouse fixture is like a silent stagehand who prepares the set and props before every actor enters the stage, without being asked.

Consider using explicit fixture requests or scoped fixtures (module/session) for finer control over test setup when autouse introduces unnecessary overhead or hidden dependencies.