Lutra/ui/tests/i18n/catalog.test.ts
danny cde6e119c6 M1.10: light theme, live theme switching, editor tokens
- theme::LIGHT next to DARK with the 10 new tokens (editor selection,
  active line, cursor, gutter, match, font size, tab active/modified,
  notice); light fg-muted, accent and error darkened for WCAG AA
- theme.list, theme.systemPreference, themeChanged event when the
  resolved theme changes (settings.set/reset appearance.theme, or the
  OS preference in system mode)
- desktop init script and window background from the stored setting;
  system mode uses a prefers-color-scheme media query for the first frame
- ui/src/theme.ts applies tokens to :root and color-scheme live; editor,
  tabs and notice drop their var() fallbacks
- Vitest WCAG AA contrast check against a Rust-maintained snapshot,
  DOM tests, headless control-channel test
- docs: architecture Themes, parity rows, ui-parity, gaps, roadmaps

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:49:23 +02:00

115 lines
3.7 KiB
TypeScript

/**
* Tests of the message catalog: the `t` helper (lookup, interpolation,
* missing keys) and a scan of the frontend source that every literal key
* passed to `t` exists in `en.json`.
*/
import { readdirSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";
import en from "../../src/i18n/en.json";
import { hasMessage, t } from "../../src/i18n";
/** Root of the frontend source tree. */
const SRC = join(import.meta.dirname, "..", "..", "src");
/**
* Lists the `.ts` and `.vue` files below a directory.
*
* @param dir - the directory.
*/
function sourceFiles(dir: string): string[] {
return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
const path = join(dir, entry.name);
if (entry.isDirectory()) {
return sourceFiles(path);
}
return /\.(ts|vue)$/.test(entry.name) ? [path] : [];
});
}
/** Every call of `t` with a literal first argument, by file. */
const usedKeys = sourceFiles(SRC).flatMap((file) =>
[...readFileSync(file, "utf8").matchAll(/\bt\(\s*(["'`])([^"'`]*)\1/g)].map((m) => ({
file,
key: m[2] ?? "",
})),
);
/**
* Keys the source never passes to `t` literally because they arrive at
* runtime from the engine: theme labels from `theme.list`.
*/
const RUNTIME_KEYS = new Set(["theme.lutraDark", "theme.lutraLight"]);
afterEach(() => {
vi.restoreAllMocks();
});
describe("t", () => {
it("returns the message of a key", () => {
expect(t("common.cancel")).toBe("Cancel");
});
it("fills in placeholders", () => {
expect(t("editor.tabs.close", { name: "index.php" })).toBe("Close index.php");
expect(t("app.statusBar.version", { name: "Lutra", version: "0.1.0" })).toBe("Lutra 0.1.0");
});
it("formats numbers", () => {
expect(t("common.toolWindow.hide", { title: 3 })).toBe("Hide 3");
});
it("keeps a placeholder without a value", () => {
expect(t("editor.tabs.close")).toBe("Close {name}");
expect(t("editor.tabs.close", { other: "x" })).toBe("Close {name}");
});
it("does not resolve placeholders from the prototype", () => {
expect(t("editor.tabs.close", {})).toBe("Close {name}");
expect(t("common.error.unexpectedResult", { command: "{name}" })).toBe(
"unexpected result of {name}",
);
});
it("returns the key and warns on a missing key", () => {
const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
expect(t("no.such.key")).toBe("no.such.key");
expect(warn).toHaveBeenCalledWith(expect.stringContaining("no.such.key"));
});
it("does not treat prototype names as keys", () => {
vi.spyOn(console, "warn").mockImplementation(() => undefined);
expect(hasMessage("toString")).toBe(false);
expect(t("toString")).toBe("toString");
});
});
describe("en.json", () => {
it("uses flat dotted keys of known areas with string values", () => {
for (const [key, value] of Object.entries(en)) {
expect(key).toMatch(/^(app|project|editor|common|theme)\.[A-Za-z0-9]+(\.[A-Za-z0-9]+)*$/);
expect(typeof value).toBe("string");
expect(value.trim()).not.toBe("");
}
});
it("is sorted by key", () => {
const keys = Object.keys(en);
expect(keys).toEqual([...keys].sort());
});
it("contains every key the source passes to t", () => {
expect(usedKeys.length).toBeGreaterThan(0);
const missing = usedKeys.filter(({ key }) => !hasMessage(key));
expect(missing).toEqual([]);
});
it("has every runtime key", () => {
expect([...RUNTIME_KEYS].filter((key) => !hasMessage(key))).toEqual([]);
});
it("has no unused keys", () => {
const used = new Set([...usedKeys.map(({ key }) => key), ...RUNTIME_KEYS]);
expect(Object.keys(en).filter((key) => !used.has(key))).toEqual([]);
});
});