Mocking

Enables isolated unit testing by temporarily substituting dependencies with controllable mocks.

Unit testing: replacing an external API call with a mock to avoid network requests; Unit testing: substituting a class method to simulate different return values; Unit testing: patching a module‑level constant to test configuration‑dependent code

Test suites using Python's unittest framework, pytest with unittest.mock, any Python project that isolates dependencies.

with patch('target') as mock:

with patch(...) as ...:

target: str, the dotted path to the object to mock; mock: unittest.mock.MagicMock, the mock object that replaces the target for the duration of the block

• unittest.TestCase
• mock.assert_called_once_with
• mock.return_value
• mock.side_effect

• Using patch as a decorator: @patch('module.Class.method')\ndef test_something(mock_method): ...
• Using patch.start() and patch.stop() manually for finer control.

Failing to provide the mock argument (using a different variable) causes AttributeError when the test tries to access the mock; the test will fail because the intended mock is not bound. Providing an incorrect target string (typo) results in the patch not applying, so the real object is used and tests may pass incorrectly. Forgetting to start the patch (using patch without a context manager or decorator) leaves the mock inactive, leading to real calls and unpredictable test behavior. Nesting multiple with statements incorrectly can cause scope confusion where a mock is active only in the inner block, causing outer code to use the real object.

patch.object: patches an attribute on a specific object instance or class rather than by dotted‑path string; mock.create_autospec: creates a mock that enforces the spec of the original object, preventing accidental attribute access; using MagicMock directly: creates a standalone mock without patching, useful for stubbing simple objects.

Coming from Java: may expect @Mock annotation to inject mocks — Python's unittest.mock requires explicit patching via context manager or decorator.

• unittest.mock.MagicMock
• mock.assert_called
• mock.return_value
• mock.side_effect
• patch.object
• patch.dict

Do not use patch for objects that are imported locally inside a function, because the import may occur after the patch is applied and the mock will not take effect; Patching adds negligible runtime overhead, but excessive mocking in a test suite can slow test execution due to the extra setup and teardown of mocks; Patch only works on attributes that are resolvable via import at the time the patch starts, so patching a class attribute after instances have been created will not affect those existing instances.

Enables isolated unit testing by temporarily replacing dependencies with controllable mocks, preventing external side effects and allowing deterministic assertions.

Think of patch as a stagehand who swaps out a prop for a fake one during a scene, then restores the original when the curtain falls.

Remember that patch targets are resolved at runtime; if the object is imported under a different name in the module under test, you must patch the name used in that module, not the original import path.

Using patch.object and patch.dict for more precise mocking, or adopting the pytest‑mock plugin for a more concise syntax.