Testing

Enables isolated unit testing by injecting a mocking fixture that can patch and stub dependencies

Unit testing: isolating a function that calls an external API or database; Legacy code: testing modules with hard-coded dependencies that cannot be injected; CI/CD: ensuring fast test suites by replacing slow I/O with instant mock returns

pytest, pytest-mock plugin, Python unit testing, test-driven development, CI/CD pipelines

def test_name(mocker): mocker.patch(target, return_value=value) assert module.function() == expected

def test_...(mocker): ... assert ... == ...

test_name: str starting with test_, mocker: pytest-mock fixture, target: dotted path to object being patched, value: return value for mock, module: Python module object, function: callable under test, expected: expected return value

• mocker.patch
• mocker.patch.object
• mocker.patch.multiple
• mocker.spy
• pytest.raises
• capsys
• tmp_path
• @pytest.fixture

• monkeypatch (pytest built-in
• simpler but lacks spy and stop() features)
• unittest.mock.patch (stdlib
• more verbose decorator/context manager usage)
• unittest.TestCase.mock (class-based
• requires self.setUp cleanup)

Forgetting to install pytest-mock plugin → fixture not found error at collection time; Patching at the wrong path (where defined vs where used) → mock not applied, real function executes; Not setting return_value on mock → mock returns a MagicMock object instead of the expected value, causing assertion failures; Placing mocker.patch after the function call → mock is never active during execution

monkeypatch (pytest built-in fixture, simpler API but no spy or call tracking), unittest.mock (stdlib, requires manual cleanup and more boilerplate), @patch decorator (class-style, applies to entire test function scope)

Coming from JavaScript/Jest: expect jest.fn() pattern → pytest-mock uses mocker.patch() with Python dotted-path strings instead of module factory functions; Coming from unittest: self.setUp()/self.tearDown() patching → pytest-mock auto-cleans patches at test teardown, no manual stop() needed; Coming from Ruby/RSpec: allow().to_receive → pytest-mock uses mocker.patch with return_value, not message expectation syntax

• pytest fixtures
• pytest-mock
• unittest.mock
• monkeypatch
• pytest.raises

1. When NOT to use: for pure functions with no external dependencies, plain assertions suffice and mocking adds unnecessary complexity. 2. The mocker fixture auto-reverses all patches at test teardown, preventing state leakage between tests. 3. mocker.patch target must reference the object where it is looked up (import site), not where it is originally defined — patching the definition site silently fails.

Prevents flaky tests caused by real network or database calls, enables testing error paths and edge cases that are difficult or impossible to reproduce with live dependencies

Like a stunt double standing in for the real actor — the mocker fixture swaps in a controlled replacement so the scene plays out exactly as scripted, then cleans up after itself.

The mocker fixture requires the pytest-mock plugin (pip install pytest-mock). It wraps unittest.mock with a pytest-friendly interface and automatic cleanup.

mocker.patch.object for method-level patching, mocker.patch.multiple for batch patching, mocker.spy for call tracking without replacing behavior