Servers dialog (write-only keychain secret, test connection, unknown and changed host key), status-bar progress with Cancel, Deployment log tool window, Upload/Download in the project tree menu and Tools › Deployment. docs/deployment.md, architecture section, G17 row. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
504 lines
20 KiB
TypeScript
504 lines
20 KiB
TypeScript
/**
|
|
* Tests of the diff viewer (M4.3): reading the untrusted params and
|
|
* `git.show` results, line-break normalisation, `vcs.showDiff` opening a
|
|
* "Diff: <name>" tab with the index (or HEAD for the staged view) on the
|
|
* left and the working copy's buffer on the right, edits on the right
|
|
* reaching the engine through the buffer, engine changes reaching the right
|
|
* side, left side refresh on `gitChanged`, notices for binary, too large,
|
|
* failed and deleted files, switching between diff and editor tabs, the
|
|
* next/previous change commands and the project tree's context menu. The
|
|
* engine is a fake behind the mocked Tauri `invoke` and `listen`.
|
|
*/
|
|
import { flushPromises, mount, type VueWrapper } from "@vue/test-utils";
|
|
import { EditorView } from "@codemirror/view";
|
|
import { createPinia, setActivePinia, type Pinia } from "pinia";
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const invoke = vi.hoisted(() => vi.fn());
|
|
const listen = vi.hoisted(() => vi.fn());
|
|
vi.mock("@tauri-apps/api/core", () => ({ invoke }));
|
|
vi.mock("@tauri-apps/api/event", () => ({ listen }));
|
|
|
|
import { useCommandsStore } from "../../src/commands/store";
|
|
import EditorArea from "../../src/components/editor/EditorArea.vue";
|
|
import { emitEngineEvent } from "../../src/components/project/engineEvents";
|
|
import ProjectToolWindow from "../../src/components/project/ProjectToolWindow.vue";
|
|
import {
|
|
diffKey,
|
|
normaliseEol,
|
|
parseShowDiff,
|
|
refFor,
|
|
toShowResult,
|
|
useDiffStore,
|
|
} from "../../src/components/vcs/diff/diff";
|
|
import { currentMerge } from "../../src/components/vcs/diff/navigation";
|
|
import { useEditorStore } from "../../src/stores/editor";
|
|
import { useNotificationsStore } from "../../src/stores/notifications";
|
|
import { useProjectStore } from "../../src/stores/project";
|
|
|
|
/** A buffer of the fake engine. */
|
|
interface FakeBuffer {
|
|
path: string;
|
|
text: string;
|
|
version: number;
|
|
saved: number;
|
|
}
|
|
|
|
/** Fake engine buffers by id. */
|
|
let buffers: Map<number, FakeBuffer>;
|
|
/** Files in the working copy. */
|
|
let disk: Record<string, string>;
|
|
/** What `git.show` answers, by `ref:path`; missing entries mean "not at that ref". */
|
|
let blobs: Record<string, unknown>;
|
|
/** Errors to throw, by command id. */
|
|
let failures: Record<string, { code: string; message: string }>;
|
|
/** Next buffer id. */
|
|
let nextId: number;
|
|
/** Every engine call, in order. */
|
|
let calls: { via: string; command: string; params: Record<string, unknown> }[];
|
|
/** Engine event callbacks of every subscription. */
|
|
let listeners: ((event: { payload: unknown }) => void)[];
|
|
/** Pinia of the current test. */
|
|
let pinia: Pinia;
|
|
/** Mounted components. */
|
|
let mounted: VueWrapper[];
|
|
|
|
/**
|
|
* Sends an engine event to every subscription.
|
|
*
|
|
* @param payload - the event.
|
|
*/
|
|
async function emit(payload: unknown): Promise<void> {
|
|
for (const listener of [...listeners]) {
|
|
listener({ payload });
|
|
}
|
|
await flushPromises();
|
|
}
|
|
|
|
/**
|
|
* Describes a buffer as `file.open` and `buffer.get` do.
|
|
*
|
|
* @param id - buffer id.
|
|
*/
|
|
function describeBuffer(id: number): unknown {
|
|
const b = buffers.get(id);
|
|
return b ? { id, path: b.path, text: b.text, version: b.version, dirty: b.version !== b.saved, lineEnding: b.text.includes("\r\n") ? "crlf" : "lf" } : null;
|
|
}
|
|
|
|
/**
|
|
* Rejects like the shell does with an engine error.
|
|
*
|
|
* @param code - error code.
|
|
* @param message - error text.
|
|
*/
|
|
function fail(code: string, message = code): Promise<never> {
|
|
return Promise.reject(Object.assign(new Error(message), { code, message }));
|
|
}
|
|
|
|
/**
|
|
* The fake engine.
|
|
*
|
|
* @param command - command id.
|
|
* @param p - params.
|
|
*/
|
|
function execute(command: string, p: Record<string, unknown>): Promise<unknown> {
|
|
const failure = failures[command];
|
|
if (failure) {
|
|
return fail(failure.code, failure.message);
|
|
}
|
|
const id = typeof p.id === "number" ? p.id : -1;
|
|
const b = buffers.get(id);
|
|
switch (command) {
|
|
case "git.show": {
|
|
const blob = blobs[`${String(p.ref)}:${String(p.path)}`];
|
|
return Promise.resolve(blob === undefined ? { text: null, binary: false, tooLarge: false } : blob);
|
|
}
|
|
case "file.open": {
|
|
const path = String(p.path);
|
|
for (const [existing, buffer] of buffers) {
|
|
if (buffer.path === path) {
|
|
return Promise.resolve(describeBuffer(existing));
|
|
}
|
|
}
|
|
const text = disk[path];
|
|
if (text === undefined) {
|
|
return fail("failed", `${path}: file not found`);
|
|
}
|
|
const newId = nextId++;
|
|
buffers.set(newId, { path, text, version: 1, saved: 1 });
|
|
return Promise.resolve(describeBuffer(newId));
|
|
}
|
|
case "buffer.get":
|
|
return b ? Promise.resolve(describeBuffer(id)) : fail("failed");
|
|
case "buffer.edit": {
|
|
if (!b) {
|
|
return fail("failed");
|
|
}
|
|
if (p.baseVersion !== b.version) {
|
|
return fail("stale_version");
|
|
}
|
|
let out = "";
|
|
let pos = 0;
|
|
for (const e of p.edits as { from: number; to: number; insert: string }[]) {
|
|
out += b.text.slice(pos, e.from) + e.insert;
|
|
pos = e.to;
|
|
}
|
|
b.text = out + b.text.slice(pos);
|
|
b.version += 1;
|
|
return Promise.resolve({ id, version: b.version, dirty: true });
|
|
}
|
|
case "project.children":
|
|
return Promise.resolve({
|
|
dir: "",
|
|
entries: Object.keys(disk).map((path) => ({ name: path, path, kind: "file", ignored: false, role: null })),
|
|
truncated: false,
|
|
});
|
|
default:
|
|
return Promise.resolve({});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The calls of a command.
|
|
*
|
|
* @param command - the command id.
|
|
*/
|
|
function callsOf(command: string): { via: string; command: string; params: Record<string, unknown> }[] {
|
|
return calls.filter((c) => c.command === command);
|
|
}
|
|
|
|
/** jsdom has no layout; CodeMirror measures text ranges, so give ranges empty rectangles. */
|
|
function stubRangeGeometry(): void {
|
|
const empty = (): DOMRectList => Object.assign([] as DOMRect[], { item: () => null });
|
|
Range.prototype.getClientRects = empty;
|
|
Range.prototype.getBoundingClientRect = () => new DOMRect(0, 0, 0, 0);
|
|
}
|
|
|
|
/** Mounts the editor area with the keymap and an open project. */
|
|
async function mountArea(): Promise<VueWrapper> {
|
|
await useCommandsStore(pinia).start();
|
|
useProjectStore(pinia).root = { path: "/p", name: "p" };
|
|
const wrapper = mount(EditorArea, { attachTo: document.body, slots: { default: "empty" }, global: { plugins: [pinia] } });
|
|
mounted.push(wrapper);
|
|
await flushPromises();
|
|
return wrapper;
|
|
}
|
|
|
|
/**
|
|
* Runs a command through the command store and waits for it.
|
|
*
|
|
* @param id - command id.
|
|
* @param params - its params.
|
|
*/
|
|
async function runCommand(id: string, params: Record<string, unknown> = {}): Promise<void> {
|
|
await useCommandsStore(pinia).execute(id, params as never);
|
|
await vi.dynamicImportSettled();
|
|
await flushPromises();
|
|
}
|
|
|
|
/** Both sides of the merge view. */
|
|
function sides(): { a: EditorView; b: EditorView } {
|
|
const merge = currentMerge();
|
|
if (!merge) {
|
|
throw new Error("no merge view");
|
|
}
|
|
return { a: merge.a, b: merge.b };
|
|
}
|
|
|
|
beforeEach(() => {
|
|
stubRangeGeometry();
|
|
Element.prototype.scrollIntoView = () => undefined;
|
|
pinia = createPinia();
|
|
setActivePinia(pinia);
|
|
buffers = new Map();
|
|
disk = { "a.php": "<?php\necho 2;\nnew();\n", "b.txt": "bee\n" };
|
|
blobs = {
|
|
"index:a.php": { text: "<?php\r\necho 1;\r\n", binary: false, tooLarge: false },
|
|
"HEAD:a.php": { text: "<?php\necho 0;\n", binary: false, tooLarge: false },
|
|
};
|
|
failures = {};
|
|
nextId = 1;
|
|
calls = [];
|
|
listeners = [];
|
|
mounted = [];
|
|
invoke.mockReset();
|
|
listen.mockReset();
|
|
listen.mockImplementation((_name: string, callback: (event: { payload: unknown }) => void) => {
|
|
listeners.push(callback);
|
|
return Promise.resolve(() => {
|
|
listeners = listeners.filter((l) => l !== callback);
|
|
});
|
|
});
|
|
invoke.mockImplementation((cmd: string, args?: { command: string; params: Record<string, unknown> }) => {
|
|
if (cmd === "engine_list_commands") {
|
|
return Promise.resolve([]);
|
|
}
|
|
if ((cmd === "engine_execute" || cmd === "engine_execute_waiting") && args) {
|
|
calls.push({ via: cmd, command: args.command, params: args.params });
|
|
return execute(args.command, args.params);
|
|
}
|
|
return Promise.resolve(null);
|
|
});
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await flushPromises();
|
|
useCommandsStore(pinia).stop();
|
|
for (const wrapper of mounted) {
|
|
wrapper.unmount();
|
|
}
|
|
document.body.innerHTML = "";
|
|
});
|
|
|
|
describe("helpers", () => {
|
|
it("normalises every line break to LF", () => {
|
|
expect(normaliseEol("a\r\nb\rc\nd")).toBe("a\nb\nc\nd");
|
|
expect(normaliseEol("")).toBe("");
|
|
});
|
|
|
|
it("reads the params of vcs.showDiff", () => {
|
|
expect(parseShowDiff({})).toEqual({ path: null, staged: false });
|
|
expect(parseShowDiff({ path: "a.php", staged: true })).toEqual({ path: "a.php", staged: true });
|
|
expect(parseShowDiff(null)).toEqual({ path: null, staged: false });
|
|
expect(parseShowDiff({ path: 3 })).toBeNull();
|
|
expect(parseShowDiff({ path: "" })).toBeNull();
|
|
expect(parseShowDiff({ path: "a", staged: "yes" })).toBeNull();
|
|
});
|
|
|
|
it("reads git.show results and picks the ref", () => {
|
|
expect(toShowResult({ text: "x", binary: false, tooLarge: false })).toEqual({ text: "x", binary: false, tooLarge: false });
|
|
expect(toShowResult({ text: null, binary: true })).toEqual({ text: null, binary: true, tooLarge: false });
|
|
expect(toShowResult({ text: 5 })).toBeNull();
|
|
expect(toShowResult([])).toBeNull();
|
|
expect(toShowResult("x")).toBeNull();
|
|
expect(refFor(true)).toBe("HEAD");
|
|
expect(refFor(false)).toBe("index");
|
|
expect(diffKey("a", true)).not.toBe(diffKey("a", false));
|
|
});
|
|
});
|
|
|
|
describe("vcs.showDiff", () => {
|
|
it("opens a diff tab: index on the left (CRLF normalised), the working copy's buffer on the right", async () => {
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php", staged: false });
|
|
expect(callsOf("git.show")).toEqual([{ via: "engine_execute_waiting", command: "git.show", params: { path: "a.php", ref: "index" } }]);
|
|
expect(area.findAll("[data-test=diff-tab]").map((t) => t.text())).toEqual(["Diff: a.php"]);
|
|
expect(area.find("[data-test=diff-tab]").attributes("aria-selected")).toBe("true");
|
|
expect(area.find("[data-test=editor-tab]").attributes("aria-selected")).toBe("false");
|
|
expect(area.find("[data-test=code-editor]").exists()).toBe(false);
|
|
expect(area.find("[data-test=diff-caption]").text()).toContain("staged version");
|
|
const { a, b } = sides();
|
|
expect(a.state.doc.toString()).toBe("<?php\necho 1;\n");
|
|
expect(a.state.readOnly).toBe(true);
|
|
expect(b.state.doc.toString()).toBe("<?php\necho 2;\nnew();\n");
|
|
expect(b.state.readOnly).toBe(false);
|
|
expect(currentMerge()?.chunks.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("compares with HEAD for the staged view and reuses one tab per path and side", async () => {
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php", staged: true });
|
|
expect(callsOf("git.show")[0]?.params).toEqual({ path: "a.php", ref: "HEAD" });
|
|
expect(sides().a.state.doc.toString()).toBe("<?php\necho 0;\n");
|
|
expect(area.find("[data-test=diff-caption]").text()).toContain("last commit");
|
|
expect(area.find("[data-test=diff-tab]").text()).toBe("Diff: a.php (staged)");
|
|
await runCommand("vcs.showDiff", { path: "a.php", staged: true });
|
|
expect(area.findAll("[data-test=diff-tab]")).toHaveLength(1);
|
|
expect(callsOf("file.open")).toHaveLength(1);
|
|
});
|
|
|
|
it("without a path, diffs the active editor tab's file", async () => {
|
|
await mountArea();
|
|
await useEditorStore(pinia).openFile("a.php");
|
|
await runCommand("vcs.showDiff");
|
|
expect(callsOf("git.show")[0]?.params).toEqual({ path: "a.php", ref: "index" });
|
|
expect(useDiffStore(pinia).activeTab?.path).toBe("a.php");
|
|
});
|
|
|
|
it("refuses bad params and a missing file with an error toast", async () => {
|
|
await mountArea();
|
|
await runCommand("vcs.showDiff", { path: 7 });
|
|
await runCommand("vcs.showDiff");
|
|
const texts = useNotificationsStore(pinia).toasts.map((toast) => toast.text);
|
|
expect(texts.some((text) => text.includes("{path?: string"))).toBe(true);
|
|
expect(texts.some((text) => text.includes("Open a file"))).toBe(true);
|
|
expect(callsOf("git.show")).toHaveLength(0);
|
|
});
|
|
|
|
it("is disabled without a project", async () => {
|
|
await mountArea();
|
|
useProjectStore(pinia).root = null;
|
|
expect(useCommandsStore(pinia).isEnabled("vcs.showDiff")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("editing and refreshing", () => {
|
|
it("sends edits on the right through the buffer", async () => {
|
|
await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
const { b } = sides();
|
|
b.dispatch({ changes: { from: 0, insert: "// x\n" }, userEvent: "input.type" });
|
|
await flushPromises();
|
|
const edits = callsOf("buffer.edit");
|
|
expect(edits).toHaveLength(1);
|
|
expect(edits[0]?.params.edits).toEqual([{ from: 0, to: 0, insert: "// x\n" }]);
|
|
expect(buffers.get(1)?.text).toBe("// x\n<?php\necho 2;\nnew();\n");
|
|
expect(useEditorStore(pinia).syncOf(1)?.state.doc.toString()).toBe("// x\n<?php\necho 2;\nnew();\n");
|
|
});
|
|
|
|
it("shows engine changes of the buffer on the right", async () => {
|
|
await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
const buffer = buffers.get(1);
|
|
if (!buffer) {
|
|
throw new Error("no buffer");
|
|
}
|
|
buffer.text = "<?php\necho 3;\n";
|
|
buffer.version = 5;
|
|
await emit({ kind: "bufferChanged", id: 1, version: 5 });
|
|
await flushPromises();
|
|
expect(sides().b.state.doc.toString()).toBe("<?php\necho 3;\n");
|
|
expect(callsOf("buffer.edit")).toHaveLength(0);
|
|
});
|
|
|
|
it("re-reads the left side on gitChanged", async () => {
|
|
await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
blobs["index:a.php"] = { text: "<?php\necho 2;\nnew();\n", binary: false, tooLarge: false };
|
|
await emit({ kind: "gitChanged", available: true, repo: null, filesChanged: true });
|
|
await flushPromises();
|
|
expect(sides().a.state.doc.toString()).toBe("<?php\necho 2;\nnew();\n");
|
|
expect(currentMerge()?.chunks).toHaveLength(0);
|
|
});
|
|
|
|
it("closes the diff when the working copy's buffer closes", async () => {
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
await emit({ kind: "bufferClosed", id: 1 });
|
|
await flushPromises();
|
|
expect(area.findAll("[data-test=diff-tab]")).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("notices", () => {
|
|
it("shows a notice for binary and too large files without opening the file", async () => {
|
|
blobs["index:img.png"] = { text: null, binary: true, tooLarge: false };
|
|
blobs["index:big.sql"] = { text: null, binary: false, tooLarge: true };
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "img.png" });
|
|
expect(area.find("[data-test=diff-notice]").text()).toContain("Binary file");
|
|
await runCommand("vcs.showDiff", { path: "big.sql" });
|
|
expect(area.find("[data-test=diff-notice]").text()).toContain("too large");
|
|
expect(callsOf("file.open")).toHaveLength(0);
|
|
expect(currentMerge()).toBeNull();
|
|
});
|
|
|
|
it("shows git's error", async () => {
|
|
failures["git.show"] = { code: "failed", message: "fatal: bad object" };
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
expect(area.find("[data-test=diff-notice]").text()).toContain("fatal: bad object");
|
|
});
|
|
|
|
it("shows a deleted working copy as an empty read-only side with a notice", async () => {
|
|
blobs["index:gone.php"] = { text: "<?php\n", binary: false, tooLarge: false };
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "gone.php" });
|
|
expect(area.find("[data-test=diff-notice]").text()).toContain("may have been deleted");
|
|
expect(area.find("[data-test=editor-error]").exists()).toBe(false);
|
|
const { a, b } = sides();
|
|
expect(a.state.doc.toString()).toBe("<?php\n");
|
|
expect(b.state.doc.toString()).toBe("");
|
|
expect(b.state.readOnly).toBe(true);
|
|
});
|
|
|
|
it("shows a new file against an empty left side", async () => {
|
|
await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "b.txt" });
|
|
const { a, b } = sides();
|
|
expect(a.state.doc.toString()).toBe("");
|
|
expect(b.state.doc.toString()).toBe("bee\n");
|
|
});
|
|
});
|
|
|
|
describe("tabs and navigation", () => {
|
|
it("switches between the diff and the editor tab, and closes the diff tab", async () => {
|
|
const area = await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
await area.find("[data-test=editor-tab]").trigger("click");
|
|
expect(area.find("[data-test=diff-view]").exists()).toBe(false);
|
|
expect(area.find("[data-test=code-editor]").exists()).toBe(true);
|
|
await area.find("[data-test=diff-tab]").trigger("click");
|
|
await flushPromises();
|
|
expect(area.find("[data-test=diff-view]").exists()).toBe(true);
|
|
await area.find("[data-test=diff-tab-close]").trigger("click");
|
|
await flushPromises();
|
|
expect(area.findAll("[data-test=diff-tab]")).toHaveLength(0);
|
|
expect(area.find("[data-test=code-editor]").exists()).toBe(true);
|
|
expect(area.findAll("[data-test=editor-tab]")).toHaveLength(1);
|
|
});
|
|
|
|
it("moves to the next and previous change, wrapping around", async () => {
|
|
blobs["index:a.php"] = { text: "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n", binary: false, tooLarge: false };
|
|
disk["a.php"] = "1\nX\n3\n4\n5\n6\n7\n8\n9\n10\nY\n12\n";
|
|
await mountArea();
|
|
await runCommand("vcs.showDiff", { path: "a.php" });
|
|
const { b } = sides();
|
|
expect(currentMerge()?.chunks).toHaveLength(2);
|
|
const lineOfCursor = (): number => b.state.doc.lineAt(b.state.selection.main.head).number;
|
|
expect(useCommandsStore(pinia).isEnabled("vcs.nextChange")).toBe(true);
|
|
await runCommand("vcs.nextChange");
|
|
expect(lineOfCursor()).toBe(2);
|
|
await runCommand("vcs.nextChange");
|
|
expect(lineOfCursor()).toBe(11);
|
|
await runCommand("vcs.nextChange");
|
|
expect(lineOfCursor()).toBe(2);
|
|
await runCommand("vcs.previousChange");
|
|
expect(lineOfCursor()).toBe(11);
|
|
});
|
|
|
|
it("disables next/previous change without a visible diff", async () => {
|
|
await mountArea();
|
|
expect(useCommandsStore(pinia).isEnabled("vcs.nextChange")).toBe(false);
|
|
expect(useCommandsStore(pinia).isEnabled("vcs.previousChange")).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("project tree context menu", () => {
|
|
it("opens on a right click and runs Show Diff for the file", async () => {
|
|
const area = await mountArea();
|
|
const tree = mount(ProjectToolWindow, { attachTo: document.body, global: { plugins: [pinia] } });
|
|
mounted.push(tree);
|
|
emitEngineEvent({ kind: "projectOpened", root: "/p", name: "p" });
|
|
await flushPromises();
|
|
useProjectStore(pinia).root = { path: "/p", name: "p" };
|
|
await tree.find("[data-path='a.php']").trigger("contextmenu", { clientX: 40, clientY: 50 });
|
|
const menu = document.querySelector("[data-test=tree-menu]");
|
|
expect(menu).not.toBeNull();
|
|
expect([...document.querySelectorAll("[data-test=tree-menu-item]")].map((item) => item.textContent.trim())).toEqual(["Open", "Show Diff", "Show History", "Upload to Server", "Download from Server"]);
|
|
(document.querySelector("[data-item=showDiff]") as HTMLElement).click();
|
|
await flushPromises();
|
|
await flushPromises();
|
|
expect(document.querySelector("[data-test=tree-menu]")).toBeNull();
|
|
expect(callsOf("git.show")[0]?.params).toEqual({ path: "a.php", ref: "index" });
|
|
expect(area.findAll("[data-test=diff-tab]").map((t) => t.text())).toEqual(["Diff: a.php"]);
|
|
});
|
|
|
|
it("opens from the keyboard with Shift+F10 and closes with Escape", async () => {
|
|
await mountArea();
|
|
const tree = mount(ProjectToolWindow, { attachTo: document.body, global: { plugins: [pinia] } });
|
|
mounted.push(tree);
|
|
emitEngineEvent({ kind: "projectOpened", root: "/p", name: "p" });
|
|
await flushPromises();
|
|
useProjectStore(pinia).select("a.php");
|
|
await tree.find("[data-test=project-tree]").trigger("keydown", { key: "F10", shiftKey: true });
|
|
await flushPromises();
|
|
const menu = document.querySelector<HTMLElement>("[data-test=tree-menu]");
|
|
expect(menu).not.toBeNull();
|
|
expect(document.activeElement).toBe(menu);
|
|
menu?.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
|
|
await flushPromises();
|
|
expect(document.querySelector("[data-test=tree-menu]")).toBeNull();
|
|
expect(callsOf("git.show")).toHaveLength(0);
|
|
});
|
|
});
|