Why can't unittest.mock.patch replace datetime.datetime.now directly?

### How patch does its work `unittest.mock.patch` is not magic. It resolves the target string down to an object, remembers the current value of the named attribute, calls `setattr` to install the replacement, and calls `setattr` again on exit to restore the original. Everything it can do follows from that: if the attribute cannot be set, the patch cannot happen. ### Why the type refuses `datetime.datetime` is implemented in C. A C-defined type's methods live in a static structure built when the extension module initialises, and CPython refuses attribute assignment on such types — `datetime.datetime.now = something` raises `TypeError`, and so does `unittest.mock.patch.object(datetime.datetime, "now")`, which is the same assignment wearing a context manager. This is not specific to `datetime`; `str.upper`, `int.__add__` and `list.append` are equally unassignable. Pure-Python classes have a writable class dictionary, which is why the same technique works everywhere else and produces a surprising, seemingly arbitrary failure here. Note the distinction that resolves most of the confusion: the `datetime` *module* is an ordinary module object and its attributes **are** writable, so `patch("datetime.datetime", Replacement)` succeeds — it rebinds a name on the module — while `patch.object(datetime.datetime, "now")` fails, because it tries to write on the type itself. ### Route one: inject the callable (preferred) Give the function a `now` parameter defaulting to the real thing: ```python import datetime def stamp(event, now=datetime.datetime.now): return f"{event}@{now(datetime.timezone.utc).isoformat()}" ``` The test passes `lambda tz: fixed`. No patching, no type gymnastics, and the dependency is visible in the signature. When many call sites need it, hoist a single project-level `utcnow()` helper that everything calls; then there is exactly one seam to inject or, at worst, one pure-Python function to patch. ### Route two: substitute a subclass When the code is already written against `datetime.datetime.now()`, define a pure-Python subclass with the classmethod you want and rebind the module-global name that the code under test imported: ```python class FrozenClock(datetime.datetime): @classmethod def now(cls, tz=None): return cls(2026, 9, 3, 12, 0, tzinfo=tz or datetime.timezone.utc) ``` Because `FrozenClock` subclasses `datetime.datetime`, any `isinstance` check, comparison or arithmetic in the production code keeps working. What you patch depends on how the consumer imported the name — a module that did `from datetime import datetime` has its own global to rebind, one that did `import datetime` reaches the class through the module object. ### Freeze an *aware* time Whichever route you take, return a timezone-aware value: `datetime.datetime.now(datetime.timezone.utc)`. A frozen naive datetime reintroduces exactly the environment dependence you were removing, because `datetime.datetime.now()` with no argument uses the machine's local timezone, so the same test can format a different string on a laptop and on a build agent. `datetime.datetime.utcnow()` is deprecated as of 3.12 precisely because it returns a naive value that *looks* like UTC; new code should not use it, frozen or otherwise. ### Do not fuse the two clocks The wall clock and the monotonic clock answer different questions, and a test should fake them separately. Deriving a frozen `time.monotonic()` from a frozen `datetime` value encodes a relationship that does not exist in production — the monotonic clock's zero point is undefined and unrelated to the calendar — and it will hide a bug where the code mixes the two, which is the very mistake worth catching. ### The smell behind the question Needing to freeze the clock in twenty tests, each with its own patch, is the code telling you the current time is a hard-wired global. One injected clock seam replaces all twenty patches and removes the failure mode entirely. The interview value of this question is not the `TypeError` trivia; it is whether the candidate reads the error as "mock is broken" or as "this dependency has no seam".