Skip to content
Python
10.6 KB
Raw Blame
// @vitest-environment jsdom

import type { LanguageSnapshot } from "@one-memory/i18n";
import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { StrictMode } from "react";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import {
  LANGUAGE_STORAGE_KEY,
  LanguageProvider,
  useGuiLanguage,
} from "./gui-language";

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((yes, no) => {
    resolve = yes;
    reject = no;
  });
  return { promise, resolve, reject };
}
function Probe() {
  const language = useGuiLanguage();
  return (
    <>
      <output>
        {language.locale}:{language.preference}
      </output>
      <input aria-label="draft" defaultValue="draft" />
      <button onClick={() => void language.setPreference("es")} type="button">
        Spanish
      </button>
      {language.error && <p role="alert">{language.error}</p>}
    </>
  );
}
function mount() {
  return render(
    <StrictMode>
      <LanguageProvider>
        <Probe />
      </LanguageProvider>
    </StrictMode>,
  );
}
function desktop(get: () => Promise<LanguageSnapshot>) {
  const listeners = new Set<(value: LanguageSnapshot) => void>();
  const unsubscribe = vi.fn();
  const bridge = {
    getLanguagePreference: vi.fn(() => {
      expect(listeners.size).toBe(1);
      return get();
    }),
    setLanguagePreference: vi
      .fn()
      .mockResolvedValue({ preference: "es", locale: "es", revision: 2 }),
    onLanguagePreferenceChanged: vi.fn(
      (listener: (value: LanguageSnapshot) => void) => {
        listeners.add(listener);
        return () => {
          listeners.delete(listener);
          unsubscribe();
        };
      },
    ),
  };
  window.oneMemory = bridge as unknown as NonNullable<Window["oneMemory"]>;
  return { bridge, listeners, unsubscribe };
}
beforeEach(() => {
  localStorage.clear();
  delete window.oneMemory;
  vi.spyOn(navigator, "language", "get").mockReturnValue("zh-Hans");
});
afterEach(() => {
  cleanup();
  delete window.oneMemory;
  vi.restoreAllMocks();
  localStorage.clear();
});

it("persists before publishing and retains form state without remounting", async () => {
  const user = userEvent.setup();
  mount();
  await user.type(screen.getByRole("textbox"), " preserved");
  await user.click(screen.getByRole("button"));
  expect(localStorage.getItem(LANGUAGE_STORAGE_KEY)).toBe("es");
  expect(screen.getByText("es:es")).toBeTruthy();
  expect(document.documentElement.lang).toBe("es");
  expect((screen.getByRole("textbox") as HTMLInputElement).value).toBe(
    "draft preserved",
  );
  cleanup();
  mount();
  expect(screen.getByText("es:es")).toBeTruthy();
});
it("keeps confirmed language and exposes storage write errors", async () => {
  mount();
  vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
    throw new Error("private storage");
  });
  await userEvent.click(screen.getByRole("button"));
  expect(screen.getByText("zh-Hans:system")).toBeTruthy();
  expect(screen.getByRole("alert").textContent).toBe("languageSaveError");
});
it("exposes browser read errors without crashing", () => {
  vi.spyOn(Storage.prototype, "getItem").mockImplementation(() => {
    throw new Error("denied");
  });
  mount();
  expect(screen.getByRole("alert").textContent).toBe("languageLoadError");
});
it("validates browser storage and synchronizes tabs and principal navigator language", () => {
  localStorage.setItem(LANGUAGE_STORAGE_KEY, "invalid");
  mount();
  expect(screen.getByText("zh-Hans:system")).toBeTruthy();
  act(() => {
    localStorage.setItem(LANGUAGE_STORAGE_KEY, "es");
    window.dispatchEvent(
      new StorageEvent("storage", {
        key: LANGUAGE_STORAGE_KEY,
        storageArea: localStorage,
      }),
    );
  });
  expect(screen.getByText("es:es")).toBeTruthy();
  act(() => {
    localStorage.removeItem(LANGUAGE_STORAGE_KEY);
    window.dispatchEvent(
      new StorageEvent("storage", { key: null, storageArea: localStorage }),
    );
  });
  vi.spyOn(navigator, "language", "get").mockReturnValue("es-MX");
  act(() => window.dispatchEvent(new Event("languagechange")));
  expect(screen.getByText("es:system")).toBeTruthy();
});
it("subscribes before reads, rejects stale snapshots and cleans StrictMode subscriptions", async () => {
  const reads = [deferred<LanguageSnapshot>(), deferred<LanguageSnapshot>()];
  let index = 0;
  const { listeners, unsubscribe } = desktop(() => reads[index++].promise);
  const view = mount();
  expect(listeners.size).toBe(1);
  act(() => {
    for (const listener of listeners)
      listener({ preference: "es", locale: "es", revision: 5 });
  });
  await act(async () => {
    for (const read of reads)
      read.resolve({ preference: "zh-Hans", locale: "zh-Hans", revision: 1 });
  });
  expect(screen.getByText("es:es")).toBeTruthy();
  view.unmount();
  expect(listeners.size).toBe(0);
  expect(unsubscribe).toHaveBeenCalledTimes(2);
});
it("never accesses browser persistence or browser locale in desktop mode and exposes read failures", async () => {
  const { listeners } = desktop(() => Promise.reject(new Error("unavailable")));
  const read = vi.spyOn(Storage.prototype, "getItem");
  const write = vi.spyOn(Storage.prototype, "setItem");
  mount();
  await waitFor(() =>
    expect(screen.getByRole("alert").textContent).toBe("languageLoadError"),
  );
  vi.spyOn(navigator, "language", "get").mockReturnValue("es");
  act(() => window.dispatchEvent(new Event("languagechange")));
  expect(screen.getByText("zh-Hans:system")).toBeTruthy();
  act(() => {
    for (const listener of listeners)
      listener({ preference: "system", locale: "es", revision: 3 });
  });
  expect(screen.queryByRole("alert")).toBeNull();
  expect(screen.getByText("es:system")).toBeTruthy();
  expect(read).not.toHaveBeenCalled();
  expect(write).not.toHaveBeenCalled();
});
it("does not surface an obsolete write failure after a newer save succeeds", async () => {
  const { bridge } = desktop(async () => ({
    preference: "system",
    locale: "zh-Hans",
    revision: 0,
  }));
  const first = deferred<LanguageSnapshot>();
  bridge.setLanguagePreference
    .mockReturnValueOnce(first.promise)
    .mockResolvedValueOnce({ preference: "es", locale: "es", revision: 2 });
  mount();
  await act(async () => {});
  await userEvent.click(screen.getByRole("button"));
  await userEvent.click(screen.getByRole("button"));
  expect(screen.getByText("es:es")).toBeTruthy();
  await act(async () => first.reject(new Error("obsolete failure")));
  expect(screen.queryByRole("alert")).toBeNull();
});

it("rejects conflicting native locale and explicit preference pairs", async () => {
  desktop(async () => ({ preference: "es", locale: "zh-Hans", revision: 1 }));
  mount();
  await waitFor(() =>
    expect(screen.getByRole("alert").textContent).toBe("languageLoadError"),
  );
  expect(screen.getByText("zh-Hans:system")).toBeTruthy();
});

it("does not allow a late write reply to overwrite a newer native event", async () => {
  const { bridge, listeners } = desktop(async () => ({
    preference: "system",
    locale: "zh-Hans",
    revision: 0,
  }));
  const write = deferred<LanguageSnapshot>();
  bridge.setLanguagePreference.mockReturnValue(write.promise);
  mount();
  await act(async () => {});
  await userEvent.click(screen.getByRole("button"));
  act(() => {
    for (const listener of listeners)
      listener({ preference: "zh-Hans", locale: "zh-Hans", revision: 8 });
  });
  await act(async () =>
    write.resolve({ preference: "es", locale: "es", revision: 7 }),
  );
  expect(screen.getByText("zh-Hans:zh-Hans")).toBeTruthy();
});

it("groups counts in Chinese only where tn asks for it, never with tnPlain", () => {
  function Counts() {
    const { tn, tnPlain } = useGuiLanguage();
    return (
      <>
        <p>{tn("healthMemories", 12345)}</p>
        <p>{tnPlain("healthRetrying", 12345)}</p>
        <p>{tnPlain("healthRetrying", 1)}</p>
      </>
    );
  }
  const view = (stored: string | null) => {
    if (stored) localStorage.setItem(LANGUAGE_STORAGE_KEY, stored);
    const { container, unmount } = render(
      <LanguageProvider>
        <Counts />
      </LanguageProvider>,
    );
    const lines = [...container.querySelectorAll("p")].map(
      (p) => p.textContent,
    );
    unmount();
    localStorage.clear();
    return lines;
  };
  expect(view(null)).toEqual([
    "12,345 条记忆",
    "12345 条这次没能整理成功,正在重试",
    "1 条这次没能整理成功,正在重试",
  ]);
  expect(view("es")).toEqual([
    "12.345 memorias",
    "12.345 no se pudieron procesar esta vez; reintentando",
    "1 no se pudo procesar esta vez; reintentando",
  ]);
});

it.each([
  ["zh-CN", "zh-Hans"],
  ["es", "es"],
  ["en", "en"],
])(
  "keeps an existing browser user's stored %s choice as %s",
  (stored, preference) => {
    localStorage.setItem(LANGUAGE_STORAGE_KEY, stored);
    mount();
    expect(screen.getByText(`${preference}:${preference}`)).toBeTruthy();
    expect(localStorage.getItem(LANGUAGE_STORAGE_KEY)).toBe(preference);
  },
);

it("tells Core the browser choice, null for the system language", async () => {
  const reportToCore = vi.fn().mockRejectedValueOnce(new Error("offline"));
  function Choose() {
    const language = useGuiLanguage();
    return (
      <>
        <output>{language.preference}</output>
        <button onClick={() => void language.setPreference("ja")} type="button">
          ja
        </button>
        <button
          onClick={() => void language.setPreference("system")}
          type="button"
        >
          system
        </button>
      </>
    );
  }
  render(
    <LanguageProvider reportToCore={reportToCore}>
      <Choose />
    </LanguageProvider>,
  );
  // Opening the browser UI tells Core nothing; only a choice does.
  expect(reportToCore).not.toHaveBeenCalled();
  await userEvent.click(screen.getByRole("button", { name: "ja" }));
  // A failed report never undoes the saved display language.
  expect(screen.getByRole("status").textContent).toBe("ja");
  await userEvent.click(screen.getByRole("button", { name: "system" }));
  expect(reportToCore.mock.calls).toEqual([["ja"], [null]]);
});

it("leaves telling Core to the Desktop main process", async () => {
  desktop(async () => ({
    preference: "system",
    locale: "zh-Hans",
    revision: 1,
  }));
  const reportToCore = vi.fn();
  render(
    <LanguageProvider reportToCore={reportToCore}>
      <Probe />
    </LanguageProvider>,
  );
  await userEvent.click(screen.getByRole("button", { name: "Spanish" }));
  await waitFor(() => expect(screen.getByText("es:es")).toBeTruthy());
  expect(reportToCore).not.toHaveBeenCalled();
});