M4.6: Git log and file history
- crates/vcs log.rs: Repo::log (topological, all refs, paging, literal message/author filters, a path's history with --follow), show_commit (message and files against the first parent, renames) and show_at (a file at any commit); parsers property-tested. - Engine git.log, git.showCommit, git.showAt in cmd/git_log.rs through the step-1 hook. - Log tab in the bottom panel: graph lanes carried across pages, ref badges, filters, lazy paging, keyboard; commit details whose files open a read-only diff at that commit in M4.3's viewer. - vcs.showLog and vcs.showHistory (menu, tree context menu, active editor tab), no default shortcuts. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
b814c49733
commit
a8531825a3
27 changed files with 3349 additions and 16 deletions
|
|
@ -475,7 +475,7 @@ describe("project tree context menu", () => {
|
|||
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"]);
|
||||
expect([...document.querySelectorAll("[data-test=tree-menu-item]")].map((item) => item.textContent.trim())).toEqual(["Open", "Show Diff", "Show History"]);
|
||||
(document.querySelector("[data-item=showDiff]") as HTMLElement).click();
|
||||
await flushPromises();
|
||||
await flushPromises();
|
||||
|
|
|
|||
483
ui/tests/vcs/Log.test.ts
Normal file
483
ui/tests/vcs/Log.test.ts
Normal file
|
|
@ -0,0 +1,483 @@
|
|||
/**
|
||||
* Tests of the Log (M4.6): graph lanes, reading the untrusted `git.log`
|
||||
* and `git.showCommit` results, ref badges, paging, filters, reloading on
|
||||
* `gitChanged` when HEAD moves, commit details, the Log window (rows,
|
||||
* badges, keyboard, filters, history chip), a file's diff at a commit in
|
||||
* the diff viewer (both sides read-only), `vcs.showHistory` and the 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 { 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 { UI_COMMANDS } from "../../src/commands/uiCommands";
|
||||
import EditorArea from "../../src/components/editor/EditorArea.vue";
|
||||
import TreeContextMenu from "../../src/components/project/TreeContextMenu.vue";
|
||||
import { commitDiffKey, useDiffStore } from "../../src/components/vcs/diff/diff";
|
||||
import { currentMerge } from "../../src/components/vcs/diff/navigation";
|
||||
import { layoutGraph, MAX_LANES } from "../../src/components/vcs/log/graph";
|
||||
import {
|
||||
logParams,
|
||||
PAGE_SIZE,
|
||||
refBadges,
|
||||
SHOW_HISTORY_COMMAND,
|
||||
SHOW_LOG_COMMAND,
|
||||
toCommits,
|
||||
toDetails,
|
||||
useLogStore,
|
||||
} from "../../src/components/vcs/log/log";
|
||||
import LogToolWindow from "../../src/components/vcs/log/LogToolWindow.vue";
|
||||
import { useNotificationsStore } from "../../src/stores/notifications";
|
||||
import { useProjectStore } from "../../src/stores/project";
|
||||
|
||||
/** A commit of the fake history. */
|
||||
interface FakeCommit {
|
||||
hash: string;
|
||||
parents: string[];
|
||||
author: string;
|
||||
email: string;
|
||||
date: string;
|
||||
subject: string;
|
||||
refs: string[];
|
||||
}
|
||||
|
||||
/** The fake history, newest first. */
|
||||
let history: FakeCommit[];
|
||||
/** What `git.showAt` answers, by `rev:path`. */
|
||||
let blobs: Record<string, string>;
|
||||
/** Errors to throw, by command id. */
|
||||
let failures: Record<string, { code: string; message: string }>;
|
||||
/** Every engine call, in order. */
|
||||
let calls: { command: string; params: Record<string, unknown> }[];
|
||||
/** Engine event callbacks. */
|
||||
let listeners: ((event: { payload: unknown }) => void)[];
|
||||
/** Pinia of the current test. */
|
||||
let pinia: Pinia;
|
||||
/** Mounted components. */
|
||||
let mounted: VueWrapper[];
|
||||
|
||||
/**
|
||||
* A fake commit.
|
||||
*
|
||||
* @param hash - its hash.
|
||||
* @param parents - its parents.
|
||||
* @param refs - its decorations.
|
||||
*/
|
||||
function fake(hash: string, parents: string[], refs: string[] = []): FakeCommit {
|
||||
return { hash, parents, author: `A ${hash}`, email: `${hash}@x`, date: "2026-10-27T10:00:00+01:00", subject: `Subject ${hash}`, refs };
|
||||
}
|
||||
|
||||
/**
|
||||
* A linear history of `count` commits, newest first.
|
||||
*
|
||||
* @param count - how many.
|
||||
*/
|
||||
function linear(count: number): FakeCommit[] {
|
||||
return Array.from({ length: count }, (_, i) => {
|
||||
const n = count - i;
|
||||
return fake(`c${String(n)}`, n > 1 ? [`c${String(n - 1)}`] : []);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends an engine event.
|
||||
*
|
||||
* @param payload - the event.
|
||||
*/
|
||||
async function emit(payload: unknown): Promise<void> {
|
||||
for (const listener of [...listeners]) {
|
||||
listener({ payload });
|
||||
}
|
||||
await flushPromises();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 Promise.reject(Object.assign(new Error(failure.message), failure));
|
||||
}
|
||||
switch (command) {
|
||||
case "git.log": {
|
||||
const query = typeof p.query === "string" ? p.query.toLowerCase() : null;
|
||||
const matching = history.filter((c) => query === null || c.subject.toLowerCase().includes(query));
|
||||
const skip = Number(p.skip ?? 0);
|
||||
return Promise.resolve({ commits: matching.slice(skip, skip + Number(p.limit ?? 100)) });
|
||||
}
|
||||
case "git.showCommit": {
|
||||
const commit = history.find((c) => c.hash === p.hash);
|
||||
if (!commit) {
|
||||
return Promise.reject(Object.assign(new Error("no such commit"), { code: "failed", message: "no such commit" }));
|
||||
}
|
||||
return Promise.resolve({
|
||||
hash: commit.hash,
|
||||
parents: commit.parents,
|
||||
author: commit.author,
|
||||
email: commit.email,
|
||||
date: commit.date,
|
||||
message: `${commit.subject}\n\nBody`,
|
||||
files: [
|
||||
{ path: "src/New.php", status: "renamed", origPath: "src/Old.php" },
|
||||
{ path: "gone.php", status: "deleted" },
|
||||
{ path: "bad", status: "exploded" },
|
||||
],
|
||||
truncated: false,
|
||||
});
|
||||
}
|
||||
case "git.showAt": {
|
||||
const text = blobs[`${String(p.rev)}:${String(p.path)}`];
|
||||
return Promise.resolve({ text: text ?? null, binary: false, tooLarge: false });
|
||||
}
|
||||
default:
|
||||
return Promise.resolve({});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The calls of a command.
|
||||
*
|
||||
* @param command - the command id.
|
||||
*/
|
||||
function callsOf(command: string): Record<string, unknown>[] {
|
||||
return calls.filter((c) => c.command === command).map((c) => c.params);
|
||||
}
|
||||
|
||||
/** Mounts the Log window with an open project. */
|
||||
async function mountLog(): Promise<VueWrapper> {
|
||||
useProjectStore(pinia).root = { path: "/p", name: "p" };
|
||||
const wrapper = mount(LogToolWindow, { attachTo: document.body, global: { plugins: [pinia] } });
|
||||
mounted.push(wrapper);
|
||||
await flushPromises();
|
||||
return wrapper;
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
Range.prototype.getClientRects = () => Object.assign([] as DOMRect[], { item: () => null });
|
||||
Range.prototype.getBoundingClientRect = () => new DOMRect(0, 0, 0, 0);
|
||||
Element.prototype.scrollIntoView = () => undefined;
|
||||
pinia = createPinia();
|
||||
setActivePinia(pinia);
|
||||
history = [fake("m", ["a", "b"], ["HEAD -> main", "tag: v2"]), fake("b", ["r"], ["origin/feature", "origin/HEAD"]), fake("a", ["r"]), fake("r", [], ["tag: v1"])];
|
||||
blobs = {};
|
||||
failures = {};
|
||||
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({ 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("graph", () => {
|
||||
it("draws a straight line for a linear history", () => {
|
||||
const { rows, lanes } = layoutGraph(linear(3));
|
||||
expect(rows.map((r) => r.column)).toEqual([0, 0, 0]);
|
||||
expect(rows[0]?.up).toEqual([]);
|
||||
expect(rows[0]?.down).toEqual([{ from: 0, to: 0, lane: 0 }]);
|
||||
expect(rows[2]?.down).toEqual([]);
|
||||
expect(lanes).toEqual([]);
|
||||
});
|
||||
|
||||
it("branches out at a merge and joins again at the fork point", () => {
|
||||
const { rows } = layoutGraph(history);
|
||||
expect(rows[0]).toMatchObject({ column: 0, merge: true });
|
||||
expect(rows[0]?.down).toEqual([
|
||||
{ from: 0, to: 0, lane: 0 },
|
||||
{ from: 0, to: 1, lane: 1 },
|
||||
]);
|
||||
expect(rows[1]?.column).toBe(1);
|
||||
expect(rows[2]?.column).toBe(0);
|
||||
expect(rows[3]?.column).toBe(0);
|
||||
expect(rows[3]?.up).toEqual([
|
||||
{ from: 0, to: 0, lane: 0 },
|
||||
{ from: 1, to: 0, lane: 1 },
|
||||
]);
|
||||
expect(rows[3]?.width).toBe(2);
|
||||
});
|
||||
|
||||
it("continues across pages without redrawing", () => {
|
||||
const all = layoutGraph(history).rows;
|
||||
const first = layoutGraph(history.slice(0, 2));
|
||||
const second = layoutGraph(history.slice(2), first.lanes);
|
||||
expect([...first.rows, ...second.rows]).toEqual(all);
|
||||
});
|
||||
|
||||
it("caps the lanes", () => {
|
||||
const tips = Array.from({ length: MAX_LANES + 5 }, (_, i) => ({ hash: `t${String(i)}`, parents: [`p${String(i)}`] }));
|
||||
const { rows, lanes } = layoutGraph(tips);
|
||||
expect(Math.max(...rows.map((r) => r.column))).toBe(MAX_LANES - 1);
|
||||
expect(lanes.length).toBeLessThanOrEqual(MAX_LANES);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parsing", () => {
|
||||
it("reads commits and drops malformed ones", () => {
|
||||
expect(toCommits({ commits: [history[0], { hash: "x" }, null, { ...history[1], refs: [1] }] })).toEqual([history[0]]);
|
||||
expect(toCommits({ commits: "no" })).toBeNull();
|
||||
expect(toCommits(null)).toBeNull();
|
||||
});
|
||||
|
||||
it("reads details and drops unknown file states", () => {
|
||||
const d = toDetails({ hash: "h", parents: ["p"], author: "A", email: "e", date: "d", message: "m", files: [{ path: "a", status: "added" }, { path: "b", status: "?" }, { path: "c", status: "renamed", origPath: "o" }] });
|
||||
expect(d?.files).toEqual([
|
||||
{ path: "a", status: "added", origPath: null },
|
||||
{ path: "c", status: "renamed", origPath: "o" },
|
||||
]);
|
||||
expect(toDetails({ hash: "h" })).toBeNull();
|
||||
});
|
||||
|
||||
it("splits decorations into badges", () => {
|
||||
expect(refBadges(["HEAD -> main", "origin/main", "origin/HEAD", "tag: v1", "HEAD", "dev"])).toEqual([
|
||||
{ name: "HEAD", kind: "head" },
|
||||
{ name: "main", kind: "branch" },
|
||||
{ name: "origin/main", kind: "remote" },
|
||||
{ name: "v1", kind: "tag" },
|
||||
{ name: "HEAD", kind: "head" },
|
||||
{ name: "dev", kind: "branch" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("builds git.log params from the filters", () => {
|
||||
expect(logParams({ query: " fix ", author: "", path: null }, 200)).toEqual({ skip: 200, limit: PAGE_SIZE, query: "fix" });
|
||||
expect(logParams({ query: "", author: "ada", path: "a.php" }, 0)).toEqual({ skip: 0, limit: PAGE_SIZE, author: "ada", path: "a.php" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("store", () => {
|
||||
it("pages lazily and stops at a short page", async () => {
|
||||
history = linear(PAGE_SIZE + 20);
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
expect(log.commits).toHaveLength(PAGE_SIZE);
|
||||
expect(log.complete).toBe(false);
|
||||
expect(log.selected).toBe(history[0]?.hash);
|
||||
await log.loadMore();
|
||||
expect(log.commits).toHaveLength(PAGE_SIZE + 20);
|
||||
expect(log.rows).toHaveLength(PAGE_SIZE + 20);
|
||||
expect(log.complete).toBe(true);
|
||||
await log.loadMore();
|
||||
expect(callsOf("git.log").map((p) => p.skip)).toEqual([0, PAGE_SIZE]);
|
||||
});
|
||||
|
||||
it("filters by text without a graph, and drops stale answers", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
const first = log.setFilters({ query: "subject b" });
|
||||
const second = log.setFilters({ query: "subject a" });
|
||||
await Promise.all([first, second]);
|
||||
expect(log.commits.map((c) => c.hash)).toEqual(["a"]);
|
||||
expect(log.graphShown).toBe(false);
|
||||
expect(log.rows).toEqual([]);
|
||||
});
|
||||
|
||||
it("reloads on gitChanged only when HEAD or the branch moved", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
log.start();
|
||||
await log.open();
|
||||
await emit({ kind: "gitChanged", available: true, repo: { head: "m", branch: "main" }, filesChanged: true });
|
||||
const before = callsOf("git.log").length;
|
||||
await emit({ kind: "gitChanged", available: true, repo: { head: "m", branch: "main" }, filesChanged: true });
|
||||
expect(callsOf("git.log")).toHaveLength(before);
|
||||
history.unshift(fake("n", ["m"], ["HEAD -> main"]));
|
||||
await emit({ kind: "gitChanged", available: true, repo: { head: "n", branch: "main" }, filesChanged: true });
|
||||
expect(callsOf("git.log")).toHaveLength(before + 1);
|
||||
expect(log.commits[0]?.hash).toBe("n");
|
||||
await emit({ kind: "projectClosed" });
|
||||
expect(log.commits).toEqual([]);
|
||||
log.stop();
|
||||
});
|
||||
|
||||
it("shows git's error", async () => {
|
||||
failures["git.log"] = { code: "failed", message: "the project is not inside a Git repository" };
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
expect(log.error).toBe("the project is not inside a Git repository");
|
||||
expect(log.complete).toBe(true);
|
||||
});
|
||||
|
||||
it("reads the selected commit's details", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
expect(log.details?.message).toBe("Subject m\n\nBody");
|
||||
expect(log.details?.files.map((f) => f.status)).toEqual(["renamed", "deleted"]);
|
||||
failures["git.showCommit"] = { code: "failed", message: "gone" };
|
||||
await log.select("b");
|
||||
expect(log.detailsError).toBe("gone");
|
||||
});
|
||||
|
||||
it("shows a file's history, or warns without a file", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
await log.runShowHistory({ path: "src/a.php" }, null);
|
||||
expect(log.visible).toBe(true);
|
||||
expect(log.filters.path).toBe("src/a.php");
|
||||
expect(callsOf("git.log").at(-1)).toMatchObject({ path: "src/a.php" });
|
||||
await log.runShowHistory({}, "b.php");
|
||||
expect(log.filters.path).toBe("b.php");
|
||||
await log.runShowHistory({}, null);
|
||||
expect(useNotificationsStore(pinia).toasts.at(-1)?.text).toContain("history");
|
||||
});
|
||||
});
|
||||
|
||||
describe("window", () => {
|
||||
it("lists commits with badges, dots and details", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
const wrapper = await mountLog();
|
||||
const rows = wrapper.findAll("[data-test=log-row]");
|
||||
expect(rows).toHaveLength(4);
|
||||
expect(rows[0]?.text()).toContain("Subject m");
|
||||
expect(rows[0]?.findAll("[data-test=log-badge]").map((b) => b.text())).toEqual(["HEAD", "main", "v2"]);
|
||||
expect(rows[1]?.findAll("[data-test=log-badge]").map((b) => b.text())).toEqual(["origin/feature"]);
|
||||
expect(wrapper.findAll("[data-test=log-dot]")).toHaveLength(4);
|
||||
expect(wrapper.find("[data-test=log-message]").text()).toBe("Subject m\n\nBody");
|
||||
expect(wrapper.findAll("[data-test=log-file]").map((f) => f.text())).toEqual([
|
||||
expect.stringContaining("from src/Old.php"),
|
||||
expect.stringContaining("gone.php"),
|
||||
]);
|
||||
});
|
||||
|
||||
it("moves the selection with the keyboard", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
const wrapper = await mountLog();
|
||||
const list = wrapper.find("[data-test=log-list]");
|
||||
await list.trigger("keydown", { key: "ArrowDown" });
|
||||
await flushPromises();
|
||||
expect(log.selected).toBe("b");
|
||||
await list.trigger("keydown", { key: "End" });
|
||||
await flushPromises();
|
||||
expect(log.selected).toBe("r");
|
||||
await list.trigger("keydown", { key: "Home" });
|
||||
await flushPromises();
|
||||
expect(log.selected).toBe("m");
|
||||
expect(callsOf("git.showCommit").map((p) => p.hash)).toEqual(["m", "b", "r", "m"]);
|
||||
});
|
||||
|
||||
it("applies the text filter on Enter and clears a history's path", async () => {
|
||||
const log = useLogStore(pinia);
|
||||
await log.showHistory("a.php");
|
||||
const wrapper = await mountLog();
|
||||
expect(wrapper.find("[data-test=log-path]").text()).toContain("a.php");
|
||||
const input = wrapper.find("[data-test=log-filter-text]");
|
||||
await input.setValue("subject r");
|
||||
await input.trigger("keydown", { key: "Enter" });
|
||||
await flushPromises();
|
||||
expect(callsOf("git.log").at(-1)).toMatchObject({ query: "subject r", path: "a.php" });
|
||||
await wrapper.find("[data-test=log-path-clear]").trigger("click");
|
||||
await flushPromises();
|
||||
expect(log.filters.path).toBeNull();
|
||||
expect(wrapper.find("[data-test=log-path]").exists()).toBe(false);
|
||||
});
|
||||
|
||||
it("says when nothing matches or git fails", async () => {
|
||||
history = [];
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
const wrapper = await mountLog();
|
||||
expect(wrapper.find("[data-test=log-status]").text()).toBe("No commits match");
|
||||
failures["git.log"] = { code: "failed", message: "boom" };
|
||||
await log.reload();
|
||||
await flushPromises();
|
||||
expect(wrapper.find("[data-test=log-status]").text()).toContain("boom");
|
||||
});
|
||||
});
|
||||
|
||||
describe("diff at a commit", () => {
|
||||
it("compares the file at the commit with its parent, read-only", async () => {
|
||||
blobs = { "a:src/Old.php": "<?php\r\nold();\r\n", "m:src/New.php": "<?php\nnew();\n" };
|
||||
await useCommandsStore(pinia).start();
|
||||
useProjectStore(pinia).root = { path: "/p", name: "p" };
|
||||
const area = mount(EditorArea, { attachTo: document.body, slots: { default: "empty" }, global: { plugins: [pinia] } });
|
||||
mounted.push(area);
|
||||
const log = useLogStore(pinia);
|
||||
await log.open();
|
||||
const wrapper = await mountLog();
|
||||
const file = wrapper.findAll("[data-test=log-file]")[0];
|
||||
await file?.trigger("dblclick");
|
||||
await vi.dynamicImportSettled();
|
||||
await flushPromises();
|
||||
const diff = useDiffStore(pinia);
|
||||
expect(diff.activeKey).toBe(commitDiffKey("src/New.php", "m"));
|
||||
expect(callsOf("git.showAt")).toEqual([
|
||||
{ path: "src/Old.php", rev: "a" },
|
||||
{ path: "src/New.php", rev: "m" },
|
||||
]);
|
||||
const merge = currentMerge();
|
||||
expect(merge?.a.state.doc.toString()).toBe("<?php\nold();\n");
|
||||
expect(merge?.b.state.doc.toString()).toBe("<?php\nnew();\n");
|
||||
expect(merge?.b.state.readOnly).toBe(true);
|
||||
expect(area.find("[data-test=diff-tab]").text()).toBe("Diff: New.php (m)");
|
||||
expect(area.find("[data-test=diff-caption]").text()).toContain("commit m");
|
||||
expect(callsOf("file.open")).toEqual([]);
|
||||
|
||||
await emit({ kind: "gitChanged", available: true, repo: null, filesChanged: true });
|
||||
expect(callsOf("git.showAt")).toHaveLength(2);
|
||||
|
||||
await log.openFile({ path: "gone.php", status: "deleted", origPath: null });
|
||||
await flushPromises();
|
||||
expect(callsOf("git.showAt").at(-1)).toEqual({ path: "gone.php", rev: "a" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("commands", () => {
|
||||
it("registers Log and Show History without default shortcuts", () => {
|
||||
const specs = UI_COMMANDS.filter((c) => c.id === SHOW_LOG_COMMAND || c.id === SHOW_HISTORY_COMMAND);
|
||||
expect(specs.map((c) => [c.id, c.menuPath, c.defaultShortcut])).toEqual([
|
||||
["vcs.showLog", "Git/Log", undefined],
|
||||
["vcs.showHistory", "Git/Show History", undefined],
|
||||
]);
|
||||
});
|
||||
|
||||
it("offers Show History in the tree's context menu", async () => {
|
||||
const commands = useCommandsStore(pinia);
|
||||
const run = vi.fn();
|
||||
commands.provide(SHOW_HISTORY_COMMAND, { run });
|
||||
const wrapper = mount(TreeContextMenu, {
|
||||
attachTo: document.body,
|
||||
props: { path: "src/a.php", name: "a.php", x: 0, y: 0 },
|
||||
global: { plugins: [pinia] },
|
||||
});
|
||||
mounted.push(wrapper);
|
||||
await flushPromises();
|
||||
const item = wrapper.findAll("[data-test=tree-menu-item]").find((i) => i.text() === "Show History");
|
||||
await item?.trigger("click");
|
||||
await flushPromises();
|
||||
expect(run).toHaveBeenCalledWith({ path: "src/a.php" });
|
||||
});
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue