@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/dev-reload.test.ts

@@ -1,252 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  createDevReloadCoordinator,
-  type DevReloadDeps,
-} from "../layers/dms-layout/app/build/composables/dev-reload/useDevReloadHolder";
-
-/**
- * The dev-reload coordinator is the single mechanism behind both the SSE
- * `reload` handler and the `useDevReload().awaitRoute` module frontends
- * call. These tests drive the real implementation with fake dependencies and a
- * virtual clock: `delay` never waits, it just moves `now` forward, so a
- * timeout is reached in as many iterations as the real one would take.
- */
-
-interface Harness {
-  deps: DevReloadDeps;
-  /** Routes the backend serves right now. */
-  backend: Set<string>;
-  /** Routes the committed site layout serves right now. */
-  committed: Set<string>;
-  probes: number;
-  reloadingLog: boolean[];
-  commits: number;
-  derivedFor: string[];
-  clearedFor: string[];
-  /** Virtual milliseconds burnt by the coordinator's own waiting. */
-  elapsed: () => number;
-}
-
-function createHarness(
-  overrides: Partial<DevReloadDeps> & {
-    /** Probes the backend answers with "route absent" before serving it. */
-    probesBeforeServed?: number;
-  } = {},
-): Harness {
-  const { probesBeforeServed = 0, ...depOverrides } = overrides;
-  let time = 0;
-  const harness: Harness = {
-    deps: undefined as unknown as DevReloadDeps,
-    backend: new Set<string>(),
-    committed: new Set<string>(),
-    probes: 0,
-    reloadingLog: [],
-    commits: 0,
-    derivedFor: [],
-    clearedFor: [],
-    elapsed: () => time,
-  };
-
-  harness.deps = {
-    isDev: true,
-    currentPath: () => "/current",
-    isRouteKnown: (path) => harness.committed.has(path),
-    probeAndCommitRoute: (path) => {
-      harness.probes += 1;
-      if (harness.probes <= probesBeforeServed || !harness.backend.has(path)) {
-        return Promise.resolve(false);
-      }
-      harness.committed = new Set(harness.backend);
-      return Promise.resolve(true);
-    },
-    commitLayout: () => {
-      harness.commits += 1;
-      harness.committed = new Set(harness.backend);
-      return Promise.resolve();
-    },
-    refreshDerived: (path) => {
-      harness.derivedFor.push(path);
-      return Promise.resolve();
-    },
-    clearTransient404: (path) => {
-      harness.clearedFor.push(path);
-    },
-    setReloading: (value) => {
-      harness.reloadingLog.push(value);
-    },
-    now: () => time,
-    delay: async (ms) => {
-      time += ms;
-      await Promise.resolve();
-    },
-    ...depOverrides,
-  };
-
-  return harness;
-}
-
-describe("dev reload coordinator", () => {
-  let harness: Harness;
-
-  beforeEach(() => {
-    vi.spyOn(console, "warn").mockImplementation(() => {});
-    vi.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  describe("awaitRoute", () => {
-    it("answers from the committed layout without probing the backend", async () => {
-      harness = createHarness();
-      harness.committed.add("/pages/a");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(coordinator.awaitRoute("/pages/a")).resolves.toBe(true);
-      // Nothing to wait for: no fetch, and no reload flag raised for a
-      // no-op — the reload must stay invisible.
-      expect(harness.probes).toBe(0);
-      expect(harness.reloadingLog).toEqual([]);
-    });
-
-    it("holds until the re-registering backend serves the route", async () => {
-      harness = createHarness({ probesBeforeServed: 3 });
-      harness.backend.add("/pages/new");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(coordinator.awaitRoute("/pages/new")).resolves.toBe(true);
-      expect(harness.probes).toBe(4);
-      expect(harness.committed.has("/pages/new")).toBe(true);
-      // The layout is committed by the probe itself, so the route the caller
-      // asked for is the one that got validated.
-      expect(harness.commits).toBe(0);
-    });
-
-    it("resolves false when the route never comes back", async () => {
-      harness = createHarness();
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(coordinator.awaitRoute("/pages/gone")).resolves.toBe(false);
-      // Timing out still commits whatever the backend has now, so a genuinely
-      // deleted page reaches the renderer and 404s there.
-      expect(harness.commits).toBe(1);
-      expect(harness.clearedFor).toEqual([]);
-    });
-
-    it("honours a caller-supplied timeout", async () => {
-      harness = createHarness();
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(
-        coordinator.awaitRoute("/pages/gone", { timeoutMs: 600 }),
-      ).resolves.toBe(false);
-      expect(harness.elapsed()).toBeLessThan(1000);
-    });
-
-    it("joins an in-flight refresh instead of racing a second fetch loop", async () => {
-      harness = createHarness({ probesBeforeServed: 4 });
-      harness.backend.add("/current");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      const refresh = coordinator.requestRefresh("/current");
-      const waited = coordinator.awaitRoute("/current");
-
-      await expect(waited).resolves.toBe(true);
-      await refresh;
-      // One loop, not two: the probe count is the one the SSE refresh needed.
-      expect(harness.probes).toBe(5);
-    });
-
-    it("clears the transient 404 once the route is committed", async () => {
-      harness = createHarness({ probesBeforeServed: 1 });
-      harness.backend.add("/current");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await coordinator.awaitRoute("/current");
-      expect(harness.clearedFor).toEqual(["/current"]);
-    });
-  });
-
-  describe("awaitRoute outside dev", () => {
-    it("never probes and only reads the committed layout", async () => {
-      harness = createHarness({ isDev: false });
-      harness.backend.add("/pages/a");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(coordinator.awaitRoute("/pages/a")).resolves.toBe(false);
-      expect(harness.probes).toBe(0);
-      expect(harness.commits).toBe(0);
-      expect(harness.reloadingLog).toEqual([]);
-    });
-
-    it("resolves true when a refresh driven elsewhere commits the route", async () => {
-      harness = createHarness({ isDev: false });
-      const coordinator = createDevReloadCoordinator(harness.deps);
-      let reads = 0;
-      harness.deps.isRouteKnown = (path) => {
-        reads += 1;
-        return reads > 3 && path === "/pages/a";
-      };
-
-      await expect(coordinator.awaitRoute("/pages/a")).resolves.toBe(true);
-    });
-
-    it("caps the wait well short of the dev timeout", async () => {
-      harness = createHarness({ isDev: false });
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(
-        coordinator.awaitRoute("/pages/a", { timeoutMs: 60000 }),
-      ).resolves.toBe(false);
-      expect(harness.elapsed()).toBeLessThan(3000);
-    });
-  });
-
-  describe("requestRefresh", () => {
-    it("coalesces a burst into a single trailing re-run on the current route", async () => {
-      harness = createHarness();
-      harness.backend.add("/pages/a");
-      harness.backend.add("/current");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      const first = coordinator.requestRefresh("/pages/a");
-      const second = coordinator.requestRefresh("/pages/a");
-      expect(second).toBe(first);
-      coordinator.requestRefresh("/pages/a");
-
-      await coordinator.settled();
-      // Two passes for three events, and the trailing one re-reads the route
-      // the user is on rather than the stale path captured at burst time.
-      expect(harness.derivedFor).toEqual(["/pages/a", "/current"]);
-    });
-
-    it("keeps the reload flag raised across the trailing re-run", async () => {
-      harness = createHarness();
-      harness.backend.add("/current");
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      const first = coordinator.requestRefresh("/current");
-      coordinator.requestRefresh("/current");
-      await first;
-      await coordinator.settled();
-
-      // Never lowered between the two passes: a flicker there would let the
-      // renderer raise the 404 the reload is about to fix.
-      expect(harness.reloadingLog).toEqual([true, true, false]);
-    });
-
-    it("lowers the reload flag when a pass throws", async () => {
-      harness = createHarness({
-        commitLayout: () => Promise.reject(new Error("backend down")),
-      });
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(coordinator.requestRefresh("/pages/a")).resolves.toBe(false);
-      expect(harness.reloadingLog).toEqual([true, false]);
-    });
-
-    it("settles immediately when nothing is in flight", async () => {
-      harness = createHarness();
-      const coordinator = createDevReloadCoordinator(harness.deps);
-
-      await expect(coordinator.settled()).resolves.toBeUndefined();
-    });
-  });
-});

package/frontend-vue/tests/download-action-target.test.ts

@@ -1,172 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A `download` action target fetches its file with the user's session and
- * saves it: its URL and file name take the page's `{{params.X}}` /
- * `{{query.X}}` and the row's `{field}`, and a refusal is toasted.
- */
-import { createApp, defineComponent, h, reactive, type App } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useActionTargets } from "../layers/dms-ui/app/build/composables/actions/useActionTargets";
-import { interpolateUrl } from "../layers/dms-core/app/utils/url-interpolation";
-import type { CustomButton } from "../layers/dms-ui/app/composables/table-view/types/custom-button";
-import type { CustomRowAction } from "../layers/dms-ui/app/types/row-action";
-
-const route = reactive<{ path: string; query: Record<string, unknown> }>({
-  path: "/modules/lang/queue/de",
-  query: {},
-});
-const fetchRaw = vi.fn();
-const handleApiError = vi.fn();
-const saved: string[] = [];
-let app: App | undefined;
-
-function mountTargets() {
-  let targets: ReturnType<typeof useActionTargets> | undefined;
-  app = createApp(
-    defineComponent({
-      setup() {
-        targets = useActionTargets({
-          api: vi.fn() as never,
-          pageId: "queue-page",
-          componentId: "page-header",
-          handleApiError,
-        });
-        return () => h("div");
-      },
-    }),
-  );
-  app.mount(document.createElement("div"));
-  return targets!;
-}
-
-const downloadButton = (filename?: string): CustomButton => ({
-  id: "download-language",
-  label: "Download",
-  target: {
-    type: "download",
-    url: "/api/lang/translations/export?workspace={{query.workspace}}&locale={{query.locale}}",
-    filename,
-  },
-});
-
-const served = (disposition?: string) =>
-  fetchRaw.mockResolvedValue({
-    _data: new Blob(["{}"]),
-    headers: new Headers(
-      disposition ? { "content-disposition": disposition } : {},
-    ),
-  });
-
-beforeEach(() => {
-  route.query = { workspace: "web", locale: "pt BR" };
-  fetchRaw.mockReset();
-  handleApiError.mockReset();
-  saved.length = 0;
-  vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (text: string) => text,
-    processApiMessage: (text: string) => text,
-  }));
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useModal", () => ({ open: vi.fn() }));
-  vi.stubGlobal("useDrawer", () => ({ open: vi.fn() }));
-  vi.stubGlobal("useExportJob", () => ({ runJob: vi.fn() }));
-  vi.stubGlobal("useConfirm", () => ({ confirm: vi.fn(async () => true) }));
-  vi.stubGlobal("useAuthFetch", () => ({
-    $authFetch: Object.assign(vi.fn(), { raw: fetchRaw }),
-  }));
-  vi.stubGlobal("interpolateUrl", interpolateUrl);
-  vi.stubGlobal("useDmsRoute", () => route);
-  vi.stubGlobal("useSiteLayout", () => ({
-    findMatchingRoute: () => ({ params: { locale: "de" } }),
-  }));
-  vi.stubGlobal(
-    "URL",
-    Object.assign(URL, {
-      createObjectURL: vi.fn(() => "blob:file"),
-      revokeObjectURL: vi.fn(),
-    }),
-  );
-  vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(function (
-    this: HTMLAnchorElement,
-  ) {
-    saved.push(this.download);
-  });
-});
-
-afterEach(() => {
-  app?.unmount();
-  app = undefined;
-  vi.restoreAllMocks();
-  vi.unstubAllGlobals();
-});
-
-describe("a download action target", () => {
-  it("fetches the page's file with the session, under the declared name", async () => {
-    served('attachment; filename="served.json"');
-    mountTargets().handleCustomButton(downloadButton("{{query.locale}}.json"));
-    await vi.waitFor(() => expect(saved).toEqual(["pt BR.json"]));
-    expect(fetchRaw).toHaveBeenCalledWith(
-      "/api/lang/translations/export?workspace=web&locale=pt%20BR",
-      { responseType: "blob" },
-    );
-  });
-
-  it("leaves out a query pair the page has no value for", async () => {
-    route.query = { locale: "fr" };
-    served();
-    mountTargets().handleCustomButton(downloadButton());
-    await vi.waitFor(() => expect(saved).toHaveLength(1));
-    expect(fetchRaw).toHaveBeenCalledWith(
-      "/api/lang/translations/export?locale=fr",
-      { responseType: "blob" },
-    );
-  });
-
-  it("is saved under the server's name, else the URL's, without one declared", async () => {
-    served('attachment; filename="fr.json"');
-    mountTargets().handleCustomButton(downloadButton());
-    await vi.waitFor(() => expect(saved).toEqual(["fr.json"]));
-
-    served();
-    mountTargets().handleCustomButton(downloadButton());
-    await vi.waitFor(() => expect(saved).toEqual(["fr.json", "export"]));
-  });
-
-  it("falls back to the server's name while a name token has no value", async () => {
-    route.query = { workspace: "web" };
-    served('attachment; filename="web.json"');
-    mountTargets().handleCustomButton(downloadButton("{{query.locale}}.json"));
-    await vi.waitFor(() => expect(saved).toEqual(["web.json"]));
-  });
-
-  it("fills a row action's URL and name with the row's fields", async () => {
-    served();
-    const action: CustomRowAction = {
-      label: "Download",
-      target: {
-        type: "download",
-        url: "/api/files/{{row._id}}?workspace={{query.workspace}}",
-        filename: "{{row.name}}",
-      },
-    };
-    mountTargets().handleCustomRowAction(action, {
-      _id: "f 1",
-      name: "report.csv",
-    });
-    await vi.waitFor(() => expect(saved).toEqual(["report.csv"]));
-    expect(fetchRaw).toHaveBeenCalledWith("/api/files/f%201?workspace=web", {
-      responseType: "blob",
-    });
-  });
-
-  it("toasts a refused download under the button's label", async () => {
-    const refusal = new Error("Forbidden");
-    fetchRaw.mockRejectedValue(refusal);
-    mountTargets().handleCustomButton(downloadButton());
-    await vi.waitFor(() =>
-      expect(handleApiError).toHaveBeenCalledWith(refusal, "Download"),
-    );
-    expect(saved).toEqual([]);
-  });
-});

package/frontend-vue/tests/drawer-target-direction.test.ts

@@ -1,206 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  provide,
-  reactive,
-  ref,
-  watch,
-  type App,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useActionTargets } from "../layers/dms-ui/app/build/composables/actions/useActionTargets";
-import type { ActionTarget } from "../layers/dms-ui/app/composables/table-view/types/action-target";
-
-vi.mock("reka-ui", () => {
-  const passThrough = defineComponent({
-    setup: (_props, { slots }) => () => h("div", slots.default?.()),
-  });
-  return {
-    DialogTitle: passThrough,
-    DialogDescription: passThrough,
-    VisuallyHidden: passThrough,
-  };
-});
-
-let app: App | undefined;
-let host: HTMLDivElement;
-
-beforeEach(() => {
-  host = document.createElement("div");
-  document.body.append(host);
-});
-
-afterEach(() => {
-  app?.unmount();
-  app = undefined;
-  host.remove();
-  vi.unstubAllGlobals();
-});
-
-describe("a drawer action target's direction", () => {
-  const opened: Array<Record<string, unknown>> = [];
-
-  const mountTargets = () => {
-    let targets: ReturnType<typeof useActionTargets> | undefined;
-    app = createApp(
-      defineComponent({
-        setup() {
-          targets = useActionTargets({
-            api: vi.fn() as never,
-            pageId: "page",
-            componentId: "table",
-            handleApiError: vi.fn(),
-          });
-          return () => h("div");
-        },
-      }),
-    );
-    app.mount(host);
-    return targets!;
-  };
-
-  const drawerTarget = (
-    direction?: "right" | "left" | "top" | "bottom",
-  ): ActionTarget => ({
-    type: "drawer",
-    component: { componentName: "Inspector" },
-    ...(direction && { direction }),
-  });
-
-  beforeEach(() => {
-    opened.length = 0;
-    vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
-    vi.stubGlobal("useTranslation", () => ({
-      processI18n: (text: string) => text,
-      processApiMessage: (text: string) => text,
-    }));
-    vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-    vi.stubGlobal("useModal", () => ({ open: vi.fn() }));
-    vi.stubGlobal("useDrawer", () => ({
-      open: (options: Record<string, unknown>) => {
-        opened.push(options);
-        return {
-          result: new Promise(() => {}),
-          close: vi.fn(),
-          patch: vi.fn(),
-        };
-      },
-    }));
-    vi.stubGlobal("useExportJob", () => ({ runJob: vi.fn() }));
-    vi.stubGlobal("useConfirm", () => ({ confirm: vi.fn(async () => true) }));
-    vi.stubGlobal("useAuthFetch", () => ({ $authFetch: vi.fn() }));
-    vi.stubGlobal("resolveDmsComponent", () =>
-      defineComponent({ render: () => null }),
-    );
-  });
-
-  it("opens a toolbar or header button's drawer from the edge it names", async () => {
-    const targets = mountTargets();
-    targets.handleCustomButton({
-      label: "Inspect",
-      target: drawerTarget("right"),
-    });
-    await vi.waitFor(() => expect(opened).toHaveLength(1));
-    expect(opened[0]!.direction).toBe("right");
-  });
-
-  it("opens a row action's drawer from the edge it names", async () => {
-    const targets = mountTargets();
-    targets.handleCustomRowAction(
-      { label: "Inspect", target: drawerTarget("left") },
-      { _id: "r1" },
-    );
-    await vi.waitFor(() => expect(opened).toHaveLength(1));
-    expect(opened[0]!.direction).toBe("left");
-  });
-
-  it("leaves the direction to the drawer when the target names none", async () => {
-    const targets = mountTargets();
-    targets.handleCustomButton({ label: "Inspect", target: drawerTarget() });
-    await vi.waitFor(() => expect(opened).toHaveLength(1));
-    expect(opened[0]!.direction).toBe(undefined);
-  });
-});
-
-describe("the drawer container", () => {
-  interface DrawerStubProps {
-    direction?: string;
-    ui?: Record<string, string>;
-  }
-
-  const rendered = reactive<DrawerStubProps>({});
-
-  const mountDrawer = async (props: Record<string, unknown>) => {
-    const { default: DynamicDrawer } = await import(
-      "../layers/dms-ui/app/build/components/containers/drawer/DynamicDrawer.vue"
-    );
-    app = createApp({
-      setup: () => () =>
-        h(DynamicDrawer, {
-          title: "Inspector",
-          containerId: "drawer-1",
-          component: defineComponent({ render: () => null }),
-          ...props,
-        }),
-    });
-    app.component(
-      "UDrawer",
-      defineComponent({
-        props: { direction: String, ui: Object },
-        setup(stubProps, { slots }) {
-          return () => {
-            Object.assign(rendered, stubProps);
-            return h("div", [slots.header?.(), slots.body?.()]);
-          };
-        },
-      }),
-    );
-    app.component(
-      "UContainer",
-      defineComponent({
-        setup: (_props, { slots }) => () =>
-          h("div", { "data-container": "" }, slots.default?.()),
-      }),
-    );
-    app.component("UButton", () => h("button"));
-    app.component("USkeleton", () => h("span"));
-    app.mount(host);
-    await nextTick();
-  };
-
-  beforeEach(() => {
-    rendered.direction = undefined;
-    rendered.ui = undefined;
-    vi.stubGlobal("ref", ref);
-    vi.stubGlobal("computed", computed);
-    vi.stubGlobal("watch", watch);
-    vi.stubGlobal("provide", provide);
-    vi.stubGlobal("useLeaveGuard", () => ({
-      executeGuards: async () => true,
-      clearGuards: vi.fn(),
-    }));
-    vi.stubGlobal("useDmsRoute", () => reactive({ path: "/" }));
-    vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  });
-
-  it("slides in from the bottom, full width, by default", async () => {
-    await mountDrawer({});
-    expect(rendered.direction).toBe("bottom");
-    expect(rendered.ui?.content).toBe(undefined);
-    const containers = host.querySelectorAll("[data-container]");
-    expect(containers[0]!.className).toContain("max-sm:px-0");
-    expect(containers[0]!.className).not.toContain("lg:px-0");
-  });
-
-  it("is a side sheet as wide as a side panel from the right", async () => {
-    await mountDrawer({ direction: "right" });
-    expect(rendered.direction).toBe("right");
-    expect(rendered.ui?.content).toBe("w-[440px]");
-    const containers = host.querySelectorAll("[data-container]");
-    expect(containers[0]!.className).toContain("px-0 sm:px-0 lg:px-0");
-  });
-});