Files
kandev/apps/web/hooks/domains/comments/plan-comment-migration.test.ts
T

568 lines
22 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { createAppStore } from "@/lib/state/store";
import { COMMENTS_STORAGE_PREFIX } from "@/lib/state/slices/comments/persistence";
import type { PlanComment } from "@/lib/state/slices/comments";
import type { TaskPlan, TaskPlanCommentSnapshot } from "@/lib/types/http";
import { WebSocketRequestError, toWebSocketRequestError } from "@/lib/ws/request-error";
import { planCommentMigrationFor } from "./plan-comment-migration";
const api = vi.hoisted(() => ({
createTaskPlanComment: vi.fn(),
updateTaskPlanComment: vi.fn(),
}));
const plans = vi.hoisted(() => ({ getTaskPlan: vi.fn() }));
vi.mock("@/lib/api/domains/plan-comment-api", () => api);
vi.mock("@/lib/api/domains/plan-api", () => plans);
const TASK = "task-1";
const SESSION = "session-1";
const PLAN = "plan-1";
const DATE = "2026-09-02T00:00:00Z";
const EDITED_BODY = "Edited feedback";
const plan: TaskPlan = {
id: PLAN,
task_id: TASK,
title: "Plan",
content: "Step",
created_by: "agent",
created_at: DATE,
updated_at: DATE,
};
const comment: PlanComment = {
id: "legacy-1",
sessionId: SESSION,
source: "plan",
text: "Feedback",
selectedText: "Step",
from: 1,
to: 5,
createdAt: DATE,
status: "pending",
};
const snapshot: TaskPlanCommentSnapshot = {
task_id: TASK,
plan_id: PLAN,
revision: 1,
comments: [
{
id: comment.id,
task_id: TASK,
plan_id: PLAN,
body: comment.text,
selected_text: comment.selectedText,
anchor_from: 1,
anchor_to: 5,
version: 1,
created_at: DATE,
updated_at: DATE,
},
],
};
let releases: Array<() => void>;
function write(rows = [comment], sessionId = SESSION) {
window.sessionStorage.setItem(`${COMMENTS_STORAGE_PREFIX}${sessionId}`, JSON.stringify(rows));
}
function saved() {
return JSON.parse(window.sessionStorage.getItem(`${COMMENTS_STORAGE_PREFIX}${SESSION}`) ?? "[]");
}
function setup(connected = true) {
const store = createAppStore();
store.getState().setTaskPlan(TASK, plan);
store.getState().setConnectionStatus(connected ? "connected" : "disconnected");
const recovery = planCommentMigrationFor(store, TASK);
const detach = recovery.attach(vi.fn().mockResolvedValue(undefined));
releases.push(detach);
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
const state = () => store.getState().taskPlans.commentsMigrationByTaskId[TASK];
return { store, recovery, detach, state };
}
function settle() {
return vi.advanceTimersByTimeAsync(0);
}
function deferred<T = TaskPlanCommentSnapshot>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((done) => {
resolve = done;
});
return { promise, resolve };
}
function editedSnapshot(body = EDITED_BODY, version = 2): TaskPlanCommentSnapshot {
return { ...snapshot, revision: version, comments: [{ ...snapshot.comments[0], body, version }] };
}
async function acknowledgeDuringLocalEdit(edited = { ...comment, text: EDITED_BODY }) {
write();
const pending = deferred();
api.createTaskPlanComment
.mockReturnValueOnce(pending.promise)
.mockRejectedValue(new WebSocketRequestError("UUID already used", "plan_comments_changed"));
const fixture = setup();
await settle();
write([edited]);
fixture.recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
pending.resolve(snapshot);
await settle();
return fixture;
}
beforeEach(() => {
vi.useFakeTimers();
vi.resetAllMocks();
window.sessionStorage.clear();
releases = [];
api.createTaskPlanComment.mockResolvedValue(snapshot);
plans.getTaskPlan.mockResolvedValue(plan);
});
afterEach(() => {
for (const release of releases) release();
vi.restoreAllMocks();
vi.useRealTimers();
});
describe("task-scoped plan comment recovery", () => {
it("resolves an unknown plan without relying on an ordinary comment loader", async () => {
write();
const store = createAppStore();
store.getState().setConnectionStatus("connected");
const recovery = planCommentMigrationFor(store, TASK);
releases.push(recovery.attach(vi.fn()));
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
await settle();
expect(store.getState().taskPlans.commentsMigrationByTaskId[TASK]).toMatchObject({
status: "complete",
pendingCount: 0,
});
expect(plans.getTaskPlan).toHaveBeenCalledOnce();
expect(saved()).toEqual([]);
});
// @covers AC-TASKS-PLAN-COMMENTS-004.2, AC-TASKS-PLAN-COMMENTS-004.6
it("uses three connected attempts then bounded background backoff with the original UUID", async () => {
write();
api.createTaskPlanComment.mockRejectedValue(new Error("offline"));
const { state } = setup();
await settle();
expect(state()).toMatchObject({ status: "retrying", pendingCount: 1 });
for (const [index, delay] of [1000, 2000, 30000, 60000, 120000, 120000].entries()) {
await vi.advanceTimersByTimeAsync(delay - 1);
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(index + 1);
await vi.advanceTimersByTimeAsync(1);
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(index + 2);
}
expect(state()).toMatchObject({ status: "failed", pendingCount: 1, failure: "transient" });
expect(
api.createTaskPlanComment.mock.calls.every(
([input]) => input.id === comment.id && input.body === comment.text,
),
).toBe(true);
expect(saved()).toEqual([comment]);
});
it("gives a replacement plan a fresh quiet retry burst", async () => {
write();
api.createTaskPlanComment.mockRejectedValue(new Error("offline"));
const { store, state } = setup();
await settle();
await vi.advanceTimersByTimeAsync(1000);
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(2);
store.getState().setTaskPlan(TASK, { ...plan, id: "plan-2" });
await settle();
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(3);
expect(api.createTaskPlanComment).toHaveBeenLastCalledWith(
expect.objectContaining({ planId: "plan-2", id: comment.id }),
);
expect(state()).toMatchObject({ status: "retrying", pendingCount: 1 });
await vi.advanceTimersByTimeAsync(1000);
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(4);
expect(state()?.status).toBe("retrying");
await vi.advanceTimersByTimeAsync(2000);
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(5);
expect(state()).toMatchObject({ status: "failed", pendingCount: 1, failure: "transient" });
expect(saved()).toEqual([comment]);
});
it("coalesces multiple surfaces and resume signals around one in-flight upload", async () => {
write();
const pending = deferred();
api.createTaskPlanComment.mockReturnValue(pending.promise);
const { store, recovery, state, detach } = setup();
const other = planCommentMigrationFor(store, TASK);
expect(other).toBe(recovery);
releases.push(other.attach(vi.fn()));
other.update({ sessionIds: [SESSION], complete: true, loading: false });
recovery.wake();
other.wake();
await settle();
detach();
pending.resolve(snapshot);
await settle();
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
});
it("spends no attempts while hidden or offline and resumes without a manual retry", async () => {
write();
const { store, recovery, state } = setup(false);
await vi.advanceTimersByTimeAsync(120000);
expect(api.createTaskPlanComment).not.toHaveBeenCalled();
expect(state()?.pendingCount).toBe(1);
const visibility = vi.spyOn(document, "visibilityState", "get").mockReturnValue("hidden");
store.getState().setConnectionStatus("connected");
await settle();
expect(api.createTaskPlanComment).not.toHaveBeenCalled();
visibility.mockReturnValue("visible");
await recovery.wake();
expect(state()?.status).toBe("complete");
});
});
describe("legacy recovery scope lifecycle", () => {
it("keeps an in-flight upload when a load confirms the same plan identity", async () => {
write();
const pending = deferred();
api.createTaskPlanComment.mockReturnValueOnce(pending.promise);
const { store, state } = setup(false);
store.setState((previous) => ({
taskPlans: {
...previous.taskPlans,
loadedByTaskId: { ...previous.taskPlans.loadedByTaskId, [TASK]: false },
},
}));
store.getState().setConnectionStatus("connected");
await settle();
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
store.getState().setTaskPlan(TASK, plan);
pending.resolve(snapshot);
await settle();
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
expect(saved()).toEqual([]);
});
it("stops timers when the last surface unmounts and resumes on remount", async () => {
write();
api.createTaskPlanComment.mockRejectedValueOnce(new Error("offline"));
const { recovery, detach, state } = setup();
await settle();
detach();
await vi.advanceTimersByTimeAsync(120000);
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
releases.push(recovery.attach(vi.fn()));
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
await settle();
expect(state()?.status).toBe("complete");
});
it("does not acknowledge a late result after task departure, including immediate remount", async () => {
write();
const old = deferred();
const next = deferred();
api.createTaskPlanComment.mockReturnValueOnce(old.promise).mockReturnValueOnce(next.promise);
const { recovery, detach, store } = setup();
await settle();
detach();
releases.push(recovery.attach(vi.fn()));
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
old.resolve(snapshot);
await settle();
expect(saved()).toEqual([comment]);
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toBeUndefined();
next.resolve(snapshot);
await settle();
expect(saved()).toEqual([]);
});
});
describe("legacy recovery wire errors", () => {
// @covers AC-TASKS-PLAN-COMMENTS-004.6
it.each(["INTERNAL_ERROR", "internal_error"])("automatically retries %s", async (code) => {
write();
api.createTaskPlanComment.mockRejectedValueOnce(
toWebSocketRequestError({ code, message: "Temporary server failure" }),
);
const { state } = setup();
await settle();
expect(state()).toMatchObject({ status: "retrying", pendingCount: 1 });
expect(saved()).toEqual([comment]);
await vi.advanceTimersByTimeAsync(1000);
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(2);
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
expect(saved()).toEqual([]);
});
it.each([
["NOT_FOUND", "automatic"],
["not_found", "automatic"],
["NOT_FOUND", "manual"],
["not_found", "manual"],
])("refreshes a missing plan after %s through %s retry", async (code, trigger) => {
write();
const replacement = { ...plan, id: "plan-2" };
const recovered = {
...snapshot,
plan_id: replacement.id,
comments: snapshot.comments.map((row) => ({ ...row, plan_id: replacement.id })),
};
plans.getTaskPlan.mockResolvedValue(replacement);
api.createTaskPlanComment
.mockRejectedValueOnce(toWebSocketRequestError({ code, message: "Plan not found" }))
.mockResolvedValue(recovered);
const { store, recovery, state } = setup();
await settle();
expect(saved()).toEqual([comment]);
if (trigger === "manual") await recovery.retry();
else await vi.advanceTimersByTimeAsync(1000);
await settle();
expect(plans.getTaskPlan).toHaveBeenCalledOnce();
expect(api.createTaskPlanComment).toHaveBeenLastCalledWith(
expect.objectContaining({ planId: replacement.id, id: comment.id, body: comment.text }),
);
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toEqual(recovered);
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
expect(saved()).toEqual([]);
});
});
describe("legacy recovery identity", () => {
it("ignores a late plan lookup after another reader confirms absence", async () => {
write();
const lookup = deferred<TaskPlan | null>();
plans.getTaskPlan.mockReturnValueOnce(lookup.promise);
const store = createAppStore();
store.getState().setConnectionStatus("connected");
const recovery = planCommentMigrationFor(store, TASK);
releases.push(recovery.attach(vi.fn()));
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
await settle();
expect(plans.getTaskPlan).toHaveBeenCalledOnce();
store.getState().setTaskPlan(TASK, null);
lookup.resolve(plan);
await settle();
expect(store.getState().taskPlans.byTaskId[TASK]).toBeNull();
expect(api.createTaskPlanComment).not.toHaveBeenCalled();
expect(saved()).toEqual([comment]);
expect(store.getState().taskPlans.commentsMigrationByTaskId[TASK]).toMatchObject({
status: "waiting_for_plan",
pendingCount: 1,
});
});
it("surfaces exhausted plan lookup failures for known drafts and later recovers", async () => {
write();
plans.getTaskPlan.mockRejectedValue(new Error("offline"));
const store = createAppStore();
store.getState().setConnectionStatus("connected");
const recovery = planCommentMigrationFor(store, TASK);
releases.push(recovery.attach(vi.fn()));
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
await vi.advanceTimersByTimeAsync(3000);
expect(plans.getTaskPlan).toHaveBeenCalledTimes(3);
expect(store.getState().taskPlans.commentsMigrationByTaskId[TASK]).toMatchObject({
status: "failed",
pendingCount: 1,
failure: "transient",
});
expect(saved()).toEqual([comment]);
plans.getTaskPlan.mockResolvedValue(plan);
await vi.advanceTimersByTimeAsync(30000);
expect(store.getState().taskPlans.commentsMigrationByTaskId[TASK]).toMatchObject({
status: "complete",
pendingCount: 0,
});
expect(saved()).toEqual([]);
});
it("does not let a hidden wake suppress the immediate visible retry", async () => {
write();
api.createTaskPlanComment.mockRejectedValueOnce(new Error("offline"));
const { recovery, state } = setup();
await settle();
const visibility = vi.spyOn(document, "visibilityState", "get").mockReturnValue("hidden");
document.dispatchEvent(new Event("visibilitychange"));
await recovery.wake();
visibility.mockReturnValue("visible");
await recovery.wake();
expect(api.createTaskPlanComment).toHaveBeenCalledTimes(2);
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
});
it("does not acknowledge a stale generation after a plan is deleted and restored", async () => {
write();
const old = deferred();
const next = deferred();
api.createTaskPlanComment.mockReturnValueOnce(old.promise).mockReturnValueOnce(next.promise);
const { store } = setup();
await settle();
store.getState().setTaskPlan(TASK, null);
store.getState().setTaskPlan(TASK, plan);
old.resolve(snapshot);
await settle();
expect(saved()).toEqual([comment]);
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toBeUndefined();
next.resolve(snapshot);
await settle();
expect(saved()).toEqual([]);
});
});
describe("legacy edits during acknowledgement", () => {
it("updates an acknowledged body at its original UUID and exact version", async () => {
api.updateTaskPlanComment.mockResolvedValue(editedSnapshot());
const { store, state } = await acknowledgeDuringLocalEdit();
expect(saved()).toEqual([{ ...comment, text: EDITED_BODY }]);
await vi.advanceTimersByTimeAsync(1000);
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toEqual(editedSnapshot());
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(api.updateTaskPlanComment).toHaveBeenCalledWith({
taskId: TASK,
planId: PLAN,
id: comment.id,
expectedVersion: 1,
body: EDITED_BODY,
});
expect(saved()).toEqual([]);
});
it("retains local feedback without overwriting a conflicting server edit", async () => {
const remote = editedSnapshot("Another client's feedback", 3);
api.updateTaskPlanComment.mockRejectedValue(
new WebSocketRequestError("Changed version", "plan_comments_changed", { snapshot: remote }),
);
const { store, recovery, state } = await acknowledgeDuringLocalEdit();
await vi.advanceTimersByTimeAsync(121000);
expect(api.updateTaskPlanComment).toHaveBeenCalledOnce();
expect(state()).toMatchObject({ status: "failed", pendingCount: 1, failure: "conflict" });
expect(saved()).toEqual([{ ...comment, text: EDITED_BODY }]);
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toEqual(remote);
await recovery.retry();
expect(api.updateTaskPlanComment).toHaveBeenCalledTimes(2);
expect(api.updateTaskPlanComment).toHaveBeenLastCalledWith({
taskId: TASK,
planId: PLAN,
id: comment.id,
expectedVersion: 1,
body: EDITED_BODY,
});
expect(state()).toMatchObject({ status: "failed", pendingCount: 1, failure: "conflict" });
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toEqual(remote);
expect(saved()).toEqual([{ ...comment, text: EDITED_BODY }]);
const resolved = editedSnapshot(EDITED_BODY, 4);
api.updateTaskPlanComment.mockRejectedValueOnce(
new WebSocketRequestError("Changed version", "plan_comments_changed", { snapshot: resolved }),
);
await recovery.retry();
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
expect(store.getState().taskPlans.commentsByTaskId[TASK]).toEqual(resolved);
expect(saved()).toEqual([]);
});
it("reconciles an accepted update whose response was lost", async () => {
api.updateTaskPlanComment.mockRejectedValueOnce(new Error("response lost")).mockRejectedValue(
new WebSocketRequestError("Changed version", "plan_comments_changed", {
snapshot: editedSnapshot(),
}),
);
const { state } = await acknowledgeDuringLocalEdit();
await vi.advanceTimersByTimeAsync(3000);
expect(state()).toMatchObject({ status: "complete", pendingCount: 0 });
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(api.updateTaskPlanComment).toHaveBeenCalledTimes(2);
expect(saved()).toEqual([]);
});
it("does not reinterpret a changed legacy selection as a body-only update", async () => {
const edited = { ...comment, text: EDITED_BODY, selectedText: "Other step" };
const { state } = await acknowledgeDuringLocalEdit(edited);
await vi.advanceTimersByTimeAsync(1000);
expect(state()).toMatchObject({ status: "failed", pendingCount: 1, failure: "conflict" });
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(api.updateTaskPlanComment).not.toHaveBeenCalled();
expect(saved()).toEqual([edited]);
});
});
describe("legacy feedback retention", () => {
it("keeps a paused partial recovery quiet when a plan still exists", async () => {
write([comment, { ...comment, id: "legacy-2" }]);
const pending = deferred();
api.createTaskPlanComment.mockReturnValueOnce(pending.promise);
const { store, state } = setup();
await settle();
store.getState().setConnectionStatus("disconnected");
pending.resolve(snapshot);
await settle();
expect(state()).toMatchObject({ status: "idle", pendingCount: 1 });
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
});
it("retains identified drafts when later storage scans are empty or unavailable", async () => {
write();
const { recovery, state } = setup(false);
window.sessionStorage.clear();
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
expect(state()?.pendingCount).toBe(1);
const read = vi.spyOn(window.sessionStorage, "getItem").mockImplementation(() => {
throw new DOMException("denied", "SecurityError");
});
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
expect(state()?.pendingCount).toBe(1);
expect(read).toHaveBeenCalled();
});
it("retries refused cleanup without uploading the acknowledged feedback again", async () => {
write();
const removal = vi.spyOn(window.sessionStorage, "removeItem").mockImplementation(() => {
throw new DOMException("denied", "SecurityError");
});
const { state } = setup();
await settle();
expect(state()?.pendingCount).toBe(1);
expect(saved()).toEqual([comment]);
removal.mockRestore();
await vi.advanceTimersByTimeAsync(1000);
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(saved()).toEqual([]);
expect(state()?.status).toBe("complete");
});
it.each(["validation_error", "unauthorized", "plan_comments_changed"])(
"requires explicit retry for %s instead of looping mutations",
async (code) => {
write();
api.createTaskPlanComment.mockRejectedValue(new WebSocketRequestError("rejected", code));
const { recovery, state } = setup();
await settle();
recovery.wake();
await vi.advanceTimersByTimeAsync(120000);
expect(api.createTaskPlanComment).toHaveBeenCalledOnce();
expect(state()).toMatchObject({ status: "failed", pendingCount: 1 });
api.createTaskPlanComment.mockResolvedValue(snapshot);
await recovery.retry();
expect(saved()).toEqual([]);
},
);
it("rescans newly discovered task sessions without touching another task's records", async () => {
write([comment], "foreign-session");
const { recovery, state } = setup();
await settle();
expect(state()?.status).toBe("complete");
expect(api.createTaskPlanComment).not.toHaveBeenCalled();
write();
recovery.update({ sessionIds: [SESSION], complete: true, loading: false });
await settle();
expect(state()?.pendingCount).toBe(0);
expect(
JSON.parse(
window.sessionStorage.getItem(`${COMMENTS_STORAGE_PREFIX}foreign-session`) ?? "[]",
),
).toEqual([comment]);
});
});