@antelopejs/dms 0.9.2 → 0.9.4

package/frontend-vue/tests/block-not-found.test.ts

@@ -1,234 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A data block whose source answers 404 shows what it reads does not exist:
- * a translated not-found state (the server's message or `emptyState` over
- * it), never "Check your connection" with a retry, and never the values it
- * showed for the record it read before.
- */
-import {
-  type Component,
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  reactive,
-  ref,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useRealDataEngine } from "./fixtures/dataEngine";
-import { readFetchNotFound } from "../layers/dms-ui/app/build/utils/fetchNotFound";
-
-interface FetchFailure extends Error {
-  statusCode?: number;
-  data?: unknown;
-}
-
-const route = reactive<{ query: Record<string, unknown> }>({ query: {} });
-const answers = new Map<string, unknown>();
-
-function failure(statusCode: number, data?: unknown): FetchFailure {
-  return Object.assign(new Error(`${statusCode}`), {
-    name: "FetchError",
-    statusCode,
-    data,
-  });
-}
-
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: async (url: string) => {
-    const answer = answers.get(url);
-    if (answer instanceof Error) throw answer;
-    return answer;
-  },
-}));
-vi.stubGlobal("useDmsRoute", () => route);
-
-vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
-  useWatch: () => ({ state: ref({}) }),
-}));
-vi.mock(
-  "../layers/dms-core/app/composables/components/useComponentEvent",
-  () => ({ useComponentEvent: () => ({}) }),
-);
-
-const { useChartFetch } = await import(
-  "../layers/dms-ui/app/composables/chart/useChartFetch"
-);
-const { useBlockItems } = await import(
-  "../layers/dms-ui/app/build/composables/blocks/useBlockItems"
-);
-const { default: BlockStatus } = await import(
-  "../layers/dms-ui/app/build/components/blocks/BlockStatus.vue"
-);
-
-// useChartFetch debounces every refresh past the first by 180ms.
-const SETTLE_MS = 250;
-const settle = () => new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
-const URL = "/api/kpis?workspace={{query.workspace}}";
-
-const mounted: Array<{ unmount: () => void }> = [];
-
-// Runs a composable inside a component's setup.
-const Probe = defineComponent({
-  props: { run: { type: Function, required: true } },
-  setup(props) {
-    props.run();
-    return () => h("div");
-  },
-});
-
-const probe = (run: () => void) => mount({ render: () => h(Probe, { run }) });
-
-function mount(component: Component): HTMLElement {
-  const app = createApp(component);
-  for (const name of ["UIcon", "UButton", "DmsLink"]) {
-    app.component(name, (props: Record<string, unknown>) =>
-      h("i", { "data-stub": name, "data-label": props.label }),
-    );
-  }
-  const host = document.createElement("div");
-  app.mount(host);
-  mounted.push(app);
-  return host;
-}
-
-beforeEach(() => useRealDataEngine());
-
-beforeEach(() => {
-  answers.clear();
-  route.query = { workspace: "web" };
-  answers.set("/api/kpis?workspace=web", { items: [{ label: "web" }] });
-  answers.set(
-    "/api/kpis?workspace=gone",
-    failure(404, { code: "unknown_workspace", message: "No such workspace" }),
-  );
-  answers.set("/api/kpis?workspace=down", failure(500));
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("useI18n", () => ({
-    t: (key: string) => `t(${key})`,
-    locale: ref("en"),
-  }));
-  vi.stubGlobal("useTranslation", () => ({
-    processI18n: (text: string) => (text.startsWith("$") ? `t(${text})` : text),
-  }));
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-});
-
-async function switchWorkspace(workspace: string) {
-  route.query = { workspace };
-  await nextTick();
-  await settle();
-}
-
-describe("readFetchNotFound", () => {
-  it("reads a 404's message and emptyState", () => {
-    expect(
-      readFetchNotFound(
-        failure(404, { message: "Gone", emptyState: { title: "$x.y" } }),
-      ),
-    ).toEqual({ message: "Gone", emptyState: { title: "$x.y" } });
-  });
-
-  it("is null for any other failure", () => {
-    expect(readFetchNotFound(failure(500))).toBeNull();
-    expect(readFetchNotFound(new TypeError("Failed to fetch"))).toBeNull();
-    expect(readFetchNotFound(null)).toBeNull();
-  });
-});
-
-describe("useChartFetch on a 404", () => {
-  function mountFetch() {
-    const state: Partial<ReturnType<typeof useChartFetch<unknown>>> = {};
-    probe(() =>
-      Object.assign(state, useChartFetch<unknown>({ fetchUrl: URL })),
-    );
-    return state;
-  }
-
-  it("drops the values of the record it read before", async () => {
-    const state = mountFetch();
-    await settle();
-    expect(state.data?.value).toEqual({ items: [{ label: "web" }] });
-    await switchWorkspace("gone");
-    expect(state.data?.value).toBeNull();
-    expect(readFetchNotFound(state.error?.value)?.message).toBe(
-      "No such workspace",
-    );
-  });
-
-  it("keeps them when a read of the same request fails otherwise", async () => {
-    const state = mountFetch();
-    await settle();
-    answers.set("/api/kpis?workspace=web", failure(500));
-    await state.refresh?.();
-    await settle();
-    expect(state.data?.value).toEqual({ items: [{ label: "web" }] });
-  });
-
-  it("never shows a record's values for another request that failed", async () => {
-    // They belong to another workspace: the card shows its failure instead.
-    const state = mountFetch();
-    await settle();
-    await switchWorkspace("down");
-    expect(state.data?.value).toBeNull();
-    expect(state.error?.value).toBeTruthy();
-  });
-});
-
-describe("useBlockItems on a 404", () => {
-  it("reports not found, not a load error, and lists nothing", async () => {
-    const state: Partial<ReturnType<typeof useBlockItems<unknown>>> = {};
-    probe(() =>
-      Object.assign(
-        state,
-        useBlockItems<unknown>({ items: () => [], fetchUrl: URL }),
-      ),
-    );
-    await settle();
-    await switchWorkspace("gone");
-    expect(state.items?.value).toEqual([]);
-    expect(state.hasError?.value).toBe(false);
-    expect(state.notFound?.value?.message).toBe("No such workspace");
-    // Nothing left on screen to keep: the next failure is a load error.
-    await switchWorkspace("down");
-    expect(state.notFound?.value).toBeNull();
-    expect(state.hasError?.value).toBe(true);
-  });
-});
-
-describe("BlockStatus not-found", () => {
-  const render = (notFound: unknown) =>
-    mount({
-      render: () => h(BlockStatus, { state: "not-found", notFound }),
-    }).textContent;
-
-  it("says so in the user's language, with no retry", () => {
-    const text = render({});
-    expect(text).toContain("t(dms.blocks.not_found)");
-    expect(text).toContain("t(dms.blocks.not_found_hint)");
-    expect(text).not.toContain("load_error");
-  });
-
-  it("describes it with the server's message", () => {
-    expect(render({ message: "No such workspace" })).toContain(
-      "No such workspace",
-    );
-  });
-
-  it("lays the server's emptyState over it", () => {
-    const text = render({
-      message: "No such workspace",
-      emptyState: {
-        title: "$lang.unknown_title",
-        description: "$lang.unknown_hint",
-      },
-    });
-    expect(text).toContain("t($lang.unknown_title)");
-    expect(text).toContain("t($lang.unknown_hint)");
-    expect(text).not.toContain("No such workspace");
-  });
-});

package/frontend-vue/tests/block-page-refresh.test.ts

@@ -1,131 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Once an action changes the record a page shows, its data blocks read their
- * data again in place: `refreshPageBlocks()` (or the `REFRESH_PAGE` watch
- * function a form names) re-fetches every mounted block, keeps what it shows
- * until the answer lands, and leaves an unmounted block alone.
- */
-import { createApp, defineComponent, h, ref } from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { useRealDataEngine } from "./fixtures/dataEngine";
-import {
-  BlockFunctions,
-  refreshPageBlocks,
-} from "../layers/dms-ui/app/utils/blockRefresh";
-
-const requests: string[] = [];
-let answer = 1;
-
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: async (url: string) => {
-    requests.push(url);
-    return { value: answer };
-  },
-}));
-vi.stubGlobal("useDmsRoute", () => ({ query: {} }));
-vi.stubGlobal("ref", ref);
-
-const { useChartFetch } = await import(
-  "../layers/dms-ui/app/composables/chart/useChartFetch"
-);
-const { useDefinedFunctions } = await import(
-  "../layers/dms-core/app/composables/functions/useDefinedFunction"
-);
-vi.stubGlobal("useDefinedFunctions", useDefinedFunctions);
-const { registerBlockFunctions } = await import(
-  "../layers/dms-ui/app/build/composables/blocks/registerBlockFunctions"
-);
-
-// useChartFetch debounces every refresh past the first by 180ms.
-const SETTLE_MS = 250;
-const settle = () => new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
-
-interface Probe {
-  data?: { value: { value: number } | null };
-  isLoading?: { value: boolean };
-}
-
-function mountBlock(fetchUrl: string) {
-  const probe: Probe = {};
-  const Block = defineComponent({
-    setup() {
-      const { data, isLoading } = useChartFetch<{ value: number }>({
-        fetchUrl,
-        routeParams: () => ({ id: "ws-1" }),
-      });
-      probe.data = data;
-      probe.isLoading = isLoading;
-      return () => h("div");
-    },
-  });
-  const app = createApp(Block);
-  app.mount(document.createElement("div"));
-  return { probe, unmount: () => app.unmount() };
-}
-
-const apps: Array<() => void> = [];
-
-beforeEach(() => useRealDataEngine());
-
-beforeEach(() => {
-  requests.length = 0;
-  answer = 1;
-});
-
-afterEach(() => {
-  apps.splice(0).forEach((unmount) => unmount());
-});
-
-it("re-fetches every mounted block, keeping its values until the answer", async () => {
-  const facts = mountBlock("/api/ws/{{params.id}}/facts");
-  const counts = mountBlock("/api/ws/{{params.id}}/tab-counts");
-  apps.push(facts.unmount, counts.unmount);
-  await settle();
-  expect(requests).toEqual(["/api/ws/ws-1/facts", "/api/ws/ws-1/tab-counts"]);
-
-  answer = 2;
-  refreshPageBlocks();
-  expect(facts.probe.isLoading?.value).toBe(false);
-  expect(facts.probe.data?.value).toEqual({ value: 1 });
-  await settle();
-
-  expect(requests).toEqual([
-    "/api/ws/ws-1/facts",
-    "/api/ws/ws-1/tab-counts",
-    "/api/ws/ws-1/facts",
-    "/api/ws/ws-1/tab-counts",
-  ]);
-  expect(facts.probe.data?.value).toEqual({ value: 2 });
-});
-
-it("leaves an unmounted block alone", async () => {
-  const block = mountBlock("/api/ws/{{params.id}}/facts");
-  await settle();
-  block.unmount();
-  refreshPageBlocks();
-  await settle();
-  expect(requests).toEqual(["/api/ws/ws-1/facts"]);
-});
-
-it("does not request a URL whose token is unresolved", async () => {
-  const block = mountBlock("/api/ws/{{params.workspace}}/facts");
-  apps.push(block.unmount);
-  refreshPageBlocks();
-  await settle();
-  expect(requests).toEqual([]);
-});
-
-it("runs from the REFRESH_PAGE watch function", async () => {
-  registerBlockFunctions();
-  const block = mountBlock("/api/ws/{{params.id}}/facts");
-  apps.push(block.unmount);
-  await settle();
-
-  const refresh = useDefinedFunctions().getFunction(
-    BlockFunctions.REFRESH_PAGE,
-  );
-  expect(refresh).toBeTypeOf("function");
-  refresh?.();
-  await settle();
-  expect(requests).toEqual(["/api/ws/ws-1/facts", "/api/ws/ws-1/facts"]);
-});

package/frontend-vue/tests/block-route-params.test.ts

@@ -1,241 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A data block on a detail page reads the record of that page: the
- * `{{params.X}}` / `{{query.X}}` tokens of its `fetchUrl` are filled from the
- * page URL, again when it changes, and a URL with a token left unresolved is
- * never requested.
- */
-import {
-  type Component,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  reactive,
-  ref,
-} from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useRealDataEngine } from "./fixtures/dataEngine";
-import {
-  replaceUrlVariables,
-  resolveTextVariables,
-  resolveUrlVariables,
-} from "../layers/dms-ui/app/build/utils/urlVariables";
-
-const requests: string[] = [];
-const route = reactive<{ query: Record<string, unknown> }>({ query: {} });
-
-vi.stubGlobal("useAuthFetch", () => ({
-  $authFetch: async (url: string) => {
-    requests.push(url);
-    return { items: [{ label: url }] };
-  },
-}));
-vi.stubGlobal("useDmsRoute", () => route);
-
-vi.mock("../layers/dms-core/app/composables/watch/useWatch", () => ({
-  useWatch: () => ({ state: ref({}) }),
-}));
-vi.mock(
-  "../layers/dms-core/app/composables/components/useComponentEvent",
-  () => ({ useComponentEvent: () => ({}) }),
-);
-
-const { useChartFetch } = await import(
-  "../layers/dms-ui/app/composables/chart/useChartFetch"
-);
-const { useBlockItems } = await import(
-  "../layers/dms-ui/app/build/composables/blocks/useBlockItems"
-);
-
-// useChartFetch debounces every refresh past the first by 180ms.
-const SETTLE_MS = 250;
-const settle = () => new Promise((resolve) => setTimeout(resolve, SETTLE_MS));
-
-const mounted: Array<{ unmount: () => void }> = [];
-
-function mount(component: Component) {
-  const app = createApp(component);
-  app.mount(document.createElement("div"));
-  mounted.push(app);
-}
-
-beforeEach(() => useRealDataEngine());
-
-beforeEach(() => {
-  requests.length = 0;
-  route.query = {};
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-});
-
-describe("resolveUrlVariables", () => {
-  it("fills route parameters and query values", () => {
-    expect(
-      resolveUrlVariables("/api/ws/{{params.id}}/facts?tab={{query.tab}}", {
-        routeParams: { id: "ws-1" },
-        routeQuery: { tab: "billing" },
-      }),
-    ).toBe("/api/ws/ws-1/facts?tab=billing");
-  });
-
-  it("reaches one occurrence of a repeated parameter", () => {
-    expect(
-      resolveUrlVariables("/api/ws/{{params.id:1}}/rows/{{params.id}}", {
-        routeParams: { id: "row-7", "id:1": "ws-1", "id:2": "row-7" },
-        routeQuery: {},
-      }),
-    ).toBe("/api/ws/ws-1/rows/row-7");
-  });
-
-  it("gives nothing while a token has no value", () => {
-    const context = { routeParams: {}, routeQuery: {} };
-    expect(resolveUrlVariables("/api/ws/{{params.id}}", context)).toBe(
-      undefined,
-    );
-    expect(replaceUrlVariables("/api/ws/{{params.id}}", context)).toBe(
-      "/api/ws/{{params.id}}",
-    );
-  });
-
-  it("encodes the values it fills, so each stays one parameter", () => {
-    expect(
-      resolveUrlVariables("/api/log/{{params.id}}?route={{query.route}}", {
-        routeParams: { id: "a b" },
-        routeQuery: { route: "GET /api/a?b=c&d" },
-      }),
-    ).toBe("/api/log/a%20b?route=GET%20%2Fapi%2Fa%3Fb%3Dc%26d");
-  });
-
-  // The router keeps the page path percent-encoded, and route parameters are
-  // read from it.
-  it("does not encode a route parameter twice", () => {
-    expect(
-      replaceUrlVariables("/api/ws/{{params.id}}", {
-        routeParams: { id: "caf%C3%A9%20bar" },
-        routeQuery: {},
-      }),
-    ).toBe("/api/ws/caf%C3%A9%20bar");
-    expect(
-      replaceUrlVariables("/api/ws/{{params.id}}", {
-        routeParams: { id: "100%" },
-        routeQuery: {},
-      }),
-    ).toBe("/api/ws/100%25");
-  });
-
-  it("writes response values as answered", () => {
-    expect(
-      replaceUrlVariables("{{response.redirectPath}}&tab={{query.tab}}", {
-        routeQuery: { tab: "a&b" },
-        response: { redirectPath: "/settings/users?invited=1" },
-      }),
-    ).toBe("/settings/users?invited=1&tab=a%26b");
-  });
-
-  it("fills a plain value without encoding it", () => {
-    expect(
-      resolveTextVariables("{{query.status}} / {{params.id}}", {
-        routeParams: { id: "ws-1" },
-        routeQuery: { status: "on hold" },
-      }),
-    ).toBe("on hold / ws-1");
-    expect(resolveTextVariables("{{query.status}}", { routeQuery: {} })).toBe(
-      undefined,
-    );
-  });
-
-  it("leaves a URL without tokens as it is", () => {
-    expect(resolveUrlVariables("/api/plain", { routeQuery: {} })).toBe(
-      "/api/plain",
-    );
-  });
-});
-
-describe("useChartFetch with a templated fetchUrl", () => {
-  function mountFetch(
-    fetchUrl: string,
-    routeParams: () => Record<string, string> | undefined,
-  ) {
-    const state: { isLoading?: { value: boolean } } = {};
-    const Probe = defineComponent({
-      setup() {
-        const { isLoading } = useChartFetch<unknown>({ fetchUrl, routeParams });
-        state.isLoading = isLoading;
-        return () => h("div");
-      },
-    });
-    mount(Probe);
-    return state;
-  }
-
-  it("requests the URL of the page's record", async () => {
-    mountFetch("/api/ws/{{params.id}}/facts", () => ({ id: "ws-1" }));
-    await settle();
-    expect(requests).toEqual(["/api/ws/ws-1/facts"]);
-  });
-
-  it("requests nothing, and shows no skeleton, while a token is unresolved", async () => {
-    const state = mountFetch("/api/ws/{{params.id}}/facts", () => ({}));
-    await settle();
-    expect(requests).toEqual([]);
-    expect(state.isLoading?.value).toBe(false);
-  });
-
-  it("follows the route to another record", async () => {
-    const params = ref<Record<string, string>>({ id: "ws-1" });
-    mountFetch("/api/ws/{{params.id}}/facts", () => params.value);
-    await settle();
-    params.value = { id: "ws-2" };
-    await nextTick();
-    await settle();
-    expect(requests).toEqual(["/api/ws/ws-1/facts", "/api/ws/ws-2/facts"]);
-  });
-
-  it("fetches once a query value it waited for appears", async () => {
-    mountFetch("/api/activity?actor={{query.actor}}", () => ({}));
-    await settle();
-    expect(requests).toEqual([]);
-    route.query = { actor: "u-1" };
-    await nextTick();
-    await settle();
-    expect(requests).toEqual(["/api/activity?actor=u-1"]);
-  });
-});
-
-describe("useBlockItems with a templated fetchUrl", () => {
-  function mountItems(routeParams: Record<string, string>) {
-    const state: { items?: { value: unknown[] } } = {};
-    const Probe = defineComponent({
-      setup() {
-        const { items } = useBlockItems<{ label: string }>({
-          items: () => [{ label: "static" }],
-          fetchUrl: "/api/ws/{{params.id}}/billing-info",
-          routeParams: () => routeParams,
-        });
-        state.items = items;
-        return () => h("div");
-      },
-    });
-    mount(Probe);
-    return state;
-  }
-
-  it("lists the items of the page's record", async () => {
-    const state = mountItems({ id: "ws-1" });
-    await settle();
-    expect(requests).toEqual(["/api/ws/ws-1/billing-info"]);
-    expect(state.items?.value).toEqual([
-      { label: "/api/ws/ws-1/billing-info" },
-    ]);
-  });
-
-  it("shows its empty state, not the static items, without the record", async () => {
-    const state = mountItems({});
-    await settle();
-    expect(requests).toEqual([]);
-    expect(state.items?.value).toEqual([]);
-  });
-});

package/frontend-vue/tests/branding-defaults.test.ts

@@ -1,34 +0,0 @@
-import { defu } from "defu";
-import { describe, expect, it } from "vitest";
-import appConfig from "../layers/dms-layout/app/app.config";
-
-const ANTELOPE_ICON = "/images/antelope-logo/icon.svg";
-
-describe("branding defaults", () => {
-  it("hold the palettes and logos the layout ships", () => {
-    expect(appConfig.branding.defaults).toEqual({
-      colors: appConfig.ui.colors,
-      logo: appConfig.branding.logo,
-    });
-    expect(appConfig.branding.defaults.colors.primary).toBe("dms");
-    expect(appConfig.branding.logo.favicon).toEqual({
-      light: ANTELOPE_ICON,
-      dark: ANTELOPE_ICON,
-    });
-  });
-
-  it("survive a live edit of the merged palette and logos", () => {
-    // A clone keeps any object shared between the two places, like the
-    // loader's merge keeps the objects no layer overrides.
-    const merged = defu(
-      { branding: { footer: { githubStar: false } } },
-      structuredClone(appConfig),
-    );
-
-    merged.ui.colors.primary = "violet";
-    merged.branding.logo.favicon!.light = "/branding/icon.png";
-
-    expect(merged.branding.defaults.colors.primary).toBe("dms");
-    expect(merged.branding.defaults.logo.favicon?.light).toBe(ANTELOPE_ICON);
-  });
-});

package/frontend-vue/tests/breadcrumb-target.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildBreadcrumbTarget } from "../layers/dms-layout/app/utils/breadcrumb";
-
-const PAGE = { layoutUrl: "/projects/project/pagelayout" };
-const PROJECT_PAGE = {
-  ...PAGE,
-  validation: { requiredQueryParams: ["project"] },
-};
-
-describe("buildBreadcrumbTarget", () => {
-  it("links a page without query requirements to its bare path", () => {
-    expect(
-      buildBreadcrumbTarget("/projects", PAGE, { project: "p1" }),
-    ).to.equal("/projects");
-  });
-
-  it("gives a category without a page no link", () => {
-    expect(buildBreadcrumbTarget("/projects", {}, {})).to.equal(undefined);
-  });
-
-  it("links a module's root to the module's landing page", () => {
-    expect(
-      buildBreadcrumbTarget(
-        "/modules/api",
-        { landingSlug: "/modules/api/overview" },
-        {},
-      ),
-    ).to.equal("/modules/api/overview");
-  });
-
-  it("carries only the query values an ancestor page requires", () => {
-    expect(
-      buildBreadcrumbTarget("/projects/project", PROJECT_PAGE, {
-        project: "p 1&x",
-        service: "s1",
-      }),
-    ).to.equal("/projects/project?project=p+1%26x");
-  });
-
-  it("gives no link when a required query value is missing", () => {
-    expect(
-      buildBreadcrumbTarget("/projects/project", PROJECT_PAGE, {
-        service: "s1",
-      }),
-    ).to.equal(undefined);
-  });
-
-  it("gives no link when a required query value is empty or repeated", () => {
-    expect(
-      buildBreadcrumbTarget("/projects/project", PROJECT_PAGE, {
-        project: "",
-      }),
-    ).to.equal(undefined);
-    expect(
-      buildBreadcrumbTarget("/projects/project", PROJECT_PAGE, {
-        project: ["a", "b"],
-      }),
-    ).to.equal(undefined);
-  });
-});