@antelopejs/dms 0.9.2 → 0.9.3

package/frontend-vue/tests/oauth-complete-handoff.test.ts

@@ -1,209 +0,0 @@
-// @vitest-environment jsdom
-import {
-  computed,
-  createApp,
-  defineComponent,
-  h,
-  nextTick,
-  onMounted,
-  reactive,
-  ref,
-  Suspense,
-  watch,
-  type App,
-  type Ref,
-} from "vue";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import { usePostLoginRedirect } from "../layers/dms-auth/app/composables/usePostLoginRedirect";
-import { usePageLayout } from "../layers/dms-layout/app/composables/page/usePageLayout";
-import { useSiteLayout } from "../layers/dms-layout/app/composables/page/useSiteLayout";
-import type { PageLayout } from "../layers/dms-layout/app/types/page";
-
-// The OAuth completion page, drawn by the real page layout cache: the
-// post-login redirect refreshes the site layout for the new identity, which
-// empties that cache and remounts the page while its layout comes back.
-
-const { default: OAuthCompletePage } = await import(
-  "../layers/dms-auth/app/custom-pages/auth/oauth-complete.vue"
-);
-
-const PATH = "/auth/oauth/complete";
-const LAYOUT_URL = `${PATH}/pagelayout`;
-const SITE_LAYOUT_URL = "/dms/sitelayout";
-const HANDOFF_URL = "/auth/oauth/handoff";
-const HOMEPAGE = "/home";
-
-const state = new Map<string, Ref>();
-const authFetch = vi.fn();
-const fetchHandoff = vi.fn();
-const navigate = vi.fn();
-let mounts = 0;
-let route: { path: string; query: Record<string, string> };
-let app: App;
-let host: HTMLDivElement;
-
-const completionLayout: PageLayout = {
-  components: { complete: { options: {} } },
-  layout: {},
-} as unknown as PageLayout;
-
-const siteResponse = {
-  siteLayout: {
-    pages: {
-      [PATH]: {
-        id: "auth-oauth-complete",
-        fullId: "auth-oauth-complete",
-        fullSlug: PATH,
-        displayName: "Completing",
-        layoutUrl: LAYOUT_URL,
-        publicAccess: true,
-      },
-    },
-    categories: {},
-  },
-  siteLayoutTree: undefined,
-  quickActions: undefined,
-  modules: {},
-  isOwner: false,
-};
-
-const Page = defineComponent({
-  async setup() {
-    const { pageLayout } = await usePageLayout();
-    return () =>
-      h(
-        "main",
-        Object.keys(pageLayout.value?.components ?? {}).map((key) =>
-          h(OAuthCompletePage, { key }),
-        ),
-      );
-  },
-});
-
-function installRuntime() {
-  const runtime = {
-    runWithContext: (fn: () => unknown) => fn(),
-    $i18n: { setLocale: vi.fn() },
-  };
-  Object.entries({ computed, ref, watch }).forEach(([key, value]) =>
-    vi.stubGlobal(key, value),
-  );
-  vi.stubGlobal("onMounted", (hook: () => unknown) =>
-    onMounted(() => {
-      mounts += 1;
-      return hook();
-    }),
-  );
-  vi.stubGlobal("useDmsApp", () => runtime);
-  vi.stubGlobal("useDmsRoute", () => route);
-  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 }));
-  vi.stubGlobal("useSiteLayout", useSiteLayout);
-  vi.stubGlobal("useHomepage", () => HOMEPAGE);
-  vi.stubGlobal("useDmsUserSession", () => ({
-    fetch: async () => undefined,
-    user: ref({ _id: "user" }),
-  }));
-  vi.stubGlobal("useMultiAccount", () => ({ addCurrentAccount: vi.fn() }));
-  vi.stubGlobal("usePostLoginRedirect", usePostLoginRedirect);
-  vi.stubGlobal("navigateDms", navigate);
-  vi.stubGlobal("$fetch", (url: string, options: unknown) =>
-    url === HANDOFF_URL ? fetchHandoff(options) : Promise.reject(url),
-  );
-}
-
-function mountCompletionPage() {
-  route.path = PATH;
-  const layout = useSiteLayout();
-  layout.siteLayout.value = siteResponse.siteLayout as never;
-  layout.pageLayouts.value = { [LAYOUT_URL]: completionLayout };
-  app = createApp({
-    render: () => h(Suspense, null, { default: () => h(Page) }),
-  });
-  app.config.globalProperties.$t = (key: string) => key;
-  app.component("UIcon", defineComponent({ setup: () => () => h("i") }));
-  app.mount(host);
-}
-
-const siteLayoutFetches = () =>
-  authFetch.mock.calls.filter(([url]) => url === SITE_LAYOUT_URL).length;
-
-async function settle() {
-  for (let tick = 0; tick < 20; tick++) {
-    await Promise.resolve();
-    await nextTick();
-  }
-}
-
-beforeEach(() => {
-  state.clear();
-  mounts = 0;
-  // Answered on later tasks, like the network, the page layout first as on
-  // the playground: the page is drawn again before the redirect leaves it.
-  authFetch.mockImplementation(async (url: string) => {
-    const site = url === SITE_LAYOUT_URL;
-    await new Promise((resolve) => setTimeout(resolve, site ? 5 : 0));
-    return site ? siteResponse : completionLayout;
-  });
-  fetchHandoff.mockResolvedValue({ kind: "none" });
-  route = reactive({ path: PATH, query: {} });
-  // Leaving the page unmounts it, as the router does: the completion page
-  // has no layout on any other route.
-  navigate.mockImplementation(async (to: string | { path: string }) => {
-    route.path = typeof to === "string" ? to : to.path;
-  });
-  installRuntime();
-  host = document.createElement("div");
-  document.body.append(host);
-});
-
-afterEach(() => {
-  app?.unmount();
-  host.remove();
-  vi.unstubAllGlobals();
-  vi.resetAllMocks();
-});
-
-it("consumes the handoff once when the identity refresh remounts the page", async () => {
-  mountCompletionPage();
-  await vi.waitFor(() =>
-    expect(navigate).toHaveBeenCalledWith(HOMEPAGE, { replace: true }),
-  );
-  await settle();
-
-  expect(fetchHandoff).toHaveBeenCalledOnce();
-  expect(siteLayoutFetches()).toBe(1);
-  expect(navigate).toHaveBeenCalledOnce();
-  // The refresh did empty the cache and remount the page: the new instance
-  // joined the completion already running.
-  expect(mounts).toBe(2);
-});
-
-it("redirects to the sign-in page once when the handoff fails", async () => {
-  fetchHandoff.mockRejectedValue(new Error("offline"));
-  mountCompletionPage();
-  await vi.waitFor(() => expect(navigate).toHaveBeenCalled());
-  await settle();
-
-  expect(fetchHandoff).toHaveBeenCalledOnce();
-  expect(navigate).toHaveBeenCalledExactlyOnceWith(
-    { path: "/auth", query: { oauth_error: "error.oauth.failed" } },
-    { replace: true },
-  );
-});
-
-it("completes again on a later visit, once the previous one settled", async () => {
-  mountCompletionPage();
-  await vi.waitFor(() => expect(navigate).toHaveBeenCalledOnce());
-  await settle();
-  app.unmount();
-
-  mountCompletionPage();
-  await vi.waitFor(() => expect(navigate).toHaveBeenCalledTimes(2));
-  await settle();
-
-  expect(fetchHandoff).toHaveBeenCalledTimes(2);
-});

package/frontend-vue/tests/onboarding-middleware.test.ts

@@ -1,103 +0,0 @@
-import { readFileSync } from "node:fs";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-type Middleware = (to: { path: string }) => Promise<unknown>;
-
-const navigateDms = vi.fn();
-const onboarding = vi.fn();
-const session = { loggedIn: { value: false } };
-
-beforeEach(() => {
-  vi.resetModules();
-  vi.stubGlobal("defineDmsMiddleware", (handler: Middleware) => handler);
-  vi.stubGlobal("navigateDms", navigateDms);
-  vi.stubGlobal("useOnboarding", onboarding);
-  vi.stubGlobal("useDmsUserSession", () => session);
-  vi.stubGlobal("useHomepage", () => "/dashboard");
-});
-
-afterEach(() => {
-  session.loggedIn.value = false;
-  navigateDms.mockReset();
-  onboarding.mockReset();
-  vi.unstubAllGlobals();
-});
-
-async function loadMiddleware(): Promise<Middleware> {
-  const module = await import(
-    "../layers/dms-onboarding/app/middleware/onboarding.global"
-  );
-  return module.default as unknown as Middleware;
-}
-
-describe("onboarding middleware", () => {
-  it("sends every route to the wizard while no admin exists", async () => {
-    onboarding.mockResolvedValue({ hasOnboarded: false });
-    const middleware = await loadMiddleware();
-
-    await middleware({ path: "/settings" });
-
-    expect(navigateDms).toHaveBeenCalledWith("/onboarding");
-  });
-
-  it("lets the wizard render while no admin exists", async () => {
-    onboarding.mockResolvedValue({ hasOnboarded: false });
-    const middleware = await loadMiddleware();
-
-    await middleware({ path: "/onboarding" });
-
-    expect(navigateDms).not.toHaveBeenCalled();
-  });
-
-  it("sends a signed-in user away from the finished wizard to the homepage", async () => {
-    onboarding.mockResolvedValue({ hasOnboarded: true });
-    session.loggedIn.value = true;
-    const middleware = await loadMiddleware();
-
-    await middleware({ path: "/onboarding" });
-
-    expect(navigateDms).toHaveBeenCalledWith("/dashboard", { replace: true });
-  });
-
-  it("sends an anonymous visitor away from the finished wizard to the login page", async () => {
-    onboarding.mockResolvedValue({ hasOnboarded: true });
-    const middleware = await loadMiddleware();
-
-    await middleware({ path: "/onboarding" });
-
-    expect(navigateDms).toHaveBeenCalledWith("/auth", { replace: true });
-  });
-
-  it("leaves other routes alone once onboarding is done", async () => {
-    onboarding.mockResolvedValue({ hasOnboarded: true });
-    const middleware = await loadMiddleware();
-
-    await middleware({ path: "/settings" });
-
-    expect(navigateDms).not.toHaveBeenCalled();
-  });
-
-  it("does not block navigation when the onboarding status is unavailable", async () => {
-    onboarding.mockRejectedValue(new Error("offline"));
-    const middleware = await loadMiddleware();
-
-    await middleware({ path: "/onboarding" });
-
-    expect(navigateDms).not.toHaveBeenCalled();
-  });
-});
-
-describe("onboarding page", () => {
-  // Global middleware runs on a direct load only for a page declaring its
-  // meta: without it, a finished wizard would render instead of redirecting.
-  it("declares its meta so the onboarding middleware runs on a direct load", () => {
-    const page = readFileSync(
-      new URL(
-        "../layers/dms-onboarding/app/custom-pages/onboarding.vue",
-        import.meta.url,
-      ),
-      "utf8",
-    );
-    expect(page).toMatch(/defineDmsPageMeta\(/);
-  });
-});

package/frontend-vue/tests/onboarding-register.test.ts

@@ -1,155 +0,0 @@
-import { readFileSync } from "node:fs";
-import { transpileModule } from "typescript";
-import { computed, reactive, ref } from "vue";
-import * as z from "zod";
-import striptags from "striptags";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-
-const register = vi.fn();
-const login = vi.fn();
-const complete = vi.fn();
-const redirect = vi.fn();
-const emit = vi.fn();
-const showError = vi.fn();
-const replaceLocation = vi.fn();
-const platform = { name: "Acme back office", language: "fr" };
-const data = {
-  firstName: "Camille",
-  lastName: "Laurent",
-  email: "admin@example.test",
-  password: "test-only",
-};
-
-const REGISTER_STEP = "components/onboarding/steps/register.vue";
-const READY_STEP = "build/components/onboarding/steps/ready.vue";
-
-const IMPORT_STATEMENT = /^import[\s\S]*?from\s+"[^"]+";$/gm;
-
-/** The named function of a step's `<script setup>`, run against stubs. */
-function loadStepFunction<T>(file: string, name: string): T {
-  const component = readFileSync(
-    new URL(`../layers/dms-onboarding/app/${file}`, import.meta.url),
-    "utf8",
-  );
-  const script = component
-    .split('<script setup lang="ts">')[1]!
-    .split("</script>")[0]!;
-  const { outputText } = transpileModule(
-    script.replace(IMPORT_STATEMENT, ""),
-    {},
-  );
-  return new Function("z", "striptags", `${outputText}; return ${name};`)(
-    z,
-    striptags,
-  );
-}
-
-beforeEach(() => {
-  vi.stubGlobal("ref", ref);
-  // Imports are stripped from the steps run here: their constants are stubbed.
-  vi.stubGlobal("TILE_ROW_INTERACTIVE_CLASS", "");
-  vi.stubGlobal("reactive", reactive);
-  vi.stubGlobal("computed", computed);
-  vi.stubGlobal("defineProps", () => ({ platform }));
-  vi.stubGlobal("defineEmits", () => emit);
-  vi.stubGlobal("passwordSchema", z.string());
-  vi.stubGlobal("useLocalizedSchema", (schema: unknown) => schema);
-  vi.stubGlobal("useLiveFormErrors", () => undefined);
-  vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
-  vi.stubGlobal("useAuthFetch", () => ({ $authFetch: register }));
-  vi.stubGlobal("useAuthFormError", () => ({
-    formError: ref(null),
-    showError,
-    clearFormError: vi.fn(),
-  }));
-  vi.stubGlobal("useTemplateRef", () => ref(null));
-  vi.stubGlobal("$fetch", login);
-  vi.stubGlobal("useUniqueLocales", () => ({ uniqueLocales: ref([]) }));
-  vi.stubGlobal("useDmsApp", () => ({
-    runWithContext: (fn: () => unknown) => fn(),
-  }));
-  vi.stubGlobal("useSiteLayout", () => ({ siteLayoutTree: ref(undefined) }));
-  vi.stubGlobal("setOnboardingComplete", complete);
-  vi.stubGlobal("firstAccessiblePagePath", () => "/dashboard");
-  vi.stubGlobal("usePostLoginRedirect", redirect);
-  vi.stubGlobal("window", { location: { replace: replaceLocation } });
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.resetAllMocks();
-});
-
-type Submit = (event: { data: typeof data }) => Promise<void>;
-type Open = (destination?: string) => Promise<void>;
-
-it("registers with the platform details, signs in, then moves to the Ready step", async () => {
-  await loadStepFunction<Submit>(REGISTER_STEP, "onSubmit")({ data });
-
-  expect(register).toHaveBeenCalledWith("/api/onboarding/register", {
-    method: "POST",
-    body: { ...data, platformName: platform.name, language: platform.language },
-  });
-  expect(complete).toHaveBeenCalledOnce();
-  expect(login).toHaveBeenCalledWith("/auth/login", {
-    method: "POST",
-    body: { email: data.email, password: data.password },
-  });
-  expect(emit).toHaveBeenCalledExactlyOnceWith("registered", {
-    name: "Camille Laurent",
-    email: data.email,
-  });
-  expect(redirect).not.toHaveBeenCalled();
-  expect(showError).not.toHaveBeenCalled();
-});
-
-it("shows the error in the card and stays on the step when registration fails", async () => {
-  register.mockRejectedValueOnce(new Error("Registration failed"));
-  await loadStepFunction<Submit>(REGISTER_STEP, "onSubmit")({ data });
-  expect(complete).not.toHaveBeenCalled();
-  expect(login).not.toHaveBeenCalled();
-  expect(emit).not.toHaveBeenCalled();
-  expect(showError).toHaveBeenCalledOnce();
-  expect(replaceLocation).not.toHaveBeenCalled();
-});
-
-it("opens login without allowing another registration after automatic login fails", async () => {
-  login.mockRejectedValueOnce(new Error("Login failed"));
-  const submit = loadStepFunction<Submit>(REGISTER_STEP, "onSubmit");
-  await submit({ data });
-  await submit({ data });
-  expect(register).toHaveBeenCalledOnce();
-  expect(complete).toHaveBeenCalledOnce();
-  expect(emit).not.toHaveBeenCalled();
-  expect(replaceLocation).toHaveBeenCalledExactlyOnceWith("/auth");
-});
-
-it("opens the first accessible page from the Ready step once the session is refreshed", async () => {
-  await loadStepFunction<Open>(READY_STEP, "open")();
-
-  expect(redirect).toHaveBeenCalledOnce();
-  expect(redirect.mock.calls[0]![0]()).toBe("/dashboard");
-});
-
-it("opens a next step's page from the Ready step", async () => {
-  await loadStepFunction<Open>(
-    READY_STEP,
-    "open",
-  )("/settings/workspace/members");
-
-  expect(redirect).toHaveBeenCalledExactlyOnceWith(
-    "/settings/workspace/members",
-  );
-});
-
-it.each(["Session failed", "Layout failed"])(
-  "uses a full reload to recover from %s when leaving the Ready step",
-  async (message) => {
-    redirect.mockRejectedValueOnce(new Error(message));
-    const open = loadStepFunction<Open>(READY_STEP, "open");
-    await open();
-    await open();
-    expect(redirect).toHaveBeenCalledOnce();
-    expect(replaceLocation).toHaveBeenCalledExactlyOnceWith("/auth");
-  },
-);

package/frontend-vue/tests/onboarding-transfer.test.ts

@@ -1,106 +0,0 @@
-// @vitest-environment jsdom
-/**
- * The onboarding status the global middleware reads while a server renders a
- * page reaches the browser with the page, through the runtime's real state
- * transfer: the browser's run of the middleware asks nothing.
- */
-import { createApp, createSSRApp, defineComponent, h, nextTick } from "vue";
-import { renderToString } from "vue/server-renderer";
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import type { App } from "vue";
-import type { DmsFrontendRuntime } from "#dms/frontend-module";
-
-const engine = await import("#dms/frontend-module");
-vi.stubGlobal("useDmsState", engine.useDmsState);
-vi.stubGlobal("defineDmsMiddleware", engine.defineDmsMiddleware);
-vi.stubGlobal("navigateDms", engine.navigateDms);
-vi.stubGlobal("useDmsUserSession", () => ({ loggedIn: { value: true } }));
-vi.stubGlobal("useHomepage", () => "/dashboard");
-
-const $authFetch = vi.fn(async () => ({ has_onboarded: true }));
-vi.stubGlobal("useAuthFetch", () => ({ $authFetch }));
-// The status is read once per app however many callers ask (the preload
-// started with the app, the middleware).
-// No DMS app runs here: each runtime holds the deduper on a state of its own.
-vi.stubGlobal(
-  "useDmsApp",
-  () => engine.useDmsState("onboarding-test-app", () => ({})).value,
-);
-const { createTrailingDeduper } = await import(
-  "../layers/dms-core/app/utils/trailingDeduper"
-);
-vi.stubGlobal("createTrailingDeduper", createTrailingDeduper);
-const { useTrailingDeduper } = await import(
-  "../layers/dms-core/app/composables/useTrailingDeduper"
-);
-vi.stubGlobal("useTrailingDeduper", useTrailingDeduper);
-
-const { useOnboarding } = await import(
-  "../layers/dms-onboarding/app/composables/onboarding/useOnboarding"
-);
-vi.stubGlobal("useOnboarding", useOnboarding);
-const { default: onboardingMiddleware } = await import(
-  "../layers/dms-onboarding/app/middleware/onboarding.global"
-);
-
-const Page = defineComponent({
-  setup() {
-    engine.defineDmsPageMeta({});
-    const info = engine.useDmsState<{ hasOnboarded: boolean } | null>(
-      "dms-onboarding-info",
-    );
-    return () => h("p", info.value?.hasOnboarded ? "onboarded" : "unknown");
-  },
-});
-
-const mounted: App[] = [];
-
-function attach(app: App, runtime: DmsFrontendRuntime): void {
-  runtime.route.path = "/dashboard";
-  runtime.route.fullPath = "/dashboard";
-  engine.provideDmsFrontendRuntime(app, runtime);
-}
-
-beforeEach(async () => {
-  $authFetch.mockClear();
-  await engine.setupFrontendModules([
-    {
-      options: { public: {} },
-      module: {
-        setup(sdk) {
-          sdk.registerMiddleware("onboarding", onboardingMiddleware, {
-            global: true,
-          });
-        },
-      },
-    },
-  ]);
-});
-
-afterEach(() => {
-  mounted.splice(0).forEach((app) => app.unmount());
-});
-
-it("hands the onboarding status the server read to the browser", async () => {
-  const server = engine.createDmsFrontendRuntime(undefined, {}, true);
-  const serverApp = createSSRApp(Page);
-  attach(serverApp, server);
-  expect(await renderToString(serverApp)).toBe("<p>onboarded</p>");
-  expect($authFetch).toHaveBeenCalledTimes(1);
-  const payload = structuredClone(engine.serializeDmsPayload(server));
-  expect(payload.state["dms-onboarding-info"]).toEqual({ hasOnboarded: true });
-
-  $authFetch.mockClear();
-  const browser = engine.createDmsFrontendRuntime(undefined, {});
-  engine.restoreDmsPayload(browser, payload);
-  const browserApp = createApp(Page);
-  attach(browserApp, browser);
-  const host = document.createElement("div");
-  browserApp.mount(host);
-  mounted.push(browserApp);
-  await nextTick();
-  await new Promise((done) => setTimeout(done, 0));
-
-  expect($authFetch).not.toHaveBeenCalled();
-  expect(host.textContent).toBe("onboarded");
-});

package/frontend-vue/tests/otp-input.test.ts

@@ -1,97 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, expect, it, vi } from "vitest";
-import {
-  type App,
-  createApp,
-  type FunctionalComponent,
-  h,
-  nextTick,
-  ref,
-} from "vue";
-
-const CELLS = 6;
-
-interface PinInputStubProps {
-  modelValue?: string[];
-  length?: number;
-}
-
-const PinInput: FunctionalComponent<PinInputStubProps, ["complete"]> = (
-  props,
-  { attrs, emit },
-) =>
-  h(
-    "div",
-    { ...attrs },
-    Array.from({ length: props.length ?? CELLS }, (_, index) =>
-      h("input", {
-        value: props.modelValue?.[index] ?? "",
-        onInput: () => emit("complete"),
-      }),
-    ),
-  );
-PinInput.props = ["modelValue", "length"];
-PinInput.emits = ["complete"];
-
-let app: App | undefined;
-let host: HTMLDivElement;
-
-async function mount(props: Record<string, unknown> = {}) {
-  const { default: OtpInput } = await import(
-    "../layers/dms-ui/app/build/components/form/OtpInput.vue"
-  );
-  const exposed = ref<{ focus: () => void } | null>(null);
-  const onComplete = vi.fn();
-  app = createApp({
-    setup: () => () =>
-      h(OtpInput, { ref: exposed, label: "Code", onComplete, ...props }),
-  });
-  app.component("UPinInput", PinInput);
-  app.component("UIcon", () => h("i"));
-  app.mount(host);
-  await nextTick();
-  return { exposed, onComplete };
-}
-
-const cells = () => [...host.querySelectorAll("input")];
-
-beforeEach(() => {
-  vi.useFakeTimers();
-  host = document.createElement("div");
-  document.body.append(host);
-});
-
-afterEach(() => {
-  app?.unmount();
-  host.remove();
-  vi.useRealTimers();
-});
-
-it("names its cells and reports a full code", async () => {
-  const { onComplete } = await mount();
-  const group = host.querySelector("[role=group]")!;
-  expect(group.getAttribute("aria-label")).toBe("Code");
-  expect(group.getAttribute("aria-describedby")).toBeNull();
-
-  cells()[0]!.dispatchEvent(new Event("input"));
-  expect(onComplete).toHaveBeenCalledOnce();
-});
-
-it("describes the cells with a refused code's message", async () => {
-  await mount({ error: "Wrong code" });
-  const group = host.querySelector("[role=group]")!;
-  const errorId = group.getAttribute("aria-describedby")!;
-  expect(document.getElementById(errorId)?.textContent).toBe("Wrong code");
-  expect(
-    host.querySelector("[aria-invalid]")?.getAttribute("aria-invalid"),
-  ).toBe("true");
-});
-
-it("focuses the first empty cell, once the form gives the cells back", async () => {
-  const { exposed } = await mount({ modelValue: ["1", "2"] });
-  exposed.value!.focus();
-  expect(document.activeElement).not.toBe(cells()[2]);
-
-  vi.runAllTimers();
-  expect(document.activeElement).toBe(cells()[2]);
-});