From 3e1c56c72e10a867d8993afdaebad96efd2936f1 Mon Sep 17 00:00:00 2001 From: Jinjing <6427696+AmethystLiang@users.noreply.github.com> Date: Mon, 13 Jul 2026 00:00:56 -0700 Subject: [PATCH] =?UTF-8?q?fix(e2e):=20third=20pass=20=E2=80=94=20harden?= =?UTF-8?q?=20the=20last=204=20chronic/flaky=20e2e=20gates?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - agent-session-live-force-exit-resume: raise persisted-record poll 15sā†’30s (two-stage debounced write + main scheduleSave needs headroom under the CI event-loop starvation that also drifts renderer timers ~1s in this shard); on miss, dump store vs disk state to distinguish a lost write from slow flush. - artificial-opencode-terminal-load: add MAX_TIMER_DRIFT_UNDER_LOAD_MS (2.5s) for the injected-load scenarios, mirroring MAX_WORST_KEY_LATENCY_UNDER_LOAD_MS; baseline single-terminal gate stays at 250ms. - combined-diff-scroll-restore: converge the after-tab-switch anchor via bounded retry (Monaco restores scroll over several layout passes) before asserting; a genuine restore miss still fails since the last anchor is returned on timeout. - terminal-reattach-mouse-mode-leak: poll rAFs until the enable-mouse-events class lands after re-arming instead of a single frame (batched xterm render). Co-authored-by: Orca --- ...ent-session-live-force-exit-resume.spec.ts | 32 +++++++++++++++---- .../artificial-opencode-terminal-load.spec.ts | 12 +++++-- .../e2e/combined-diff-scroll-restore.spec.ts | 27 +++++++++++++++- .../terminal-reattach-mouse-mode-leak.spec.ts | 10 ++++-- 4 files changed, 69 insertions(+), 12 deletions(-) diff --git a/tests/e2e/agent-session-live-force-exit-resume.spec.ts b/tests/e2e/agent-session-live-force-exit-resume.spec.ts index adc5ee2d579..ac4d5a47260 100644 --- a/tests/e2e/agent-session-live-force-exit-resume.spec.ts +++ b/tests/e2e/agent-session-live-force-exit-resume.spec.ts @@ -211,12 +211,32 @@ test('resumes a live agent record after force-exit restart when pane PTY ownersh // hydration-gated writer before polling persisted state. await page.evaluate(() => window.__store?.getState().captureAllSleepingAgentSessions()) - await expect - .poll(() => persistedLiveRecordExists(session.userDataDir), { - timeout: 15_000, - message: 'Live sleeping-agent record was not persisted before force exit' - }) - .toBe(true) + // Why: the record reaches disk via the debounced session writer (150ms) plus + // the main-process scheduleSave (up to 5s). Under CI event-loop starvation ā€” + // the same shard drifts renderer timers ~1s ā€” both stages need headroom, so + // poll to 30s (this suite's other readiness budget). On a miss, surface store + // vs disk state to separate a lost write from a merely slow flush. + const persistDeadline = Date.now() + 30_000 + let persisted = false + while (Date.now() < persistDeadline) { + if (persistedLiveRecordExists(session.userDataDir)) { + persisted = true + break + } + await page.waitForTimeout(250) + } + if (!persisted) { + const storeRecords = await page.evaluate( + () => window.__store?.getState().sleepingAgentSessionsByPaneKey + ) + throw new Error( + `Live sleeping-agent record was not persisted before force exit. store=${JSON.stringify( + storeRecords + )} disk=${JSON.stringify( + readPersistedData(session.userDataDir).workspaceSession?.sleepingAgentSessionsByPaneKey + )}` + ) + } const daemonPid = readDaemonPid(session.userDataDir) await forceKillElectronApp(firstApp) diff --git a/tests/e2e/artificial-opencode-terminal-load.spec.ts b/tests/e2e/artificial-opencode-terminal-load.spec.ts index 1744fec4fa0..031f705373e 100644 --- a/tests/e2e/artificial-opencode-terminal-load.spec.ts +++ b/tests/e2e/artificial-opencode-terminal-load.spec.ts @@ -139,6 +139,12 @@ const MAX_REVISIT_LATENCY_UNDER_LOAD_MS = 3_000 // Why: GitHub's two-worker Electron shards can briefly starve renderer timers // without visible typing lag. Keep this as a smoke gate, not a CPU lottery. const MAX_TIMER_DRIFT_MS = 250 +// Why: under injected multi-pane redraw load the renderer event loop is +// environment-dominated (seen at ~1s on a CPU-starved OSS shard) even when +// typing stays responsive, mirroring MAX_WORST_KEY_LATENCY_UNDER_LOAD_MS. Keep +// this only as a catastrophic-starvation gate; the unloaded 250ms budget guards +// the real baseline. +const MAX_TIMER_DRIFT_UNDER_LOAD_MS = 2_500 const MAX_SCROLL_LATENCY_MS = 150 const MAX_RENDERER_SCHEDULER_QUEUED_CHARS = 3 * 1024 * 1024 @@ -446,7 +452,7 @@ async function measureCrossWorkspaceTypingDuringHiddenLoad({ expect(scheduler?.rendererDroppedBacklogs ?? 0).toBe(0) expect(measurement.medianLatencyMs).toBeLessThan(MAX_MEDIAN_KEY_LATENCY_MS) expect(measurement.worstLatencyMs).toBeLessThan(MAX_WORST_KEY_LATENCY_UNDER_LOAD_MS) - expect(measurement.maxTimerDriftMs).toBeLessThan(MAX_TIMER_DRIFT_MS) + expect(measurement.maxTimerDriftMs).toBeLessThan(MAX_TIMER_DRIFT_UNDER_LOAD_MS) } finally { await load.stop() await sendToTerminal(orcaPage, typingPtyId, '\x03').catch(() => undefined) @@ -578,7 +584,7 @@ test.describe('Artificial OpenCode terminal load', () => { ) expect(measurement.medianLatencyMs).toBeLessThan(MAX_MEDIAN_KEY_LATENCY_MS) expect(measurement.worstLatencyMs).toBeLessThan(MAX_WORST_KEY_LATENCY_UNDER_LOAD_MS) - expect(measurement.maxTimerDriftMs).toBeLessThan(MAX_TIMER_DRIFT_MS) + expect(measurement.maxTimerDriftMs).toBeLessThan(MAX_TIMER_DRIFT_UNDER_LOAD_MS) } finally { await load.stop() await sendToTerminal(orcaPage, typingPane.ptyId, '\x03').catch(() => undefined) @@ -673,7 +679,7 @@ test.describe('Artificial OpenCode terminal load', () => { ) expect(measurement.medianLatencyMs).toBeLessThan(MAX_MEDIAN_KEY_LATENCY_MS) expect(measurement.worstLatencyMs).toBeLessThan(MAX_WORST_KEY_LATENCY_UNDER_LOAD_MS) - expect(measurement.maxTimerDriftMs).toBeLessThan(MAX_TIMER_DRIFT_MS) + expect(measurement.maxTimerDriftMs).toBeLessThan(MAX_TIMER_DRIFT_UNDER_LOAD_MS) } finally { await load.stop() await sendToTerminal(orcaPage, typingPane.ptyId, '\x03').catch(() => undefined) diff --git a/tests/e2e/combined-diff-scroll-restore.spec.ts b/tests/e2e/combined-diff-scroll-restore.spec.ts index 039bdf7f13a..7bab026f52f 100644 --- a/tests/e2e/combined-diff-scroll-restore.spec.ts +++ b/tests/e2e/combined-diff-scroll-restore.spec.ts @@ -241,6 +241,31 @@ async function waitForStableViewportAnchor(page: Page): Promise throw new Error(`combined diff viewport anchor did not settle: ${JSON.stringify(lastAnchor)}`) } +// Why: remounting the diff on tab switch restores scroll in several Monaco +// layout passes, so the first settled anchor can be a mid-restore frame. Poll +// until the anchor converges near the pre-switch offset before asserting; a +// genuine restore miss still surfaces because the last anchor is returned on +// timeout for the caller's assertion to fail on. +async function waitForRestoredViewportAnchor( + page: Page, + target: ViewportAnchor, + tolerancePx = 80 +): Promise { + const startedAt = Date.now() + let lastAnchor = await waitForStableViewportAnchor(page) + while (Date.now() - startedAt < 10_000) { + if (lastAnchor.key === target.key && Math.abs(lastAnchor.top - target.top) < tolerancePx) { + return lastAnchor + } + await page.waitForTimeout(100) + const anchor = await readViewportAnchor(page) + if (anchor) { + lastAnchor = anchor + } + } + return lastAnchor +} + async function startCombinedDiffScrollProbe(page: Page): Promise { await page.evaluate(() => { type CombinedDiffScrollProbe = { @@ -415,7 +440,7 @@ test.describe('Combined diff scroll restore', () => { await orcaPage.locator(`[data-tab-id="${diffTabId}"]`).click({ force: true }) await expect(orcaPage.locator('.combined-diff-scroll-container')).toBeVisible() - const afterSwitch = await waitForStableViewportAnchor(orcaPage) + const afterSwitch = await waitForRestoredViewportAnchor(orcaPage, beforeSwitch) expect(afterSwitch.key).toBe(beforeSwitch.key) expect(Math.abs(afterSwitch.top - beforeSwitch.top)).toBeLessThan(80) diff --git a/tests/e2e/terminal-reattach-mouse-mode-leak.spec.ts b/tests/e2e/terminal-reattach-mouse-mode-leak.spec.ts index 5f2a68ce787..43a715f0585 100644 --- a/tests/e2e/terminal-reattach-mouse-mode-leak.spec.ts +++ b/tests/e2e/terminal-reattach-mouse-mode-leak.spec.ts @@ -230,8 +230,14 @@ test.describe('reattach mouse-mode leak', () => { await new Promise((resolve) => pane.terminal.write('\x1b[?1003h\x1b[?1006h', () => resolve()) ) - await new Promise((resolve) => requestAnimationFrame(() => resolve(undefined))) - const classAfterArm = pane.terminal.element.classList.contains('enable-mouse-events') + // Why: xterm toggles the enable-mouse-events class from a batched + // render pass, so a single rAF can race it on a slow CI shard; poll a + // few frames until the class lands before probing motion. + let classAfterArm = false + for (let attempt = 0; attempt < 30 && !classAfterArm; attempt += 1) { + await new Promise((resolve) => requestAnimationFrame(() => resolve(undefined))) + classAfterArm = pane.terminal.element.classList.contains('enable-mouse-events') + } await dispatchMotion() return { afterReattach, classAfterArm, armedReports: motionReports().length }