magus-cli 7.5.3 → 7.6.0

package/src/__tests__/installed-version-scope.test.tsx

@@ -0,0 +1,425 @@
+/**
+ * A plugin's installed version comes only from scopes where it is INSTALLED —
+ * and "does this project hold a row?" reads only this project's own row.
+ *
+ * `getAvailablePlugins` took `installedVersion` from the project lookup whenever
+ * the plugin was installed anywhere, and that lookup resolves a row inherited
+ * from another checkout, installed here or not. So with the plugin installed at
+ * user scope at 0.9.0 beside an inherited project row at 0.8.1, the panel said
+ * "(v0.8.1 installed)" next to a status of current at 0.9.0; with its user files
+ * missing, the header said "● Installed" above a status saying files missing.
+ *
+ * The same kind of fallback sat under the apply engine's row check: the
+ * read-back fell back to the user row, so a plugin installed only at user scope,
+ * and turned on in project settings, ran `update --scope project` from a folder
+ * holding no project row.
+ *
+ * The pure halves — which row each question reads — are in
+ * scope-row-lookup.test.ts.
+ *
+ * The real `getAvailablePlugins` and the real registry read-back run in a CHILD
+ * process that starts with HOME, CLAUDE_CONFIG_DIR and XDG_* inside a temp dir:
+ * Bun's `os.homedir()` ignores a HOME changed at runtime, and the registry path
+ * is built from it. The child's `fetch` serves one catalog and 404s the rest, and
+ * its PATH holds only `git`, so no network and no `claude` CLI is reachable.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import {
+	mkdir,
+	mkdtemp,
+	readFile,
+	realpath,
+	rm,
+	symlink,
+	writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { testRender } from "@opentui/react/test-utils";
+import { type ReactNode, act } from "react";
+import {
+	type PluginInfo,
+	hasMissingFiles,
+} from "../services/plugin-manager.js";
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+} from "../services/update-plan.js";
+import type { InstalledPluginEntry, Marketplace } from "../types/index.js";
+import {
+	type PluginPluginItem,
+	buildPluginBrowserItems,
+} from "../ui/adapters/pluginsAdapter.js";
+import { renderPluginDetail } from "../ui/renderers/pluginRenderers.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+
+const ID = "probe@magus";
+const SRC = join(import.meta.dir, "..");
+
+const MAGUS: Marketplace = {
+	name: "magus",
+	displayName: "Magus",
+	source: { source: "github", repo: "MadAppGang/magus" },
+	description: "",
+	owned: true,
+} as Marketplace;
+
+// ── the child ────────────────────────────────────────────────────────────────
+
+/**
+ * Loads the plugin list with the real `getAvailablePlugins`, and — when the job
+ * asks — plans it and applies it with the real engine and the real registry
+ * read-back, the Claude CLI's three commands recorded instead of run.
+ */
+const CHILD = `
+const job = JSON.parse(await Bun.file(process.argv[2]).text());
+const os = await import("node:os");
+if (os.homedir() !== job.home) {
+	await Bun.write(job.out, JSON.stringify({ guard: false }));
+	process.exit(0);
+}
+globalThis.fetch = async (input) => {
+	const url = String(input instanceof Request ? input.url : input);
+	if (url === job.catalogUrl) {
+		return new Response(JSON.stringify(job.catalog), {
+			status: 200,
+			headers: { "content-type": "application/json" },
+		});
+	}
+	return new Response("", { status: 404, statusText: "Not Found" });
+};
+console.log = () => {};
+const pm = await import(job.modules.pluginManager);
+const plugins = await pm.getAvailablePlugins(job.project);
+let apply = null;
+if (job.apply) {
+	const plan = await import(job.modules.updatePlan);
+	const engine = await import(job.modules.updateEngine);
+	const item = plan.planPluginUpdates({}, plugins).find((i) => i.pluginId === job.id);
+	const calls = [];
+	const record = (command) => async (_id, scope) => { calls.push([command, scope]); };
+	await engine.applyPlugins([item], job.project, {
+		...engine.REAL_PLUGIN_DEPS,
+		install: record("install"),
+		update: record("update"),
+		repair: record("repair"),
+		saveInstalled: async () => {},
+		repairStaleLoad: async () => { throw new Error("no stale-load repair expected"); },
+		loadedVersion: undefined,
+		registryRows: undefined,
+	});
+	apply = { action: item.action, scopes: item.scopes, calls };
+}
+await Bun.write(job.out, JSON.stringify({ guard: true, plugins, apply }));
+process.exit(0);
+`;
+
+interface World {
+	base: string;
+	home: string;
+	/** A git repository: its root's registry rows are inherited by `project`. */
+	repo: string;
+	/** `<repo>/sub` — the directory magus runs in. */
+	project: string;
+	env: Record<string, string>;
+}
+
+interface Seed {
+	/** `~/.claude/settings.json` enabledPlugins. */
+	userEnabled?: Record<string, boolean>;
+	/** `<project>/.claude/settings.json` enabledPlugins. */
+	projectEnabled?: Record<string, boolean>;
+	/** The plugin's registry rows; `onDisk` creates the row's cache directory. */
+	rows: Array<{
+		scope: "user" | "project" | "local";
+		projectPath?: string;
+		version: string;
+		onDisk: boolean;
+	}>;
+	/** The version the magus catalog publishes for the plugin. */
+	catalogVersion: string;
+	/** Plan and apply the plugin, recording the Claude CLI calls. */
+	apply?: boolean;
+}
+
+interface ChildResult {
+	plugins: PluginInfo[];
+	apply: {
+		action: string;
+		scopes: string[];
+		calls: Array<[string, string]>;
+	} | null;
+}
+
+let root: string;
+let binDir: string;
+let childScript: string;
+
+beforeAll(async () => {
+	root = await realpath(await mkdtemp(join(tmpdir(), "installed-version-")));
+	binDir = join(root, "bin");
+	await mkdir(binDir);
+	const git = Bun.which("git");
+	if (!git) throw new Error("git is required: inherited rows are found by it");
+	await symlink(git, join(binDir, "git"));
+	childScript = join(root, "child.ts");
+	await writeFile(childScript, CHILD);
+});
+
+afterAll(async () => {
+	await rm(root, { recursive: true, force: true });
+});
+
+let worlds = 0;
+async function world(): Promise<World> {
+	const base = join(root, `world-${++worlds}`);
+	const home = join(base, "home");
+	const xdg = join(base, "xdg");
+	const repo = join(base, "repo");
+	const project = join(repo, "sub");
+	await mkdir(join(home, ".claude", "plugins"), { recursive: true });
+	for (const kind of ["config", "cache", "data", "state"]) {
+		await mkdir(join(xdg, kind), { recursive: true });
+	}
+	await mkdir(join(project, ".claude"), { recursive: true });
+	const env = {
+		PATH: `${binDir}:/usr/bin:/bin`,
+		HOME: home,
+		CLAUDE_CONFIG_DIR: join(home, ".claude"),
+		XDG_CONFIG_HOME: join(xdg, "config"),
+		XDG_CACHE_HOME: join(xdg, "cache"),
+		XDG_DATA_HOME: join(xdg, "data"),
+		XDG_STATE_HOME: join(xdg, "state"),
+		TMPDIR: tmpdir(),
+		NO_COLOR: "1",
+		TERM: "dumb",
+		GIT_CONFIG_NOSYSTEM: "1",
+		GIT_CONFIG_GLOBAL: "/dev/null",
+	};
+	const init = spawnSync("git", ["init", "-q", repo], { env });
+	if (init.status !== 0) throw new Error(`git init failed: ${init.stderr}`);
+	return { base, home, repo, project, env };
+}
+
+async function writeJson(file: string, value: unknown): Promise<void> {
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, JSON.stringify(value, null, 2));
+}
+
+async function run(w: World, seed: Seed): Promise<ChildResult> {
+	const claude = join(w.home, ".claude");
+	await writeJson(join(claude, "settings.json"), {
+		enabledPlugins: seed.userEnabled ?? {},
+	});
+	await writeJson(join(w.project, ".claude", "settings.json"), {
+		enabledPlugins: seed.projectEnabled ?? {},
+	});
+	const rows: InstalledPluginEntry[] = [];
+	for (const row of seed.rows) {
+		const installPath = join(
+			claude,
+			"plugins",
+			"cache",
+			"magus",
+			"probe",
+			row.version,
+		);
+		if (row.onDisk) await mkdir(installPath, { recursive: true });
+		rows.push({
+			scope: row.scope,
+			...(row.projectPath ? { projectPath: row.projectPath } : {}),
+			installPath,
+			version: row.version,
+			installedAt: "2026-09-01T00:00:00.000Z",
+			lastUpdated: "2026-09-01T00:00:00.000Z",
+		});
+	}
+	await writeJson(join(claude, "plugins", "installed_plugins.json"), {
+		version: 2,
+		plugins: { [ID]: rows },
+	});
+
+	const out = join(w.base, "result.json");
+	const jobFile = join(w.base, "job.json");
+	await writeJson(jobFile, {
+		home: w.home,
+		project: w.project,
+		id: ID,
+		out,
+		apply: seed.apply ?? false,
+		catalogUrl:
+			"https://raw.githubusercontent.com/MadAppGang/magus/main/.claude-plugin/marketplace.json",
+		catalog: {
+			name: "magus",
+			plugins: [
+				{
+					name: "probe",
+					version: seed.catalogVersion,
+					description: "Probe plugin.",
+					source: "./plugins/probe",
+				},
+			],
+		},
+		modules: {
+			pluginManager: join(SRC, "services", "plugin-manager.ts"),
+			updatePlan: join(SRC, "services", "update-plan.ts"),
+			updateEngine: join(SRC, "services", "update-engine.ts"),
+		},
+	});
+
+	const proc = spawnSync(
+		process.execPath,
+		["--no-env-file", childScript, jobFile],
+		{ cwd: w.project, env: w.env, timeout: 60_000 },
+	);
+	let raw: string;
+	try {
+		raw = await readFile(out, "utf8");
+	} catch {
+		throw new Error(
+			`child produced no result (exit ${proc.status}):\n${proc.stderr}`,
+		);
+	}
+	const result = JSON.parse(raw) as ChildResult & { guard: boolean };
+	if (!result.guard) throw new Error("the child's home was not redirected");
+	return result;
+}
+
+// ── the surfaces, rendered the way the Plugins screen renders them ───────────
+
+async function detailText(item: PluginPluginItem): Promise<string> {
+	const { captureCharFrame, renderOnce, renderer } = await testRender(
+		<box flexDirection="column">
+			{renderPluginDetail(item, new Set<string>()) as ReactNode}
+		</box>,
+		{ width: 120, height: 80 },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const frame = captureCharFrame();
+	await act(async () => renderer.destroy());
+	return frame;
+}
+
+interface Surfaces {
+	plugin: PluginInfo;
+	status: PluginUpdateItem;
+	row: string;
+	detail: string;
+}
+
+/** The screen's own path: classify, build the browser items, render. */
+async function surfaces(plugins: PluginInfo[]): Promise<Surfaces> {
+	const items = buildPluginBrowserItems({
+		marketplaces: [MAGUS],
+		plugins,
+		collapsedMarketplaces: new Set(),
+		statuses: classifyPluginRows(plugins, {}),
+	});
+	const item = items.find(
+		(i): i is PluginPluginItem => i.kind === "plugin" && i.plugin.id === ID,
+	);
+	if (!item?.status) throw new Error(`no classified row for ${ID}`);
+	return {
+		plugin: item.plugin,
+		status: item.status,
+		row: pluginRowText(item).text,
+		detail: await detailText(item),
+	};
+}
+
+// ── Finding 2 ────────────────────────────────────────────────────────────────
+
+describe("installedVersion comes only from installed scopes", () => {
+	test("case B: installed at user v0.9.0 beside an inherited project row v0.8.1 — every surface says 0.9.0", async () => {
+		const w = await world();
+		const { plugins } = await run(w, {
+			userEnabled: { [ID]: true },
+			rows: [
+				{ scope: "user", version: "0.9.0", onDisk: true },
+				{
+					scope: "project",
+					projectPath: w.repo,
+					version: "0.8.1",
+					onDisk: false,
+				},
+			],
+			catalogVersion: "0.9.0",
+		});
+		const s = await surfaces(plugins);
+
+		// The reported shape: user installed at 0.9.0, the inherited row not on here.
+		expect(s.plugin.userScope).toEqual({ installed: true, version: "0.9.0" });
+		expect(s.plugin.projectScope).toEqual({
+			installed: false,
+			version: "0.8.1",
+		});
+
+		expect(s.status.action).toBe("current");
+		expect(s.status.installed).toBe("0.9.0");
+		expect(s.plugin.installedVersion).toBe("0.9.0");
+		expect(s.plugin.installedVersion ?? null).toBe(s.status.installed);
+		expect(hasMissingFiles(s.plugin)).toBe(false);
+		expect(s.row).toBe(" v0.9.0");
+		expect(s.detail).toContain("● Installed");
+		expect(s.detail).not.toContain("files missing");
+		// Not "(v0.8.1 installed)", and not anywhere else either.
+		expect(s.detail).not.toContain("0.8.1");
+	});
+
+	test("case A: files missing at user scope beside the same inherited row — every surface says files missing", async () => {
+		const w = await world();
+		const { plugins } = await run(w, {
+			userEnabled: { [ID]: true },
+			rows: [
+				{
+					scope: "project",
+					projectPath: w.repo,
+					version: "0.8.1",
+					onDisk: false,
+				},
+			],
+			catalogVersion: "0.9.0",
+		});
+		const s = await surfaces(plugins);
+
+		expect(s.plugin.userScope).toEqual({ installed: true });
+		expect(s.plugin.projectScope).toEqual({
+			installed: false,
+			version: "0.8.1",
+		});
+
+		expect(s.status.action).toBe("install");
+		expect(s.status.reason).toBe("files-missing");
+		expect(s.status.installed).toBeNull();
+		expect(s.plugin.installedVersion).toBeUndefined();
+		expect(hasMissingFiles(s.plugin)).toBe(true);
+		// No version beside "files missing" — the row has none to show.
+		expect(s.row).toBe(" files missing");
+		expect(s.detail).toContain("● Installed — files missing");
+		expect(s.detail).not.toContain("0.8.1");
+	});
+});
+
+// ── Finding 3 ────────────────────────────────────────────────────────────────
+
+describe("no row for this project → install, not update", () => {
+	test("a user row only, turned on in project settings: `install --scope project`, never `update`", async () => {
+		const w = await world();
+		const { apply } = await run(w, {
+			projectEnabled: { [ID]: true },
+			rows: [{ scope: "user", version: "1.0.0", onDisk: true }],
+			catalogVersion: "2.0.0",
+			apply: true,
+		});
+
+		// Planned as project scope behind — the project resolves to the user row.
+		expect(apply?.action).toBe("update");
+		expect(apply?.scopes).toEqual(["project"]);
+		expect(apply?.calls).toEqual([["install", "project"]]);
+	});
+});

package/src/__tests__/key-focus-guard.test.tsx

@@ -0,0 +1,260 @@
+/**
+ * Key focus rule: "A key goes only to the input that had focus when the key was
+ * pressed."
+ *
+ * Written blind — from the spec and the exported signatures of KeyRouter,
+ * AppProvider/useModal, DimensionsProvider and ModalContainer only. The real
+ * providers and the real ModalContainer are mounted; keys are sent through the
+ * test renderer's mock keyboard, and the outcome is read from what the user
+ * sees (the frame) and what the caller receives (onSubmit).
+ *
+ * REQ-A1  a select modal's onSelect opens an input modal in the same Enter:
+ *         that Enter shows the input and does NOT submit it.
+ * REQ-A2  the next Enter submits the input's default value ("default-2").
+ * REQ-A3  keys typed after the input opened do reach it.
+ * REQ-A4  an input modal that was already open receives typed text: "abc" +
+ *         Enter submits "abc".
+ * REQ-A5  a screen-level key that opens an input modal is not typed into it:
+ *         the default value is unchanged after the key.
+ */
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import { ModalContainer } from "../ui/components/modals/ModalContainer.js";
+import { KeyRouter, useKeyLayer } from "../ui/input/KeyRouter.js";
+import { AppProvider, useModal } from "../ui/state/AppContext.js";
+import { DimensionsProvider } from "../ui/state/DimensionsContext.js";
+import type { ModalState } from "../ui/state/types.js";
+
+type ModalApi = ReturnType<typeof useModal>;
+
+const SELECT_TITLE = "Pick a setup";
+const INPUT_TITLE = "Name the new profile";
+const INPUT_LABEL = "Profile name";
+
+let cleanup: Array<() => Promise<void> | void> = [];
+
+afterEach(async () => {
+	for (const fn of cleanup.reverse()) await fn();
+	cleanup = [];
+});
+
+interface Mounted {
+	modal: () => ModalApi;
+	frame: () => Promise<string>;
+	/** Run input actions, then let React and the renderer settle. */
+	send: (fn: () => void | Promise<void>) => Promise<void>;
+	mockInput: Awaited<ReturnType<typeof testRender>>["mockInput"];
+}
+
+/** A screen that opens an input modal on its own key `e`. */
+function ScreenWithKey({
+	onKey,
+}: {
+	onKey: () => void;
+}) {
+	useKeyLayer("screen", true, (key) => {
+		if (key.name === "e" && !key.ctrl && !key.meta) {
+			onKey();
+			return true;
+		}
+		return false;
+	});
+	return <text>screen body</text>;
+}
+
+async function mount(
+	opts: { screenKey?: (modal: ModalApi) => void } = {},
+): Promise<Mounted> {
+	// A throwaway project path: nothing here reads or writes a real project.
+	const project = mkdtempSync(join(tmpdir(), "key-focus-guard-"));
+	cleanup.push(() => rmSync(project, { recursive: true, force: true }));
+
+	let api: ModalApi | null = null;
+	function Harness() {
+		const modal = useModal();
+		api = modal;
+		return (
+			<box flexDirection="column" width="100%" height="100%">
+				{opts.screenKey ? (
+					<ScreenWithKey onKey={() => opts.screenKey?.(modal)} />
+				) : (
+					<text>screen body</text>
+				)}
+				<ModalContainer />
+			</box>
+		);
+	}
+
+	const { renderer, mockInput, renderOnce, captureCharFrame } =
+		await testRender(
+			<AppProvider initialProjectPath={project}>
+				<DimensionsProvider>
+					<KeyRouter>
+						<Harness />
+					</KeyRouter>
+				</DimensionsProvider>
+			</AppProvider>,
+			{ width: 100, height: 30 },
+		);
+	cleanup.push(async () => {
+		await act(async () => renderer.destroy());
+	});
+
+	const settle = async () => {
+		for (let i = 0; i < 3; i++) {
+			await new Promise((r) => setTimeout(r, 10));
+			await renderOnce();
+		}
+	};
+	await act(settle);
+
+	return {
+		mockInput,
+		modal: () => {
+			if (!api) throw new Error("useModal was never reached");
+			return api;
+		},
+		frame: async () => {
+			await act(settle);
+			return captureCharFrame();
+		},
+		send: async (fn) => {
+			await act(async () => {
+				await fn();
+				await settle();
+			});
+		},
+	};
+}
+
+function inputModal(
+	defaultValue: string | undefined,
+	onSubmit: (value: string) => void,
+): ModalState {
+	return {
+		type: "input",
+		title: INPUT_TITLE,
+		label: INPUT_LABEL,
+		...(defaultValue !== undefined ? { defaultValue } : {}),
+		onSubmit,
+		onCancel: () => {},
+	};
+}
+
+/** Open a select whose onSelect opens the input modal, in the same handler. */
+async function openSelectThatOpensInput(
+	m: Mounted,
+	onSelect: (value: string) => void,
+	onSubmit: (value: string) => void,
+): Promise<void> {
+	await m.send(() => {
+		m.modal().showModal({
+			type: "select",
+			title: SELECT_TITLE,
+			message: "Which setup should this project start from?",
+			options: [
+				{ label: "Default setup", value: "default" },
+				{ label: "Empty setup", value: "empty" },
+			],
+			defaultIndex: 0,
+			onSelect: (value) => {
+				onSelect(value);
+				m.modal().showModal(inputModal("default-2", onSubmit));
+			},
+			onCancel: () => {},
+		});
+	});
+	const frame = await m.frame();
+	// Precondition: the select is on screen, the input is not.
+	expect(frame).toContain(SELECT_TITLE);
+	expect(frame).not.toContain(INPUT_TITLE);
+}
+
+describe("key focus: a key goes only to the input that had focus when it was pressed", () => {
+	test("REQ-A1 one Enter on a select whose onSelect opens an input shows the input and does not submit it", async () => {
+		const m = await mount();
+		const onSelect = mock((_v: string) => {});
+		const onSubmit = mock((_v: string) => {});
+		await openSelectThatOpensInput(m, onSelect, onSubmit);
+
+		await m.send(() => m.mockInput.pressEnter());
+
+		expect(onSelect).toHaveBeenCalledTimes(1);
+		expect(onSelect).toHaveBeenCalledWith("default");
+		const frame = await m.frame();
+		expect(frame).toContain(INPUT_TITLE);
+		expect(frame).toContain("default-2");
+		expect(onSubmit).not.toHaveBeenCalled();
+	});
+
+	test('REQ-A2 a second Enter submits the input\'s default value "default-2"', async () => {
+		const m = await mount();
+		const onSubmit = mock((_v: string) => {});
+		await openSelectThatOpensInput(m, () => {}, onSubmit);
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).not.toHaveBeenCalled();
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("default-2");
+	});
+
+	test('REQ-A3 keys typed after the input opened reach it: "x" then Enter submits "default-2x"', async () => {
+		const m = await mount();
+		const onSubmit = mock((_v: string) => {});
+		await openSelectThatOpensInput(m, () => {}, onSubmit);
+
+		await m.send(() => m.mockInput.pressEnter());
+		await m.send(() => m.mockInput.typeText("x"));
+		expect(await m.frame()).toContain("default-2x");
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("default-2x");
+	});
+
+	test('REQ-A4 an input modal that was already open receives typing: "abc" then Enter submits "abc"', async () => {
+		const m = await mount();
+		const onSubmit = mock((_v: string) => {});
+		await m.send(() => m.modal().showModal(inputModal(undefined, onSubmit)));
+		expect(await m.frame()).toContain(INPUT_TITLE);
+
+		await m.send(() => m.mockInput.typeText("abc"));
+		expect(await m.frame()).toContain("abc");
+		expect(onSubmit).not.toHaveBeenCalled();
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("abc");
+	});
+
+	test('REQ-A5 a screen key that opens an input modal is not typed into it: default "cfg" stays "cfg"', async () => {
+		const onSubmit = mock((_v: string) => {});
+		const opened = mock(() => {});
+		const m = await mount({
+			screenKey: (modal) => {
+				opened();
+				modal.showModal(inputModal("cfg", onSubmit));
+			},
+		});
+		expect(await m.frame()).not.toContain(INPUT_TITLE);
+
+		await m.send(() => m.mockInput.pressKey("e"));
+
+		expect(opened).toHaveBeenCalledTimes(1);
+		const frame = await m.frame();
+		expect(frame).toContain(INPUT_TITLE);
+		expect(frame).toContain("cfg");
+		expect(frame).not.toContain("cfge");
+		expect(onSubmit).not.toHaveBeenCalled();
+
+		await m.send(() => m.mockInput.pressEnter());
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+		expect(onSubmit).toHaveBeenCalledWith("cfg");
+	});
+});