@antelopejs/dms 0.7.9 → 0.7.10

package/frontend-vue/tests/page-live-parity.test.ts

@@ -0,0 +1,367 @@
+// @vitest-environment jsdom
+/**
+ * The live mode beyond Live / Pause: what a pause counts (published rows, not
+ * messages), the holds a component takes with a reason, the hidden tab, the
+ * `?live=0` URL, the shared `rememberKey`, the polling while the stream is down and
+ * its slower cadence over a long period, and the remembered pause applied only
+ * once the page is mounted.
+ */
+import { createApp, defineComponent, h, nextTick, ref } from "vue";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RealtimeTopicHandler } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
+import {
+  createPageLiveController,
+  type PageLiveController,
+} from "../layers/dms-ui/app/build/composables/live/pageLiveController";
+import { setCurrentPageLive } from "../layers/dms-ui/app/build/composables/live/currentPageLive";
+import {
+  bindPageLiveEnvironment,
+  usePageLiveHost,
+} from "../layers/dms-ui/app/build/composables/live/usePageLiveHost";
+import {
+  liveIntervalMs,
+  livePeriodMs,
+} from "../layers/dms-ui/app/build/composables/live/liveCadence";
+import { MissedTally } from "../layers/dms-ui/app/build/composables/live/missedTally";
+import { usePageLive } from "../layers/dms-ui/app/composables/live/usePageLive";
+import { currentPageLive } from "../layers/dms-ui/app/build/composables/live/currentPageLive";
+
+const topicHandlers = new Map<string, RealtimeTopicHandler[]>();
+
+vi.mock("../layers/dms-core/app/composables/realtime/useRealtimeTopic", () => ({
+  useRealtimeTopic: (topic: string, handler: RealtimeTopicHandler) => {
+    topicHandlers.set(topic, [...(topicHandlers.get(topic) ?? []), handler]);
+  },
+}));
+
+const { useRefreshTriggers } = await import(
+  "../layers/dms-ui/app/build/composables/blocks/useRefreshTriggers"
+);
+
+const PAGE = "modules.api.logs";
+const TOPIC = "api:monitor:requests";
+const ROW_TOPIC = "dms:table:requests";
+const DAY_MS = 24 * 60 * 60 * 1000;
+const mounted: Array<{ unmount: () => void }> = [];
+const controllers: PageLiveController[] = [];
+
+function publish(payload?: Record<string, unknown>, topic = TOPIC) {
+  const event = { topic, type: "requests", ts: Date.now(), payload };
+  for (const handler of topicHandlers.get(topic) ?? []) handler(event);
+}
+
+function mountBlock(topic: string = TOPIC) {
+  const onRefresh = vi.fn();
+  const app = createApp(
+    defineComponent({
+      setup() {
+        useRefreshTriggers(topic, onRefresh);
+        return () => h("div");
+      },
+    }),
+  );
+  app.mount(document.createElement("div"));
+  mounted.push(app);
+  return onRefresh;
+}
+
+function install(
+  options: Parameters<typeof createPageLiveController>[1] = {},
+  start?: Parameters<typeof createPageLiveController>[2],
+  pageId = PAGE,
+): PageLiveController {
+  const controller = createPageLiveController(pageId, options, start);
+  controllers.push(controller);
+  setCurrentPageLive(controller);
+  return controller;
+}
+
+function setVisibility(state: "visible" | "hidden") {
+  Object.defineProperty(document, "visibilityState", {
+    configurable: true,
+    get: () => state,
+  });
+  document.dispatchEvent(new Event("visibilitychange"));
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  topicHandlers.clear();
+  window.localStorage.clear();
+  window.history.replaceState(null, "", "/");
+  setVisibility("visible");
+});
+
+afterEach(() => {
+  mounted.splice(0).forEach((app) => app.unmount());
+  controllers.splice(0).forEach((controller) => controller.dispose());
+  setCurrentPageLive(null);
+  vi.useRealTimers();
+});
+
+describe("the pause counter", () => {
+  // The dms-api regression: the capture publishes one message per 1.5 s with
+  // the number of requests it stands for; 40 requests over two messages read
+  // "2 new" before.
+  it("counts the requests a batch announces, not the messages", () => {
+    const live = install({ maxRate: 5 });
+    const table = mountBlock();
+    mountBlock();
+    live.pause();
+
+    publish({ count: 25, server5xx: 2, tester: 0 });
+    publish({ count: 15, server5xx: 0, tester: 1 });
+
+    expect(live.missedCount.value).toBe(40);
+    live.resume();
+    expect(table).toHaveBeenCalledTimes(1);
+  });
+
+  it("counts each published row once, across messages", () => {
+    const live = install();
+    mountBlock(ROW_TOPIC);
+    live.pause();
+
+    publish({ ids: ["a", "b", "c"] }, ROW_TOPIC);
+    publish({ ids: ["b", "d"] }, ROW_TOPIC);
+
+    expect(live.missedCount.value).toBe(4);
+  });
+
+  it("counts a message without ids nor count as one", () => {
+    const tally = new MissedTally();
+    tally.add({ topic: TOPIC, payload: { count: 0 } });
+    tally.add({ topic: TOPIC, payload: { count: 2.5 } });
+    tally.add({ topic: TOPIC });
+    tally.add(undefined);
+    expect(tally.total.value).toBe(4);
+    tally.reset();
+    expect(tally.total.value).toBe(0);
+  });
+
+  it("counts every event a pause cut short, not only the first", () => {
+    const live = install({ maxRate: 5 });
+    mountBlock();
+    publish({ count: 1 });
+    publish({ count: 3 });
+    publish({ count: 4 });
+    live.pause();
+    expect(live.missedCount.value).toBe(7);
+  });
+});
+
+describe("holds", () => {
+  it("pauses with a reason while a component holds, and resumes on release", () => {
+    const live = install();
+    const block = mountBlock();
+    const tester = usePageLive();
+
+    tester.hold("$api.live.typing_in_tester");
+    expect(live.isPaused.value).toBe(true);
+    expect(live.pauseReason.value).toEqual({
+      text: "$api.live.typing_in_tester",
+    });
+    publish({ count: 2 });
+    expect(block).not.toHaveBeenCalled();
+
+    tester.release();
+    expect(live.isPaused.value).toBe(false);
+    expect(block).toHaveBeenCalledTimes(1);
+  });
+
+  it("stays paused on release when the user paused", () => {
+    const live = install();
+    const tester = usePageLive();
+    tester.hold("typing");
+    live.pause();
+    expect(live.pauseReason.value).toBeNull();
+    tester.release();
+    expect(live.isPaused.value).toBe(true);
+  });
+
+  it("lets the user resume over a hold until it is taken anew", () => {
+    const live = install();
+    const tester = usePageLive();
+    tester.hold("typing");
+    live.resume();
+    expect(live.isPaused.value).toBe(false);
+
+    tester.hold("still typing");
+    expect(live.isPaused.value).toBe(false);
+
+    tester.release();
+    tester.hold("typing again");
+    expect(live.isPaused.value).toBe(true);
+  });
+
+  it("releases a hold when its component goes", () => {
+    const live = install();
+    const app = createApp(
+      defineComponent({
+        setup() {
+          usePageLive().hold("typing");
+          return () => h("div");
+        },
+      }),
+    );
+    app.mount(document.createElement("div"));
+    expect(live.isPaused.value).toBe(true);
+    app.unmount();
+    expect(live.isPaused.value).toBe(false);
+  });
+
+  it("keeps a module's breakdown of the missed events until resume", () => {
+    const live = install();
+    const state = usePageLive();
+    live.pause();
+    state.setMissedDetail({
+      text: "$api.live.in_5xx",
+      params: { count: 2 },
+      tone: "error",
+    });
+    expect(state.missedDetail.value?.tone).toBe("error");
+    live.resume();
+    expect(state.missedDetail.value).toBeNull();
+  });
+});
+
+describe("the browser around the page", () => {
+  it("pauses while the tab is hidden and resumes on return", () => {
+    const live = install();
+    const block = mountBlock();
+    const unbind = bindPageLiveEnvironment(live, {});
+
+    setVisibility("hidden");
+    expect(live.isPaused.value).toBe(true);
+    expect(live.pauseReason.value?.text).toBe("$dms.live.reason_hidden");
+    publish();
+
+    setVisibility("visible");
+    expect(live.isPaused.value).toBe(false);
+    expect(block).toHaveBeenCalledTimes(1);
+    unbind();
+  });
+
+  it("stays paused on return when the user had paused", () => {
+    const live = install();
+    const unbind = bindPageLiveEnvironment(live, {});
+    live.pause();
+    setVisibility("hidden");
+    setVisibility("visible");
+    expect(live.isPaused.value).toBe(true);
+    unbind();
+  });
+
+  it("opens paused with ?live=0, unremembered, and drops it on resume", async () => {
+    window.history.replaceState(null, "", "/logs?live=0&tab=5xx");
+    const { isPausedByUrl } = await import(
+      "../layers/dms-ui/app/build/composables/live/usePageLiveHost"
+    );
+    const live = install({}, { isPausedByUrl: isPausedByUrl() });
+    const unbind = bindPageLiveEnvironment(live, {});
+    expect(live.isPaused.value).toBe(true);
+    expect(window.localStorage.length).toBe(0);
+
+    live.resume();
+    await nextTick();
+    expect(window.location.search).toBe("?tab=5xx");
+    unbind();
+  });
+
+  it("shares the remembered choice between the pages of one remember key", () => {
+    install({ rememberKey: "api" }).pause();
+    expect(
+      install({ rememberKey: "api" }, {}, "modules.api.routes").isPaused.value,
+    ).toBe(true);
+    expect(install({}, {}, "modules.api.routes").isPaused.value).toBe(false);
+  });
+
+  it("applies the remembered pause only once the page is mounted", async () => {
+    window.localStorage.setItem(`dms.live.paused:${PAGE}`, "1");
+    let pausedAtSetup: boolean | undefined;
+    const app = createApp(
+      defineComponent({
+        setup() {
+          usePageLiveHost(() => ({ pageId: PAGE, live: {} }));
+          pausedAtSetup = currentPageLive()?.isPaused.value;
+          return () => h("div");
+        },
+      }),
+    );
+    app.mount(document.createElement("div"));
+    await nextTick();
+    expect(pausedAtSetup).toBe(false);
+    expect(currentPageLive()?.isPaused.value).toBe(true);
+    app.unmount();
+  });
+});
+
+describe("the cadence", () => {
+  it("polls at maxRate while the stream is down, not while paused", () => {
+    const poll = vi.fn();
+    const live = install({ maxRate: 5 }, { poll });
+    live.setStreamConnected(false);
+    expect(live.isPolling.value).toBe(true);
+
+    vi.advanceTimersByTime(5000);
+    vi.advanceTimersByTime(5000);
+    expect(poll).toHaveBeenCalledTimes(2);
+
+    live.pause();
+    vi.advanceTimersByTime(20_000);
+    expect(poll).toHaveBeenCalledTimes(2);
+
+    live.resume();
+    live.setStreamConnected(true);
+    vi.advanceTimersByTime(20_000);
+    expect(poll).toHaveBeenCalledTimes(2);
+    expect(live.isPolling.value).toBe(false);
+  });
+
+  it("does not poll a page without a cadence", () => {
+    const poll = vi.fn();
+    const live = install({}, { poll });
+    live.setStreamConnected(false);
+    vi.advanceTimersByTime(60_000);
+    expect(poll).not.toHaveBeenCalled();
+  });
+
+  it("slows down once the period shown reaches slowRateAfter", () => {
+    const options = {
+      maxRate: 5,
+      slowRateAfter: { period: "7d" as const, maxRate: 60 },
+    };
+    expect(livePeriodMs("7d")).toBe(7 * DAY_MS);
+    expect(livePeriodMs("30m")).toBe(30 * 60 * 1000);
+    expect(livePeriodMs("week")).toBeNull();
+    expect(liveIntervalMs(options, null)).toBe(5000);
+    expect(liveIntervalMs(options, DAY_MS)).toBe(5000);
+    expect(liveIntervalMs(options, 7 * DAY_MS)).toBe(60_000);
+    expect(liveIntervalMs(options, Number.POSITIVE_INFINITY)).toBe(60_000);
+
+    const poll = vi.fn();
+    const live = install(options, { poll });
+    live.reportPeriodSpan(Symbol("period"), 30 * DAY_MS);
+    live.setStreamConnected(false);
+    vi.advanceTimersByTime(59_000);
+    expect(poll).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(1000);
+    expect(poll).toHaveBeenCalledTimes(1);
+  });
+
+  it("gates a block at the slower cadence over a long period", () => {
+    const live = install({
+      maxRate: 5,
+      slowRateAfter: { period: "7d", maxRate: 60 },
+    });
+    const block = mountBlock();
+    const span = ref(7 * DAY_MS);
+    live.reportPeriodSpan(Symbol("period"), span.value);
+    publish();
+    publish();
+    vi.advanceTimersByTime(5000);
+    expect(block).toHaveBeenCalledTimes(1);
+    vi.advanceTimersByTime(55_000);
+    expect(block).toHaveBeenCalledTimes(2);
+  });
+});

package/frontend-vue/tests/page-realtime-remount.test.ts

@@ -0,0 +1,185 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  computed,
+  effectScope,
+  nextTick,
+  onScopeDispose,
+  ref,
+  toValue,
+  watch,
+  type EffectScope,
+} from "vue";
+import type { UserRealtimeApi } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
+
+const BASE_URL = "http://api";
+const USER_STREAM_URL = `${BASE_URL}/api/realtime/user`;
+const SUBSCRIBE_URL_PREFIX = `${BASE_URL}/api/realtime/subscribe/`;
+const UNSUBSCRIBE_URL = `${BASE_URL}/api/realtime/unsubscribe`;
+const PAGE_ID = "lang.translations";
+const OTHER_PAGE_ID = "lang.overview";
+const SESSION_ID = "session-1";
+
+type PageCall = () => void;
+
+interface FakeServer {
+  /** The page the server holds the session's topics for. */
+  page: string | null;
+  isHoldingCalls: boolean;
+  heldCalls: PageCall[];
+}
+
+const encoder = new TextEncoder();
+
+const openUserStream = () => {
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(
+        encoder.encode(
+          `event: hello\ndata: ${JSON.stringify({ sessionId: SESSION_ID })}\n\n`,
+        ),
+      );
+    },
+  });
+  return { ok: true, status: 200, body };
+};
+
+const applyPageCall = (server: FakeServer, url: string): void => {
+  server.page =
+    url === UNSUBSCRIBE_URL ? null : url.slice(SUBSCRIBE_URL_PREFIX.length);
+};
+
+const installFetch = (server: FakeServer): void => {
+  globalThis.fetch = vi.fn(async (url: string) => {
+    if (url === USER_STREAM_URL) return openUserStream();
+    if (!server.isHoldingCalls) {
+      applyPageCall(server, url);
+      return { ok: true, status: 200 };
+    }
+    await new Promise<void>((resolve) =>
+      server.heldCalls.push(() => {
+        applyPageCall(server, url);
+        resolve();
+      }),
+    );
+    return { ok: true, status: 200 };
+  }) as unknown as typeof fetch;
+};
+
+const settle = async (): Promise<void> => {
+  for (let round = 0; round < 5; round += 1) {
+    await vi.advanceTimersByTimeAsync(0);
+    await nextTick();
+  }
+};
+
+const realFetch = globalThis.fetch;
+let loggedIn = ref(false);
+let server: FakeServer;
+let user: UserRealtimeApi;
+let mountPage: (pageId: string) => EffectScope;
+
+const releaseHeldCalls = async (): Promise<void> => {
+  server.isHoldingCalls = false;
+  while (server.heldCalls.length) {
+    server.heldCalls.shift()!();
+    await settle();
+  }
+};
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
+  vi.stubEnv("SSR", false);
+  vi.stubGlobal("ref", ref);
+  vi.stubGlobal("watch", watch);
+  vi.stubGlobal("computed", computed);
+  vi.stubGlobal("toValue", toValue);
+  vi.stubGlobal("onScopeDispose", onScopeDispose);
+  vi.stubGlobal("useDmsState", (_key: string, init: () => unknown) =>
+    ref(init()),
+  );
+  vi.stubGlobal("useDmsRuntimeConfig", () => ({
+    public: { dms: { baseURL: BASE_URL } },
+  }));
+  vi.stubGlobal("useUserSession", () => ({ loggedIn }));
+  vi.stubGlobal("useSessionRecovery", () => ({
+    refreshSession: async () => true,
+    redirectToAuth: async () => {},
+  }));
+  server = { page: null, isHoldingCalls: false, heldCalls: [] };
+  installFetch(server);
+  loggedIn = ref(true);
+  const userModule = await import(
+    "../layers/dms-core/app/composables/realtime/useUserRealtime"
+  );
+  vi.stubGlobal("useUserRealtime", userModule.useUserRealtime);
+  const pageModule = await import(
+    "../layers/dms-core/app/composables/realtime/usePageRealtime"
+  );
+  user = userModule.useUserRealtime();
+  mountPage = (pageId) => {
+    const scope = effectScope(true);
+    scope.run(() => pageModule.usePageRealtime(pageId));
+    return scope;
+  };
+  await settle();
+});
+
+afterEach(async () => {
+  loggedIn.value = false;
+  await settle();
+  globalThis.fetch = realFetch;
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+
+describe("usePageRealtime remount at the same path", () => {
+  it("keeps the page when the new instance mounts before the old one unmounts", async () => {
+    const previous = mountPage(PAGE_ID);
+    await settle();
+    expect(server.page).toBe(PAGE_ID);
+
+    const next = mountPage(PAGE_ID);
+    previous.stop();
+    await settle();
+
+    expect(user.pageId.value).toBe(PAGE_ID);
+    expect(server.page).toBe(PAGE_ID);
+    next.stop();
+    await settle();
+    expect(server.page).toBeNull();
+  });
+
+  it("re-subscribes when the new instance mounts while the old unsubscribe is in flight", async () => {
+    const previous = mountPage(PAGE_ID);
+    await settle();
+
+    server.isHoldingCalls = true;
+    previous.stop();
+    await settle();
+    const next = mountPage(PAGE_ID);
+    await settle();
+    await releaseHeldCalls();
+
+    expect(user.pageId.value).toBe(PAGE_ID);
+    expect(server.page).toBe(PAGE_ID);
+    next.stop();
+    await settle();
+  });
+
+  it("keeps the new page when navigating away unmounts the old one last", async () => {
+    const previous = mountPage(OTHER_PAGE_ID);
+    await settle();
+
+    const next = mountPage(PAGE_ID);
+    await settle();
+    previous.stop();
+    await settle();
+
+    expect(user.pageId.value).toBe(PAGE_ID);
+    expect(server.page).toBe(PAGE_ID);
+    next.stop();
+    await settle();
+  });
+});

package/frontend-vue/tests/period-selector-parity.test.ts

@@ -0,0 +1,138 @@
+/**
+ * What a PeriodSelector offers besides its presets: every period (`all`, no
+ * bounds sent), a window labelled relative to now ("since yesterday 11:52"),
+ * and a comparison drawn as a menu, a toggle or nothing.
+ */
+import { effectScope } from "vue";
+import { describe, expect, it } from "vitest";
+import { resolvePresetRange } from "../layers/dms-core/app/composables/period/presetResolvers";
+import { resolveComparisonRange } from "../layers/dms-core/app/composables/period/compareResolvers";
+import { usePeriod } from "../layers/dms-core/app/composables/period/usePeriod";
+import { appendPeriodToUrl } from "../layers/dms-core/app/composables/period/usePeriodScope";
+import { usePeriodDraft } from "../layers/dms-ui/app/build/composables/period/usePeriodDraft";
+import { formatRelativeInstant } from "../layers/dms-ui/app/build/composables/period/periodDisplay";
+import { resolveComparisonControl } from "../layers/dms-ui/app/build/composables/period/periodComparisonControl";
+
+const NOW = new Date(2026, 9, 11, 19, 54);
+const FALLBACK = { from: new Date(2026, 0, 1), to: new Date(2026, 0, 31) };
+
+function allTimePeriod() {
+  const scope = effectScope();
+  const result = scope.run(() => {
+    const period = usePeriod({
+      defaultPreset: "all",
+      defaultComparison: "previous-period",
+      presets: ["last-24h", "all", "custom"],
+    });
+    return { period, draft: usePeriodDraft(period) };
+  });
+  if (!result) throw new Error("scope did not run");
+  return { ...result, stop: () => scope.stop() };
+}
+
+describe("every period", () => {
+  it("resolves to no bounds, and nothing to compare with", () => {
+    expect(resolvePresetRange("all", NOW, FALLBACK)).toBeNull();
+    expect(resolveComparisonRange("previous-period", null, null)).toBeNull();
+  });
+
+  it("is published with no range, and sends no from / to", () => {
+    const { period, stop } = allTimePeriod();
+    const { state } = period;
+    expect(state.value.range).toBeNull();
+    expect(state.value.compareRange).toBeNull();
+
+    const url = appendPeriodToUrl("/api/requests?route=1", state.value)!;
+    const params = new URL(url, "http://dms.local").searchParams;
+    expect(params.has("from")).toBe(false);
+    expect(params.has("to")).toBe(false);
+    expect(params.has("compareFrom")).toBe(false);
+    expect(params.get("preset")).toBe("all");
+    expect(params.get("route")).toBe("1");
+    stop();
+  });
+
+  it("starts a custom range from today in the popover", () => {
+    const { draft, stop } = allTimePeriod();
+    expect(draft.range.value).toBeNull();
+    draft.selectPreset("custom");
+    const today = new Date();
+    expect(draft.range.value!.from.getDate()).toBe(today.getDate());
+    expect(draft.range.value!.to.getHours()).toBe(23);
+    stop();
+  });
+});
+
+describe("a window labelled relative to now", () => {
+  it("gives the time alone today", () => {
+    const start = new Date(2026, 9, 11, 11, 52);
+    expect(formatRelativeInstant(start, NOW, "en-GB")).toBe("11:52");
+  });
+
+  it("says yesterday in the reader's language", () => {
+    const start = new Date(2026, 9, 10, 11, 52);
+    expect(formatRelativeInstant(start, NOW, "en-GB")).toBe("yesterday 11:52");
+    expect(formatRelativeInstant(start, NOW, "fr-FR")).toBe("hier 11:52");
+  });
+
+  it("gives the weekday within a week", () => {
+    const start = new Date(2026, 9, 7, 11, 52);
+    expect(formatRelativeInstant(start, NOW, "en-GB")).toMatch(/^Wed 11:52$/);
+  });
+
+  it("gives the date beyond a week, and its year when not this one's", () => {
+    expect(
+      formatRelativeInstant(new Date(2026, 9, 4, 11, 52), NOW, "en-US"),
+    ).toBe("Oct 4, 11:52 AM");
+    expect(
+      formatRelativeInstant(new Date(2025, 9, 4, 11, 52), NOW, "en-US"),
+    ).toContain("2025");
+  });
+});
+
+describe("the comparison control", () => {
+  it("is a menu of several comparisons by default", () => {
+    expect(resolveComparisonControl({}).control).toBe("menu");
+  });
+
+  it("is a toggle when a single comparison is offered, none accepted too", () => {
+    const resolved = resolveComparisonControl({
+      comparisons: ["previous-period"],
+    });
+    expect(resolved).toMatchObject({
+      control: "toggle",
+      toggled: "previous-period",
+      comparisons: ["none", "previous-period"],
+    });
+  });
+
+  it("toggles the default comparison when asked for a toggle among several", () => {
+    const resolved = resolveComparisonControl({
+      comparisonControl: "toggle",
+      defaultComparison: "previous-year",
+    });
+    expect(resolved.toggled).toBe("previous-year");
+  });
+
+  it("keeps the comparison on when hidden", () => {
+    const resolved = resolveComparisonControl({
+      comparisonControl: "hidden",
+      comparisons: ["previous-period"],
+    });
+    expect(resolved).toMatchObject({
+      control: "hidden",
+      toggled: null,
+      defaultComparison: "previous-period",
+      comparisons: ["previous-period"],
+    });
+  });
+
+  it("draws nothing when nothing but none is offered", () => {
+    expect(
+      resolveComparisonControl({
+        comparisons: ["none"],
+        comparisonControl: "menu",
+      }).control,
+    ).toBe("hidden");
+  });
+});