Mocking and Patching with unittest.mock

diagram patch where the name is LOOKED UP, not where it is defined mermaid

  flowchart TD
  A["svc.py defines now()"] --> B["app.py does: from svc import now"]
  B --> C["app.now and svc.now both point at the same function"]
  D["patch('svc.now')"] --> E["replaces the name in svc"]
  E --> F["app.now still points at the ORIGINAL"]
  F --> G["greet() returns 'hello REAL' -- the mock did nothing"]
  H["patch('app.now')"] --> I["replaces the name app actually looks up"]
  I --> J["greet() returns 'hello FAKE' -- the mock works"]

from x import y copies the reference into the importing module's namespace. After that there are two names pointing at the same function, and replacing the original does nothing to the copy the code under test actually calls. This is the single most common reason a mock appears to be ignored.

Measured: the same mock, two targets, two outcomes

svc.py defines now(). app.py does from svc import now and greet() calls it.

Patch target	greet() returns
patch("mk.svc.now") — where it is defined	hello REAL — the mock had no effect
patch("mk.app.now") — where it is used	hello FAKE

from x import y binds y into the importing module. Patching the original leaves that binding untouched, so the code under test keeps calling the real thing — and the test passes for the wrong reason, or fails with a confusing message about the real function.

The rule: patch the name in the module under test, not the module that defined it. If you prefer not to think about it, import svc and call svc.now() — then the lookup happens at call time and patching svc.now works as expected.

Why mock?

You mock when a dependency is:

• slow
• flaky
• external (network, API)
• expensive to set up

Example: patch a function call

service.py

import requests
 
 
def fetch_status(url: str) -> int:
    return requests.get(url, timeout=10).status_code

test_service.py

from unittest.mock import patch
 
import service
 
 
def test_fetch_status_mocked():
    with patch("service.requests.get") as get:
        get.return_value.status_code = 200
        assert service.fetch_status("https://example.com") == 200

Using autospec

autospec=True helps match real signatures.

patch_autospec.py

from unittest.mock import patch
 
 
def sample(a, b):
    return a + b
 
 
with patch("__main__.sample", autospec=True) as fn:
    fn.return_value = 10
    assert sample(1, 2) == 10

Tips

• mock at the import location used by the code under test
• keep mocks minimal; prefer real unit logic