@antelopejs/dms 0.9.2 → 0.9.3

package/frontend-vue/tests/form-display-options.test.ts

@@ -1,64 +0,0 @@
-// @vitest-environment jsdom
-import { computed, createApp, h, useAttrs } from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import Display from "../layers/dms-ui/app/components/form/components/Display.vue";
-
-interface StatusOptions {
-  onlineLabel?: string;
-  offlineLabel?: string;
-}
-
-// A status type worded from its options, as the registered one is: the
-// fallback labels show when the options do not reach the formatter.
-const statusType = {
-  id: "status",
-  formatter: {
-    default: (value: unknown, _locale: string, options?: unknown) => {
-      const opts = options as StatusOptions | undefined;
-      return value
-        ? (opts?.onlineLabel ?? "Online")
-        : (opts?.offlineLabel ?? "Offline");
-    },
-  },
-};
-
-/** A read-only field as a form renders it: its options spread on it. */
-function mountDisplay(modelValue: unknown, options: Record<string, unknown>) {
-  const app = createApp({
-    render: () => h(Display, { modelValue, type: "status", ...options }),
-  });
-  const container = document.createElement("div");
-  app.mount(container);
-  return { app, container };
-}
-
-beforeEach(() => {
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("useAttrs", useAttrs);
-  vi.stubGlobal("useI18n", () => ({
-    locale: { value: "en" },
-    t: (key: string) => key,
-  }));
-  vi.stubGlobal("useDataTypes", () => ({ getDataType: () => statusType }));
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-it("words a read-only status with the labels its column sets", () => {
-  const options = {
-    onlineLabel: "Pending",
-    offlineLabel: "Expired",
-    onlineColor: "warning",
-    offlineColor: "neutral",
-  };
-
-  const pending = mountDisplay(true, options);
-  const expired = mountDisplay(false, options);
-
-  expect(pending.container.textContent).toBe("Pending");
-  expect(expired.container.textContent).toBe("Expired");
-  pending.app.unmount();
-  expired.app.unmount();
-});

package/frontend-vue/tests/form-enclosing-form.test.ts

@@ -1,120 +0,0 @@
-// @vitest-environment jsdom
-/**
- * What a `Form` offers a custom field through `useEnclosingForm`: submitting
- * the form as its save button does, a validator that can stop a submit and
- * leaves with its component, and focusing a field by id. A page opened on a
- * field's anchor focuses that field.
- */
-import { createApp, defineComponent, h } from "vue";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  FORM_HANDLE_KEY,
-  type FormHandle,
-  linkedFieldId,
-} from "../layers/dms-ui/app/build/composables/form/enclosingForm";
-import {
-  type EnclosingForm,
-  useEnclosingForm,
-} from "../layers/dms-ui/app/composables/form/useEnclosingForm";
-import type { FormValidator } from "../layers/dms-ui/app/composables/form/types/validation";
-
-const FIELD_IDS = ["retentionDays", "requestLogMaxBodyKb"];
-const mounted: Array<{ unmount: () => void }> = [];
-
-afterEach(() => mounted.splice(0).forEach((app) => app.unmount()));
-
-interface FakeForm {
-  handle: FormHandle;
-  validators: Set<FormValidator>;
-}
-
-function fakeForm(): FakeForm {
-  const validators = new Set<FormValidator>();
-  return {
-    validators,
-    handle: {
-      submit: vi.fn(async () => {}),
-      registerValidator: (validator) => {
-        validators.add(validator);
-        return () => validators.delete(validator);
-      },
-      revealField: vi.fn(async () => {}),
-    },
-  };
-}
-
-function mountField(
-  handle: FormHandle | null,
-  setup: (form: EnclosingForm | null) => void,
-) {
-  const app = createApp(
-    defineComponent({
-      setup() {
-        setup(useEnclosingForm());
-        return () => h("div");
-      },
-    }),
-  );
-  if (handle) app.provide(FORM_HANDLE_KEY, handle);
-  app.mount(document.createElement("div"));
-  mounted.push(app);
-  return app;
-}
-
-describe("useEnclosingForm", () => {
-  it("is null outside a Form", () => {
-    let form: EnclosingForm | null | undefined;
-    mountField(null, (enclosing) => (form = enclosing));
-    expect(form).toBeNull();
-  });
-
-  it("submits the form and focuses a field through the form", async () => {
-    const { handle } = fakeForm();
-    let form: EnclosingForm | null = null;
-    mountField(handle, (enclosing) => (form = enclosing));
-
-    await form!.submit();
-    await form!.focusField("retentionDays");
-
-    expect(handle.submit).toHaveBeenCalledOnce();
-    expect(handle.revealField).toHaveBeenCalledWith("retentionDays");
-  });
-
-  it("adds a validator that leaves with its component", () => {
-    const { handle, validators } = fakeForm();
-    const validator = () => false;
-    const app = mountField(handle, (form) => form?.addValidator(validator));
-
-    expect([...validators]).toEqual([validator]);
-
-    app.unmount();
-    mounted.splice(mounted.indexOf(app), 1);
-    expect(validators.size).toBe(0);
-  });
-
-  it("removes a validator on request", () => {
-    const { handle, validators } = fakeForm();
-    let remove: (() => void) | undefined;
-    mountField(handle, (form) => (remove = form?.addValidator(() => true)));
-
-    remove?.();
-    expect(validators.size).toBe(0);
-  });
-});
-
-describe("a field's anchor", () => {
-  it("names a field of the form by its id", () => {
-    expect(linkedFieldId("#retentionDays", FIELD_IDS)).toBe("retentionDays");
-    expect(
-      linkedFieldId("#request%4CogMaxBodyKb", ["requestLogMaxBodyKb"]),
-    ).toBe("requestLogMaxBodyKb");
-  });
-
-  it("names nothing for another anchor, none, or a broken one", () => {
-    expect(linkedFieldId("#dms-form-settings-section-logs", FIELD_IDS)).toBe(
-      undefined,
-    );
-    expect(linkedFieldId("", FIELD_IDS)).toBe(undefined);
-    expect(linkedFieldId("#%E0%A4%A", FIELD_IDS)).toBe(undefined);
-  });
-});

package/frontend-vue/tests/form-entry-order.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { orderFormEntries } from "../layers/dms-ui/app/build/composables/form/formEntryOrder";
-import type { FormFieldOrGroup } from "../layers/dms-ui/app/composables/form/types/field";
-
-const field = (id: string) => ({
-  id,
-  component: { componentName: "dms-input-text" },
-});
-
-const group = (id: string, order?: number) => ({
-  id,
-  order,
-  fields: [field(`${id}Member`)],
-});
-
-const ids = (entries: FormFieldOrGroup[]) => entries.map((entry) => entry.id);
-
-describe("orderFormEntries", () => {
-  it("moves the groups giving an order into their places, lowest first", () => {
-    const entries: FormFieldOrGroup[] = [
-      field("username"),
-      group("contact"),
-      field("bio"),
-      group("social", 2),
-      group("address", 1),
-    ];
-    expect(ids(orderFormEntries(entries))).toEqual([
-      "username",
-      "contact",
-      "bio",
-      "address",
-      "social",
-    ]);
-  });
-
-  it("keeps the declaration order of equal orders and of no order at all", () => {
-    const entries: FormFieldOrGroup[] = [
-      group("first", 1),
-      field("name"),
-      group("second", 1),
-      group("loose"),
-    ];
-    expect(ids(orderFormEntries(entries))).toEqual(ids(entries));
-  });
-});

package/frontend-vue/tests/form-footer-kind.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  formSaveMode,
-  type SaveBarContext,
-  saveBarState,
-} from "../layers/dms-ui/app/build/composables/form/formFooter";
-
-describe("formSaveMode", () => {
-  it("saves with the bar by default", () => {
-    expect(formSaveMode(undefined)).toBe("bar");
-  });
-
-  it("saves as it goes when instant, unless it is an action form", () => {
-    expect(formSaveMode("instant")).toBe("instant");
-    expect(formSaveMode("instant", "record")).toBe("instant");
-    expect(formSaveMode("instant", "action")).toBe("bar");
-  });
-
-  it("keeps the footer and no buttons as asked", () => {
-    expect(formSaveMode("footer")).toBe("footer");
-    expect(formSaveMode("none")).toBe("none");
-  });
-});
-
-const context = (overrides: Partial<SaveBarContext>): SaveBarContext => ({
-  kind: "record",
-  dirty: false,
-  cancellable: false,
-  resettable: true,
-  ...overrides,
-});
-
-describe("saveBarState of a record form", () => {
-  it("says what is unsaved, with Discard and Save, once a value changed", () => {
-    expect(saveBarState(context({ dirty: true }))).toEqual({
-      showsStatus: true,
-      secondary: "discard",
-      showsSubmit: true,
-      isSubmitHeld: false,
-      isHidden: false,
-    });
-  });
-
-  it("offers Cancel alone while clean, when it has somewhere to go back to", () => {
-    expect(saveBarState(context({ cancellable: true }))).toMatchObject({
-      showsStatus: false,
-      secondary: "cancel",
-      showsSubmit: false,
-      isHidden: false,
-    });
-  });
-
-  it("hides, keeping its place, with nothing to offer", () => {
-    expect(saveBarState(context({})).isHidden).toBe(true);
-  });
-});
-
-describe("saveBarState of an action form", () => {
-  const action = (overrides: Partial<SaveBarContext>) =>
-    saveBarState(context({ kind: "action", ...overrides }));
-
-  it("shows Reset and its submit once a value changed, never a status", () => {
-    expect(action({ dirty: true })).toEqual({
-      showsStatus: false,
-      secondary: "discard",
-      showsSubmit: true,
-      isSubmitHeld: false,
-      isHidden: false,
-    });
-  });
-
-  it("shows its submit alone, ready, on a page while untouched", () => {
-    // A pre-filled form sends its defaults as they are.
-    expect(action({})).toEqual({
-      showsStatus: false,
-      showsSubmit: true,
-      isSubmitHeld: false,
-      isHidden: false,
-    });
-  });
-
-  it("offers Cancel beside its ready submit in a drawer or a modal", () => {
-    expect(action({ cancellable: true })).toEqual({
-      showsStatus: false,
-      secondary: "cancel",
-      showsSubmit: true,
-      isSubmitHeld: false,
-      isHidden: false,
-    });
-  });
-
-  it("shows its submit alone, ready, when nothing in it can be changed", () => {
-    const bar = action({ resettable: false, dirty: true });
-    expect(bar.secondary).toBeUndefined();
-    expect(bar).toMatchObject({
-      showsSubmit: true,
-      isSubmitHeld: false,
-      isHidden: false,
-    });
-  });
-});

package/frontend-vue/tests/form-load-error.test.ts

@@ -1,229 +0,0 @@
-import { readFileSync } from "node:fs";
-import { createSSRApp, defineComponent, h, nextTick, ref } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import FormLoadError from "../layers/dms-ui/app/build/components/form/FormLoadError.vue";
-import {
-  type FormLoadFailure,
-  type FormLoadSource,
-  missingRecordFailure,
-  trackFormRecordLoad,
-} from "../layers/dms-ui/app/build/composables/form/formRecordLoad";
-
-// A role that may edit a table's rows but not view them opened the edit form
-// empty: the row's read was refused, the form showed its blank fields, and a
-// value picked there replaced the row's own. A form whose record does not
-// load shows why, with a retry, and cannot be saved.
-
-const ROW = { values: { email: "zz-invitee@example.com" }, initial: {} };
-const FORBIDDEN = Object.assign(new Error("Forbidden"), { statusCode: 403 });
-
-interface Payload {
-  values: Record<string, unknown>;
-  initial: Record<string, unknown>;
-}
-
-function loadOf(
-  data: Payload | null,
-  error: unknown,
-  next?: { data: Payload; error: unknown },
-): FormLoadSource<Payload> {
-  const load: FormLoadSource<Payload> = {
-    data: ref(data),
-    error: ref(error),
-    refresh: vi.fn(async () => {
-      if (!next) return;
-      load.data.value = next.data;
-      load.error.value = next.error;
-    }),
-  };
-  return load;
-}
-
-describe("a form's record load", () => {
-  it("reports a refused read as forbidden and applies nothing", () => {
-    const apply = vi.fn();
-    const load = trackFormRecordLoad(loadOf(null, FORBIDDEN), apply);
-    expect(load.failure.value).toBe("forbidden");
-    expect(apply).not.toHaveBeenCalled();
-  });
-
-  it("never applies the values an earlier opening left in the cache", () => {
-    const apply = vi.fn();
-    const load = trackFormRecordLoad(loadOf(ROW, new Error("network")), apply);
-    expect(load.failure.value).toBe("error");
-    expect(apply).not.toHaveBeenCalled();
-  });
-
-  it("opens on the record once a retry loads it", async () => {
-    const apply = vi.fn();
-    const source = loadOf(null, FORBIDDEN, { data: ROW, error: null });
-    const load = trackFormRecordLoad(source, apply);
-    await load.retry();
-    expect(source.refresh).toHaveBeenCalledOnce();
-    expect(load.failure.value).toBe(null);
-    expect(load.retrying.value).toBe(false);
-    expect(apply).toHaveBeenCalledWith(ROW);
-  });
-
-  it("takes a later read of the record, its values becoming the saved ones", async () => {
-    const apply = vi.fn();
-    const onReloaded = vi.fn();
-    const source = loadOf(ROW, null);
-    trackFormRecordLoad(source, apply, { onReloaded });
-    const fresh = { values: { email: "fresh@example.com" }, initial: {} };
-    source.data.value = fresh;
-    await nextTick();
-    expect(apply).toHaveBeenLastCalledWith(fresh);
-    expect(onReloaded).toHaveBeenCalledOnce();
-  });
-
-  it("leaves a later read out while the user edits", async () => {
-    const apply = vi.fn();
-    const onReloaded = vi.fn();
-    const source = loadOf(ROW, null);
-    trackFormRecordLoad(source, apply, {
-      isEditing: () => true,
-      onReloaded,
-    });
-    source.data.value = { values: { email: "other@example.com" }, initial: {} };
-    await nextTick();
-    expect(apply).toHaveBeenCalledOnce();
-    expect(onReloaded).not.toHaveBeenCalled();
-  });
-
-  it("stops showing the cached record once a later read is refused", async () => {
-    const apply = vi.fn();
-    const source = loadOf(ROW, null);
-    const load = trackFormRecordLoad(source, apply);
-    source.error.value = FORBIDDEN;
-    await nextTick();
-    expect(load.failure.value).toBe("forbidden");
-  });
-
-  it("applies a record that loaded", () => {
-    const apply = vi.fn();
-    const load = trackFormRecordLoad(loadOf(ROW, null), apply);
-    expect(load.failure.value).toBe(null);
-    expect(apply).toHaveBeenCalledWith(ROW);
-  });
-});
-
-describe("Form.vue", () => {
-  const source = readFileSync(
-    new URL("../layers/dms-ui/app/components/form/Form.vue", import.meta.url),
-    "utf8",
-  );
-
-  it("leaves reading the record again on mount to the data layer", () => {
-    // The renderer reads cached data again on each mount (stale while
-    // revalidate): no status reset forces it any more.
-    expect(source).not.toMatch(/status\.value\s*=\s*"idle"/);
-  });
-
-  it("keys the record's load on the record it reads", () => {
-    expect(source).toMatch(
-      /`form-\$\{props\.componentId\}-\$\{props\.pageId\}-\$\{resolvedFetchUrl\.value/,
-    );
-  });
-});
-
-describe("a form about a record its address names none of", () => {
-  const FETCH_URL = "/api/tasks/get?id={{query.id}}";
-
-  it("reports the record missing while the id is not in the address", () => {
-    expect(
-      missingRecordFailure({ requiresRecord: true, fetchUrl: FETCH_URL }),
-    ).toBe("missing");
-  });
-
-  it("reports nothing once the address names the record", () => {
-    expect(
-      missingRecordFailure({
-        requiresRecord: true,
-        fetchUrl: FETCH_URL,
-        resolvedFetchUrl: "/api/tasks/get?id=1",
-      }),
-    ).toBe(null);
-  });
-
-  it("leaves a form that may open without a record to its defaults", () => {
-    // A create form seeded by `?duplicate=` when there is one.
-    expect(missingRecordFailure({ fetchUrl: FETCH_URL })).toBe(null);
-    expect(missingRecordFailure({ requiresRecord: true })).toBe(null);
-  });
-});
-
-describe("the load error a form shows", () => {
-  const Slot = defineComponent({
-    props: {
-      title: { type: String, default: "" },
-      description: { type: String, default: "" },
-      label: { type: String, default: "" },
-    },
-    setup:
-      (props, { slots }) =>
-      () =>
-        h("div", [
-          props.title,
-          props.description,
-          props.label,
-          slots.default?.(),
-          slots.actions?.(),
-        ]),
-  });
-
-  async function render(failure: FormLoadFailure): Promise<string> {
-    const app = createSSRApp({
-      render: () => h(FormLoadError, { failure }),
-    });
-    for (const name of ["UButton", "UIcon"]) app.component(name, Slot);
-    return renderToString(app);
-  }
-
-  beforeEach(() => {
-    vi.stubGlobal("useI18n", () => ({ t: String }));
-  });
-
-  afterEach(() => vi.unstubAllGlobals());
-
-  it("says the read was refused, with a retry", async () => {
-    const html = await render("forbidden");
-    expect(html).toContain("dms.form.load_error.forbidden_title");
-    expect(html).toContain("dms.form.load_error.forbidden_description");
-    expect(html).toContain("dms.form.load_error.retry");
-  });
-
-  it("says the load failed, with a retry", async () => {
-    const html = await render("error");
-    expect(html).toContain("dms.form.load_error.error_title");
-    expect(html).toContain("dms.form.load_error.retry");
-  });
-
-  it("says no entry is selected, with nothing to retry", async () => {
-    const html = await render("missing");
-    expect(html).toContain("dms.form.load_error.missing_title");
-    expect(html).toContain("dms.form.load_error.missing_description");
-    expect(html).not.toContain("dms.form.load_error.retry");
-  });
-
-  it("has its texts in English and French", () => {
-    for (const file of ["ui-en-GB.json", "ui-fr-FR.json"]) {
-      const locale = JSON.parse(
-        readFileSync(
-          new URL(`../layers/dms-ui/i18n/locales/${file}`, import.meta.url),
-          "utf8",
-        ),
-      );
-      expect(Object.keys(locale.dms.form.load_error).sort()).toEqual([
-        "error_description",
-        "error_title",
-        "forbidden_description",
-        "forbidden_title",
-        "missing_description",
-        "missing_title",
-        "retry",
-      ]);
-    }
-  });
-});

package/frontend-vue/tests/form-page-url-fill.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { fillFormPageUrl } from "../layers/dms-ui/app/build/composables/table-view/useTableViewConfig";
-
-const ROW = "row-1";
-
-describe("filling a serialized form page URL", () => {
-  it("substitutes the row id of a default slug", () => {
-    expect(
-      fillFormPageUrl("/settings/users/roles/table/:id/edit", {}, ROW),
-    ).toBe("/settings/users/roles/table/row-1/edit");
-  });
-
-  it("leaves a URL without placeholder alone", () => {
-    expect(fillFormPageUrl("/settings/users/roles/table/new", {})).toBe(
-      "/settings/users/roles/table/new",
-    );
-  });
-
-  it("substitutes the row id inside the query string of an absolute slug", () => {
-    expect(
-      fillFormPageUrl("/modules/automation/builder?selected=:id", {}, ROW),
-    ).toBe("/modules/automation/builder?selected=row-1");
-  });
-
-  // The page slug contributes its own `:id`, and the form slug appends another:
-  // the row takes the last, the route params fill the first.
-  it("tells the row id apart from the id of the carrying page", () => {
-    expect(
-      fillFormPageUrl("/modules/workspaces/:id/:id/view", { id: "ws-1" }, ROW),
-    ).toBe("/modules/workspaces/ws-1/row-1/view");
-  });
-
-  // What a table view nested under a `:id` detail page now resolves to: the
-  // key segment sits between the two placeholders and changes nothing.
-  it("tells the ids apart across the key segment of the table view", () => {
-    expect(
-      fillFormPageUrl(
-        "/modules/workspaces/:id/invoiceTable/:id/view",
-        { id: "ws-1" },
-        ROW,
-      ),
-    ).toBe("/modules/workspaces/ws-1/invoiceTable/row-1/view");
-  });
-
-  it("fills the params of the carrying page when the form takes no row id", () => {
-    expect(fillFormPageUrl("/modules/workspaces/:id/new", { id: "ws-1" })).toBe(
-      "/modules/workspaces/ws-1/new",
-    );
-  });
-
-  it("matches a route param on its whole name", () => {
-    expect(
-      fillFormPageUrl(
-        "/projects/:project/:projectRole/:id/view",
-        {
-          project: "p-1",
-          projectRole: "owner",
-        },
-        ROW,
-      ),
-    ).toBe("/projects/p-1/owner/row-1/view");
-  });
-});