@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/tab-fit.test.ts

@@ -1,99 +0,0 @@
-// @vitest-environment jsdom
-/**
- * `fit` draws a horizontal pill list as wide as its tabs: the list stops
- * taking the column's width and the triggers stop growing to share it. A
- * link list, a vertical one and a list without `fit` keep their classes.
- */
-import * as vue from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { AxeOrientation } from "../layers/dms-core/app/types/orientation";
-import { Color } from "../layers/dms-core/app/types/color";
-import { Size } from "../layers/dms-core/app/types/size";
-import { TabVariant } from "../layers/dms-ui/app/composables/tab/types/props";
-
-vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
-  useChartFetch: () => ({ data: vue.ref(null) }),
-}));
-
-interface TabsUi {
-  list?: unknown;
-  trigger?: unknown;
-}
-
-let received: TabsUi = {};
-let app: vue.App | undefined;
-
-const Tabs = vue.defineComponent({
-  props: { ui: { type: Object, default: () => ({}) } },
-  setup: (props) => () => {
-    received = props.ui as TabsUi;
-    return vue.h("div");
-  },
-});
-
-const classesOf = (value: unknown): string =>
-  [value].flat(Infinity).filter(Boolean).join(" ");
-
-async function mount(props: Record<string, unknown>): Promise<TabsUi> {
-  const { default: Tab } = await import(
-    "../layers/dms-ui/app/components/tab/Tab.vue"
-  );
-  app = vue.createApp({
-    render: () =>
-      vue.h(Tab, {
-        items: [
-          { label: "Activity", slot: "activity" },
-          { label: "Logins", slot: "logins" },
-        ],
-        componentId: "tabs",
-        pageId: "dashboard",
-        ...props,
-      }),
-  });
-  app.component("UTabs", Tabs);
-  app.mount(document.createElement("div"));
-  await vue.nextTick();
-  return received;
-}
-
-beforeEach(() => {
-  for (const name of ["computed", "ref", "useTemplateRef"] as const) {
-    vi.stubGlobal(name, vue[name]);
-  }
-  vi.stubGlobal("AxeOrientation", AxeOrientation);
-  vi.stubGlobal("Color", Color);
-  vi.stubGlobal("Size", Size);
-  vi.stubGlobal("useI18n", () => ({ locale: vue.ref("en-US"), t: String }));
-  vi.stubGlobal("useTranslation", () => ({ processI18n: String }));
-  vi.stubGlobal("useWatch", () => ({ state: vue.ref({}) }));
-  vi.stubGlobal("useTab", () => ({ activeTab: vue.ref("0") }));
-  vi.stubGlobal("useTabShortcuts", () => {});
-});
-
-afterEach(() => {
-  app?.unmount();
-  vi.unstubAllGlobals();
-});
-
-describe("Tab fit", () => {
-  it("hugs a horizontal pill list to its tabs", async () => {
-    const ui = await mount({ fit: true });
-    expect(classesOf(ui.list)).toContain("w-fit");
-    expect(classesOf(ui.trigger)).toContain("grow-0");
-  });
-
-  it("keeps the full width by default", async () => {
-    const ui = await mount({});
-    expect(classesOf(ui.list)).not.toContain("w-fit");
-    expect(classesOf(ui.trigger)).toBe("");
-  });
-
-  it.each([
-    { variant: TabVariant.link },
-    { orientation: AxeOrientation.vertical },
-  ])("leaves %o as it was", async (props) => {
-    const ui = await mount({ fit: true, ...props });
-    expect(classesOf(ui.list)).not.toContain("w-fit");
-    expect(classesOf(ui.trigger)).toBe("");
-  });
-});

package/frontend-vue/tests/tab-url-slot.test.ts

@@ -1,150 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A tab set keeping its open tab in the URL writes the tab's slot
- * (`?tab=tester`), which stays right when tabs are added or reordered, and
- * still opens a tab named by its index (`?tab=2`). A tab's badge is a
- * BlockText: an i18n key is written in the reader's language.
- */
-import * as vue from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useTab } from "../layers/dms-ui/app/composables/tab/useTab";
-import { TabEvents } from "../layers/dms-ui/app/composables/tab/types/events";
-import type { TabProps } from "../layers/dms-ui/app/composables/tab/types";
-import { AxeOrientation } from "../layers/dms-core/app/types/orientation";
-import { Color } from "../layers/dms-core/app/types/color";
-import { Size } from "../layers/dms-core/app/types/size";
-
-vi.mock("../layers/dms-ui/app/composables/chart/useChartFetch", () => ({
-  useChartFetch: () => ({ data: vue.ref(null) }),
-}));
-
-const ITEMS = [
-  { label: "Statistics", slot: "statistics" },
-  { label: "Documentation", slot: "documentation" },
-  { label: "Tester", slot: "tester" },
-];
-
-let route: { query: Record<string, string> };
-const push = vi.fn(async (to: { query: Record<string, string> }) => {
-  route.query = to.query;
-});
-
-function tabsAt(query: Record<string, string>) {
-  route.query = query;
-  return useTab(ITEMS.length, {
-    items: ITEMS,
-    persistState: true,
-  } as TabProps);
-}
-
-beforeEach(() => {
-  route = vue.reactive({ query: {} });
-  push.mockClear();
-  for (const name of ["computed", "ref", "watch", "useTemplateRef"] as const)
-    vi.stubGlobal(name, vue[name]);
-  vi.stubGlobal("TabEvents", TabEvents);
-  vi.stubGlobal("isNumber", (value: unknown) => typeof value === "number");
-  vi.stubGlobal("isString", (value: unknown) => typeof value === "string");
-  vi.stubGlobal("useComponentEvent", () => ({ sendComponentEvent: vi.fn() }));
-  vi.stubGlobal("useWatch", () => ({
-    isLoading: vue.ref(false),
-    state: vue.ref({}),
-  }));
-  vi.stubGlobal("useDmsRoute", () => route);
-  vi.stubGlobal("useDmsRouter", () => ({ push }));
-});
-
-afterEach(() => vi.unstubAllGlobals());
-
-describe("a tab in the URL", () => {
-  it("opens the tab its slot names", () => {
-    expect(tabsAt({ tab: "tester" }).activeTab.value).toBe("2");
-  });
-
-  it("still opens a tab named by its index", () => {
-    expect(tabsAt({ tab: "1" }).activeTab.value).toBe("1");
-  });
-
-  it("opens the first tab on a name it does not know", () => {
-    expect(tabsAt({ tab: "settings" }).activeTab.value).toBe("0");
-    expect(tabsAt({ tab: "7" }).activeTab.value).toBe("0");
-  });
-
-  it("writes the open tab's slot, and nothing for the first", async () => {
-    const { goToTab } = tabsAt({});
-    goToTab(2);
-    await vue.nextTick();
-    expect(push).toHaveBeenLastCalledWith({ query: { tab: "tester" } });
-    goToTab("statistics");
-    await vue.nextTick();
-    expect(push).toHaveBeenLastCalledWith({ query: {} });
-  });
-
-  it("follows a URL naming another slot", async () => {
-    const { activeTab } = tabsAt({});
-    route.query = { tab: "documentation" };
-    await vue.nextTick();
-    expect(activeTab.value).toBe("1");
-  });
-});
-
-describe("a tab's badge", () => {
-  interface TabsItem {
-    badge?: unknown;
-  }
-  let received: TabsItem[] = [];
-  let app: vue.App | undefined;
-
-  const Tabs = vue.defineComponent({
-    props: { items: { type: Array, default: () => [] } },
-    setup: (props) => () => {
-      received = props.items as TabsItem[];
-      return vue.h("div");
-    },
-  });
-
-  async function badgesOf(badges: unknown[]): Promise<unknown[]> {
-    vi.stubGlobal("AxeOrientation", AxeOrientation);
-    vi.stubGlobal("Color", Color);
-    vi.stubGlobal("Size", Size);
-    vi.stubGlobal("useI18n", () => ({
-      locale: vue.ref("en"),
-      t: (key: string) => `t(${key})`,
-    }));
-    vi.stubGlobal("useTranslation", () => ({ processI18n: String }));
-    vi.stubGlobal("useTab", () => ({ activeTab: vue.ref("0") }));
-    vi.stubGlobal("useTabShortcuts", () => {});
-    const { default: Tab } = await import(
-      "../layers/dms-ui/app/components/tab/Tab.vue"
-    );
-    app = vue.createApp({
-      render: () =>
-        vue.h(Tab, {
-          items: badges.map((badge, index) => ({ ...ITEMS[index], badge })),
-        }),
-    });
-    app.component("UTabs", Tabs);
-    app.mount(document.createElement("div"));
-    await vue.nextTick();
-    app.unmount();
-    return received.map((item) => item.badge);
-  }
-
-  it("writes an i18n key, a composed text and a badge label in the reader's language", async () => {
-    expect(
-      await badgesOf([
-        "$api.tabs.beta",
-        { key: "api.tabs.count" },
-        { label: "$api.tabs.new", color: "primary" },
-      ]),
-    ).toEqual([
-      "t(api.tabs.beta)",
-      "t(api.tabs.count)",
-      { label: "t(api.tabs.new)", color: "primary" },
-    ]);
-  });
-
-  it("keeps a count and a plain text as they are", async () => {
-    expect(await badgesOf([3, "Beta"])).toEqual([3, "Beta"]);
-  });
-});

package/frontend-vue/tests/tab-without-component-id.test.ts

@@ -1,51 +0,0 @@
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { computed, nextTick, reactive, ref, watch } from "vue";
-import { useTab } from "../layers/dms-ui/app/composables/tab/useTab";
-import { TabEvents } from "../layers/dms-ui/app/composables/tab/types/events";
-import type { TabProps } from "../layers/dms-ui/app/composables/tab/types";
-
-const TAB_COUNT = 3;
-const sendComponentEvent = vi.fn();
-
-beforeEach(() => {
-  sendComponentEvent.mockClear();
-  Object.entries({ computed, ref, watch, TabEvents }).forEach(([key, value]) =>
-    vi.stubGlobal(key, value),
-  );
-  vi.stubGlobal("isNumber", (value: unknown) => typeof value === "number");
-  vi.stubGlobal("isString", (value: unknown) => typeof value === "string");
-  vi.stubGlobal("useComponentEvent", () => ({ sendComponentEvent }));
-  vi.stubGlobal("useWatch", () => ({ isLoading: ref(false), state: ref({}) }));
-  vi.stubGlobal("useDmsRoute", () => reactive({ query: {} }));
-  vi.stubGlobal("useDmsRouter", () => ({ push: vi.fn() }));
-});
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-it("switches tabs without announcing them when no component owns the set", async () => {
-  const { activeTab, goToTab } = useTab(TAB_COUNT, { items: [] } as TabProps);
-
-  goToTab(1);
-  await nextTick();
-
-  expect(activeTab.value).toBe("1");
-  expect(sendComponentEvent).not.toHaveBeenCalled();
-});
-
-it("announces a tab change for a registered component", async () => {
-  const { goToTab } = useTab(TAB_COUNT, {
-    items: [],
-    componentId: "settings.tabs",
-    pageId: "settings",
-  } as TabProps);
-
-  goToTab(2);
-  await nextTick();
-
-  expect(sendComponentEvent).toHaveBeenCalledWith(
-    TabEvents.TAB_CHANGE,
-    "settings.tabs",
-    { previousTab: 0, currentTab: 2 },
-  );
-});

package/frontend-vue/tests/table-actions-column-width.test.ts

@@ -1,135 +0,0 @@
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import {
-  computed,
-  h,
-  nextTick,
-  reactive,
-  ref,
-  shallowRef,
-  watch,
-  watchEffect,
-} from "vue";
-import { useTable } from "../layers/dms-ui/app/build/composables/table/useTable";
-import { useTableColumns } from "../layers/dms-ui/app/build/composables/table/useTableColumns";
-import * as ruleEvaluator from "../layers/dms-core/app/utils/row-action-rule-evaluator";
-import * as colors from "../layers/dms-core/app/types/color";
-
-vi.mock("@nuxt/ui/components/Button.vue", () => ({
-  default: { render: () => null },
-}));
-vi.mock("@nuxt/ui/components/Checkbox.vue", () => ({
-  default: { render: () => null },
-}));
-vi.mock("@nuxt/ui/components/DropdownMenu.vue", () => ({
-  default: { render: () => null },
-}));
-vi.mock("@nuxt/ui/runtime/utils/index.js", () => ({
-  get: (row: Record<string, unknown>, key: string) => row[key],
-}));
-
-type Row = Record<string, unknown>;
-
-// An invitation is pending (Revoke) or expired (Remove), never both: two
-// labelled actions sharing a row only through their rules.
-const PENDING = { field: "status", equals: true };
-const EXPIRED = { field: "status", equals: false };
-
-const rowActions = {
-  add: false,
-  copyLink: false,
-  delete: false,
-  details: false,
-  duplicate: false,
-  edit: false,
-  hasSelection: false,
-  custom: [
-    { label: "Resend", isVisible: true, showLabel: true },
-    { label: "Revoke", isVisible: true, showLabel: true, rule: PENDING },
-    { label: "Remove", isVisible: true, showLabel: true, rule: EXPIRED },
-  ],
-};
-
-beforeEach(() => {
-  for (const [name, value] of Object.entries({ ...ruleEvaluator, ...colors })) {
-    vi.stubGlobal(name, value);
-  }
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("watchEffect", watchEffect);
-  vi.stubGlobal("shallowRef", shallowRef);
-  vi.stubGlobal("isFunction", (value: unknown) => typeof value === "function");
-  vi.stubGlobal("h", h);
-  vi.stubGlobal("isString", (value: unknown) => typeof value === "string");
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useDmsRouter", () => ({ push: vi.fn() }));
-  vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
-  vi.stubGlobal("useDmsAppConfig", () => ({}));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (key: string) => key,
-  }));
-  vi.stubGlobal("useConfirm", () => ({ confirm: vi.fn() }));
-  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: vi.fn() }));
-  vi.stubGlobal("useDataTypes", () => ({ getDataType: () => undefined }));
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-function actionsColumnSize(rows: Row[]): number | undefined {
-  const { columns } = useTableColumns<Row>({
-    data: computed(() => rows),
-    columns: [{ accessorKey: "email", header: "Email" }],
-    rowIdKey: "_id",
-    rowActions,
-    emits: (() => undefined) as never,
-    ui: computed(() => ({}) as never),
-  });
-  return columns.value.find((column) => column.id === "actions")?.size;
-}
-
-it("sizes an empty list's actions as a row with no values, through the rules", () => {
-  const empty = actionsColumnSize([]);
-  const pending = actionsColumnSize([{ _id: "1", status: true }]);
-  // Resend alone shows on a row without a status; a pending row adds Revoke.
-  expect(empty).toBeLessThan(pending!);
-  expect(empty).toBe(actionsColumnSize([{ _id: "1" }]));
-});
-
-// A table opened by client-side navigation (the members page's Invitations
-// tab) is set up before its first page arrives: the actions column must grow
-// to the rows' buttons once they are listed, not keep the empty list's width.
-it("resizes the table's actions column once the rows arrive", async () => {
-  const tableProps = reactive({
-    data: [] as Row[],
-    columns: [{ accessorKey: "email", header: "Email" }],
-    rowActions,
-  });
-  const { table } = useTable<Row>({
-    tableProps: tableProps as never,
-    emits: (() => undefined) as never,
-    ui: computed(() => ({}) as never),
-    states: {
-      globalFilterState: ref(""),
-      columnFiltersState: ref([]),
-      columnOrderState: ref([]),
-      columnVisibilityState: ref({}),
-      columnPinningState: ref({}),
-      columnSizingState: ref({}),
-      rowSelectionState: ref({}),
-      sortingState: ref([]),
-      expandedState: ref({}),
-      paginationState: ref({ pageIndex: 0, pageSize: 10 }),
-    } as never,
-  });
-  const emptyWidth = table.getColumn("actions")!.getSize();
-
-  tableProps.data = [{ _id: "1", status: true }];
-  await nextTick();
-
-  expect(table.getColumn("actions")!.getSize()).toBe(
-    actionsColumnSize([{ _id: "1", status: true }]),
-  );
-  expect(table.getColumn("actions")!.getSize()).toBeGreaterThan(emptyWidth);
-});

package/frontend-vue/tests/table-actions-search-label.test.ts

@@ -1,224 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  provide,
-  ref,
-  shallowRef,
-  watch,
-  type App,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { defineShortcuts } from "@nuxt/ui/runtime/composables/defineShortcuts.js";
-import TableActions from "../layers/dms-ui/app/build/components/table/Actions.vue";
-import { FULL_TABLE_CHROME } from "../layers/dms-ui/app/build/composables/table-view/utils/chrome";
-
-vi.mock("../layers/dms-ui/app/build/components/table/Menu.vue", () => ({
-  default: { render: () => null },
-}));
-
-vi.mock("../layers/dms-ui/app/build/components/form/SearchInput.vue", () => ({
-  default: { render: () => null },
-}));
-
-const PassThrough = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", slots.default?.()),
-});
-
-const ButtonStub = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("button", slots.default?.()),
-});
-
-// A real UInput wraps its field: the toolbar focuses the input inside it.
-const InputStub = defineComponent({
-  inheritAttrs: false,
-  setup:
-    (_, { attrs }) =>
-    () =>
-      h("div", [h("input", attrs)]),
-});
-
-let app: App | undefined;
-
-function mountActions(
-  searchPlaceholder: string | undefined,
-  search = "",
-  searchShortcut?: string,
-) {
-  const Host = defineComponent({
-    setup() {
-      provide(
-        "tableSharedData",
-        shallowRef({
-          activeCapabilities: ref({
-            search: true,
-            filters: false,
-            sorting: false,
-          }),
-          labeledColumns: ref([]),
-          globalFilterState: ref(search),
-          columnFiltersState: ref([]),
-          paginationState: ref({ pageIndex: 0, pageSize: 10 }),
-          filtersRowOpenState: ref(false),
-          hasCustomSort: ref(false),
-          displays: [],
-          activeDisplayState: ref("table"),
-          kanbanGroupByOptions: [],
-          kanbanGroupByState: ref(undefined),
-          onFiltersCleared: () => undefined,
-          emits: () => undefined,
-        }),
-      );
-      return () =>
-        h(TableActions, {
-          searchPlaceholder,
-          searchShortcut,
-          chrome: { ...FULL_TABLE_CHROME, refresh: false, menu: false },
-        });
-    },
-  });
-  app = createApp(Host);
-  for (const [name, stub] of Object.entries({
-    UButton: ButtonStub,
-    UInput: InputStub,
-    UKbd: PassThrough,
-    UPopover: PassThrough,
-    UDropdownMenu: PassThrough,
-    UTooltip: PassThrough,
-    UIcon: PassThrough,
-  })) {
-    app.component(name, stub);
-  }
-  const container = document.createElement("div");
-  document.body.append(container);
-  app.mount(container);
-  return container;
-}
-
-beforeEach(() => {
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("defineShortcuts", () => undefined);
-  vi.stubGlobal("useDmsAppConfig", () => ({
-    ui: { icons: { close: "close", plus: "plus", ellipsis: "ellipsis" } },
-  }));
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (value: string) =>
-      value.startsWith("$") ? `translated:${value.slice(1)}` : value,
-  }));
-});
-
-afterEach(() => {
-  app?.unmount();
-  app = undefined;
-  document.body.replaceChildren();
-  vi.unstubAllGlobals();
-});
-
-describe("table toolbar search", () => {
-  it("names the button opening the search", () => {
-    const container = mountActions(undefined);
-    expect(container.querySelector("button")?.getAttribute("aria-label")).toBe(
-      "dms.table.search_open",
-    );
-  });
-
-  it("opens the search field from its button and focuses it", async () => {
-    const container = mountActions(undefined);
-    const trigger = container.querySelector("button");
-    trigger?.focus();
-    trigger?.click();
-    await nextTick();
-    await nextTick();
-    const input = container.querySelector("input");
-    expect(input).not.toBeNull();
-    expect(document.activeElement).toBe(input);
-    await nextTick();
-    expect(container.querySelector("input")).not.toBeNull();
-  });
-
-  it("uses the configured placeholder, which also names the field", async () => {
-    const container = mountActions("$page.members.search", "ada");
-    await nextTick();
-    const input = container.querySelector("input");
-    expect(input?.getAttribute("placeholder")).toBe(
-      "translated:page.members.search",
-    );
-    expect(input?.getAttribute("aria-label")).toBe(
-      "translated:page.members.search",
-    );
-  });
-
-  it("falls back to the default placeholder as the field's name", async () => {
-    const container = mountActions(undefined, "ada");
-    await nextTick();
-    const input = container.querySelector("input");
-    expect(input?.getAttribute("placeholder")).toBe(
-      "dms.table.search_placeholder",
-    );
-    expect(input?.getAttribute("aria-label")).toBe(
-      "dms.table.search_placeholder",
-    );
-  });
-});
-
-describe("table search shortcut", () => {
-  const press = (
-    key: string,
-    init: KeyboardEventInit = {},
-    target: EventTarget = document.body,
-  ) =>
-    target.dispatchEvent(
-      new KeyboardEvent("keydown", { key, bubbles: true, ...init }),
-    );
-  const settle = async () => {
-    await nextTick();
-    await nextTick();
-  };
-
-  beforeEach(() => {
-    vi.stubGlobal("defineShortcuts", defineShortcuts);
-    vi.stubGlobal("nextTick", nextTick);
-  });
-
-  it("opens and focuses the search on ⇧F by default", async () => {
-    const container = mountActions(undefined);
-    press("F", { shiftKey: true });
-    await settle();
-    const input = container.querySelector("input");
-    expect(input).not.toBeNull();
-    expect(document.activeElement).toBe(input);
-  });
-
-  it("opens it on the table's own key, ⇧F no longer bound", async () => {
-    const container = mountActions(undefined, "", "/");
-    press("F", { shiftKey: true });
-    await settle();
-    expect(container.querySelector("input")).toBeNull();
-    press("/");
-    await settle();
-    expect(document.activeElement).toBe(container.querySelector("input"));
-  });
-
-  it("leaves / to a field the user types in", async () => {
-    const container = mountActions(undefined, "", "/");
-    const field = document.createElement("input");
-    document.body.append(field);
-    field.focus();
-    press("/", {}, field);
-    await settle();
-    expect(container.querySelector("input")).toBeNull();
-    expect(document.activeElement).toBe(field);
-  });
-});

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

@@ -1,33 +0,0 @@
-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"]);
-  });
-});