Skip to content

Commit 9664fbd

Browse files
committed
fix(web): bound agent session reconciliation retries
1 parent 09f86ff commit 9664fbd

2 files changed

Lines changed: 291 additions & 14 deletions

File tree

‎apps/web/src/hooks/useAgentSessionAutoReconcile.test.ts‎

Lines changed: 224 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,16 @@
1-
import { describe, expect, it } from "vite-plus/test";
1+
import { act, createElement } from "react";
2+
import { create, type ReactTestRenderer } from "react-test-renderer";
3+
import { EnvironmentRpcUnavailableError } from "@t3tools/client-runtime/rpc";
4+
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
25
import type { EnvironmentId, ProjectId } from "@t3tools/contracts";
36
import type { EnvironmentProject } from "@t3tools/client-runtime/state/models";
47
import * as Cause from "effect/Cause";
58
import { AsyncResult } from "effect/unstable/reactivity";
69
import { RpcClientError } from "effect/unstable/rpc";
10+
import { SocketCloseError } from "effect/unstable/socket/Socket";
711

812
import {
13+
useAgentSessionAutoReconcile,
914
classifyImportFailure,
1015
isDefinitiveOutcome,
1116
projectReconcileKey,
@@ -96,18 +101,52 @@ describe("classifyImportFailure", () => {
96101
expect(classifyImportFailure(result)).toBe("interrupted");
97102
});
98103

99-
it("classifies an RpcClientError as unsupported-server", () => {
104+
it("classifies a transport RpcClientDefect as unexpected", () => {
100105
const rpcError = new RpcClientError.RpcClientError({
101106
reason: new RpcClientError.RpcClientDefect({
102107
message: "unknown method",
103108
cause: new Error("socket closed"),
104109
}),
105110
});
106-
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(rpcError)))).toBe(
107-
"unsupported-server",
111+
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(rpcError)))).toBe("unexpected");
112+
});
113+
114+
it.each([
115+
"Unknown request tag: agentSessions.import",
116+
new Error("Unknown request tag: agentSessions.import"),
117+
new RpcClientError.RpcClientError({
118+
reason: new RpcClientError.RpcClientDefect({
119+
message: "Remote defect",
120+
cause: "Unknown request tag: agentSessions.import",
121+
}),
122+
}),
123+
])("recognizes the server's missing import method defect: %s", (error) => {
124+
expect(classifyImportFailure(AsyncResult.failure(Cause.die(error)))).toBe("unsupported-server");
125+
});
126+
127+
it("does not mistake a different unknown request tag for a missing import method", () => {
128+
expect(classifyImportFailure(AsyncResult.failure(Cause.die("Unknown request tag: Ack")))).toBe(
129+
"unexpected",
108130
);
109131
});
110132

133+
it("keeps socket closure errors retryable", () => {
134+
const error = new RpcClientError.RpcClientError({
135+
reason: new SocketCloseError({ code: 1006, closeReason: "Disconnected" }),
136+
});
137+
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(error)))).toBe("unexpected");
138+
});
139+
140+
it("keeps protocol decoding defects retryable", () => {
141+
const error = new RpcClientError.RpcClientError({
142+
reason: new RpcClientError.RpcClientDefect({
143+
message: "Error decoding HTTP response",
144+
cause: new Error("Invalid JSON"),
145+
}),
146+
});
147+
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(error)))).toBe("unexpected");
148+
});
149+
111150
it("classifies AgentSessionImportProjectNotFoundError as expected", () => {
112151
const error = { _tag: "AgentSessionImportProjectNotFoundError" as const, projectId: "proj-1" };
113152
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(error)))).toBe("expected");
@@ -123,9 +162,14 @@ describe("classifyImportFailure", () => {
123162
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(error)))).toBe("expected");
124163
});
125164

126-
it("classifies EnvironmentRpcUnavailableError as expected", () => {
127-
const error = { _tag: "EnvironmentRpcUnavailableError" as const, environmentId: "env-1" };
128-
expect(classifyImportFailure(AsyncResult.failure(Cause.fail(error)))).toBe("expected");
165+
it("keeps a temporarily unavailable environment retryable", () => {
166+
const error = new EnvironmentRpcUnavailableError({
167+
environmentId: "env-1",
168+
message: "Disconnected",
169+
});
170+
const kind = classifyImportFailure(AsyncResult.failure(Cause.fail(error)));
171+
expect(kind).toBe("unexpected");
172+
expect(isDefinitiveOutcome(kind)).toBe(false);
129173
});
130174

131175
it("classifies EnvironmentAuthorizationError as expected", () => {
@@ -168,3 +212,176 @@ describe("isDefinitiveOutcome", () => {
168212
expect(isDefinitiveOutcome("interrupted")).toBe(false);
169213
});
170214
});
215+
216+
const state = vi.hoisted(() => ({
217+
projects: [] as EnvironmentProject[],
218+
bootstrapped: true,
219+
importSessions: vi.fn(),
220+
}));
221+
vi.mock("../state/entities", () => ({
222+
useProjects: () => state.projects,
223+
useAllEnvironmentShellsBootstrapped: () => state.bootstrapped,
224+
}));
225+
vi.mock("../state/agentSessions", () => ({ agentSessionImport: {} }));
226+
vi.mock("../state/use-atom-command", () => ({ useAtomCommand: () => state.importSessions }));
227+
228+
function Reconciler() {
229+
useAgentSessionAutoReconcile();
230+
return null;
231+
}
232+
233+
describe("useAgentSessionAutoReconcile retry lifecycle", () => {
234+
let renderer: ReactTestRenderer | undefined;
235+
const success = AsyncResult.success({ importedCount: 1, skippedCount: 0 });
236+
const unexpected = AsyncResult.failure(Cause.die(new Error("socket closed")));
237+
const unsupported = AsyncResult.failure(Cause.die("Unknown request tag: agentSessions.import"));
238+
239+
async function render() {
240+
await act(() => {
241+
if (renderer) renderer.update(createElement(Reconciler));
242+
else renderer = create(createElement(Reconciler));
243+
});
244+
}
245+
async function advance(ms: number) {
246+
await act(() => vi.advanceTimersByTimeAsync(ms));
247+
}
248+
249+
beforeEach(() => {
250+
vi.useFakeTimers();
251+
vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
252+
vi.spyOn(console, "info").mockImplementation(() => {});
253+
vi.spyOn(console, "warn").mockImplementation(() => {});
254+
vi.spyOn(console, "error").mockImplementation(() => {});
255+
state.projects = [makeProject("env-1", "proj-a")];
256+
state.bootstrapped = true;
257+
state.importSessions.mockReset().mockResolvedValue(unexpected);
258+
});
259+
afterEach(async () => {
260+
await act(() => renderer?.unmount());
261+
renderer = undefined;
262+
vi.useRealTimers();
263+
vi.unstubAllGlobals();
264+
vi.restoreAllMocks();
265+
});
266+
267+
it("delays retries across project updates and stops after three attempts", async () => {
268+
await render();
269+
for (let i = 0; i < 4; i++) {
270+
state.projects = [...state.projects];
271+
await render();
272+
}
273+
await advance(4_999);
274+
expect(state.importSessions).toHaveBeenCalledTimes(1);
275+
await advance(1);
276+
expect(state.importSessions).toHaveBeenCalledTimes(2);
277+
await advance(5_000);
278+
expect(state.importSessions).toHaveBeenCalledTimes(3);
279+
state.projects = [...state.projects];
280+
await render();
281+
await advance(60_000);
282+
expect(state.importSessions).toHaveBeenCalledTimes(3);
283+
});
284+
285+
it("marks success reconciled and cancels further retries", async () => {
286+
state.importSessions.mockResolvedValueOnce(unexpected).mockResolvedValue(success);
287+
await render();
288+
await advance(5_000);
289+
state.projects = [...state.projects];
290+
await render();
291+
await advance(60_000);
292+
expect(state.importSessions).toHaveBeenCalledTimes(2);
293+
});
294+
295+
it("keeps retry budgets separate across projects and environments", async () => {
296+
state.projects.push(makeProject("env-1", "proj-b"), makeProject("env-2", "proj-a"));
297+
await render();
298+
await advance(5_000);
299+
await advance(5_000);
300+
await advance(60_000);
301+
expect(state.importSessions).toHaveBeenCalledTimes(9);
302+
for (const project of state.projects) {
303+
expect(
304+
state.importSessions.mock.calls.filter(
305+
([request]) =>
306+
request.environmentId === project.environmentId &&
307+
request.input.projectId === project.id,
308+
),
309+
).toHaveLength(3);
310+
}
311+
});
312+
313+
it("retries a temporary disconnect after bootstrap returns", async () => {
314+
state.importSessions
315+
.mockResolvedValueOnce(
316+
AsyncResult.failure(
317+
Cause.fail(
318+
new EnvironmentRpcUnavailableError({ environmentId: "env-1", message: "Disconnected" }),
319+
),
320+
),
321+
)
322+
.mockResolvedValue(success);
323+
await render();
324+
state.bootstrapped = false;
325+
await render();
326+
await advance(5_000);
327+
expect(state.importSessions).toHaveBeenCalledTimes(1);
328+
state.bootstrapped = true;
329+
await render();
330+
expect(state.importSessions).toHaveBeenCalledTimes(2);
331+
});
332+
333+
it("clears unsupported environments on bootstrap loss", async () => {
334+
state.projects.push(makeProject("env-1", "proj-b"));
335+
state.importSessions.mockResolvedValueOnce(unsupported).mockResolvedValue(success);
336+
await render();
337+
state.projects = [...state.projects];
338+
await render();
339+
expect(state.importSessions).toHaveBeenCalledTimes(1);
340+
state.bootstrapped = false;
341+
await render();
342+
state.bootstrapped = true;
343+
await render();
344+
expect(state.importSessions).toHaveBeenCalledTimes(3);
345+
});
346+
347+
it("does not overlap requests when projects change during an import", async () => {
348+
let finish!: (result: typeof unexpected) => void;
349+
state.importSessions.mockReturnValueOnce(
350+
new Promise<typeof unexpected>((resolve) => {
351+
finish = resolve;
352+
}),
353+
);
354+
await render();
355+
state.projects = [...state.projects];
356+
await render();
357+
await advance(10_000);
358+
expect(state.importSessions).toHaveBeenCalledTimes(1);
359+
await act(() => finish(unexpected));
360+
await advance(4_999);
361+
expect(state.importSessions).toHaveBeenCalledTimes(1);
362+
await advance(1);
363+
expect(state.importSessions).toHaveBeenCalledTimes(2);
364+
});
365+
366+
it("records success even if projects changed during the request", async () => {
367+
let finish!: (result: typeof success) => void;
368+
state.importSessions.mockReturnValueOnce(
369+
new Promise<typeof success>((resolve) => {
370+
finish = resolve;
371+
}),
372+
);
373+
await render();
374+
state.projects = [...state.projects];
375+
await render();
376+
await act(() => finish(success));
377+
await advance(60_000);
378+
expect(state.importSessions).toHaveBeenCalledTimes(1);
379+
});
380+
381+
it("clears pending retry timers on unmount", async () => {
382+
await render();
383+
await act(() => renderer?.unmount());
384+
await advance(60_000);
385+
expect(state.importSessions).toHaveBeenCalledTimes(1);
386+
});
387+
});

0 commit comments

Comments
 (0)