Skip to content

test: stamp canned chat replies after the send, not at test start - #27

Merged
MarcoDotIO merged 1 commit into
mainfrom
test/reply-clock-after-send
Oct 1, 2026
Merged

test: stamp canned chat replies after the send, not at test start#27
MarcoDotIO merged 1 commit into
mainfrom
test/reply-clock-after-send

Conversation

@MarcoDotIO

@MarcoDotIO MarcoDotIO commented Sep 30, 2026

Copy link
Copy Markdown
Owner

Summary

ChatViewModelTests › "stale fallback refresh keeps retrying while run remains pending" failed every time the cooperative pool was starved for about 12 s, but passed at 6–8 s. The cause is the test's own data: it stamps its canned reply at test start + 10 s. This is not a production bug, and there is no source change.

Root cause

Temporary logging under a 12 s stall showed:

  • No extra history request. Index 4, the reply, reached the intended delayMs=20 poll refresh and was applied. pendingRunTerminalHistoryGraceMs and pendingRunTerminalRetryMs played no part: the default fake returns .unavailable from waitForRunCompletion, so the terminal path never runs.
  • The reply predates the send. now is captured at test start + 10 s, but a stall before vm.send() puts the local user stamp about 12 s after test start. clearPendingRunIfAssistantMessagePresent(after:) only credits assistant rows stamped at or after the send, so it correctly ignores the reply. The run stays pending, and the next refresh is 60 s away.

Seven tests in the file use the same Date() + offset stamp. Under a 12 s stall:

Test Before After
stale fallback refresh keeps retrying while run remains pending ✘ run never clears ✔
session activity without chat snapshot does not retain completed pending run ✘ run never clears ✔
bounded repeated same text reply invalidates older stale refresh ✘ stale refresh overwrites the answer; canInvalidateOlderHistory sees the latest user turn as unanswered ✔
terminal wait keeps ownership until history becomes available ✔ but only through the 10 s no-output grace (22 s) ✔ intended path
superseded pending refresh preserves an in-flight run ✔ but the reply no longer counts, so the in-flight protection isn't exercised ✔ intended path
completion wait refreshes history and clears pending run (+70 s) ✔ ✔
agent lifecycle end refreshes history and clears pending run (+70 s) ✔ ✔

Upstream OpenClaw's test file uses the same + 10000 stamp; it came in with the 2026.9.6 port.

Fix

  • New helper. A file-local ReplyClock actor stamps a canned reply the first time the fake serves it after the send, then reuses that base so repeated responses keep one order. Static reply payloads became index-keyed historyResponseHooks that keep the same index mapping.
  • Bounded test. The first turn predates the second send, so it is now stamped just before test start (now - 2, now - 1). Only the bounded reply comes from ReplyClock. With temporary logging, both versions take the same hasAnsweredUser path (idempotency key on the local echo, canInvalidate=true for the send-path refresh).

Test plan

  • Seven changed tests, each in its own process with a scratch starver (activeProcessorCount * 2 detached usleep blockers), at 6, 12 and 18 s stalls: 21/21 pass, each finishing right after its stall ends.
  • The same matrix at 12 and 18 s with test: drop the wall-clock deadline from waitUntil #25 (deadline-free waitUntil) merged in locally: all pass. This branch merges cleanly with test: drop the wall-clock deadline from waitUntil #25.
  • Before the fix, the original test failed at waitUntil("later fallback applies assistant reply") under a 12 s stall.
  • Full swift test: 582 + 3,150 + 20 tests pass.
  • Scripts/lint-swift.sh passes.

🤖 Generated with Claude Code

@MarcoDotIO @claude
test: stamp canned chat replies after the send, not at test start
6cf0d59 
Seven ChatViewModelTests stamped canned gateway replies from a timestamp
captured at test start plus 10 s (70 s in two tests). The view model
credits a reply to a send only when the reply is stamped at or after the
local send: `clearPendingRunIfAssistantMessagePresent(after:)` retires
the pending run, and `canInvalidateOlderHistory` requires the latest
user turn to be answered. When a starved cooperative pool delays the
send past the offset, the reply lands before the local user row.

Under a 12 s stall:
- "stale fallback refresh keeps retrying while run remains pending"
  applies the reply, but the run stays pending and the next refresh is
  60 s away.
- "session activity without chat snapshot ..." never clears its run.
- "bounded repeated same text reply ..." leaves the latest user turn
  unanswered, so the stale refresh overwrites the bounded answer.
- "terminal wait keeps ownership ..." passes, but only through the
  10 s no-output grace (22 s instead of 0.07 s).

"superseded pending refresh ...", "completion wait ..." and "agent
lifecycle end ..." use the same stamp and are changed the same way.

A file-local `ReplyClock` now stamps a canned reply the first time the
fake serves it after the send and reuses that base for later responses.
In the bounded test, the first turn predates the second send, so it is
stamped just before test start. Instrumented runs show the test still
takes the same `hasAnsweredUser` path as before.

Diagnostics ruled out an extra history request under a long stall:
index 4 reached the intended refresh. The terminal grace and retry
intervals played no part, and the view model behaved as designed. This
is a test-data fix only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@MarcoDotIO
MarcoDotIO merged commit 58bd95e into main Oct 1, 2026
19 checks passed
@MarcoDotIO MarcoDotIO mentioned this pull request Oct 1, 2026
Merged
2 of 3 tasks
MarcoDotIO added a commit that referenced this pull request Oct 1, 2026
@MarcoDotIO @claude
docs(changelog): 2026.3.2 (#31)
dca4976 
* test: wait for events instead of a 5 s wall-clock deadline

anotherAgentsRunBeforeTheAckNeverHijacksTheIntent and
preAckEventsOfTheAckedRunAreReplayed failed on main (CI run 36644330107,
xcode-27 runner) with "Caught error: CancellationError()" after ~8 s; the
same tree passed on PR #20. waitForSend polled the requester every 5 ms and
threw once a 5 s ContinuousClock deadline passed. With ~3,150 Swift Testing
tests saturating the cooperative pool, the host.send task (and the poller
itself) did not run for more than 5 s, so the deadline expired although
nothing in GatewayOpenClawIntentHost.send is slow. Blocking every cooperative
thread for 6 s reproduces the failure locally.

- OpenClawAppIntentsRunMatchingTests: HeldChatSendRequester yields each
  chat.send's params to an AsyncStream the moment the request arrives, and
  waitForSend awaits that stream. Assertions are unchanged.
- GatewayNetworkConnectionTransportTests: the loopback NWListener start waits
  on stateUpdateHandler (ready/failed/cancelled) instead of polling
  listener.state against the same 5 s deadline, which also had no final
  re-check after a late wake-up.
- WatchNodeClientTests: eventually() drops its 5 s deadline. Its conditions
  read production client state that has no change hook, so it still polls,
  but slowness no longer fails it.

Each suite gains .timeLimit(.minutes(1)) for hang protection. Every wait
ends on cancellation, so a time-limit overrun reports "Time limit was
exceeded" instead of hanging.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: bound lifecycle timeouts with a time limit, not a 5 s wall clock

keepalivePingIsBoundedWhenNoPongArrives and
handshakeTimeoutOptionBoundsTheWholeHandshake failed on PR #22's macOS job
(Xcode 27) with `ContinuousClock.now - start < .seconds(5)` at ~5.7 s. A
trivial test in the same window took 5.3 s, so the runner stalled; the
timeouts under test were 50 ms and 100 ms.

- keepalive ping: the socket never pongs, so the thrown URLError already
  proves the ping deadline ended the wait; a time limit catches a hang.
- handshake option: the fallback budget is raised to an hour through
  _test_setConnectTimeoutSeconds, so a channel that ignored the 100 ms option
  would trip the time limit instead of finishing at the 30 s default.
  Checked with a scratch test that drops the option: it fails with "Time
  limit was exceeded" and does not hang.

Both tests take .timeLimit(.minutes(1)) and pass while every cooperative
thread is blocked for several seconds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: show the device-auth write leaves the actor free by ordering, not elapsed time

issuedTokenPersistenceNeverBlocksTheChannelActor asserted the actor answered
within 3 s while a token write waited on another connection's SQLite lock.
A saturated test pool can stall the run for longer than that, and a time
limit alone would miss the regression it guards (a write on the actor holds
it for SQLite's 30 s busy timeout, less than the one-minute limit).

The test now relies on ordering. It releases the lock only after the actor
answers, so the token can reach disk only if the actor answered while the
write was pending. A write on the actor fails with SQLITE_BUSY first, the
token never lands, and the final wait trips the new suite time limit.

The 200 ms sleep that let hello-ok reach the write is replaced by a DEBUG
hook, _test_setDeviceTokenPersistenceStartedHandler, that fires on the actor
just before the persistence hop. Once the hop starts, shutdown cannot stop it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: bound the FIFO, AsyncTimeout and link-preview tests with a time limit

The three tests asserted wall-clock bounds (2 s, 5 s, 1 s) that a saturated
test pool can overrun. Each now has a one-minute time limit instead, and
each makes sure a regression ends on the limit's cancellation instead of
hanging the run:

- file fetch refuses a FIFO: a blocking open(2) never returns. The
  cancellation handler opens the FIFO's write end once to release it.
- operationThatIgnoresCancellationStillTimesOut: the parked operation is a
  gate the test opens on cancellation (and afterwards), not a
  never-resumed continuation that a loser-joining race would wait on
  forever.
- total deadline can fire before the session starts: URLSession's own
  timeouts move past the limit, so only the fetcher's zero-second
  deadline can end the fetch. The fetch is awaited through a no-deadline
  AsyncTimeout race, because a deadline lost before start would leave it
  unresumed even on cancellation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: drop wall-clock deadlines from the gateway and session-action waits

gatewayCoreWaitUntil gave up after 10 s (15 s at two call sites) and the
ChatViewModelSessionActionTests helpers after 15 s. A pool stall adds to
those waits, so they could time out even though the condition was about to
hold.

Both now wait until the condition holds or the test is cancelled. Every
suite that uses them has a one-minute time limit. gatewayCoreWaitUntil
records its GatewayCoreWaitTimeout as an issue before throwing, because
Swift Testing drops errors thrown after a time-limit cancellation and the
label says which wait hung. waitForForkStart awaits the gate's stream
directly instead of racing it against a sleep.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: drop the wall-clock deadline from waitUntil

waitUntil gave up after 15 s (7, 10 or 30 s at five call sites). The macOS
CI job runs about 3,150 tests in parallel and the cooperative pool stalls
for 5 to 8 s at a time, so a wait could time out even though the condition
was about to hold.

waitUntil now polls until the condition holds or the test is cancelled, and
the timeoutSeconds and now: parameters are gone (nothing injected a clock,
and with no deadline there is nothing to measure). Every suite whose tests
reach waitUntil, directly or through a file-local helper, has a one-minute
time limit; ChatViewModelSessionActionTests already had one. On cancellation
the helper records AsyncWaitTimeoutError as an issue before throwing it,
because Swift Testing drops errors thrown after a time-limit cancellation
and the label says which wait hung.

No call site relied on the timeout: nothing expects AsyncWaitTimeoutError,
no wait runs in a child task that the test cancels, and the one try? wait is
cleanup in a catch block that rethrows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(e2e): wait without a wall-clock deadline in the channel and reconnect tests

ChannelAdaptersE2ETests.waitFor gave up after 15 s and only recorded an
unlabelled expectation failure. reconnectFailureSchedulesAnotherAttempt
polled against a 10 s deadline. A pool stall can outlast either one.

waitFor now takes a label, polls until the condition holds or the test is
cancelled, and records a WaitTimeout issue before throwing it. The reconnect
loop polls until cancelled. The suite and the reconnect test each have a
one-minute time limit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: drop the 1 s deadline from the chat UI view-model waits

OpenClawChatUITests had its own waitUntil that gave up after 1 s and
returned false. On the macOS CI job for this PR, a pool stall of about
10 s ran past it: both view-model tests failed after about 12 s, and the
bootstrap expectations that followed failed with them.

The tests now call the shared deadline-free waitUntil with a label for
each wait, and the suite has a one-minute time limit. The private helper
is removed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: drop the wall-clock waits left in the provider and realtime relay tests

- ProviderStreamingCancellationTests polls with the shared deadline-free
  waitUntil under a one-minute suite time limit. Both request timeouts are
  now an hour, so a cancellation that never reaches the request fails as a
  hang instead of passing once the 60 s request timeout fires.
- ModelRouterStreamingFallbackTests waits for the stream termination (and
  the two stream/generate starts) with waitUntil, under a suite time limit.
- RealtimeTalkRelaySession._test_waitForStartupCancelled() drops its
  timeoutSeconds parameter. A closed session answers before any timer is
  armed; a zero timeout makes one that is not closed fail at once rather
  than after a 1 s wall-clock wait.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(linux): wait without a wall-clock deadline in the runtime tests

- A shared TestAsyncHelpers.swift replaces AgentLoopHardeningTests'
  waitUntil (500 x 10 ms, recorded an unlabelled issue and returned). It
  polls until the test is cancelled, then records and throws
  AsyncWaitTimeoutError(label:).
- GatewayServerTestHarness.collect (5 s) and Recorder.waitFor (5 s) take a
  label and wait until the time limit. The one deliberate negative wait now
  uses frames(_:arrivingWithinMs:), which returns what arrived; the old
  helper returned [] whenever its timer won, so that assertion could never
  fail.
- ChannelAdaptersLinuxSmokeTests.poll (15 s), the SIWC loopback-page wait
  (10 s), the automation run waits (10 s) and the MCP list_changed waits
  (3 s + 2 s) use waitUntil.
- addingAJobWakesTheSleepingLoop pushes the scheduler's idle cap to an hour
  through the new DEBUG hook CronScheduler._test_setMaximumSleepSeconds, so
  a missed wake hangs instead of racing the 60 s cap against the time limit.
- The MCP list_changed test uses an hour request timeout and drops its
  "< 1.5 s" elapsed assertion: a stall behind another request now hangs.
- .timeLimit(.minutes(1)) is on the nine suites that reach these waits and
  had no limit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: drop the bounded polls, elapsed bounds and positive-path timeouts

#26 left three kinds of wall-clock bounds in the test waits. A stalled
cooperative pool (5-8 s on the macOS CI job) could fail any of them.

- Iteration-count sleep polls now use waitUntil, under a one-minute time
  limit. The Task.yield loops before negative checks, the sampler
  repetitions and the media teardown grace are kept.
- Elapsed "< N s" asserts are replaced by what they stood for: error
  payloads that name the short deadline, kill checks, and a stalled
  server or run that outlives the time limit. Lower bounds and the
  synchronous cron search are kept. The throttle drop and delay checks
  use an hour-long window, so a stall between the two requests cannot
  let the window pass.
- Positive-path product timeouts move past the time limit where the
  wait ends on cancellation (SIWC signIn, runtime.run). Waits that park
  on a continuation cancellation never resumes (runtime.wait, agent.wait,
  the brokers, A2ATaskStore, imsg) go through the new
  awaitCancellable(_:) with no timeout.
- The stale-timer test retries until its first run beats its 200 ms
  timer. The run-id collision test holds its run on a gate instead of a
  3 s sleep. The coalescing reporter test uses a frozen clock.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test: wait for agent runs without a positive-path timeout

#29 left runtime.wait and agent.wait calls with 2-5 s timeouts in the
agent gateway, session branch, loop, event stream and wire shape tests,
and in the OpenClawKitTests stack, gateway server and registry tests. A
stalled cooperative pool (5-8 s on the macOS CI job) can let that timer
beat the run and turn a passing wait into a "timeout".

Both waits park on a continuation that cancellation never resumes, so
they now go through awaitCancellable(_:) with no timeout, under a
one-minute time limit. OpenClawKitTests gets its own copy of the helper.
The client-side request timeout on the SDK gateway test's agent.wait
moves past the limit too. The intended short timeouts (timeoutMs 1 and
10) are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(changelog): 2026.3.2

Date the release 2026-10-01 and move the ConfigBoxed and config-decode stack
entries under it. Add a Tests section for the test-wait hardening (#22, #25,
#26, #29, #30), the per-test synthesizer (#23), the reply clock (#27) and the
stack-depth tests (#28), with the release test counts and CI gates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@MarcoDotIO