Skip to content

The open-source app everyone uses to manage agents at work

Stabilize task lifecycle browser fixtures (#15878)

Dotta88b7bbb5e248
diff --git a/server/src/services/native-runtime/native-session-resume.test.ts b/server/src/services/native-runtime/native-session-resume.test.ts
index d486db139f..52f2f12606 100644
--- a/server/src/services/native-runtime/native-session-resume.test.ts
+++ b/server/src/services/native-runtime/native-session-resume.test.ts
@@ -743,6 +743,13 @@ const recoveryFakeCodex = resolve(
runnerDiagnostics.push(chunk.slice(-4_096));
if (runnerDiagnostics.length > 32) runnerDiagnostics.shift();
};
+ // The production resolver prefers installed Codex over PATH. Explicitly
+ // bind this disposable fixture so it can never invoke a real provider.
+ const codexCommandResolver = await vi.importActual<{ resolveCodexCommand: () => string }>(
+ "../../../../packages/paperclip-runner/src/drivers/codex/codex-command.js",
+ );
+ const resolveFixtureCodex = vi.spyOn(codexCommandResolver, "resolveCodexCommand")
+ .mockReturnValue(join(bin, "codex"));
process.env.PAPERCLIP_RUNNER_STATE_DIR = stateBase;
try {
await Promise.all(
@@ -1227,6 +1234,7 @@ const recoveryFakeCodex = resolve(
Promise.resolve().then(() => session.close({ reason: "Recovery fixture cleanup" })),
));
const closeFailures = closed.filter((result) => result.status === "rejected");
+ resolveFixtureCodex.mockRestore();
runnerPrpWebSocketInternals.resetForTests();
server.closeAllConnections();
await new Promise<void>((done) => server.close(() => done()));
diff --git a/tests/e2e/agent-chat-projects.spec.ts b/tests/e2e/agent-chat-projects.spec.ts
index d4979449e3..c8fcdc2345 100644
--- a/tests/e2e/agent-chat-projects.spec.ts
+++ b/tests/e2e/agent-chat-projects.spec.ts
@@ -124,12 +124,19 @@ test("split handoff commits relevant plans before execution and never creates ch
const runs = await json(
await request.get(`/api/companies/${f.company.id}/heartbeat-runs`),
);
- const run = runs.find(
+ const taskRuns = runs.filter(
(run: any) => run.contextSnapshot?.issueId === task.id,
);
- expect(run).toBeTruthy();
+ expect(taskRuns.length).toBeGreaterThan(0);
+ const startedAt = taskRuns
+ .filter((run: any) => run.startedAt != null)
+ .map((run: any) => Date.parse(run.startedAt));
+ // A newer queued/cancelled run need not have started. Preserve the
+ // invariant against the first actual execution, not list ordering.
+ expect(startedAt.length).toBeGreaterThan(0);
+ expect(startedAt.every(Number.isFinite)).toBe(true);
expect(Date.parse(plan.updatedAt)).toBeLessThanOrEqual(
- Date.parse(run.startedAt),
+ Math.min(...startedAt),
);
}
expect(
diff --git a/tests/e2e/legacy-failure-continuation.spec.ts b/tests/e2e/legacy-failure-continuation.spec.ts
index dc7875e862..6645935cba 100644
--- a/tests/e2e/legacy-failure-continuation.spec.ts
+++ b/tests/e2e/legacy-failure-continuation.spec.ts
@@ -99,9 +99,21 @@ for (const action of ["task_retry", "thread_retry", "inbox_retry", "message", "q
} else if (action === "message") {
await page.getByRole("textbox", { name: "editable markdown" }).fill("Please continue the pending follow-up.");
await page.getByRole("button", { name: "Send", exact: true }).click();
+ } else if (action === "inbox_retry") {
+ // Navigation can cancel the mutation before its request is sent.
+ const [response] = await Promise.all([
+ page.waitForResponse((response) => {
+ const request = response.request();
+ return request.method() === "POST"
+ && new URL(response.url()).pathname.endsWith(`/agents/${agent.id}/wakeup`)
+ && request.postDataJSON()?.failedRunId === sourceRunId;
+ }),
+ page.getByRole("button", { name: "Retry", exact: true }).click(),
+ ]);
+ expect(response.ok(), `${response.status()} ${await response.text()}`).toBe(true);
+ await page.goto(taskUrl);
} else {
await page.getByRole("button", { name: action === "thread_retry" ? "Try again" : "Retry", exact: true }).click();
- if (action === "inbox_retry") await page.goto(taskUrl);
}
await expect(page.getByText("Answered the pending follow-up once.", { exact: false })).toBeVisible({ timeout: 45_000 });
await expect(page.getByRole("status", { name: "Task recovery" })).toHaveCount(0);
diff --git a/tests/e2e/new-task-picker-touch.spec.ts b/tests/e2e/new-task-picker-touch.spec.ts
index b48d7084d6..6804125114 100644
--- a/tests/e2e/new-task-picker-touch.spec.ts
+++ b/tests/e2e/new-task-picker-touch.spec.ts
@@ -21,13 +21,23 @@ async function swipeToLastOption(page: Page, picker: Locator, list = picker.getB
}).toBeLessThanOrEqual(page.viewportSize()!.height);
expect((await picker.boundingBox())!.y).toBeGreaterThanOrEqual(0);
const session = await page.context().newCDPSession(page);
+ const targetHandle = await last.elementHandle();
+ expect(targetHandle).not.toBeNull();
try {
expect(await list.evaluate((element) => element.scrollHeight > element.clientHeight)).toBe(true);
for (let attempt = 0; attempt < 20; attempt += 1) {
- const bounds = (await list.boundingBox())!;
- const target = (await last.boundingBox())!;
+ // Momentum can finish between protocol round trips. Observe geometry and
+ // scrollTop together so a stale target cannot trigger a swipe at the end.
+ const { bounds, target, before } = await list.evaluate((element, option) => {
+ const container = element.getBoundingClientRect();
+ const item = option!.getBoundingClientRect();
+ return {
+ bounds: { x: container.x, y: container.y, width: container.width, height: container.height },
+ target: { y: item.y, height: item.height },
+ before: element.scrollTop,
+ };
+ }, targetHandle);
if (target.y >= bounds.y && target.y + target.height <= bounds.y + bounds.height) break;
- const before = await list.evaluate((element) => element.scrollTop);
const x = bounds.x + bounds.width / 2;
const y = bounds.y + bounds.height - 20;
const distance = Math.min(180, bounds.height - 40);
@@ -49,6 +59,7 @@ async function swipeToLastOption(page: Page, picker: Locator, list = picker.getB
expect(target.y).toBeGreaterThanOrEqual(bounds.y);
expect(target.y + target.height).toBeLessThanOrEqual(bounds.y + bounds.height + 1);
} finally {
+ await targetHandle?.dispose();
await session.detach();
}
return last;
@@ -56,6 +67,25 @@ async function swipeToLastOption(page: Page, picker: Locator, list = picker.getB
test.use({ viewport: { width: 390, height: 844 }, hasTouch: true, isMobile: true });
+test("touch scroll observation stays valid when momentum finishes between browser reads", async ({ page, browserName }) => {
+ test.skip(browserName !== "chromium", "Native touch drags use Chromium's input protocol.");
+ await page.setContent(`<div role="dialog" style="position:absolute;top:20px;left:20px;width:300px">
+ <div role="listbox" style="height:150px;overflow-y:auto;touch-action:pan-y">
+ ${Array.from({ length: 12 }, (_, index) => `<div role="option" style="height:40px">Option ${index}</div>`).join("")}
+ </div></div>`);
+ const picker = page.getByRole("dialog"), list = picker.getByRole("listbox"), last = list.getByRole("option").last();
+ const boundingBox = last.boundingBox.bind(last);
+ // Reproduce the observed compositor interleaving: a returned target rectangle
+ // is stale by the next scrollTop read because inertia reached the list end.
+ last.boundingBox = async (options) => {
+ const beforeMomentum = await boundingBox(options);
+ await list.evaluate((element) => { element.scrollTop = element.scrollHeight - element.clientHeight; });
+ return beforeMomentum;
+ };
+ await swipeToLastOption(page, picker, list, last);
+ await expect(picker).toBeVisible();
+});
+
test("new-task assignee, model, and project sheets scroll by touch and retain the selected values", async ({ page, request, browserName }, testInfo) => {
test.skip(browserName !== "chromium", "Native touch drags use Chromium's input protocol.");
const company = await json(await request.post("/api/companies", {
diff --git a/tests/e2e/signoff-policy.spec.ts b/tests/e2e/signoff-policy.spec.ts
index 471589cf3c..da005094f2 100644
--- a/tests/e2e/signoff-policy.spec.ts
+++ b/tests/e2e/signoff-policy.spec.ts
@@ -270,6 +270,29 @@ async function getIssueRunLockState(board: APIRequestContext, issueId: string):
};
}
+async function waitForFixtureRun(
+ board: APIRequestContext,
+ agentId: string,
+ issueId: string,
+ runId: string,
+) {
+ // Negative authorization cases deliberately invoke a non-participant. Leave
+ // their API rejection intact instead of waiting for a run they cannot own.
+ if ((await getIssueRunLockState(board, issueId)).assigneeAgentId !== agentId) return;
+ const waitBudgetMs = wakeupWaitBudgetMs();
+ const deadline = Date.now() + waitBudgetMs;
+ let status: string | null = null;
+ do {
+ const run = await fetchVerifiedRun(board, runId, agentId, issueId);
+ expect(run, "Fixture run must belong to the acting agent and issue").not.toBeNull();
+ status = run!.status;
+ if (status === "succeeded") return;
+ expect(["queued", "running"], `Fixture run ${runId} ended as ${status}`).toContain(status);
+ await new Promise((resolve) => setTimeout(resolve, WAKEUP_POLL_INTERVAL_MS));
+ } while (Date.now() < deadline);
+ throw new Error(`Fixture run ${runId} did not succeed within ${waitBudgetMs}ms (last status: ${status})`);
+}
+
async function retryAgentPatchWithCurrentLockOnConflict(
board: APIRequestContext,
agent: AgentAuth,
@@ -286,6 +309,9 @@ async function retryAgentPatchWithCurrentLockOnConflict(
if (issueRunLock.assigneeAgentId !== agent.agentId) return res;
const lockedRunId = issueRunLock.checkoutRunId ?? issueRunLock.executionRunId ?? fallbackRunId;
+ // A new lock can belong to a newly promoted fixture run, not the completed
+ // run we first invoked. Let that exact verified run settle before PATCH.
+ await waitForFixtureRun(board, agent.agentId, issueId, lockedRunId);
res = await agent.request.patch(`${BASE_URL}/api/issues/${issueId}`, {
headers: { "X-Paperclip-Run-Id": lockedRunId },
data: patchData,
@@ -325,6 +351,9 @@ async function agentPatch(
}: { maxAttempts?: number; backoffMs?: number; maxBackoffMs?: number } = {},
) {
const runId = await invokeHeartbeat(board, agent.agentId, issueId);
+ // The fixture process only prints "done". Let its startup and cleanup settle
+ // before a simulated decision reassigns the issue and cancels that process.
+ await waitForFixtureRun(board, agent.agentId, issueId, runId);
const patchWith = (patchRunId: string) =>
agent.request.patch(`${BASE_URL}/api/issues/${issueId}`, {
headers: { "X-Paperclip-Run-Id": patchRunId },
@@ -339,6 +368,7 @@ async function agentPatch(
// run-lock race — leave it for the caller to assert on.
if (issueRunLock.assigneeAgentId !== agent.agentId) break;
const retryRunId = issueRunLock.checkoutRunId ?? issueRunLock.executionRunId ?? runId;
+ await waitForFixtureRun(board, agent.agentId, issueId, retryRunId);
res = await patchWith(retryRunId);
}
return res;
@@ -353,6 +383,7 @@ async function agentCheckoutAndPatch(
patchData: Record<string, unknown>,
) {
const runId = await invokeHeartbeat(board, agent.agentId, issueId);
+ await waitForFixtureRun(board, agent.agentId, issueId, runId);
const directPatchRes = await agent.request.patch(`${BASE_URL}/api/issues/${issueId}`, {
headers: { "X-Paperclip-Run-Id": runId },
data: patchData,