mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-17 13:01:05 +01:00
## Thinking Path
> - Paperclip is the open source app people use to manage AI agents for
work
> - The board UI saves approved reads to local storage. A reload can
then show them at once.
> - The test `bounds saved PR reads and retains their original age
through later saves` checks the limit of 100 saved PR reads.
> - The test reads `Date.now()` one time and uses that value as the
cache clock. Then `seed()` writes the session and company list with the
real clock.
> - If the real clock moves 1 ms or more between these two steps, the
saved session has a time in the future. The cache correctly rejects that
session, so it restores no data.
> - This failed CI 5 times in 48 hours on 5 unrelated pull requests.
Each failure was `expected [] to have a length of 100 but got +0`.
> - This pull request freezes the clock in that test, as the sibling
tests in the same file already do.
> - The benefit is a deterministic test, and no more unrelated red CI
runs.
## Linked Issues or Issue Description
**What happened?**
The UI test `ui/src/lib/persisted-query-cache.test.ts > persisted read
cache > bounds saved PR reads and retains their original age through
later saves` failed in CI 5 times in 48 hours on 5 unrelated branches.
The error was `AssertionError: expected [] to have a length of 100 but
got +0` at line 82.
**Expected behavior**
The test passes on every run, independent of machine load.
**Steps to reproduce**
1. Start two CPU busy loops (`node -e 'while(true){}'`).
2. Run `pnpm --filter @paperclipai/ui exec vitest run
src/lib/persisted-query-cache.test.ts -t "bounds saved PR reads"` 30
times, two at a time.
3. Before this change: 0 pass, 30 fail, all at line 82.
Root cause: the test injects a fixed clock (`now`) into the cache, but
`seed()` calls `setQueryData` without `updatedAt`. TanStack Query then
uses the real `Date.now()`. When the real clock passes the fixed clock,
`fresh()` sees a session read from the future. The flush then does not
save the session, and the restore aborts. The product code is correct.
The test clock was not consistent.
## What Changed
- Call `vi.useFakeTimers()` at the start of `bounds saved PR reads and
retains their original age through later saves`. `Date.now()` is now
frozen, so the seeded reads and the injected clock agree. The other
clock-driven tests in this file already do this.
- Call `vi.useFakeTimers()` in `discards snapshots after %s changes`. It
had the same race. There, the race did not fail the test, but it let the
test pass without the discard path under test.
## Verification
- Deterministic red/green: I added a real 5 ms sleep (`Atomics.wait`)
after `let now = Date.now()` in a temporary copy of the test. Without
the fix: `expected [] to have a length of 100 but got +0`. With the fix:
pass. I removed the temporary copies.
- Loop under load (two CPU busy loops, two parallel vitest processes, 30
runs each):
- Before: 0 pass, 30 fail (all at `persisted-query-cache.test.ts:82`).
- After: 30 pass, 0 fail.
- Full file: `pnpm --filter @paperclipai/ui exec vitest run
src/lib/persisted-query-cache.test.ts`: 54 passed.
## Risks
- Low risk. The change is test-only. Fake timers are reset in the
existing `afterEach` (`vi.useRealTimers()`).
## Model Used
- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, used through Claude
Code with tool use (shell, file edit) and reasoning.
## Checklist
- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
694 lines
45 KiB
TypeScript
694 lines
45 KiB
TypeScript
import { QueryClient, QueryObserver } from "@tanstack/react-query";
|
|
import type { Agent } from "@paperclipai/shared";
|
|
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
import { ApiError, api, detachInflightGets } from "@/api/client";
|
|
import { bindAccount } from "./account-scope";
|
|
import { hasUnverifiedSession, markCachedSession } from "./cached-session";
|
|
import { queryKeys } from "./queryKeys";
|
|
import { readComposerRunSettings } from "../components/task-chat/composer-run-settings";
|
|
import { agentConnection, agentDefaultModel } from "./bulk-agent-settings";
|
|
import { clearPersistedQueryCache, persistedQueryScope, QUERY_CACHE_ACTIVE, QUERY_CACHE_CLEARED, QUERY_CACHE_MAX_AGE, QUERY_CACHE_PREFIX, startPersistedQueryCache } from "./persisted-query-cache";
|
|
|
|
const auth = vi.hoisted(() => ({ getSession: vi.fn() }));
|
|
vi.mock("@/api/auth", () => ({ authApi: auth }));
|
|
|
|
class MemoryStorage {
|
|
values = new Map<string, string>();
|
|
get length() { return this.values.size; }
|
|
key(index: number) { return [...this.values.keys()][index] ?? null; }
|
|
getItem(key: string) { return this.values.get(key) ?? null; }
|
|
setItem(key: string, value: string) { this.values.set(key, value); }
|
|
removeItem(key: string) { this.values.delete(key); }
|
|
}
|
|
const session = (id = "alice") => ({ session: { id: `session-${id}`, userId: id, token: "never-store-session-token" },
|
|
user: { id, name: id, email: `${id}@example.test`, image: null }, sentryDsn: "never-store-dsn", boardBootstrap: { private: "not-allowlisted" } });
|
|
const handles: Array<() => void> = [];
|
|
function setup(storage = new MemoryStorage(), now?: () => number, client = new QueryClient({ defaultOptions: { queries: { retry: false } } }), buildId: string | null = "build-one") {
|
|
const handle = startPersistedQueryCache(client, { storage, now, buildId, eventTarget: null, debounceMs: 100_000 });
|
|
handles.push(() => { handle.dispose(); client.clear(); });
|
|
return { client, handle, storage };
|
|
}
|
|
function seed(client: QueryClient, userId = "alice", companyId = "company-one") {
|
|
client.setQueryData(queryKeys.auth.session, session(userId));
|
|
client.setQueryData(queryKeys.companies.list(userId), { companies: [{ id: companyId, name: "Example" }], unauthorized: false });
|
|
client.setQueryData(queryKeys.health, { status: "ok", deploymentMode: "authenticated" });
|
|
client.setQueryData([...queryKeys.access.currentBoardAccess, userId], { userId, companyIds: [companyId], isInstanceAdmin: false });
|
|
client.setQueryData([...queryKeys.issues.detail("task-one"), "core"], { id: "task-one", companyId, title: "Saved task" });
|
|
}
|
|
afterEach(() => { for (const dispose of handles.splice(0)) dispose(); vi.useRealTimers(); vi.clearAllMocks(); });
|
|
|
|
describe("persisted read cache", () => {
|
|
it("restores learned PR status and negative reads without invalidating their demand-driven freshness", () => {
|
|
const first = setup(); seed(first.client);
|
|
const key = queryKeys.linkPreview("company-one", "alice", "https://github.com/acme/web/pull/241");
|
|
const result = { preview: { title: "Saved PR status", state: "merged" }, maxAgeMs: 60_000 };
|
|
first.client.setQueryData(key, result);
|
|
const absentKey = queryKeys.linkPreview("company-one", "alice", "https://github.com/acme/web/pull/242");
|
|
first.client.setQueryData(absentKey, { preview: null, maxAgeMs: 60_000 });
|
|
const updatedAt = first.client.getQueryState(key)!.dataUpdatedAt;
|
|
first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
expect(restored.client.getQueryData(key)).toEqual(result);
|
|
expect(restored.client.getQueryData(absentKey)).toEqual({ preview: null, maxAgeMs: 60_000 });
|
|
expect(restored.client.getQueryState(key)).toMatchObject({ dataUpdatedAt: updatedAt, isInvalidated: false });
|
|
});
|
|
|
|
it("persists PR reads only for the active viewer and an accessible company", () => {
|
|
const first = setup(); seed(first.client);
|
|
const url = "https://github.com/acme/web/pull/241";
|
|
const result = { preview: { title: "Private PR" }, maxAgeMs: 60_000 };
|
|
const forbidden = [
|
|
queryKeys.linkPreview("company-one", "bob", url),
|
|
queryKeys.linkPreview("other-company", "alice", url),
|
|
["link-preview", "company-one", null, url],
|
|
["link-preview", "company-one", "alice"],
|
|
["link-preview", "company-one", "alice", url, "extra"],
|
|
];
|
|
for (const key of forbidden) first.client.setQueryData(key, result);
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Private PR");
|
|
const restored = setup(first.storage);
|
|
for (const key of forbidden) expect(restored.client.getQueryData(key)).toBeUndefined();
|
|
});
|
|
|
|
it("bounds saved PR reads and retains their original age through later saves", () => {
|
|
vi.useFakeTimers();
|
|
let now = Date.now();
|
|
const first = setup(undefined, () => now); seed(first.client);
|
|
for (let i = 0; i < 120; i += 1) first.client.setQueryData(
|
|
queryKeys.linkPreview("company-one", "alice", `https://github.com/acme/web/pull/${i + 1}`),
|
|
{ preview: { title: `PR ${i + 1}`, state: "open" }, maxAgeMs: 60_000 }, { updatedAt: now - 120 + i });
|
|
first.handle.flush();
|
|
const restored = setup(first.storage, () => now);
|
|
expect(restored.client.getQueryCache().findAll({ queryKey: ["link-preview"] })).toHaveLength(100);
|
|
expect(restored.client.getQueryData(queryKeys.linkPreview("company-one", "alice", "https://github.com/acme/web/pull/1"))).toBeUndefined();
|
|
expect(restored.client.getQueryData(queryKeys.linkPreview("company-one", "alice", "https://github.com/acme/web/pull/120"))).toBeDefined();
|
|
first.client.removeQueries({ queryKey: ["link-preview"] });
|
|
now += 10 * 60_000;
|
|
first.handle.flush();
|
|
expect(setup(first.storage, () => now).client.getQueryCache().findAll({ queryKey: ["link-preview"] })).toHaveLength(100);
|
|
now += QUERY_CACHE_MAX_AGE;
|
|
first.client.setQueryData(queryKeys.auth.session, session(), { updatedAt: now });
|
|
first.client.setQueryData(queryKeys.companies.list("alice"), { companies: [{ id: "company-one" }] }, { updatedAt: now });
|
|
first.handle.flush();
|
|
expect(setup(first.storage, () => now).client.getQueryCache().findAll({ queryKey: ["link-preview"] })).toHaveLength(0);
|
|
});
|
|
|
|
it.each(["sign-out", "account-change", "membership-loss"])("removes persisted private PR reads on %s", action => {
|
|
const first = setup(); seed(first.client);
|
|
const key = queryKeys.linkPreview("company-one", "alice", "https://github.com/acme/private/pull/241");
|
|
first.client.setQueryData(key, { preview: { title: "Private PR status" }, maxAgeMs: 60_000 });
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).toContain("Private PR status");
|
|
if (action === "sign-out") clearPersistedQueryCache(first.client);
|
|
if (action === "account-change") first.client.setQueryData(queryKeys.auth.session, session("bob"));
|
|
if (action === "membership-loss") first.client.setQueryData(queryKeys.companies.list("alice"), { companies: [] });
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Private PR status");
|
|
expect(setup(first.storage).client.getQueryData(key)).toBeUndefined();
|
|
});
|
|
|
|
it.each([null, "", " "])("skips hydration and persistence without a build stamp (%s)", (buildId) => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const saved = new Map(first.storage.values);
|
|
const restored = setup(first.storage, undefined, undefined, buildId);
|
|
expect(restored.client.getQueryData(queryKeys.auth.session)).toBeUndefined();
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
seed(restored.client); restored.handle.flush();
|
|
expect(first.storage.values).toEqual(saved);
|
|
clearPersistedQueryCache(restored.client);
|
|
expect([...first.storage.values.keys()].some(key => key.startsWith(QUERY_CACHE_PREFIX))).toBe(false);
|
|
});
|
|
|
|
it.each([QUERY_CACHE_CLEARED, "paperclip:query-cache-revision:alice"])("revokes a stamped tab through exported sign-out cleanup in an unstamped build (%s)", async eventKey => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
first.storage.setItem("paperclip:private-draft", "draft retained");
|
|
const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
|
|
const events = new EventTarget();
|
|
const other = startPersistedQueryCache(client, { storage: first.storage, buildId: "build-one", eventTarget: events as Window });
|
|
handles.push(() => { other.dispose(); client.clear(); });
|
|
await client.fetchQuery({ queryKey: queryKeys.auth.session, queryFn: async () => session(), staleTime: 0 });
|
|
const account = bindAccount(client);
|
|
const unstamped = setup(first.storage, undefined, undefined, null);
|
|
unstamped.client.setQueryData(queryKeys.auth.session, session());
|
|
clearPersistedQueryCache(unstamped.client);
|
|
expect(first.storage.getItem(eventKey)).not.toBeNull();
|
|
expect([...first.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toEqual([]);
|
|
events.dispatchEvent(Object.assign(new Event("storage"), { key: eventKey, newValue: first.storage.getItem(eventKey) }));
|
|
expect(client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(client.getQueryData(queryKeys.auth.session)).toBeNull();
|
|
expect(account.isCurrentScope()).toBe(false);
|
|
other.flush();
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBeNull();
|
|
expect(first.storage.getItem("paperclip:private-draft")).toBe("draft retained");
|
|
});
|
|
|
|
it("rejects a stamped tab's delayed flush after unstamped sign-out before storage events arrive", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const other = setup(first.storage);
|
|
await other.client.fetchQuery({ queryKey: queryKeys.auth.session, queryFn: async () => session(), staleTime: 0 });
|
|
const unstamped = setup(first.storage, undefined, undefined, null);
|
|
unstamped.client.setQueryData(queryKeys.auth.session, session());
|
|
clearPersistedQueryCache(unstamped.client);
|
|
other.handle.flush();
|
|
expect(other.client.getQueryData(queryKeys.auth.session)).toBeNull();
|
|
expect([...first.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toEqual([]);
|
|
});
|
|
|
|
it("keeps recent task reads and company membership after actual five-minute memory garbage collection", async () => {
|
|
vi.useFakeTimers();
|
|
const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } });
|
|
const key = [...queryKeys.issues.detail("task-one"), "core"];
|
|
client.setQueryDefaults(key, { gcTime: 5 * 60_000 });
|
|
client.setQueryDefaults(queryKeys.companies.list("alice"), { gcTime: 5 * 60_000 });
|
|
const first = setup(undefined, undefined, client); seed(client); first.handle.flush();
|
|
const observer = new QueryObserver(client, { queryKey: key, enabled: false });
|
|
const unsubscribe = observer.subscribe(() => {});
|
|
unsubscribe();
|
|
await vi.advanceTimersByTimeAsync(5 * 60_000 + 1);
|
|
expect(client.getQueryData(key)).toBeUndefined();
|
|
expect(client.getQueryData(queryKeys.companies.list("alice"))).toBeUndefined();
|
|
client.setQueryData(queryKeys.health, { status: "ok", restarted: true });
|
|
first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
expect(restored.client.getQueryData(key)).toMatchObject({ title: "Saved task" });
|
|
expect(restored.client.getQueryData(queryKeys.companies.list("alice"))).toMatchObject({ companies: [{ id: "company-one" }] });
|
|
});
|
|
|
|
it("expires retained task data from its original read time despite later snapshot writes", () => {
|
|
vi.useFakeTimers();
|
|
let now = Date.now();
|
|
const first = setup(undefined, () => now); seed(first.client); first.handle.flush();
|
|
const key = [...queryKeys.issues.detail("task-one"), "core"];
|
|
first.client.removeQueries({ queryKey: key, exact: true });
|
|
now += 5 * 60_000;
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).toContain("Saved task");
|
|
now += QUERY_CACHE_MAX_AGE;
|
|
first.client.setQueryData(queryKeys.auth.session, session(), { updatedAt: now });
|
|
first.client.setQueryData(queryKeys.companies.list("alice"), { companies: [{ id: "company-one" }] }, { updatedAt: now });
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Saved task");
|
|
expect(setup(first.storage, () => now).client.getQueryData(key)).toBeUndefined();
|
|
});
|
|
|
|
it("applies the twenty-task limit across retained disk reads and newer live reads", () => {
|
|
vi.useFakeTimers();
|
|
const now = Date.now();
|
|
const first = setup(undefined, () => now); seed(first.client);
|
|
first.client.removeQueries({ queryKey: queryKeys.issues.detail("task-one") });
|
|
for (let i = 0; i < 20; i += 1) first.client.setQueryData([...queryKeys.issues.detail(`task-${i}`), "core"],
|
|
{ id: `task-${i}`, companyId: "company-one", title: `Retained task ${i}` }, { updatedAt: now - 20 + i });
|
|
first.handle.flush();
|
|
first.client.removeQueries({ queryKey: ["issues", "detail"] });
|
|
first.client.setQueryData([...queryKeys.issues.detail("new-task"), "core"], { id: "new-task", companyId: "company-one", title: "Newest task" }, { updatedAt: now });
|
|
first.handle.flush();
|
|
const restored = setup(first.storage, () => now);
|
|
const details = restored.client.getQueryCache().getAll().filter(query => query.queryKey[0] === "issues" && query.queryKey[1] === "detail");
|
|
expect(details).toHaveLength(20);
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("task-0"), "core"])).toBeUndefined();
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("new-task"), "core"])).toMatchObject({ title: "Newest task" });
|
|
});
|
|
|
|
it.each([403, 404])("scrubs saved aliases and inbox rows after a %s denial following memory GC, even before session verification", async status => {
|
|
const first = setup(); seed(first.client);
|
|
const task = { id: "task-one", identifier: "TST-1", companyId: "company-one", title: "Denied task body" };
|
|
const keys = [queryKeys.issues.detail(task.id), [...queryKeys.issues.detail(task.id), "core"],
|
|
queryKeys.issues.detail(task.identifier), [...queryKeys.issues.detail(task.identifier), "core"]];
|
|
for (const key of keys) first.client.setQueryData(key, task);
|
|
const inboxKey = [...queryKeys.issues.listMineByMe("company-one"), "index", "with-routine-executions", "live-descendant-summary", 100, "alice"];
|
|
first.client.setQueryData(inboxKey, [task, { id: "allowed-task", title: "Other task" }]);
|
|
first.handle.flush();
|
|
first.client.removeQueries({ queryKey: ["issues"] });
|
|
markCachedSession(first.client);
|
|
await first.client.fetchQuery({ queryKey: [...queryKeys.issues.detail("tst-1"), "core"], queryFn: async () => { throw new ApiError("Denied", status, null); } }).catch(() => {});
|
|
expect(hasUnverifiedSession(first.client)).toBe(true);
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Denied task body");
|
|
const restored = setup(first.storage);
|
|
for (const key of keys) expect(restored.client.getQueryData(key)).toBeUndefined();
|
|
expect(restored.client.getQueryData(inboxKey)).toEqual([{ id: "allowed-task", title: "Other task" }]);
|
|
});
|
|
|
|
it("removes retained company reads after fresh membership denial and does not resurrect them after memory GC", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
first.client.removeQueries({ queryKey: ["issues", "detail"] });
|
|
const membership = queryKeys.companies.list("alice");
|
|
await first.client.fetchQuery({ queryKey: membership, queryFn: async () => { throw new ApiError("Forbidden", 403, null); } }).catch(() => {});
|
|
first.client.removeQueries({ queryKey: membership, exact: true });
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Saved task");
|
|
expect(setup(first.storage).client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
});
|
|
|
|
it("replaces a retained disk task with a newer live read without persisting private fields", () => {
|
|
vi.useFakeTimers();
|
|
const now = Date.now();
|
|
const first = setup(undefined, () => now); seed(first.client); first.handle.flush();
|
|
const key = [...queryKeys.issues.detail("task-one"), "core"];
|
|
first.client.removeQueries({ queryKey: key, exact: true });
|
|
first.client.setQueryData(key, { id: "task-one", companyId: "company-one", title: "Newer task", planDocument: { body: "excluded-new-document" } }, { updatedAt: now });
|
|
first.handle.flush();
|
|
const restored = setup(first.storage, () => now);
|
|
expect(restored.client.getQueryData(key)).toMatchObject({ title: "Newer task" });
|
|
expect(restored.client.getQueryData(key)).not.toHaveProperty("planDocument");
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("excluded-new-document");
|
|
});
|
|
|
|
it("retains visible task run preferences while excluding private override options", () => {
|
|
const first = setup(); seed(first.client);
|
|
first.client.setQueryData([...queryKeys.issues.detail("task-one"), "core"], {
|
|
id: "task-one", companyId: "company-one", title: "Saved task",
|
|
assigneeAdapterOverrides: { useProjectWorkspace: true, adapterConfig: {
|
|
model: "display-model", modelReasoningEffort: "high", fastMode: true,
|
|
chrome: true, command: "excluded-command", env: { PRIVATE_VALUE: "excluded-env" },
|
|
} },
|
|
});
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).not.toMatch(/excluded-|chrome/);
|
|
const restored = setup(first.storage);
|
|
const task = restored.client.getQueryData<{ assigneeAdapterOverrides: { adapterConfig: Record<string, unknown> } }>([...queryKeys.issues.detail("task-one"), "core"])!;
|
|
expect(readComposerRunSettings(task.assigneeAdapterOverrides, "codex_local")).toEqual({ model: "display-model", effort: "high", fast: true });
|
|
expect(task.assigneeAdapterOverrides.adapterConfig).not.toHaveProperty("command");
|
|
expect(task.assigneeAdapterOverrides.adapterConfig).not.toHaveProperty("env");
|
|
});
|
|
|
|
it.each(["account-switch", "sign-out"])("does not share or persist another account's pending private-project request after %s", async boundary => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
let finishAlice!: (value: Response) => void;
|
|
const bobProjects = [{ id: "project-bob", companyId: "company-one", name: "Bob project" }];
|
|
const fetch = vi.fn().mockImplementationOnce(() => new Promise<Response>(resolve => { finishAlice = resolve; }))
|
|
.mockResolvedValue(new Response(JSON.stringify(bobProjects), { headers: { "Content-Type": "application/json" } }));
|
|
vi.stubGlobal("fetch", fetch);
|
|
try {
|
|
const key = queryKeys.projects.list("company-one");
|
|
const path = "/companies/company-one/projects";
|
|
// Match sidebar reads that do not forward React Query's AbortSignal.
|
|
const oldRead = first.client.fetchQuery({ queryKey: key, queryFn: () => api.get(path) }).catch(() => undefined);
|
|
expect(fetch).toHaveBeenCalledTimes(1);
|
|
if (boundary === "sign-out") { clearPersistedQueryCache(first.client); first.client.clear(); }
|
|
await first.client.fetchQuery({ queryKey: queryKeys.auth.session, queryFn: async () => session("bob"), staleTime: 0 });
|
|
seed(first.client, "bob");
|
|
const currentRead = first.client.fetchQuery({ queryKey: key, queryFn: () => api.get(path) });
|
|
expect(fetch).toHaveBeenCalledTimes(2);
|
|
await expect(currentRead).resolves.toEqual(bobProjects);
|
|
finishAlice(new Response(JSON.stringify([{ id: "project-alice", companyId: "company-one", name: "Alice private project" }]), { headers: { "Content-Type": "application/json" } }));
|
|
await oldRead;
|
|
await Promise.resolve();
|
|
first.handle.flush();
|
|
expect(first.client.getQueryData(key)).toEqual(bobProjects);
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Alice private project");
|
|
expect(setup(first.storage).client.getQueryData(key)).toEqual(bobProjects);
|
|
} finally {
|
|
finishAlice?.(new Response("[]", { headers: { "Content-Type": "application/json" } }));
|
|
detachInflightGets(); vi.unstubAllGlobals();
|
|
}
|
|
});
|
|
|
|
it("preserves another account published while this tab is flushing", () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const write = first.storage.setItem.bind(first.storage);
|
|
const bobKey = `${QUERY_CACHE_PREFIX}bob:root`;
|
|
const bobRecord = JSON.stringify({ userId: "bob", revision: null, state: { queries: [] } });
|
|
let published = false;
|
|
vi.spyOn(first.storage, "setItem").mockImplementation((key, value) => {
|
|
write(key, value);
|
|
if (!published && key === `${QUERY_CACHE_PREFIX}alice:root`) {
|
|
published = true;
|
|
write(bobKey, bobRecord);
|
|
write(QUERY_CACHE_ACTIVE, "bob");
|
|
}
|
|
});
|
|
first.handle.flush();
|
|
expect(first.storage.getItem(bobKey)).toBe(bobRecord);
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBe("bob");
|
|
expect(first.client.getQueryData(queryKeys.auth.session)).toBeNull();
|
|
expect(first.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
});
|
|
|
|
it("removes every saved account record when native storage reorders keys during deletion", () => {
|
|
const storage = new MemoryStorage();
|
|
const remove = storage.removeItem.bind(storage);
|
|
vi.spyOn(storage, "removeItem").mockImplementation(key => {
|
|
remove(key);
|
|
const entries = [...storage.values.entries()];
|
|
if (entries.length > 1) entries.push(entries.shift()!);
|
|
storage.values = new Map(entries);
|
|
});
|
|
const first = setup(storage); seed(first.client);
|
|
first.client.setQueryData(queryKeys.companies.list("alice"), { companies: Array.from({ length: 8 }, (_, i) => ({ id: `company-${i}` })) });
|
|
first.handle.flush();
|
|
expect([...storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toHaveLength(10);
|
|
first.handle.clear();
|
|
expect([...storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toEqual([]);
|
|
expect(storage.getItem(QUERY_CACHE_CLEARED)).toContain('"alice"');
|
|
});
|
|
|
|
it("refetches an active session after rejecting a pre-sign-out response without restoring saved reads", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const second = setup(first.storage);
|
|
let release!: (value: ReturnType<typeof session>) => void;
|
|
const lookup = vi.fn().mockImplementationOnce(() => new Promise<ReturnType<typeof session>>(resolve => { release = resolve; })).mockResolvedValue(null);
|
|
const observer = new QueryObserver(second.client, { queryKey: queryKeys.auth.session, queryFn: lookup, staleTime: 0, retry: false });
|
|
const unsubscribe = observer.subscribe(() => {});
|
|
try {
|
|
first.handle.clear();
|
|
release(session());
|
|
await vi.waitFor(() => expect(lookup).toHaveBeenCalledTimes(2));
|
|
await vi.waitFor(() => { expect(observer.getCurrentResult().data).toBeNull(); expect(observer.getCurrentResult().isFetching).toBe(false); });
|
|
second.handle.flush();
|
|
expect(second.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect([...first.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toEqual([]);
|
|
} finally { unsubscribe(); }
|
|
});
|
|
|
|
it.each(["sign-out", "session-ended", "local-sign-out", "revision-only"])("rejects an older session response delivered before the %s storage event", async ended => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const second = ended === "local-sign-out" ? first : setup(first.storage);
|
|
let release!: (value: ReturnType<typeof session>) => void;
|
|
const read = second.client.fetchQuery({ queryKey: queryKeys.auth.session, staleTime: 0,
|
|
queryFn: () => new Promise<ReturnType<typeof session>>(resolve => { release = resolve; }) });
|
|
if (ended === "revision-only") {
|
|
const write = first.storage.setItem.bind(first.storage);
|
|
vi.spyOn(first.storage, "setItem").mockImplementation((key, value) => {
|
|
if (key === QUERY_CACHE_CLEARED) throw new Error("Broadcast write failed");
|
|
write(key, value);
|
|
});
|
|
}
|
|
if (ended === "session-ended") await first.client.fetchQuery({ queryKey: queryKeys.auth.session, staleTime: 0, queryFn: async () => null });
|
|
else first.handle.clear();
|
|
release(session());
|
|
await read;
|
|
second.handle.flush();
|
|
expect(second.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(second.client.getQueryData(queryKeys.auth.session)).toBeNull();
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Saved task");
|
|
const cold = setup(first.storage);
|
|
expect(cold.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
await second.client.fetchQuery({ queryKey: queryKeys.auth.session, staleTime: 0, queryFn: async () => session() });
|
|
seed(second.client);
|
|
second.client.setQueryData([...queryKeys.issues.detail("task-one"), "core"], { id: "task-one", companyId: "company-one", title: "Freshly authorized task" });
|
|
second.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).toContain("Freshly authorized task");
|
|
});
|
|
|
|
it("restores a bounded first page of all legacy Inbox task queries", () => {
|
|
const first = setup(); seed(first.client);
|
|
const keys = [queryKeys.issues.list("company-one"), queryKeys.issues.listMineByMe("company-one"), queryKeys.issues.listTouchedByMe("company-one")]
|
|
.map(key => [...key, "compact", "with-routine-executions", "live-descendant-summary", 500]);
|
|
const rows = Array.from({ length: 500 }, (_, i) => ({ id: `legacy-${i}`, companyId: "company-one", title: `Legacy task ${i}`, planDocument: { body: "excluded-legacy-document" } }));
|
|
for (const key of keys) first.client.setQueryData(key, rows);
|
|
first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
for (const key of keys) {
|
|
expect(first.client.getQueryData(key)).toHaveLength(500);
|
|
expect(restored.client.getQueryData(key)).toHaveLength(100);
|
|
expect(restored.client.getQueryData(key)).toContainEqual({ id: "legacy-0", companyId: "company-one", title: "Legacy task 0" });
|
|
expect(persistedQueryScope([...key, "extra"], rows, "alice", ["company-one"])).toBeUndefined();
|
|
}
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("excluded-legacy-document");
|
|
const recordKey = `${QUERY_CACHE_PREFIX}alice:company-one`;
|
|
const record = JSON.parse(first.storage.getItem(recordKey)!);
|
|
for (const query of record.state.queries) if (query.queryKey.includes("compact")) query.state.data = rows;
|
|
first.storage.setItem(recordKey, JSON.stringify(record));
|
|
const older = setup(first.storage);
|
|
for (const key of keys) expect(older.client.getQueryData(key)).toHaveLength(100);
|
|
});
|
|
|
|
it("restores the approved shell and company reads without persisting authentication material", () => {
|
|
const first = setup();
|
|
seed(first.client);
|
|
first.client.setQueryData(["secrets", "company-one"], { token: "not-allowed" });
|
|
first.client.setQueryData(["issues", "browser", "task-one"], { url: "https://viewer.example.test/capability" });
|
|
first.client.setQueryData(["issues", "documents", "task-one"], [{ body: "not-allowlisted" }]);
|
|
const inboxKey = [...queryKeys.issues.listMineByMe("company-one"), "index", "with-routine-executions", "live-descendant-summary", 100, "alice"];
|
|
first.client.setQueryData(inboxKey, [{ id: "inbox-task", title: "First page" }]);
|
|
first.client.setQueryData(queryKeys.plugins.uiContributions, [{ pluginId: "example-plugin", displayName: "Example extension" }]);
|
|
first.handle.flush();
|
|
const disk = [...first.storage.values.values()].join(" ");
|
|
expect(disk).not.toMatch(/never-store|not-allowed|not-allowlisted|viewer\.example/);
|
|
const restored = setup(first.storage);
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toMatchObject({ title: "Saved task" });
|
|
expect(restored.client.getQueryData(queryKeys.companies.list("alice"))).toMatchObject({ companies: [{ id: "company-one" }] });
|
|
expect(restored.client.getQueryData(inboxKey)).toEqual([{ id: "inbox-task", title: "First page" }]);
|
|
expect(restored.client.getQueryData(queryKeys.plugins.uiContributions)).toMatchObject([{ displayName: "Example extension" }]);
|
|
expect(hasUnverifiedSession(restored.client)).toBe(true);
|
|
expect(bindAccount(restored.client).isCurrentAccount()).toBe(false);
|
|
});
|
|
|
|
it("does not hydrate another user's data into an already authenticated client", () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const client = new QueryClient();
|
|
client.setQueryData(queryKeys.auth.session, session("bob"));
|
|
setup(first.storage, undefined, client);
|
|
expect(client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(client.getQueryData(queryKeys.auth.session)).toMatchObject({ user: { id: "bob" } });
|
|
});
|
|
|
|
it("strips embedded documents and capabilities from real task-shaped responses and nested inbox rows", () => {
|
|
const first = setup(); seed(first.client);
|
|
const task = { id: "task-one", companyId: "company-one", title: "Saved task", description: "Approved task description",
|
|
planDocument: { id: "plan-one", key: "plan", format: "markdown", body: "excluded-plan-body" },
|
|
legacyPlanDocument: { body: "excluded-legacy-body" }, documentSummaries: [{ key: "plan" }],
|
|
workProducts: [{ type: "preview_url", url: "https://viewer.example.test/excluded-capability" }] };
|
|
first.client.setQueryData([...queryKeys.issues.detail(task.id), "core"], task);
|
|
first.client.setQueryData([...queryKeys.issues.listMineByMe("company-one"), "index", "with-routine-executions", "live-descendant-summary", 100, "alice"], [task]);
|
|
first.client.setQueryData(queryKeys.agents.list("company-one"), [{ id: "agent-one", name: "Saved agent", adapterConfig: { provider: "codex", model: "display-model", Authorization: "excluded-header", access_token: "excluded-token" }, runtimeConfig: { env: { OPENAI_API_KEY: "excluded-env-token" } } }]);
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).not.toMatch(/excluded-/);
|
|
const key = `${QUERY_CACHE_PREFIX}alice:company-one`;
|
|
const record = JSON.parse(first.storage.getItem(key)!);
|
|
record.state.queries.find((query: { queryKey: string[] }) => query.queryKey[1] === "detail").state.data.planDocument = { body: "excluded-old-body" };
|
|
first.storage.setItem(key, JSON.stringify(record));
|
|
const restored = setup(first.storage);
|
|
const cached = restored.client.getQueryData([...queryKeys.issues.detail(task.id), "core"]);
|
|
expect(cached).toMatchObject({ description: "Approved task description" });
|
|
expect(cached).not.toHaveProperty("planDocument");
|
|
expect(cached).not.toHaveProperty("legacyPlanDocument");
|
|
expect(cached).not.toHaveProperty("workProducts");
|
|
const cachedAgents = restored.client.getQueryData<Agent[]>(queryKeys.agents.list("company-one"))!;
|
|
expect(cachedAgents).toEqual([{ id: "agent-one", name: "Saved agent", adapterConfig: { provider: "codex", model: "display-model" }, runtimeConfig: {} }]);
|
|
expect(agentDefaultModel(cachedAgents[0]!)).toBe("display-model");
|
|
expect(agentConnection(cachedAgents[0]!)).toBeUndefined();
|
|
});
|
|
|
|
it("counts a task's UUID and identifier reads as one recent task", () => {
|
|
const first = setup(); seed(first.client);
|
|
for (let i = 0; i < 20; i += 1) {
|
|
const task = { id: `task-${i}`, companyId: "company-one", title: `Recent task ${i}` };
|
|
first.client.setQueryData([...queryKeys.issues.detail(task.id), "core"], task);
|
|
first.client.setQueryData([...queryKeys.issues.detail(`TST-${i}`), "core"], task);
|
|
}
|
|
first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
const details = restored.client.getQueryCache().getAll().filter(query => query.queryKey[0] === "issues" && query.queryKey[1] === "detail");
|
|
expect(new Set(details.map(query => (query.state.data as { id: string }).id)).size).toBe(20);
|
|
expect(details.length).toBeGreaterThan(20);
|
|
});
|
|
|
|
it("allows account-bound writes only after a fresh matching session", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
const account = bindAccount(restored.client);
|
|
let release!: (value: ReturnType<typeof session>) => void;
|
|
auth.getSession.mockImplementation(() => new Promise(resolve => { release = resolve; }));
|
|
const ready = account.whenAccountReady();
|
|
expect(account.isCurrentAccount()).toBe(false);
|
|
release(session());
|
|
await ready;
|
|
expect(hasUnverifiedSession(restored.client)).toBe(false);
|
|
expect(account.isCurrentAccount()).toBe(true);
|
|
});
|
|
|
|
it("cancels the old owner's write scope and notifies observers when session verification finds another user", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
const account = bindAccount(restored.client);
|
|
const observer = new QueryObserver(restored.client, { queryKey: [...queryKeys.issues.detail("task-one"), "core"], enabled: false });
|
|
const changes: unknown[] = [];
|
|
const unsubscribe = observer.subscribe(result => changes.push(result.data));
|
|
auth.getSession.mockResolvedValue(session("bob"));
|
|
await account.whenAccountReady();
|
|
expect(account.isCurrentAccount()).toBe(false);
|
|
expect(account.isCurrentScope()).toBe(false);
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(changes).toContain(undefined);
|
|
expect([...restored.storage.values.values()].join(" ")).not.toContain("Saved task");
|
|
unsubscribe();
|
|
});
|
|
|
|
it("enforces company ownership, exact allowlist entries and the recent-issue bound", () => {
|
|
const first = setup(); seed(first.client);
|
|
for (let i = 0; i < 25; i += 1) first.client.setQueryData([...queryKeys.issues.detail(`task-${i}`), "core"], { id: `task-${i}`, companyId: "company-one", title: `Task ${i}` });
|
|
first.client.setQueryData([...queryKeys.issues.detail("foreign"), "core"], { id: "foreign", companyId: "other-company", title: "Private elsewhere" });
|
|
first.handle.flush();
|
|
const restored = setup(first.storage);
|
|
const details = restored.client.getQueryCache().getAll().filter(query => query.queryKey[0] === "issues" && query.queryKey[1] === "detail");
|
|
expect(details).toHaveLength(20);
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("foreign"), "core"])).toBeUndefined();
|
|
expect(persistedQueryScope(["agents", "company-one", "keys"], [], "alice", ["company-one"])).toBeUndefined();
|
|
expect(persistedQueryScope(["agent-chats", "company-one", "bob"], [], "alice", ["company-one"])).toBeUndefined();
|
|
});
|
|
|
|
it.each(["build", "expiry"])("discards snapshots after %s changes", kind => {
|
|
vi.useFakeTimers();
|
|
const startedAt = Date.now();
|
|
const first = setup(undefined, () => startedAt); seed(first.client); first.handle.flush();
|
|
const restored = setup(first.storage, () => kind === "expiry" ? startedAt + QUERY_CACHE_MAX_AGE + 1 : startedAt, undefined, kind === "build" ? "build-two" : "build-one");
|
|
expect(restored.client.getQueryData(queryKeys.auth.session)).toBeUndefined();
|
|
expect([...restored.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toHaveLength(0);
|
|
});
|
|
|
|
it("clears query records on sign-out, retains drafts and resumes caching only after a new verified login", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
first.storage.setItem("paperclip:private-draft", "draft retained");
|
|
clearPersistedQueryCache(first.client);
|
|
first.client.setQueryData(queryKeys.health, { status: "ok" });
|
|
first.handle.flush();
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBeNull();
|
|
expect(first.storage.getItem("paperclip:private-draft")).toBe("draft retained");
|
|
await first.client.fetchQuery({ queryKey: queryKeys.auth.session, queryFn: async () => session("bob"), staleTime: 0 });
|
|
first.handle.flush();
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBe("bob");
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Saved task");
|
|
});
|
|
|
|
it("keeps last good data for transient failures and removes a definitively denied task immediately", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const key = [...queryKeys.issues.detail("task-one"), "core"];
|
|
await first.client.fetchQuery({ queryKey: key, queryFn: async () => { throw new ApiError("Restarting", 503, { error: "tenant_app_unavailable" }); } }).catch(() => {});
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).toContain("Saved task");
|
|
await first.client.fetchQuery({ queryKey: key, queryFn: async () => { throw new ApiError("Forbidden", 403, null); } }).catch(() => {});
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Saved task");
|
|
});
|
|
|
|
it.each([{ status: 403, uncachedAlias: false }, { status: 404, uncachedAlias: false }, { status: 403, uncachedAlias: true }])("evicts UUID, identifier, core and inbox copies after a $status task denial (uncached alias=$uncachedAlias)", async ({ status, uncachedAlias }) => {
|
|
const first = setup(); seed(first.client);
|
|
const task = { id: "task-one", identifier: "TST-1", companyId: "company-one", title: "Denied task body" };
|
|
const keys = [queryKeys.issues.detail(task.id), [...queryKeys.issues.detail(task.id), "core"],
|
|
queryKeys.issues.detail(task.identifier), [...queryKeys.issues.detail(task.identifier), "core"]];
|
|
for (const key of keys) first.client.setQueryData(key, task);
|
|
first.client.setQueryData([...queryKeys.issues.listMineByMe("company-one"), "index", "with-routine-executions", "live-descendant-summary", 100, "alice"], [task]);
|
|
first.handle.flush();
|
|
await first.client.fetchQuery({ queryKey: uncachedAlias ? [...queryKeys.issues.detail("tst-1"), "core"] : keys[3]!, queryFn: async () => { throw new ApiError("Denied", status, null); } }).catch(() => {});
|
|
for (const key of keys) expect(first.client.getQueryData(key)).toBeUndefined();
|
|
expect([...first.storage.values.values()].join(" ")).not.toContain("Denied task body");
|
|
const restored = setup(first.storage);
|
|
for (const key of keys) expect(restored.client.getQueryData(key)).toBeUndefined();
|
|
await first.client.fetchQuery({ queryKey: keys[3]!, queryFn: async () => ({ ...task, title: "Access restored" }) });
|
|
first.handle.flush();
|
|
expect([...first.storage.values.values()].join(" ")).toContain("Access restored");
|
|
});
|
|
|
|
it("ignores malformed saved queries while retaining valid recent reads on the next flush", () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const key = `${QUERY_CACHE_PREFIX}alice:company-one`;
|
|
const record = JSON.parse(first.storage.getItem(key)!);
|
|
record.state.queries.push(null, {}, { queryKey: ["unapproved"], state: {} });
|
|
first.storage.setItem(key, JSON.stringify(record));
|
|
first.client.removeQueries({ queryKey: ["issues", "detail"] });
|
|
expect(() => first.handle.flush()).not.toThrow();
|
|
expect(setup(first.storage).client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toMatchObject({ title: "Saved task" });
|
|
});
|
|
|
|
it("tolerates storage enumeration becoming unavailable before a flush", () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
vi.spyOn(first.storage, "length", "get").mockImplementation(() => { throw new Error("Storage unavailable"); });
|
|
expect(() => first.handle.flush()).not.toThrow();
|
|
});
|
|
|
|
it("tolerates unavailable or corrupt storage", () => {
|
|
const storage = new MemoryStorage();
|
|
storage.setItem(QUERY_CACHE_ACTIVE, "alice");
|
|
storage.setItem(`${QUERY_CACHE_PREFIX}alice:root`, "not json");
|
|
expect(() => setup(storage)).not.toThrow();
|
|
const client = new QueryClient();
|
|
const handle = startPersistedQueryCache(client, { buildId: "build", storage: null, eventTarget: null });
|
|
expect(() => { handle.flush(); handle.clear(); handle.dispose(); }).not.toThrow();
|
|
client.clear();
|
|
});
|
|
|
|
it("clears saved account data and publishes revocation even when storage is initially full", () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
let available = false;
|
|
const set = first.storage.setItem.bind(first.storage);
|
|
const remove = first.storage.removeItem.bind(first.storage);
|
|
vi.spyOn(first.storage, "setItem").mockImplementation((key, value) => {
|
|
if (!available) throw new Error("Quota exceeded");
|
|
set(key, value);
|
|
});
|
|
vi.spyOn(first.storage, "removeItem").mockImplementation(key => { remove(key); available = true; });
|
|
first.handle.clear();
|
|
expect([...first.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toHaveLength(0);
|
|
expect(first.storage.getItem(QUERY_CACHE_CLEARED)).toContain('"alice"');
|
|
});
|
|
|
|
it("clears saved account reads after a definitive session denial", async () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const account = bindAccount(first.client);
|
|
await first.client.fetchQuery({ queryKey: queryKeys.auth.session, staleTime: 0,
|
|
queryFn: async () => { throw new ApiError("Forbidden", 403, null); } }).catch(() => {});
|
|
expect(first.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(first.client.getQueryData(queryKeys.auth.session)).toBeNull();
|
|
expect(account.isCurrentScope()).toBe(false);
|
|
expect([...first.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toHaveLength(0);
|
|
});
|
|
|
|
it("does not restore fresh task data behind an expired saved identity", () => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const rootKey = `${QUERY_CACHE_PREFIX}alice:root`;
|
|
const root = JSON.parse(first.storage.getItem(rootKey)!);
|
|
root.state.queries.find((query: { queryKey: string[] }) => query.queryKey[0] === "auth").state.dataUpdatedAt = Date.now() - QUERY_CACHE_MAX_AGE - 1;
|
|
first.storage.setItem(rootKey, JSON.stringify(root));
|
|
const restored = setup(first.storage);
|
|
expect(restored.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(hasUnverifiedSession(restored.client)).toBe(false);
|
|
});
|
|
|
|
it.each([QUERY_CACHE_CLEARED, "paperclip:query-cache-revision:alice"])("removes another tab's restored account data on the %s sign-out event", eventKey => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const client = new QueryClient();
|
|
const events = new EventTarget();
|
|
const handle = startPersistedQueryCache(client, { storage: first.storage, buildId: "build-one", eventTarget: events as Window });
|
|
handles.push(() => { handle.dispose(); client.clear(); });
|
|
const account = bindAccount(client);
|
|
clearPersistedQueryCache(first.client);
|
|
events.dispatchEvent(Object.assign(new Event("storage"), { key: eventKey, newValue: first.storage.getItem(eventKey) }));
|
|
expect(client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
expect(client.getQueryData(queryKeys.auth.session)).toBeNull();
|
|
expect(account.isCurrentScope()).toBe(false);
|
|
handle.flush();
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBeNull();
|
|
});
|
|
|
|
it.each(["sign-out", "session-ended"])("rejects a delayed tab flush and stale records after %s, while preserving a newer account", async ended => {
|
|
const first = setup(); seed(first.client); first.handle.flush();
|
|
const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
|
|
const events = new EventTarget();
|
|
const second = startPersistedQueryCache(client, { storage: first.storage, buildId: "build-one", eventTarget: events as Window });
|
|
handles.push(() => { second.dispose(); client.clear(); });
|
|
await client.fetchQuery({ queryKey: queryKeys.auth.session, queryFn: async () => session(), staleTime: 0 });
|
|
second.flush();
|
|
const oldRecords = [...first.storage.values].filter(([key]) => key.startsWith(QUERY_CACHE_PREFIX));
|
|
if (ended === "sign-out") first.handle.clear();
|
|
else await first.client.fetchQuery({ queryKey: queryKeys.auth.session, queryFn: async () => null, staleTime: 0 });
|
|
const token = first.storage.getItem(QUERY_CACHE_CLEARED);
|
|
second.flush();
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBeNull();
|
|
for (const [key, value] of oldRecords) first.storage.setItem(key, value);
|
|
const cold = setup(first.storage);
|
|
expect(cold.client.getQueryData([...queryKeys.issues.detail("task-one"), "core"])).toBeUndefined();
|
|
for (const [key, value] of oldRecords) first.storage.setItem(key, value);
|
|
events.dispatchEvent(Object.assign(new Event("storage"), { key: QUERY_CACHE_CLEARED, newValue: token }));
|
|
expect([...first.storage.values.keys()].filter(key => key.startsWith(QUERY_CACHE_PREFIX))).toHaveLength(0);
|
|
const bob = new QueryClient();
|
|
bob.setQueryData(queryKeys.auth.session, session("bob"));
|
|
const fresh = setup(first.storage, undefined, bob);
|
|
seed(bob, "bob", "company-two");
|
|
fresh.handle.flush();
|
|
events.dispatchEvent(Object.assign(new Event("storage"), { key: QUERY_CACHE_CLEARED, newValue: token }));
|
|
expect(first.storage.getItem(QUERY_CACHE_ACTIVE)).toBe("bob");
|
|
expect(first.storage.getItem(`${QUERY_CACHE_PREFIX}bob:root`)).toContain('"bob"');
|
|
});
|
|
});
|