Stop the cancel-during-backoff test measuring the machine

[dovvnloading]

Problem

test_cancel_during_backoff_aborts_promptly ended with a hard wall-clock
budget:

assert time_module.monotonic() - started < 2.0

It was going red for reasons unrelated to the code. Investigating why found
two problems behind it, neither of them a busy machine.

1. The test made a real network call

Every chat_stream through the ollama_mode fixture asks
_get_ollama_context_window what window the daemon will serve for
"fake-model:1b", and that calls ollama.show() for real — httpx, httpcore,
connect_tcp. No daemon runs in a test environment and none anywhere serves a
model by that name, so it was always going to fail. It just took a ~2.0 second
TCP connect to find out.

cProfile over the test call:

1  0.000  2.020  api_provider.py:1870(_chat_stream_dispatch)
1  0.000  2.020  api_provider.py:780(_get_ollama_context_window)
1  0.000  2.020  ollama/_client.py:657(show)
1  0.000  2.019  httpx/_client.py:879(send)
1  0.000  2.018  httpcore/_backends/sync.py:188(connect_tcp)

2.018 of the 2.020 seconds was the connect. The assertion was measuring it.

The result is cached per process, so that cost lands entirely on whichever
ollama-mode test runs first in a worker. That is what made this look like
load flakiness — under -n auto --dist worksteal the identity of that test
changes run to run:

	result
run alone	fails 5/5, at 2.05s
run after one sibling ollama-mode test	passes in 0.06s, and the 2.07s moves onto the sibling

2. Which guard it covered was decided by the same accident

_transport_retry_wait checks the cancel event, computes its delay, and only
then blocks in event.wait(delay). The test armed a 50ms threading.Timer
against that sequence.

• When the first attempt paid the 2s connect, the timer always won, the
  pre-wait guard raised, and the interruptible wait the test is named for
  was never entered — traced, 6/6 runs.
• When the connect was already cached, the attempt took ~60ms and the wait
  was reached — also 6/6.

Both guards are worth covering. Neither was covered on purpose.

Change

The fixture stubs _get_ollama_context_window to return None — exactly what
the failed call returned, so callers still fall back to
_DEFAULT_CONTEXT_WINDOW — and no ollama-mode test opens a socket.

Stubbed at that function rather than at api_provider.ollama, because the
module object is also what the provider and the transient-error classifier
reach through; replacing the whole module with a namespace carrying only
show() silently disables the retry path these tests exercise. I found that
out by doing it that way first — the retry stopped happening and the test
stopped raising.

The test is replaced by two, each pinning one guard, both driven by a scripted
cancel event instead of a timer:

• test_a_cancel_during_backoff_interrupts_the_wait_instead_of_sleeping_it_out
• test_a_cancel_before_the_backoff_aborts_without_waiting_at_all

_ScriptedCancelEvent is a duck-typed stand-in — api_provider only ever
calls is_set() and wait() on this object — that cancels on cue rather than
on a clock, and records the timeout each wait() was handed.

Nothing asserts on elapsed time. The during-backoff test asserts the wait was
handed exactly [10.0], the full Retry-After, so it cannot pass because the
delay happened to be negligible; and that time.sleep was never called, which
is what "interruptible" means here.

Verification

Both mutations applied via monkeypatch, not to the file:

mutation	new test	old test
cancellable branch → plain time.sleep	fails	caught it, but only on a warm cache; on a cold one it failed identically either way
Retry-After stops raising the delay	fails, [1.2085877752862941] == [10.0]	could never see it — a backoff collapsing to the jittered base would have made it pass faster

Test plan

• Full suite: 3,247 passed, 19 skipped.
• The two new tests pass 8/8 run alone on a cold cache, where the old one
  failed 5/5.
• ruff check . clean.
• No suite speedup to report: the connect is once per process and invisible in
  a 130s file run (131.4s after vs 129.6s before). It only mattered because it
  was charged to a test that asserted on its own wall clock.

🤖 Generated with Claude Code