The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
import { afterEach, describe, expect, it, vi } from "vitest";
import type { Settings } from "@/bindings";
const settingsSet = vi.fn(async (_scope: string, _key: string, _value: string) => ({
status: "ok" as const,
data: {} as Settings,
}));
const executeAction = vi.fn(async () => true);
vi.mock("./ipc", async (orig) => {
const actual = await orig<typeof import("./ipc")>();
return { ...actual, commands: { ...actual.commands, settingsSet } };
});
vi.mock("./actions", async (orig) => ({ ...(await orig<typeof import("./actions")>()), executeAction }));
const {
disableInspection,
intentionControls,
patchOverride,
problemControls,
setInspectionOption,
setInspectionSeverity,
} = await import("./inspectionControls");
const { diagnosticInspection, inspectionOption, SPELLING_INSPECTION } = await import("./inspections");
const { useProject } = await import("./project");
afterEach(() => {
useProject.setState({ project: null, settings: null });
vi.clearAllMocks();
});
const written = () => {
const [scope, key, value] = settingsSet.mock.calls.at(-1)!;
return { scope, key, value: JSON.parse(value) };
};
describe("inspection controls", () => {
it("names the inspection a diagnostic belongs to", () => {
expect(diagnosticInspection("spelling", { code: null })).toEqual({ id: SPELLING_INSPECTION, name: "Typo" });
expect(diagnosticInspection("ruff", { code: "F401" })).toEqual({ id: "lsp:ruff:F401", name: "ruff F401" });
expect(diagnosticInspection("pyright", { code: null })).toEqual({ id: "lsp:pyright", name: "pyright" });
expect(diagnosticInspection("", { code: null })).toBeNull();
// A built-in check reported per code: PHPStan's identifiers.
expect(diagnosticInspection("phpstan", { code: "constant.notFound" })).toEqual({
id: "builtin:phpstan:constant.notFound",
name: "PHPStan constant.notFound",
});
expect(diagnosticInspection("phpstan", { code: null })).toEqual({ id: "builtin:phpstan", name: "PHPStan" });
expect(diagnosticInspection("build", { code: "E0308" })).toEqual({ id: "builtin:build", name: "Build problems" });
});
it("writes to the profile in effect, at its level", async () => {
useProject.setState({
project: null,
settings: { inspections: { default: { x: { severity: "error" } } } } as never,
});
await disableInspection(SPELLING_INSPECTION);
expect(written()).toEqual({
scope: "global",
key: "inspections.default",
value: { x: { severity: "error" }, [SPELLING_INSPECTION]: { enabled: false } },
});
useProject.setState({
project: { root: "/p" } as never,
settings: { inspections: { profile: "project" } } as never,
});
await setInspectionSeverity("lsp:ruff:F401", "weakWarning");
expect(written()).toEqual({
scope: "project",
key: "inspections.project",
value: { "lsp:ruff:F401": { severity: "weakWarning" } },
});
useProject.setState({
project: { root: "/p" } as never,
settings: {
inspections: { profile: "ide:strict", ideProfiles: { strict: { name: "Strict", overrides: {} } } },
} as never,
});
await setInspectionOption(SPELLING_INSPECTION, "processCode", false);
expect(written()).toEqual({
scope: "global",
key: "inspections.ideProfiles",
value: { strict: { name: "Strict", overrides: { [SPELLING_INSPECTION]: { options: { processCode: false } } } } },
});
});
it("drops entries that end up empty", () => {
expect(patchOverride({ a: { severity: "error" } }, "a", (o) => ({ ...o, severity: undefined }))).toEqual({});
});
it("reads options with their defaults", () => {
expect(inspectionOption({}, SPELLING_INSPECTION, "processCode")).toBe(true);
expect(
inspectionOption(
{ [SPELLING_INSPECTION]: { options: { processCode: false } } },
SPELLING_INSPECTION,
"processCode",
),
).toBe(false);
});
it("offers IDEA's menu rows, opening Settings on the inspection", () => {
const ref = { id: "lsp:ruff:F401", name: "ruff F401" };
const rows = intentionControls(ref);
expect(rows.map((r) => ("label" in r ? r.label : "-"))).toEqual([
"Edit inspection profile setting",
"Disable inspection",
]);
(rows[0] as { run: () => void }).run();
expect(executeAction).toHaveBeenCalledWith("file.settings", "editor.inspections#lsp:ruff:F401");
useProject.setState({
settings: { inspections: { default: { "lsp:ruff:F401": { severity: "error" } } } } as never,
});
const menu = problemControls(ref);
expect(menu.map((r) => ("label" in r ? r.label : "-"))).toEqual([
"Disable Inspection 'ruff F401'",
"Change Severity",
"Edit Inspection Profile Setting…",
]);
const severity = menu[1] as { submenu: { label: string; checked?: boolean }[] };
expect(severity.submenu.filter((s) => s.checked).map((s) => s.label)).toEqual(["Error"]);
});
});