Lutra/ui/tests/recovery/RecoveryDialog.test.ts
danny 33a7185d75
Some checks are pending
ci / ci (macos-15) (push) Waiting to run
ci / ci (ubuntu-24.04) (push) Waiting to run
ci / ci (windows-2025) (push) Waiting to run
F1: cosmetics: regex error reason, one date format, Close Tab
- Find shows a bad regex as "invalid pattern: unclosed group": the search
  crate keeps only the parser's reason, the UI drops the invalid-params
  prefix (userMessage).
- Dates read YYYY-MM-DD / YYYY-MM-DD HH:mm in local time everywhere
  (i18n formatDate/formatDateTime): Log, stash list, blame, recovery.
- buffer.close is "Close Tab" in the palette as in the menu; an engine test
  keeps palette labels starting with their menu item's wording.
- Docs: architecture, install (Jump List), localization parity, checklist.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 19:31:43 +01:00

255 lines
9.7 KiB
TypeScript

/**
* Tests for the restore dialog and its store: the list from
* `recoveryAvailable` and from `recovery.list` after `projectOpened`, the
* "changed on disk" hint, Restore all / Restore selected / Discard with
* explicit paths, failures, errors, Escape, entries settled elsewhere
* (`recoveryResolved`), and checking untrusted entries.
* The engine is a fake behind the mocked Tauri `invoke`.
*/
import { flushPromises, mount, type VueWrapper } from "@vue/test-utils";
import { createPinia, setActivePinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
const invoke = vi.hoisted(() => vi.fn());
vi.mock("@tauri-apps/api/core", () => ({ invoke }));
import RecoveryDialog from "../../src/components/recovery/RecoveryDialog.vue";
import { toRecoveryEntries, useRecoveryStore } from "../../src/components/recovery/recovery";
/** Entries as the engine sends them. */
const ENTRIES = [
{ path: "src/a.php", savedAt: Date.UTC(2026, 9, 16, 12, 0), diskChanged: false },
{ path: "src/b.php", savedAt: Date.UTC(2026, 9, 16, 12, 5), diskChanged: true },
{ path: "c.php", savedAt: Date.UTC(2026, 9, 16, 12, 9), diskChanged: false },
];
/** Every `engine_execute` call, in order. */
let calls: { command: string; params: Record<string, unknown> }[];
/** Result of `recovery.restore`, per test. */
let restoreResult: unknown;
/** Error `recovery.discard` fails with, if any. */
let discardError: { code: string; message: string } | null;
/**
* Rejects like the shell does with an engine error.
*
* @param code - error code.
* @param message - error message.
*/
function fail(code: string, message: string): Promise<never> {
return Promise.reject(Object.assign(new Error(message), { code, message }));
}
/** Mounted wrappers, unmounted after each test. */
const mounted: VueWrapper[] = [];
/** Mounts the dialog. */
function mountDialog(): VueWrapper {
const wrapper = mount(RecoveryDialog, { attachTo: document.body });
mounted.push(wrapper);
return wrapper;
}
/** Shows the entries as if `recoveryAvailable` arrived. */
async function offer(entries: unknown = ENTRIES): Promise<void> {
useRecoveryStore().handleEvent({
kind: "recoveryAvailable",
entries: entries as never,
});
await flushPromises();
}
beforeEach(() => {
setActivePinia(createPinia());
calls = [];
restoreResult = { restored: [], failed: [] };
discardError = null;
invoke.mockReset();
invoke.mockImplementation(
(cmd: string, args?: { command: string; params: Record<string, unknown> }) => {
if (cmd !== "engine_execute" || !args) {
return Promise.reject(new Error("no shell"));
}
calls.push({ command: args.command, params: args.params });
switch (args.command) {
case "recovery.list":
return Promise.resolve({ entries: ENTRIES });
case "recovery.restore":
return Promise.resolve(restoreResult);
case "recovery.discard":
return discardError
? fail(discardError.code, discardError.message)
: Promise.resolve({ discarded: args.params.paths });
default:
return fail("unknown_command", args.command);
}
},
);
});
afterEach(() => {
for (const wrapper of mounted.splice(0)) {
wrapper.unmount();
}
});
describe("RecoveryDialog", () => {
it("is hidden without entries", () => {
const wrapper = mountDialog();
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
});
it("lists the offered files with time and the changed-on-disk hint", async () => {
const wrapper = mountDialog();
await offer();
const dialog = wrapper.get("[data-test=recovery-dialog]");
expect(dialog.get("[role=dialog]").attributes("aria-modal")).toBe("true");
const rows = wrapper.findAll("[data-test=recovery-entry]");
expect(rows.map((r) => r.find(".recovery__path").text())).toEqual([
"src/a.php",
"src/b.php",
"c.php",
]);
expect(rows[0]?.text()).toMatch(/Saved \d{4}-\d{2}-\d{2} \d{2}:\d{2}/);
expect(rows[0]?.find("[data-test=recovery-changed]").exists()).toBe(false);
expect(rows[1]?.get("[data-test=recovery-changed]").text()).toBe(
"The file changed on disk since then",
);
expect(document.activeElement).toBe(
wrapper.get("[data-test=recovery-restore-all]").element,
);
});
it("asks the engine after projectOpened, for reloads and late subscribers", async () => {
const wrapper = mountDialog();
useRecoveryStore().handleEvent({ kind: "projectOpened", root: "/p", name: "p" });
await flushPromises();
expect(calls).toEqual([{ command: "recovery.list", params: {} }]);
expect(wrapper.findAll("[data-test=recovery-entry]")).toHaveLength(3);
});
it("restores all listed files with explicit paths and closes", async () => {
const wrapper = mountDialog();
await offer();
await wrapper.get("[data-test=recovery-restore-all]").trigger("click");
await flushPromises();
expect(calls).toEqual([
{ command: "recovery.restore", params: { paths: ["src/a.php", "src/b.php", "c.php"] } },
]);
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
});
it("restores the selected files and keeps the others listed", async () => {
const wrapper = mountDialog();
await offer();
const selected = wrapper.get("[data-test=recovery-restore-selected]");
expect(selected.attributes("disabled")).toBeDefined();
await wrapper.get("[data-test='recovery-select-src/b.php']").setValue(true);
expect(selected.attributes("disabled")).toBeUndefined();
await selected.trigger("click");
await flushPromises();
expect(calls).toEqual([{ command: "recovery.restore", params: { paths: ["src/b.php"] } }]);
expect(
wrapper.findAll("[data-test=recovery-entry]").map((r) => r.find(".recovery__path").text()),
).toEqual(["src/a.php", "c.php"]);
await wrapper.get("[data-test=recovery-discard]").trigger("click");
await flushPromises();
expect(calls[1]).toEqual({
command: "recovery.discard",
params: { paths: ["src/a.php", "c.php"] },
});
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
});
it("unticking a file disables Restore selected again", async () => {
const wrapper = mountDialog();
await offer();
const box = wrapper.get("[data-test='recovery-select-c.php']");
await box.setValue(true);
await box.setValue(false);
expect(
wrapper.get("[data-test=recovery-restore-selected]").attributes("disabled"),
).toBeDefined();
});
it("lists files that could not be restored until closed", async () => {
restoreResult = {
restored: [],
failed: [{ path: "src/a.php", message: "unsaved changes in src/a.php" }, { bad: 1 }],
};
const wrapper = mountDialog();
await offer([ENTRIES[0]]);
await wrapper.get("[data-test=recovery-restore-all]").trigger("click");
await flushPromises();
const failures = wrapper.get("[data-test=recovery-failures]");
expect(failures.attributes("role")).toBe("alert");
expect(failures.findAll("li")).toHaveLength(1);
expect(failures.text()).toBe(
"src/a.php could not be restored: unsaved changes in src/a.php",
);
expect(document.activeElement).toBe(wrapper.get("[data-test=recovery-close]").element);
await wrapper.get("[data-test=recovery-close]").trigger("click");
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
});
it("shows a failed call and keeps the list", async () => {
discardError = { code: "failed", message: "disk full" };
const wrapper = mountDialog();
await offer();
await wrapper.get("[data-test=recovery-discard]").trigger("click");
await flushPromises();
expect(wrapper.get("[data-test=recovery-error]").text()).toBe("disk full");
expect(wrapper.findAll("[data-test=recovery-entry]")).toHaveLength(3);
});
it("closes on Escape and on projectClosed without touching the journal", async () => {
const wrapper = mountDialog();
await offer();
await wrapper.get("[role=dialog]").trigger("keydown", { key: "Escape" });
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
await offer();
useRecoveryStore().handleEvent({ kind: "projectClosed" });
await flushPromises();
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
expect(calls).toEqual([]);
});
it("drops entries restored or discarded elsewhere and closes when none are left", async () => {
const wrapper = mountDialog();
await offer();
await wrapper.get("[data-test='recovery-select-c.php']").setValue(true);
const store = useRecoveryStore();
store.handleEvent({ kind: "recoveryResolved", paths: ["src/a.php", "c.php", 7, "gone.php"] });
await flushPromises();
expect(wrapper.findAll("[data-test=recovery-entry]").map((r) => r.find(".recovery__path").text())).toEqual([
"src/b.php",
]);
expect([...store.selected]).toEqual([]);
store.handleEvent({ kind: "recoveryResolved", paths: "nope" });
await flushPromises();
expect(wrapper.findAll("[data-test=recovery-entry]")).toHaveLength(1);
store.handleEvent({ kind: "recoveryResolved", paths: ["src/b.php"] });
await flushPromises();
expect(wrapper.find("[data-test=recovery-dialog]").exists()).toBe(false);
expect(calls).toEqual([]);
});
});
describe("toRecoveryEntries", () => {
it("skips malformed entries", () => {
expect(
toRecoveryEntries([
ENTRIES[0],
null,
"x",
{ path: 1, savedAt: 1, diskChanged: false },
{ path: "a", savedAt: Number.NaN, diskChanged: false },
{ path: "a", savedAt: 1, diskChanged: "yes" },
]),
).toEqual([ENTRIES[0]]);
expect(toRecoveryEntries({ path: "a" })).toEqual([]);
});
});