@antelopejs/dms 0.9.1 → 0.9.3

package/frontend-vue/tests/signup-invitation-link.test.ts

@@ -1,247 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import {
-  computed,
-  createApp,
-  nextTick,
-  defineComponent,
-  h,
-  reactive,
-  ref,
-  watchEffect,
-  type App,
-} from "vue";
-import * as z from "zod";
-import SignupPage from "../layers/dms-auth/app/custom-pages/auth/signup.vue";
-import {
-  browserRuntime,
-  hydrate,
-  serverRender,
-  stubApiData,
-} from "./helpers/api-data-runtime";
-
-const route = reactive<{ query: Record<string, unknown> }>({ query: {} });
-let app: App;
-let host: HTMLDivElement;
-const locale = ref("en");
-const setLocale = vi.fn(async (code: string) => {
-  locale.value = code;
-});
-const authFetch = vi.fn();
-const FORM_TITLE = "page.signup.create_account_title";
-
-const Passthrough = defineComponent({
-  inheritAttrs: false,
-  setup:
-    (_, { attrs, slots }) =>
-    () =>
-      h("div", { "data-testid": attrs["data-testid"] }, slots.default?.()),
-});
-
-const LinkButton = defineComponent({
-  props: { label: String, to: String },
-  setup: (props) => () => h("a", { href: props.to }, props.label),
-});
-
-function installRuntime() {
-  Object.entries({ computed, ref, reactive, watchEffect }).forEach(
-    ([key, value]) => vi.stubGlobal(key, value),
-  );
-  vi.stubGlobal("useI18n", () => ({
-    locale,
-    locales: ref([{ code: "en" }, { code: "fr" }]),
-    setLocale,
-  }));
-  vi.stubGlobal("useDmsRuntimeConfig", () => ({
-    public: { dms: { mustValidateEmail: false } },
-  }));
-  vi.stubGlobal("useHomepage", () => "/");
-  vi.stubGlobal("useDmsApp", () => ({
-    runWithContext: (fn: () => unknown) => fn(),
-  }));
-  vi.stubGlobal("useDmsRoute", () => route);
-  stubApiData(authFetch);
-  vi.stubGlobal("passwordSchema", z.string());
-  vi.stubGlobal("usePasswordStrength", () => ({
-    strength: ref([]),
-    score: ref(0),
-    color: ref("error"),
-  }));
-}
-
-function mountSignup(query: Record<string, unknown>) {
-  route.query = query;
-  app = createApp(SignupPage);
-  browserRuntime(app);
-  app.config.globalProperties.$t = (key: string) => key;
-  for (const name of [
-    "DmsCard",
-    "UIcon",
-    "UForm",
-    "UFormField",
-    "UInput",
-    "DmsOAuthButtons",
-    "DmsPasswordStrength",
-    "DmsLink",
-  ]) {
-    app.component(name, Passthrough);
-  }
-  app.component("UButton", LinkButton);
-  app.mount(host);
-}
-
-/** Let the invitation check the page starts settle. */
-async function settle() {
-  for (let tick = 0; tick < 4; tick++) await nextTick();
-  await new Promise((done) => setTimeout(done, 0));
-}
-
-function refusal(code: string) {
-  return { statusCode: 400, data: code };
-}
-
-beforeEach(() => {
-  locale.value = "en";
-  setLocale.mockClear();
-  authFetch.mockReset();
-  authFetch.mockResolvedValue(undefined);
-  installRuntime();
-  host = document.createElement("div");
-});
-afterEach(() => {
-  app?.unmount();
-  vi.unstubAllGlobals();
-});
-
-it.each([{}, { token: "" }, { token: ["a", "b"] }])(
-  "explains an invitation link without its token (%o)",
-  (query) => {
-    expect(() => mountSignup(query)).not.toThrow();
-    expect(
-      host.querySelector('[data-testid="signup-invalid-invitation"]'),
-    ).not.toBe(null);
-    expect(host.textContent).toContain(
-      "page.signup.invalid_invitation_description",
-    );
-    expect(host.querySelector('a[href="/auth"]')?.textContent).toBe(
-      "button.login",
-    );
-    expect(authFetch).not.toHaveBeenCalled();
-  },
-);
-
-it("shows the signup form once the server accepts the invitation", async () => {
-  mountSignup({ token: "invite-token", email: "new@local.test" });
-  expect(
-    host.querySelector('[data-testid="signup-checking-invitation"]'),
-  ).not.toBe(null);
-  expect(host.textContent).not.toContain("page.signup.submit");
-
-  await settle();
-
-  expect(authFetch).toHaveBeenCalledWith(
-    "/api/auth/validate-invite-token",
-    expect.objectContaining({
-      method: "POST",
-      body: { token: "invite-token", email: "new@local.test" },
-    }),
-  );
-  expect(host.querySelector('[data-testid="signup-invalid-invitation"]')).toBe(
-    null,
-  );
-  expect(host.textContent).toContain(FORM_TITLE);
-  expect(host.textContent).toContain("page.signup.submit");
-});
-
-it.each([
-  ["error.invite_revoked", "page.signup.invitation_revoked"],
-  ["error.invite_replaced", "page.signup.invitation_replaced"],
-  ["error.invite_expired", "page.signup.invitation_expired"],
-  ["error.invite_used", "page.signup.invitation_used"],
-  ["error.invalid_token", "page.signup.invalid_invitation"],
-])(
-  "says why a refused invitation link (%s) cannot sign up, instead of the form",
-  async (code, notice) => {
-    authFetch.mockRejectedValue(refusal(code));
-    mountSignup({ token: "stale-token", email: "new@local.test" });
-
-    await settle();
-
-    expect(
-      host.querySelector('[data-testid="signup-invalid-invitation"]'),
-    ).not.toBe(null);
-    expect(host.textContent).toContain(`${notice}_title`);
-    expect(host.textContent).toContain(`${notice}_description`);
-    expect(host.textContent).not.toContain("page.signup.submit");
-    expect(host.querySelector('a[href="/auth"]')?.textContent).toBe(
-      "button.login",
-    );
-  },
-);
-
-// A check that could not run proves nothing: the signup itself still refuses
-// a stale invitation, so the form stays usable.
-it("keeps the form when the invitation check fails for another reason", async () => {
-  authFetch.mockRejectedValue({ statusCode: 500 });
-  mountSignup({ token: "invite-token", email: "new@local.test" });
-
-  await settle();
-
-  expect(host.querySelector('[data-testid="signup-invalid-invitation"]')).toBe(
-    null,
-  );
-  expect(host.textContent).toContain("page.signup.submit");
-});
-
-it("opens in the language the invitation was written in", () => {
-  mountSignup({ token: "invite-token", email: "new@local.test", lang: "fr" });
-  expect(setLocale).toHaveBeenCalledWith("fr");
-  expect(locale.value).toBe("fr");
-});
-
-it.each([{}, { lang: "en" }, { lang: "de" }, { lang: ["fr", "en"] }])(
-  "keeps the current language for an invitation link carrying %o",
-  (query) => {
-    mountSignup({ token: "invite-token", email: "new@local.test", ...query });
-    expect(setLocale).not.toHaveBeenCalled();
-    expect(locale.value).toBe("en");
-  },
-);
-
-// Checked with the page: the server renders the notice, and the browser
-// hydrates it without asking again (no form flashing first).
-it("renders a refused invitation's notice on the server, and the browser does not check it again", async () => {
-  authFetch.mockRejectedValue(refusal("error.invite_revoked"));
-  route.query = { token: "stale-token", email: "new@local.test" };
-  const register = (application: App) => {
-    application.config.globalProperties.$t = (key: string) => key;
-    for (const name of [
-      "DmsCard",
-      "UIcon",
-      "UForm",
-      "UFormField",
-      "UInput",
-      "DmsOAuthButtons",
-      "DmsPasswordStrength",
-      "DmsLink",
-    ])
-      application.component(name, Passthrough);
-    application.component("UButton", LinkButton);
-  };
-  vi.stubEnv("SSR", true);
-  const { html, payload } = await serverRender(SignupPage, register);
-  vi.stubEnv("SSR", false);
-  expect(html).toContain("page.signup.invitation_revoked_title");
-  expect(html).not.toContain("page.signup.submit");
-  expect(authFetch).toHaveBeenCalledTimes(1);
-
-  authFetch.mockClear();
-  const hydrated = hydrate(SignupPage, html, payload, register);
-  app = hydrated.app;
-  await settle();
-  expect(authFetch).not.toHaveBeenCalled();
-  expect(hydrated.container.textContent).toContain(
-    "page.signup.invitation_revoked_title",
-  );
-  vi.unstubAllEnvs();
-});

package/frontend-vue/tests/site-layout-categories.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findNavigableCategory } from "../layers/dms-layout/app/composables/page/useSiteLayout";
-import type { SiteLayout } from "../layers/dms-layout/app/types/page";
-
-// The site layout lists every category once, by full id, and its pages name
-// theirs by id. A URL resolves against the categories that own a slug: a
-// `urlTransparent` one answers at its parent's, and is never a URL's target.
-
-const layout = {
-  pages: {},
-  categories: {
-    projects: {
-      id: "projects",
-      fullId: "projects",
-      fullSlug: "/projects",
-      displayName: "Projects",
-    },
-    "projects.reports": {
-      id: "reports",
-      fullId: "projects.reports",
-      fullSlug: "/projects",
-      displayName: "Reports",
-      categoryId: "projects",
-      urlTransparent: true,
-    },
-  },
-} as unknown as SiteLayout;
-
-describe("the category a URL resolves to", () => {
-  it("is the one owning the slug, by its full slug", () => {
-    expect(findNavigableCategory(layout, "/projects")?.fullId).toBe("projects");
-  });
-
-  it("is never a transparent category, nor an unknown slug", () => {
-    expect(findNavigableCategory(layout, "/reports")).toBeUndefined();
-    const transparentOnly = {
-      pages: {},
-      categories: { "projects.reports": layout.categories["projects.reports"] },
-    } as unknown as SiteLayout;
-    expect(findNavigableCategory(transparentOnly, "/projects")).toBeUndefined();
-  });
-});

package/frontend-vue/tests/site-layout-hydration.test.ts

@@ -1,82 +0,0 @@
-import { ref, type Ref } from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { useSiteLayout } from "../layers/dms-layout/app/composables/page/useSiteLayout";
-
-const state = new Map<string, Ref>();
-const authFetch = vi.fn();
-
-beforeEach(() => {
-  state.clear();
-  const app = {};
-  vi.stubGlobal("useDmsApp", () => app);
-  vi.stubGlobal("useDmsState", (key: string, initial: () => unknown) => {
-    if (!state.has(key)) state.set(key, ref(initial()));
-    return state.get(key);
-  });
-  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: authFetch }));
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.resetAllMocks();
-});
-
-it("deduplicates consumers but never writes an old account response into a new cache", async () => {
-  let finish!: (value: unknown) => void;
-  authFetch.mockReturnValueOnce(
-    new Promise((resolve) => {
-      finish = resolve;
-    }),
-  );
-  const first = useSiteLayout();
-  const second = useSiteLayout();
-  const oldRequest = first.loadPageLayout("/layout");
-  const joined = second.loadPageLayout("/layout");
-  expect(authFetch).toHaveBeenCalledTimes(1);
-
-  state.get("dms-pageLayouts")!.value = {};
-  authFetch.mockResolvedValueOnce({ components: { fresh: {} } });
-  await second.loadPageLayout("/layout");
-  finish({ components: { secret: {} } });
-  await Promise.all([oldRequest, joined]);
-  expect(authFetch).toHaveBeenCalledTimes(2);
-  expect(first.pageLayouts.value).toEqual({
-    "/layout": { components: { fresh: {} } },
-  });
-});
-
-it("does not overwrite an Inertia site payload with a pre-navigation fetch", async () => {
-  let finish!: (value: unknown) => void;
-  authFetch.mockReturnValueOnce(
-    new Promise((resolve) => {
-      finish = resolve;
-    }),
-  );
-  const layout = useSiteLayout();
-  const request = layout.loadSiteLayout();
-  state.get("dms-siteLayout")!.value = { pages: { fresh: {} }, categories: {} };
-  finish({ siteLayout: { pages: { secret: {} }, categories: {} } });
-  await request;
-  expect(layout.siteLayout.value).toEqual({
-    pages: { fresh: {} },
-    categories: {},
-  });
-});
-
-it("does not show a stale request error after successful Inertia navigation", async () => {
-  let fail!: (error: unknown) => void;
-  authFetch.mockReturnValueOnce(
-    new Promise((_, reject) => {
-      fail = reject;
-    }),
-  );
-  const showDmsError = vi.fn();
-  vi.stubGlobal("showDmsError", showDmsError);
-  const layout = useSiteLayout();
-  const request = layout.loadSiteLayout();
-  state.get("dms-siteLayout")!.value = { pages: { fresh: {} }, categories: {} };
-  fail(new Error("old account request"));
-  await expect(request).rejects.toThrow("old account request");
-  expect(showDmsError).not.toHaveBeenCalled();
-  expect(layout.loadingError.value).toBeNull();
-});

package/frontend-vue/tests/site-layout-refresh.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-/**
- * The refresh contract of `useSiteLayout`, extracted so it can be exercised
- * without a DMS app runtime: the composable parks its in-flight fetch on the DMS app
- * app instance, everything else here is the same control flow.
- *
- * What it has to guarantee: a refresh asked for while a fetch is already in
- * flight never reports success on that fetch's answer — it was started before
- * whatever prompted the refresh, so it cannot contain the change.
- */
-function createSiteLayoutRefresher(
-  fetchLayout: () => Promise<void>,
-  // The composable parks the in-flight fetch on the DMS app, so every caller
-  // of useSiteLayout coordinates through one holder; passing it in mirrors
-  // that, and lets a test act as a second instance.
-  holder: { loadingPromise: Promise<void> | null } = { loadingPromise: null },
-) {
-  const state = holder;
-
-  const start = (): Promise<void> => {
-    const started = fetchLayout().finally(() => {
-      if (state.loadingPromise === started) {
-        state.loadingPromise = null;
-      }
-    });
-    state.loadingPromise = started;
-    return started;
-  };
-
-  const refresh = async (): Promise<void> => {
-    const inFlight = state.loadingPromise;
-    if (inFlight) {
-      await inFlight.catch(() => undefined);
-      if (state.loadingPromise === inFlight) {
-        state.loadingPromise = null;
-      }
-    }
-    if (!state.loadingPromise) {
-      start();
-    }
-    await state.loadingPromise;
-  };
-
-  return { refresh, start, state };
-}
-
-function deferred() {
-  let resolve!: () => void;
-  let reject!: (error: unknown) => void;
-  const promise = new Promise<void>((res, rej) => {
-    resolve = () => res();
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-
-describe("useSiteLayout refresh", () => {
-  it("refetches instead of joining a fetch that predates the change", async () => {
-    const first = deferred();
-    const answers = [first.promise, Promise.resolve()];
-    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
-    const { refresh, start } = createSiteLayoutRefresher(fetchLayout);
-
-    start();
-    const refreshed = refresh();
-    first.resolve();
-    await refreshed;
-
-    // The in-flight answer cannot hold the change, so a second one is fetched.
-    expect(fetchLayout).toHaveBeenCalledTimes(2);
-  });
-
-  it("collapses a burst into a single refetch", async () => {
-    const first = deferred();
-    const answers = [first.promise, Promise.resolve(), Promise.resolve()];
-    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
-    const { refresh, start } = createSiteLayoutRefresher(fetchLayout);
-
-    start();
-    const refreshes = [refresh(), refresh(), refresh()];
-    first.resolve();
-    await Promise.all(refreshes);
-
-    // Three refreshes over one in-flight fetch: one relaunch, not three.
-    expect(fetchLayout).toHaveBeenCalledTimes(2);
-  });
-
-  it("refetches after a failed fetch instead of reporting its failure", async () => {
-    const first = deferred();
-    const answers = [first.promise, Promise.resolve()];
-    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
-    const { refresh, start } = createSiteLayoutRefresher(fetchLayout);
-
-    start().catch(() => undefined);
-    const refreshed = refresh();
-    first.reject(new Error("network blip"));
-
-    await expect(refreshed).resolves.toBeUndefined();
-    expect(fetchLayout).toHaveBeenCalledTimes(2);
-  });
-
-  // Two instances of the composable write the same shared layout state, so
-  // they have to share the in-flight fetch: otherwise the older answer can
-  // land last and overwrite the fresher menu.
-  it("shares the in-flight fetch between instances", async () => {
-    const first = deferred();
-    const answers = [first.promise, Promise.resolve()];
-    const fetchLayout = vi.fn(() => answers.shift() ?? Promise.resolve());
-    const holder = { loadingPromise: null as Promise<void> | null };
-    const instanceA = createSiteLayoutRefresher(fetchLayout, holder);
-    const instanceB = createSiteLayoutRefresher(fetchLayout, holder);
-
-    instanceA.start();
-    const refreshed = instanceB.refresh();
-    first.resolve();
-    await refreshed;
-
-    // B saw A's fetch and relaunched once, rather than racing it.
-    expect(fetchLayout).toHaveBeenCalledTimes(2);
-  });
-
-  it("starts one fetch when nothing is in flight", async () => {
-    const fetchLayout = vi.fn(() => Promise.resolve());
-    const { refresh } = createSiteLayoutRefresher(fetchLayout);
-
-    await refresh();
-
-    expect(fetchLayout).toHaveBeenCalledTimes(1);
-  });
-});

package/frontend-vue/tests/site-layout-rendered.test.ts

@@ -1,103 +0,0 @@
-// @vitest-environment jsdom
-/**
- * The site layout of a page that brings none with its props (a custom page)
- * as the sidebar reads it, through the runtime's real async data: the server
- * waits for it and renders the menu, and the browser takes it over without
- * asking again. A page that brought it reads nothing.
- */
-import {
-  defineComponent,
-  getCurrentInstance,
-  h,
-  nextTick,
-  type App,
-} from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import {
-  engine,
-  hydrate,
-  serverRender,
-  stubApiData,
-} from "./helpers/api-data-runtime";
-import {
-  useRenderedSiteLayout,
-  useSiteLayout,
-} from "../layers/dms-layout/app/composables/page/useSiteLayout";
-
-const RESPONSE = {
-  siteLayout: { pages: { "/orders": { fullId: "orders" } }, categories: {} },
-  siteLayoutTree: { children: {} },
-  quickActions: { actions: [] },
-  modules: {},
-  isOwner: true,
-};
-
-const authFetch = vi.fn();
-const mounted: App[] = [];
-
-// The menu as the header and the sidebar draw it: rendered by the frame, in
-// the persistent layout, outside the page's <Suspense>.
-const Menu = defineComponent({
-  setup() {
-    const { siteLayout } = useSiteLayout();
-    return () =>
-      h("nav", Object.keys(siteLayout.value?.pages ?? {}).join(",") || "-");
-  },
-});
-const Frame = defineComponent({
-  setup() {
-    useRenderedSiteLayout();
-    return () => h("div", [h(Menu), h(Menu)]);
-  },
-});
-const Layout = defineComponent({ setup: () => () => h("main", [h(Frame)]) });
-
-beforeEach(() => {
-  stubApiData(authFetch);
-  // The application holds the in-flight request its callers join.
-  vi.stubGlobal(
-    "useDmsApp",
-    () => getCurrentInstance()!.appContext.config.globalProperties,
-  );
-  vi.stubGlobal("showDmsError", vi.fn());
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-  vi.unstubAllGlobals();
-  vi.resetAllMocks();
-});
-
-it("renders the menu of a page without a site layout, and the browser does not read it again", async () => {
-  authFetch.mockResolvedValue(RESPONSE);
-  const { html, payload } = await serverRender(Layout);
-  expect(html).toBe(
-    "<main><div><nav>/orders</nav><nav>/orders</nav></div></main>",
-  );
-  expect(authFetch).toHaveBeenCalledTimes(1);
-  expect(authFetch).toHaveBeenCalledWith("/dms/sitelayout");
-
-  authFetch.mockClear();
-  const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-  const { app, container } = hydrate(Layout, html, payload);
-  mounted.push(app);
-  await nextTick();
-  await new Promise((done) => setTimeout(done, 0));
-  expect(authFetch).not.toHaveBeenCalled();
-  expect(container.innerHTML).toBe(html);
-  // Taken over before the frame's children render: they hydrate the menu.
-  expect(warn.mock.calls.flat().join(" ")).not.toMatch(/hydration/i);
-});
-
-it("reads nothing when the page brought its site layout", async () => {
-  const { html, payload } = await serverRender(Layout, (app) =>
-    app.runWithContext(() => {
-      engine.useDmsState("dms-siteLayout").value = RESPONSE.siteLayout;
-    }),
-  );
-  expect(html).toBe(
-    "<main><div><nav>/orders</nav><nav>/orders</nav></div></main>",
-  );
-  expect(authFetch).not.toHaveBeenCalled();
-  expect(payload.data).toEqual({});
-});

package/frontend-vue/tests/site-layout-resync.test.ts

@@ -1,87 +0,0 @@
-// @vitest-environment jsdom
-import { ref, type Ref } from "vue";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// What a realtime menu invalidation does: a partial reload of the page on
-// screen through Inertia, which replaces the site layout every visit carries
-// over (a once prop) along with the state.
-const reload = vi.hoisted(() => vi.fn());
-const flushAll = vi.hoisted(() => vi.fn());
-vi.mock("@inertiajs/vue3", () => ({ router: { reload, flushAll } }));
-
-const { useSiteLayout } = await import(
-  "../layers/dms-layout/app/composables/page/useSiteLayout"
-);
-
-type ReloadOptions = {
-  only: string[];
-  onHttpException: (response: { status: number }) => boolean | void;
-  onNetworkError: (error: Error) => boolean | void;
-  onFinish: () => void;
-};
-
-const state = new Map<string, Ref>();
-
-beforeEach(() => {
-  state.clear();
-  const app = {};
-  vi.stubGlobal("useDmsApp", () => app);
-  vi.stubGlobal("useDmsState", (key: string, initial: () => unknown) => {
-    if (!state.has(key)) state.set(key, ref(initial()));
-    return state.get(key);
-  });
-  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: vi.fn() }));
-  window.history.replaceState(null, "", "/projects");
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  reload.mockReset();
-  flushAll.mockReset();
-});
-
-describe("useSiteLayout resync", () => {
-  it("reloads the site layout and the page through Inertia", async () => {
-    reload.mockImplementation((options: ReloadOptions) => options.onFinish());
-    await useSiteLayout().resync();
-    expect(reload).toHaveBeenCalledTimes(1);
-    expect(reload.mock.calls[0]![0].only).toEqual(["shared", "page"]);
-  });
-
-  it("drops the pages prefetched with the previous menu before reloading", async () => {
-    reload.mockImplementation((options: ReloadOptions) => options.onFinish());
-    await useSiteLayout().resync();
-    expect(flushAll).toHaveBeenCalledOnce();
-    expect(flushAll.mock.invocationCallOrder[0]).toBeLessThan(
-      reload.mock.invocationCallOrder[0]!,
-    );
-  });
-
-  it("rejects a failed reload and keeps the page on screen", async () => {
-    let swapsPage: boolean | void = true;
-    reload.mockImplementation((options: ReloadOptions) => {
-      swapsPage = options.onHttpException({ status: 502 });
-      options.onFinish();
-    });
-    await expect(useSiteLayout().resync()).rejects.toThrow("502");
-    expect(swapsPage).toBe(false);
-
-    reload.mockImplementation((options: ReloadOptions) => {
-      swapsPage = options.onNetworkError(new Error("offline"));
-      options.onFinish();
-    });
-    await expect(useSiteLayout().resync()).rejects.toThrow("offline");
-    expect(swapsPage).toBe(false);
-  });
-
-  it("reloads the page a navigation opened while the reload was in flight", async () => {
-    reload.mockImplementationOnce((options: ReloadOptions) => {
-      // Inertia drops an async answer for a page the user has left.
-      window.history.replaceState(null, "", "/tasks");
-      options.onFinish();
-    });
-    reload.mockImplementation((options: ReloadOptions) => options.onFinish());
-    await useSiteLayout().resync();
-    expect(reload).toHaveBeenCalledTimes(2);
-  });
-});