@antelopejs/dms 0.9.2 → 0.9.3

package/frontend-vue/tests/post-login-redirect.test.ts

@@ -1,92 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { usePostLoginRedirect } from "../layers/dms-auth/app/composables/usePostLoginRedirect";
-
-const refreshUser = vi.fn();
-const refreshLayout = vi.fn();
-const addCurrentAccount = vi.fn();
-const setLocale = vi.fn();
-const navigateTo = vi.fn();
-
-beforeEach(() => {
-  vi.stubGlobal("useDmsApp", () => ({ $i18n: { setLocale } }));
-  vi.stubGlobal("useDmsUserSession", () => ({
-    fetch: refreshUser,
-    user: { value: { language: "fr" } },
-  }));
-  vi.stubGlobal("useMultiAccount", () => ({ addCurrentAccount }));
-  vi.stubGlobal("useSiteLayout", () => ({ refresh: refreshLayout }));
-  vi.stubGlobal("useHomepage", () => "/");
-  vi.stubGlobal("navigateDms", navigateTo);
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.resetAllMocks();
-});
-
-describe("post-login redirect", () => {
-  it("resolves the onboarding destination only after session and permissions refresh", async () => {
-    const resolveDestination = vi.fn(() => {
-      expect(refreshUser).toHaveBeenCalledOnce();
-      expect(addCurrentAccount).toHaveBeenCalledOnce();
-      expect(refreshLayout).toHaveBeenCalledOnce();
-      expect(setLocale).toHaveBeenCalledWith("fr");
-      return "/dashboard";
-    });
-
-    await usePostLoginRedirect(resolveDestination);
-
-    expect(resolveDestination).toHaveBeenCalledOnce();
-    expect(navigateTo).toHaveBeenCalledWith("/dashboard", {});
-    expect(refreshUser.mock.invocationCallOrder[0]).toBeLessThan(
-      refreshLayout.mock.invocationCallOrder[0]!,
-    );
-  });
-
-  it("preserves explicit login destinations", async () => {
-    await usePostLoginRedirect("/reports");
-    expect(navigateTo).toHaveBeenCalledWith("/reports", {});
-  });
-
-  it("opens the destination in place of the current page when asked", async () => {
-    await usePostLoginRedirect("/reports", { replace: true });
-    expect(navigateTo).toHaveBeenCalledWith("/reports", { replace: true });
-  });
-
-  it("falls back to the homepage when no page is accessible", async () => {
-    await usePostLoginRedirect(() => undefined);
-    expect(navigateTo).toHaveBeenCalledWith("/", {});
-  });
-
-  it("does not navigate when session refresh fails", async () => {
-    refreshUser.mockRejectedValueOnce(new Error("Session failed"));
-    await expect(usePostLoginRedirect()).rejects.toThrow("Session failed");
-    expect(refreshLayout).not.toHaveBeenCalled();
-    expect(navigateTo).not.toHaveBeenCalled();
-  });
-
-  it("rejects a session refresh that resolves without an authenticated user", async () => {
-    vi.stubGlobal("useDmsUserSession", () => ({
-      fetch: refreshUser,
-      user: { value: null },
-    }));
-    const resolveDestination = vi.fn();
-    await expect(usePostLoginRedirect(resolveDestination)).rejects.toThrow(
-      "Unable to load the authenticated session",
-    );
-    expect(addCurrentAccount).not.toHaveBeenCalled();
-    expect(refreshLayout).not.toHaveBeenCalled();
-    expect(resolveDestination).not.toHaveBeenCalled();
-    expect(navigateTo).not.toHaveBeenCalled();
-  });
-
-  it("propagates layout failures without resolving or opening the destination", async () => {
-    refreshLayout.mockRejectedValueOnce(new Error("Layout failed"));
-    const resolveDestination = vi.fn();
-    await expect(usePostLoginRedirect(resolveDestination)).rejects.toThrow(
-      "Layout failed",
-    );
-    expect(resolveDestination).not.toHaveBeenCalled();
-    expect(navigateTo).not.toHaveBeenCalled();
-  });
-});

package/frontend-vue/tests/preferences-cookie-size.test.ts

@@ -1,311 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createSSRApp,
-  defineComponent,
-  h,
-  nextTick,
-  readonly,
-  ref,
-  toRaw,
-  watch,
-  type Ref,
-} from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  MAX_PREFERENCES_COOKIE_BYTES,
-  usePreferences,
-} from "../layers/dms-core/app/composables/user/usePreferences";
-import {
-  decodePreferencesTree,
-  preferencesCookieBytes,
-} from "../layers/dms-core/app/build/composables/user/preferencesCookie";
-import {
-  LOCAL_TABLE_KEY_PREFIX,
-  tablePreferenceId,
-} from "../layers/dms-core/app/build/composables/user/tablePreferences";
-import { useTablePreferences } from "../layers/dms-ui/app/build/composables/table-view/useTablePreferences";
-
-// The ids of a table measured in the playground: a long component id, and a
-// page id holding dots.
-const COMPONENT_ID = "content-child-main-child-main-child-languages";
-const PAGE_ID = "modules.lang.manage.workspace";
-const SORTED_ONLY_MAX_BYTES = 50;
-const TYPICAL_MAX_BYTES = 150;
-const TYPICAL_TABLES = 20;
-const VISITED_TABLES = 80;
-const DEFAULT_PAGINATION = { pageIndex: 0, pageSize: 10 };
-const DEFAULT_SORT = [{ id: "createdAt", desc: true }];
-const DEFAULT_VISIBILITY = { name: true, email: true, phone: true };
-
-let stored: Ref<string>;
-let writes: number[];
-
-// `useDmsCookie`: one shared ref per name, every assignment written out.
-const installCookie = (initial: string) => {
-  stored = ref(initial);
-  writes = [];
-  const cookie = computed({
-    get: () => stored.value,
-    set: (next) => {
-      writes.push(preferencesCookieBytes(toRaw(next)));
-      stored.value = next;
-    },
-  });
-  vi.stubGlobal("useDmsCookie", () => cookie);
-};
-
-const cookieBytes = () => preferencesCookieBytes(stored.value);
-const storedTree = () => decodePreferencesTree(stored.value);
-
-const sortByName = (componentId: string, pageId: string) =>
-  useTablePreferences(componentId, pageId).set(
-    "sorting",
-    [{ id: "name", desc: true }],
-    DEFAULT_SORT,
-  );
-
-// Sorted, filtered, 50 rows a page and two columns hidden.
-const visitTypicalTable = (componentId: string, pageId: string) => {
-  const table = useTablePreferences(componentId, pageId);
-  table.set("sorting", [{ id: "name", desc: true }], DEFAULT_SORT);
-  table.set(
-    "columnFilters",
-    [{ accessorKey: "status", mode: "is", value: "active" }],
-    [],
-  );
-  table.set("pagination", { pageIndex: 0, pageSize: 50 }, DEFAULT_PAGINATION);
-  table.set(
-    "columnVisibility",
-    { name: true, email: false, phone: false },
-    DEFAULT_VISIBILITY,
-  );
-};
-
-const tableIds = (index: number): [string, string] => [
-  `${COMPONENT_ID}-${index}`,
-  `${PAGE_ID}.${index}`,
-];
-
-beforeEach(() => {
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("readonly", readonly);
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("usePreferences", usePreferences);
-  installCookie("");
-  localStorage.clear();
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("the size of a table's state in the preferences cookie", () => {
-  it("is at most 50 bytes for a table only sorted", () => {
-    const empty = preferencesCookieBytes("");
-    sortByName(COMPONENT_ID, PAGE_ID);
-    expect(cookieBytes() - empty).toBeLessThanOrEqual(SORTED_ONLY_MAX_BYTES);
-  });
-
-  it("is at most 150 bytes for a sorted, filtered, paged table with hidden columns", () => {
-    sortByName("another-table", "another.page");
-    const before = cookieBytes();
-    visitTypicalTable(COMPONENT_ID, PAGE_ID);
-    expect(cookieBytes() - before).toBeLessThanOrEqual(TYPICAL_MAX_BYTES);
-  });
-
-  it("keeps at least 20 typical tables", () => {
-    for (let index = 0; index < TYPICAL_TABLES; index += 1) {
-      visitTypicalTable(...tableIds(index));
-    }
-    expect(cookieBytes()).toBeLessThanOrEqual(MAX_PREFERENCES_COOKIE_BYTES);
-    const tables = storedTree().tables as Record<string, unknown>;
-    expect(Object.keys(tables)).toHaveLength(TYPICAL_TABLES);
-    expect(
-      useTablePreferences(...tableIds(0)).get("sorting", DEFAULT_SORT),
-    ).toEqual([{ id: "name", desc: true }]);
-  });
-});
-
-describe("a table's state in the preferences cookie", () => {
-  it("is read back in its own shape", () => {
-    visitTypicalTable(COMPONENT_ID, PAGE_ID);
-    const table = useTablePreferences(COMPONENT_ID, PAGE_ID);
-    expect(table.get("columnFilters", [])).toEqual([
-      { accessorKey: "status", mode: "is", value: "active" },
-    ]);
-    expect(table.get("pagination", DEFAULT_PAGINATION)).toEqual({
-      pageIndex: 0,
-      pageSize: 50,
-    });
-    expect(table.get("columnVisibility", DEFAULT_VISIBILITY)).toEqual({
-      name: true,
-      email: false,
-      phone: false,
-    });
-  });
-
-  it("does not write a value equal to its default, and forgets one back to it", () => {
-    const table = useTablePreferences(COMPONENT_ID, PAGE_ID);
-    table.set("sorting", DEFAULT_SORT, DEFAULT_SORT);
-    table.set("pagination", DEFAULT_PAGINATION, DEFAULT_PAGINATION);
-    table.set("columnVisibility", DEFAULT_VISIBILITY, DEFAULT_VISIBILITY);
-    expect(stored.value).toBe("");
-
-    table.set("sorting", [{ id: "name", desc: false }], DEFAULT_SORT);
-    expect(stored.value).not.toBe("");
-    table.set("sorting", DEFAULT_SORT, DEFAULT_SORT);
-    expect(storedTree()).toEqual({});
-  });
-
-  it("keeps a pinned filter on its declared value out of the cookie", () => {
-    useTablePreferences(COMPONENT_ID, PAGE_ID).set(
-      "columnFilters",
-      [
-        {
-          accessorKey: "status",
-          mode: "is",
-          value: "open",
-          pinned: true,
-          initialValue: "open",
-        },
-      ],
-      [],
-    );
-    expect(stored.value).toBe("");
-  });
-
-  it("lives under one short key, a dotted page id no longer nesting", () => {
-    sortByName(COMPONENT_ID, PAGE_ID);
-    const id = tablePreferenceId(COMPONENT_ID, PAGE_ID);
-    expect(id).toMatch(/^[0-9a-z]{8}$/);
-    expect(storedTree()).toEqual({ tables: { [id]: { s: "-name" } } });
-  });
-
-  it("keeps the browser-only state out of the cookie, in localStorage", () => {
-    const table = useTablePreferences(COMPONENT_ID, PAGE_ID);
-    table.set("columnOrder", ["email", "name"], []);
-    table.set("columnSizing", { name: 240 }, {});
-    table.set("density", "compact", "default");
-    expect(stored.value).toBe("");
-    const key = `${LOCAL_TABLE_KEY_PREFIX}${tablePreferenceId(COMPONENT_ID, PAGE_ID)}`;
-    expect(JSON.parse(localStorage.getItem(key)!)).toEqual({
-      columnOrder: ["email", "name"],
-      columnSizing: { name: 240 },
-      density: "compact",
-    });
-
-    table.set("density", "default", "default");
-    table.set("columnOrder", [], []);
-    table.set("columnSizing", {}, {});
-    expect(localStorage.getItem(key)).toBeNull();
-  });
-});
-
-describe("the browser-only state of a table", () => {
-  const Density = defineComponent({
-    setup() {
-      const table = useTablePreferences(COMPONENT_ID, PAGE_ID);
-      const density = ref("default");
-      table.restore("density", density);
-      return () => h("span", density.value);
-    },
-  });
-
-  it("is restored once mounted, the server render hydrating as is", async () => {
-    useTablePreferences(COMPONENT_ID, PAGE_ID).set(
-      "density",
-      "compact",
-      "default",
-    );
-    const html = await renderToString(createSSRApp(Density));
-    expect(html).toBe("<span>default</span>");
-
-    const container = document.createElement("div");
-    container.innerHTML = html;
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const error = vi.spyOn(console, "error").mockImplementation(() => {});
-    const app = createSSRApp(Density);
-    app.mount(container);
-    await nextTick();
-
-    expect(container.textContent).toBe("compact");
-    const messages = [...warn.mock.calls, ...error.mock.calls].flat();
-    expect(messages.join(" ")).not.toMatch(/hydration/i);
-    app.unmount();
-    warn.mockRestore();
-    error.mockRestore();
-  });
-});
-
-describe("the preferences cookie", () => {
-  it("stays under its budget however many tables are visited, dropping the least recently written", () => {
-    for (let index = 0; index < VISITED_TABLES; index += 1) {
-      visitTypicalTable(...tableIds(index));
-    }
-    expect(Math.max(...writes)).toBeLessThanOrEqual(
-      MAX_PREFERENCES_COOKIE_BYTES,
-    );
-    const last = tableIds(VISITED_TABLES - 1);
-    expect(useTablePreferences(...last).get("sorting", DEFAULT_SORT)).toEqual([
-      { id: "name", desc: true },
-    ]);
-    expect(
-      useTablePreferences(...tableIds(0)).get("sorting", DEFAULT_SORT),
-    ).toEqual(DEFAULT_SORT);
-  });
-
-  it("drops the table states before the remembered periods", () => {
-    const { setPreference, getPreference } = usePreferences();
-    setPreference("periods", { "orders#period": { period: "7d" } });
-    for (let index = 0; index < VISITED_TABLES; index += 1) {
-      visitTypicalTable(...tableIds(index));
-    }
-    expect(getPreference("periods")).toEqual({
-      "orders#period": { period: "7d" },
-    });
-  });
-
-  it("never evicts a module's own key, and refuses a write that cannot fit", () => {
-    const { setPreference, getPreference } = usePreferences();
-    setPreference("dms-lang.workspaceSort", { field: "name", desc: false });
-    for (let index = 0; index < VISITED_TABLES; index += 1) {
-      visitTypicalTable(...tableIds(index));
-    }
-    expect(getPreference("dms-lang.workspaceSort")).toEqual({
-      field: "name",
-      desc: false,
-    });
-
-    const before = stored.value;
-    setPreference("dms-lang.huge", "x".repeat(MAX_PREFERENCES_COOKIE_BYTES));
-    expect(stored.value).toBe(before);
-    expect(getPreference("dms-lang.huge")).toBeUndefined();
-  });
-
-  it("reads a corrupt value as no preferences", () => {
-    installCookie("not*base64{");
-    const { getPreference, setPreference } = usePreferences();
-    expect(getPreference("dms-lang.workspaceSort", "default")).toBe("default");
-    setPreference("dms-lang.workspaceSort", "name");
-    expect(getPreference("dms-lang.workspaceSort")).toBe("name");
-  });
-
-  it("is shared by every caller", () => {
-    const first = usePreferences();
-    const second = usePreferences();
-    first.setPreference("module.theme", "dense");
-    expect(second.getPreference("module.theme")).toBe("dense");
-  });
-
-  it("deletes the user-preferences cookie it replaces, unread", () => {
-    document.cookie = `user-preferences=${encodeURIComponent(
-      JSON.stringify({ tables: { a: { b: { density: "compact" } } } }),
-    )}; path=/`;
-    const { preferences } = usePreferences();
-    expect(document.cookie).not.toMatch(/user-preferences=/);
-    expect(preferences.value).toEqual({});
-  });
-});

package/frontend-vue/tests/profile-personal-info-ssr.test.ts

@@ -1,150 +0,0 @@
-// @vitest-environment jsdom
-/**
- * The profile's personal information through the runtime's real async data:
- * a server render reads the profile and the picture's URL and renders the
- * name, the address with its verification and the picture; the browser
- * hydrates with them without asking again, and the form edits a copy.
- */
-import {
-  computed,
-  defineComponent,
-  h,
-  inject,
-  nextTick,
-  onScopeDispose,
-  ref,
-  shallowReactive,
-  Suspense,
-  watch,
-  type App,
-} from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { hydrate, serverRender, stubApiData } from "./helpers/api-data-runtime";
-import { useFileReadUrls } from "../layers/dms-ui/app/composables/useFileReadUrls";
-
-vi.mock("#dms-core/app/composables/useFieldErrors", () => ({
-  useFieldErrors: () => ({
-    errors: {},
-    aria: () => ({}),
-    errorId: (field: string) => `${field}-error`,
-    clear: () => {},
-    setError: async () => {},
-    handleApiError: async () => {},
-  }),
-  fieldErrorId: (id: string) => `${id}-error`,
-}));
-vi.mock("#dms-ui/app/composables/unsaved-changes/useUnsavedChanges", () => ({
-  useUnsavedChanges: () => {},
-}));
-
-const ENDPOINT = "/settings/user/profile";
-const PROFILE = {
-  name: "Bea Owner",
-  email: "bea@example.test",
-  avatar: { key: "avatars/bea.png" },
-  isValidated: true,
-};
-
-const authFetch = vi.fn(async (url: string) =>
-  url === ENDPOINT
-    ? structuredClone(PROFILE)
-    : { url: "https://files.test/bea.png", filename: "bea.png" },
-);
-const mounted: App[] = [];
-
-const Input = defineComponent({
-  props: { modelValue: String, id: String },
-  setup: (props) => () => h("input", { id: props.id, value: props.modelValue }),
-});
-const Avatar = defineComponent({
-  props: { src: String, name: String },
-  setup: (props) => () => h("img", { src: props.src ?? "", alt: props.name }),
-});
-const Badge = defineComponent({
-  props: { label: String },
-  setup: (props) => () => h("span", props.label),
-});
-const Slots = defineComponent({
-  setup:
-    (_, { slots }) =>
-    () =>
-      h("div", [slots.label?.(), slots.default?.()]),
-});
-
-function register(app: App): void {
-  for (const name of ["DmsCard", "DmsFieldRow", "DmsLink", "DmsSaveBar"])
-    app.component(name, Slots);
-  for (const name of ["UButton", "UIcon", "USkeleton", "DmsFieldError"])
-    app.component(name, () => null);
-  app.component("UInput", Input);
-  app.component("UBadge", Badge);
-}
-
-beforeEach(async () => {
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("ref", ref);
-  vi.stubGlobal("watch", watch);
-  vi.stubGlobal("inject", inject);
-  vi.stubGlobal("onScopeDispose", onScopeDispose);
-  vi.stubGlobal("shallowReactive", shallowReactive);
-  vi.stubGlobal("useTemplateRef", () => ref(null));
-  vi.stubGlobal("CONTENT_LANGUAGE_HEADER", "x-content-language");
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useToast", () => ({ add: vi.fn() }));
-  vi.stubGlobal("useTranslation", () => ({
-    processApiMessage: (key: string) => key,
-  }));
-  vi.stubGlobal("useCurrentUser", () => ({
-    user: ref({ name: "Session name", email: "bea@example.test" }),
-    refresh: async () => {},
-  }));
-  vi.stubGlobal("useProfileAvatar", () => ({ upload: vi.fn() }));
-  vi.stubGlobal("useUploadWithProgress", () => ({}));
-  vi.stubGlobal("useFileReadUrls", useFileReadUrls);
-  stubApiData(authFetch as never);
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-  vi.unstubAllEnvs();
-  vi.unstubAllGlobals();
-  authFetch.mockClear();
-});
-
-it("renders the saved profile and its picture on the server, and the browser does not read them again", async () => {
-  vi.doMock(
-    "../layers/dms-layout/app/build/components/pages/settings/profile/ProfileAvatar.vue",
-    () => ({ default: Avatar }),
-  );
-  const { default: ProfilePersonalInfo } = await import(
-    "../layers/dms-layout/app/build/components/pages/settings/profile/ProfilePersonalInfo.vue"
-  );
-  // As the page renders it: inside the page's <Suspense>.
-  const Page = defineComponent({
-    setup: () => () =>
-      h(Suspense, null, {
-        default: () => h(ProfilePersonalInfo, { endpoint: ENDPOINT }),
-      }),
-  });
-
-  vi.stubEnv("SSR", true);
-  const { html, payload } = await serverRender(Page, register);
-  vi.stubEnv("SSR", false);
-  expect(html).toContain('value="Bea Owner"');
-  expect(html).toContain('src="https://files.test/bea.png"');
-  expect(html).toContain("page.settings.security.verified");
-  expect(authFetch.mock.calls.map(([url]) => url)).toEqual([
-    ENDPOINT,
-    "/api/files/metadata",
-  ]);
-
-  authFetch.mockClear();
-  const { app, container } = hydrate(Page, html, payload, register);
-  mounted.push(app);
-  await nextTick();
-  await new Promise((done) => setTimeout(done, 0));
-  expect(authFetch).not.toHaveBeenCalled();
-  expect(
-    container.querySelector<HTMLInputElement>("#profile-name")?.value,
-  ).toBe("Bea Owner");
-});