@antelopejs/dms 0.0.1

package/frontend-vue/tests/sidebar-widget-position.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  isSidebarWidgetVisible,
+  resolveSidebarWidgetPosition,
+  type SidebarWidget,
+  SidebarWidgetPosition,
+  useSidebarWidgets,
+} from "../layers/dms-layout/app/composables/useSidebarWidgets";
+
+const UNKNOWN_POSITION = "top" as SidebarWidgetPosition;
+
+const widget = (extra: Partial<SidebarWidget> = {}): SidebarWidget => ({
+  id: "widget",
+  component: "Widget",
+  ...extra,
+});
+
+describe("resolveSidebarWidgetPosition", () => {
+  it("keeps the pre-position placement of an unscoped widget", () => {
+    expect(resolveSidebarWidgetPosition(widget())).toBe(
+      SidebarWidgetPosition.ABOVE_SEARCH_BAR,
+    );
+  });
+
+  it("keeps the pre-position placement of a module-scoped widget", () => {
+    expect(resolveSidebarWidgetPosition(widget({ module: "demo" }))).toBe(
+      SidebarWidgetPosition.BELOW_SEARCH_BAR,
+    );
+  });
+
+  it("honors a declared position over the module-derived default", () => {
+    expect(
+      resolveSidebarWidgetPosition(
+        widget({
+          module: "demo",
+          position: SidebarWidgetPosition.ABOVE_SEARCH_BAR,
+        }),
+      ),
+    ).toBe(SidebarWidgetPosition.ABOVE_SEARCH_BAR);
+    expect(
+      resolveSidebarWidgetPosition(
+        widget({ position: SidebarWidgetPosition.BELOW_SEARCH_BAR }),
+      ),
+    ).toBe(SidebarWidgetPosition.BELOW_SEARCH_BAR);
+  });
+
+  it("falls back to the default rather than dropping an unknown position", () => {
+    expect(
+      resolveSidebarWidgetPosition(widget({ position: UNKNOWN_POSITION })),
+    ).toBe(SidebarWidgetPosition.ABOVE_SEARCH_BAR);
+    expect(
+      resolveSidebarWidgetPosition(
+        widget({ module: "demo", position: UNKNOWN_POSITION }),
+      ),
+    ).toBe(SidebarWidgetPosition.BELOW_SEARCH_BAR);
+  });
+});
+
+describe("isSidebarWidgetVisible", () => {
+  it("shows a global widget outside modules and hides it inside one", () => {
+    const global = widget();
+    expect(isSidebarWidgetVisible(global, null)).toBe(true);
+    expect(isSidebarWidgetVisible(global, undefined)).toBe(true);
+    expect(isSidebarWidgetVisible(global, "demo")).toBe(false);
+  });
+
+  it("shows a scoped widget only inside its own module", () => {
+    const scoped = widget({ module: "demo" });
+    expect(isSidebarWidgetVisible(scoped, "demo")).toBe(true);
+    expect(isSidebarWidgetVisible(scoped, "other")).toBe(false);
+    expect(isSidebarWidgetVisible(scoped, null)).toBe(false);
+  });
+});
+
+describe("useSidebarWidgets registration order", () => {
+  beforeEach(() => {
+    // The composable reads its store through the DMS app's injected `useDmsState`;
+    // a fresh array per call keeps each spec isolated.
+    vi.stubGlobal("useDmsState", (_key: string, init: () => SidebarWidget[]) => ({
+      value: init(),
+    }));
+  });
+
+  // The config sets no `unstubGlobals`, and file isolation is the pool's
+  // default rather than something this suite should rely on.
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  const ids = (widgets: readonly SidebarWidget[]) => widgets.map((w) => w.id);
+
+  it("sorts by order and keeps registration order within a tie", () => {
+    const { widgets, register } = useSidebarWidgets();
+    register(widget({ id: "a" }));
+    register(widget({ id: "b", order: -1 }));
+    register(widget({ id: "c" }));
+    expect(ids(widgets.value)).toEqual(["b", "a", "c"]);
+  });
+
+  it("upserts in place, so re-registering keeps the widget's rank", () => {
+    const { widgets, register } = useSidebarWidgets();
+    register(widget({ id: "a" }));
+    register(widget({ id: "b" }));
+    register(widget({ id: "a", component: "Replaced" }));
+    expect(ids(widgets.value)).toEqual(["a", "b"]);
+    expect(widgets.value[0]?.component).toBe("Replaced");
+  });
+
+  it("treats unregister then register as a new arrival, landing last in its tie", () => {
+    const { widgets, register, unregister } = useSidebarWidgets();
+    register(widget({ id: "a" }));
+    register(widget({ id: "b" }));
+    unregister("a");
+    register(widget({ id: "a" }));
+    expect(ids(widgets.value)).toEqual(["b", "a"]);
+  });
+});

package/frontend-vue/tests/site-layout-hydration.test.ts

@@ -0,0 +1,82 @@
+import { ref, type Ref } from "vue";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useSiteLayout } from "../layers/dms-layout/app/composables/page/useSiteLayout";
+
+const state = new Map<string, Ref>();
+const authFetch = vi.fn();
+
+beforeEach(() => {
+  state.clear();
+  const app = {};
+  vi.stubGlobal("useDmsApp", () => app);
+  vi.stubGlobal("useDmsState", (key: string, initial: () => unknown) => {
+    if (!state.has(key)) state.set(key, ref(initial()));
+    return state.get(key);
+  });
+  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: authFetch }));
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.resetAllMocks();
+});
+
+it("deduplicates consumers but never writes an old account response into a new cache", async () => {
+  let finish!: (value: unknown) => void;
+  authFetch.mockReturnValueOnce(
+    new Promise((resolve) => {
+      finish = resolve;
+    }),
+  );
+  const first = useSiteLayout();
+  const second = useSiteLayout();
+  const oldRequest = first.loadPageLayout("/layout");
+  const joined = second.loadPageLayout("/layout");
+  expect(authFetch).toHaveBeenCalledTimes(1);
+
+  state.get("dms-pageLayouts")!.value = {};
+  authFetch.mockResolvedValueOnce({ components: { fresh: {} } });
+  await second.loadPageLayout("/layout");
+  finish({ components: { secret: {} } });
+  await Promise.all([oldRequest, joined]);
+  expect(authFetch).toHaveBeenCalledTimes(2);
+  expect(first.pageLayouts.value).toEqual({
+    "/layout": { components: { fresh: {} } },
+  });
+});
+
+it("does not overwrite an Inertia site payload with a pre-navigation fetch", async () => {
+  let finish!: (value: unknown) => void;
+  authFetch.mockReturnValueOnce(
+    new Promise((resolve) => {
+      finish = resolve;
+    }),
+  );
+  const layout = useSiteLayout();
+  const request = layout.loadSiteLayout();
+  state.get("dms-siteLayout")!.value = { pages: { fresh: {} }, categories: {} };
+  finish({ siteLayout: { pages: { secret: {} }, categories: {} } });
+  await request;
+  expect(layout.siteLayout.value).toEqual({
+    pages: { fresh: {} },
+    categories: {},
+  });
+});
+
+it("does not show a stale request error after successful Inertia navigation", async () => {
+  let fail!: (error: unknown) => void;
+  authFetch.mockReturnValueOnce(
+    new Promise((_, reject) => {
+      fail = reject;
+    }),
+  );
+  const showError = vi.fn();
+  vi.stubGlobal("showError", showError);
+  const layout = useSiteLayout();
+  const request = layout.loadSiteLayout();
+  state.get("dms-siteLayout")!.value = { pages: { fresh: {} }, categories: {} };
+  fail(new Error("old account request"));
+  await expect(request).rejects.toThrow("old account request");
+  expect(showError).not.toHaveBeenCalled();
+  expect(layout.loadingError.value).toBeNull();
+});

package/frontend-vue/tests/site-layout-refresh.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi } from "vitest";
+
+/**
+ * The refresh contract of `useSiteLayout`, extracted so it can be exercised
+ * without a DMS app runtime: the composable parks its in-flight fetch on the DMS app
+ * app instance, everything else here is the same control flow.
+ *
+ * What it has to guarantee: a refresh asked for while a fetch is already in
+ * flight never reports success on that fetch's answer — it was started before
+ * whatever prompted the refresh, so it cannot contain the change.
+ */
+function createSiteLayoutRefresher(
+  fetchLayout: () => Promise<void>,
+  // The composable parks the in-flight fetch on the DMS app, so every caller
+  // of useSiteLayout coordinates through one holder; passing it in mirrors
+  // that, and lets a test act as a second instance.
+  holder: { loadingPromise: Promise<void> | null } = { loadingPromise: null },
+) {
+  const state = holder;
+
+  const start = (): Promise<void> => {
+    const started = fetchLayout().finally(() => {
+      if (state.loadingPromise === started) {
+        state.loadingPromise = null;
+      }
+    });
+    state.loadingPromise = started;
+    return started;
+  };
+
+  const refresh = async (): Promise<void> => {
+    const inFlight = state.loadingPromise;
+    if (inFlight) {
+      await inFlight.catch(() => undefined);
+      if (state.loadingPromise === inFlight) {
+        state.loadingPromise = null;
+      }
+    }
+    if (!state.loadingPromise) {
+      start();
+    }
+    await state.loadingPromise;
+  };
+
+  return { refresh, start, state };
+}
+
+function deferred() {
+  let resolve!: () => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<void>((res, rej) => {
+    resolve = () => res();
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+describe("useSiteLayout refresh", () => {
+  it("refetches instead of joining a fetch that predates the change", async () => {
+    const first = deferred();
+    const answers = [first.promise, Promise.resolve()];
+    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
+    const { refresh, start } = createSiteLayoutRefresher(fetchLayout);
+
+    start();
+    const refreshed = refresh();
+    first.resolve();
+    await refreshed;
+
+    // The in-flight answer cannot hold the change, so a second one is fetched.
+    expect(fetchLayout).toHaveBeenCalledTimes(2);
+  });
+
+  it("collapses a burst into a single refetch", async () => {
+    const first = deferred();
+    const answers = [first.promise, Promise.resolve(), Promise.resolve()];
+    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
+    const { refresh, start } = createSiteLayoutRefresher(fetchLayout);
+
+    start();
+    const refreshes = [refresh(), refresh(), refresh()];
+    first.resolve();
+    await Promise.all(refreshes);
+
+    // Three refreshes over one in-flight fetch: one relaunch, not three.
+    expect(fetchLayout).toHaveBeenCalledTimes(2);
+  });
+
+  it("refetches after a failed fetch instead of reporting its failure", async () => {
+    const first = deferred();
+    const answers = [first.promise, Promise.resolve()];
+    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
+    const { refresh, start } = createSiteLayoutRefresher(fetchLayout);
+
+    start().catch(() => undefined);
+    const refreshed = refresh();
+    first.reject(new Error("network blip"));
+
+    await expect(refreshed).resolves.toBeUndefined();
+    expect(fetchLayout).toHaveBeenCalledTimes(2);
+  });
+
+  // Two instances of the composable write the same shared layout state, so
+  // they have to share the in-flight fetch: otherwise the older answer can
+  // land last and overwrite the fresher menu.
+  it("shares the in-flight fetch between instances", async () => {
+    const first = deferred();
+    const answers = [first.promise, Promise.resolve()];
+    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
+    const holder = { loadingPromise: null as Promise<void> | null };
+    const instanceA = createSiteLayoutRefresher(fetchLayout, holder);
+    const instanceB = createSiteLayoutRefresher(fetchLayout, holder);
+
+    instanceA.start();
+    const refreshed = instanceB.refresh();
+    first.resolve();
+    await refreshed;
+
+    // B saw A's fetch and relaunched once, rather than racing it.
+    expect(fetchLayout).toHaveBeenCalledTimes(2);
+  });
+
+  it("starts one fetch when nothing is in flight", async () => {
+    const fetchLayout = vi.fn(() => Promise.resolve());
+    const { refresh } = createSiteLayoutRefresher(fetchLayout);
+
+    await refresh();
+
+    expect(fetchLayout).toHaveBeenCalledTimes(1);
+  });
+});

package/frontend-vue/tests/sse-stream.test.ts

@@ -0,0 +1,268 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  openSseStream,
+  type SseCloseReason,
+  type SseStreamOptions,
+} from "../layers/dms-core/app/composables/realtime/useSseStream";
+
+const STREAM_URL = "https://api.example.test/events";
+const encoder = new TextEncoder();
+
+afterEach(() => vi.unstubAllGlobals());
+
+function respond(chunks: Uint8Array[]): Response {
+  return new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const chunk of chunks) controller.enqueue(chunk);
+        controller.close();
+      },
+    }),
+  );
+}
+
+function read(
+  options: Partial<SseStreamOptions> = {},
+): Promise<SseCloseReason> {
+  return new Promise((resolve) => {
+    openSseStream({
+      url: STREAM_URL,
+      onEvent: vi.fn(),
+      ...options,
+      onClose: resolve,
+    });
+  });
+}
+
+describe("SSE transport lifecycle", () => {
+  it("opens before frames, preserves ids and reports EOF after releasing the reader", async () => {
+    const response = respond([
+      encoder.encode('id: cursor-1\nevent: log\ndata: {"line":"ready"}\n\n'),
+    ]);
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+    const calls: unknown[] = [];
+    expect(
+      await read({
+        onOpen: () => calls.push("open"),
+        onEvent: (...args) => calls.push(args),
+      }),
+    ).toBe("eof");
+    expect(calls).toEqual(["open", ["log", { line: "ready" }, "cursor-1"]]);
+    expect(response.body?.locked).toBe(false);
+  });
+
+  it("decodes fragmented UTF-8 and CRLF and preserves text whitespace and empty ids", async () => {
+    const bytes = encoder.encode(
+      ": ping\r\n\r\nid: old\r\nid: c1\r\nevent: log\r\ndata:  été  \r\ndata: next\r\n\r\ndata:\r\nid:\r\n\r\ndata: true\r\n\r\n",
+    );
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValue(
+          respond(Array.from(bytes, (byte) => Uint8Array.of(byte))),
+        ),
+    );
+    const onEvent = vi.fn();
+    expect(await read({ onEvent })).toBe("eof");
+    expect(onEvent.mock.calls).toEqual([
+      ["log", " été  \nnext", "c1"],
+      ["message", "", ""],
+      ["message", true, null],
+    ]);
+  });
+
+  it("ignores id-only frames, invalid ids and an unfinished frame at EOF", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValue(
+          respond([
+            encoder.encode(
+              "id: alone\n\nid: valid\nid: bad\0id\nevent:\ndata: 1\n\ndata: unfinished",
+            ),
+          ]),
+        ),
+    );
+    const onEvent = vi.fn();
+    expect(await read({ onEvent })).toBe("eof");
+    expect(onEvent.mock.calls).toEqual([["message", 1, "valid"]]);
+  });
+
+  it("reports an empty accepted response as open then EOF", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(respond([])));
+    const onOpen = vi.fn();
+    const onError = vi.fn();
+    expect(await read({ onOpen, onError })).toBe("eof");
+    expect(onOpen).toHaveBeenCalledOnce();
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("reports HTTP rejection as error without opening", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue(new Response(null, { status: 401 })),
+    );
+    const onOpen = vi.fn();
+    const onError = vi.fn();
+    expect(await read({ onOpen, onError })).toBe("error");
+    expect(onOpen).not.toHaveBeenCalled();
+    expect(onError).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({ status: 401 }),
+    );
+  });
+
+  it("does not dispatch a throwing consumer twice or reinterpret its JSON", async () => {
+    const response = respond([encoder.encode("data: {}\n\ndata: 2\n\n")]);
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+    const error = new Error("consumer failed");
+    const onEvent = vi.fn(() => {
+      throw error;
+    });
+    const onError = vi.fn();
+    expect(await read({ onEvent, onError })).toBe("error");
+    expect(onEvent).toHaveBeenCalledExactlyOnceWith("message", {}, null);
+    expect(onError).toHaveBeenCalledExactlyOnceWith(error);
+    expect(response.body?.locked).toBe(false);
+  });
+
+  it("reports a read failure before the error close notification", async () => {
+    const error = new Error("connection reset");
+    const response = new Response(
+      new ReadableStream({
+        start(controller) {
+          controller.error(error);
+        },
+      }),
+    );
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+    const calls: unknown[] = [];
+    await new Promise<void>((resolve) => {
+      openSseStream({
+        url: STREAM_URL,
+        onEvent: vi.fn(),
+        onOpen: () => calls.push("open"),
+        onError: (value) => calls.push(value),
+        onClose: (reason) => {
+          calls.push(reason);
+          resolve();
+        },
+      });
+    });
+    expect(calls).toEqual(["open", error, "error"]);
+    expect(response.body?.locked).toBe(false);
+  });
+
+  it("can close synchronously from onOpen without delivering a frame", async () => {
+    const response = respond([encoder.encode("data: 1\n\n")]);
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+    const onEvent = vi.fn();
+    const reason = await new Promise<SseCloseReason>((resolve) => {
+      const handle = openSseStream({
+        url: STREAM_URL,
+        onEvent,
+        onOpen: () => handle.close(),
+        onClose: resolve,
+      });
+    });
+    expect(reason).toBe("aborted");
+    expect(onEvent).not.toHaveBeenCalled();
+    expect(response.body?.locked).toBe(false);
+  });
+
+  it("stops buffered events after close and notifies cancellation only once", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValue(respond([encoder.encode("data: 1\n\ndata: 2\n\n")])),
+    );
+    const onError = vi.fn();
+    const onEvent = vi.fn();
+    const onClose = vi.fn();
+    const reason = await new Promise<SseCloseReason>((resolve) => {
+      const handle = openSseStream({
+        url: STREAM_URL,
+        onError,
+        onEvent: (...args) => {
+          onEvent(...args);
+          handle.close();
+          handle.close();
+        },
+        onClose: (value) => {
+          onClose(value);
+          resolve(value);
+        },
+      });
+    });
+    expect(reason).toBe("aborted");
+    expect(onEvent).toHaveBeenCalledOnce();
+    expect(onClose).toHaveBeenCalledOnce();
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it("cancels a pending read and releases its lock", async () => {
+    const cancel = vi.fn();
+    const response = new Response(new ReadableStream({ cancel }));
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+    const reason = await new Promise<SseCloseReason>((resolve) => {
+      const handle = openSseStream({
+        url: STREAM_URL,
+        onEvent: vi.fn(),
+        onClose: resolve,
+        onOpen: () => queueMicrotask(() => handle.close()),
+      });
+    });
+    expect(reason).toBe("aborted");
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(response.body?.locked).toBe(false);
+  });
+
+  it("suppresses opening and frames when closed before fetch resolves", async () => {
+    const response = respond([encoder.encode("data: 1\n\n")]);
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+    const onOpen = vi.fn();
+    const onEvent = vi.fn();
+    const reason = await new Promise<SseCloseReason>((resolve) => {
+      const handle = openSseStream({
+        url: STREAM_URL,
+        onOpen,
+        onEvent,
+        onClose: resolve,
+      });
+      handle.close();
+    });
+    expect(reason).toBe("aborted");
+    expect(onOpen).not.toHaveBeenCalled();
+    expect(onEvent).not.toHaveBeenCalled();
+  });
+
+  it("lets the caller resume after EOF using fresh auth and Last-Event-ID", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(respond([encoder.encode("id: c1\ndata: 1\n\n")]))
+      .mockResolvedValueOnce(respond([encoder.encode("id: c2\ndata: 2\n\n")]));
+    vi.stubGlobal("fetch", fetchMock);
+    let cursor: string | null = null;
+    let token = "first";
+    const options: Partial<SseStreamOptions> = {
+      headers: () => ({
+        Authorization: `Bearer ${token}`,
+        ...(cursor ? { "Last-Event-ID": cursor } : {}),
+      }),
+      onEvent: (_name, _data, id) => {
+        if (id !== null) cursor = id;
+      },
+    };
+    expect(await read(options)).toBe("eof");
+    expect(fetchMock).toHaveBeenCalledOnce();
+    token = "renewed";
+    expect(await read(options)).toBe("eof");
+    expect(fetchMock.mock.calls[1]?.[1].headers).toEqual({
+      Authorization: "Bearer renewed",
+      "Last-Event-ID": "c1",
+    });
+    expect(cursor).toBe("c2");
+  });
+});

package/frontend-vue/tests/string-type-parser.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import {
+  parse,
+  parseObject,
+} from "../layers/dms-core/app/utils/stringTypeParser";
+
+const FUNCTION_STRINGS = [
+  "(x) => x + 1",
+  "x => x * 2",
+  "function(a) { return a }",
+  '(() => { throw new Error("Input executed"); })()',
+  'function() {} , (() => { throw new Error("Input executed"); })()',
+];
+
+describe("stringTypeParser", () => {
+  it("preserves supported data conversions", () => {
+    expect(
+      parseObject([
+        { key: "enabled", value: "true" },
+        { key: "disabled", value: "false" },
+        { key: "count", value: "42" },
+        { key: "ratio", value: "3.14" },
+        { key: "empty", value: "null" },
+        { key: "missing", value: "undefined" },
+        { key: "date", value: "2024-01-01" },
+        { key: "object", value: '{"key":"value"}' },
+        { key: "array", value: "[1,2,3]" },
+        { key: "name", value: "hello world" },
+      ]),
+    ).toEqual({
+      enabled: true,
+      disabled: false,
+      count: 42,
+      ratio: 3.14,
+      empty: null,
+      missing: undefined,
+      date: new Date("2024-01-01T00:00:00.000Z"),
+      object: { key: "value" },
+      array: [1, 2, 3],
+      name: "hello world",
+    });
+  });
+
+  it.each(FUNCTION_STRINGS)("preserves function syntax: %s", (input) => {
+    expect(parse(input)).toBe(input);
+    expect(parseObject([{ key: "filter", value: input }])).toEqual({
+      filter: input,
+    });
+  });
+});

package/frontend-vue/tests/table-async-data-key.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { buildTableDataKey } from "../layers/dms-ui/app/build/composables/table-view/utils/tableQuery";
+
+const baseRequest = {
+  componentId: "runs",
+  pageId: "automation.runs",
+  query: { offset: 0, limit: 10 },
+  archiveQuery: {},
+  isSelfManaged: false,
+};
+
+describe("TableView async-data key", () => {
+  it("refetches when a client preference changes the hydrated SSR query", () => {
+    const serverKey = buildTableDataKey(baseRequest);
+    const clientKey = buildTableDataKey({
+      ...baseRequest,
+      query: { ...baseRequest.query, filter_status: "is:failed" },
+    });
+    const hydratedData = new Map([[serverKey, ["success", "failed"]]]);
+
+    expect(clientKey).not.toBe(serverKey);
+    expect(hydratedData.has(clientKey)).toBe(false);
+  });
+
+  it("reuses hydration when the client and server requests match", () => {
+    const serverKey = buildTableDataKey(baseRequest);
+    const hydratedData = new Map([[serverKey, ["success", "failed"]]]);
+    const clientKey = buildTableDataKey({ ...baseRequest });
+
+    expect(clientKey).toBe(serverKey);
+    expect(hydratedData.get(clientKey)).toEqual(["success", "failed"]);
+  });
+});