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 { describe, expect, it } from "vitest";
import {
DEFAULT_LANGUAGES,
JAVA_LANGUAGE_LEVELS,
PHP_LANGUAGE_LEVELS,
folderRole,
markFolder,
normalizeFolder,
validateLanguages,
validateProjectStructure,
} from "@/platform/languageSettings";
import { buildPageTree } from "../model/pages";
import { LANGUAGE_PAGES } from "../pages/languages";
import { filterPackages } from "../languages/PythonInterpreterPage";
import { tildify } from "../languages/components";
import { validateSettings } from "../model/schema";
describe("languages settings", () => {
it("defaults and normalises malformed values", () => {
expect(validateLanguages(undefined)).toEqual(DEFAULT_LANGUAGES);
expect(validateLanguages({ pluginFormatters: { sql: "example.formatter", text: 42 } }).pluginFormatters).toEqual({
sql: "example.formatter",
});
const v = validateLanguages({
python: { interpreter: " /usr/bin/python3 ", activateVirtualenv: "yes" },
node: { packageManager: "pip" },
rust: { checkCommand: "clippy", checkOnSave: false },
typescript: { version: "" },
java: {
jdtlsVmArgs: " -Xmx2g ",
jdk: 21,
jdtlsJdk: " /opt/jdk-25 ",
maven: {
runnerJre: " /opt/jdk-21 ",
home: " /opt/maven ",
daemon: "yes",
mvndHome: " /opt/mvnd ",
threads: " 2C ",
},
},
});
expect(v.python).toEqual({ interpreter: "/usr/bin/python3", activateVirtualenv: true });
expect(v.node.packageManager).toBe("");
expect(v.rust.checkCommand).toBe("clippy");
expect(v.rust.checkOnSave).toBe(false);
expect(v.typescript.version).toBe("bundled");
expect(v.java.jdtlsVmArgs).toBe("-Xmx2g");
expect(v.java.jdk).toBe("");
expect(v.java.jdtlsJdk).toBe("/opt/jdk-25");
expect(v.java.maven).toEqual({
runnerJre: "/opt/jdk-21",
home: "/opt/maven",
userSettings: "",
toolchains: "",
localRepository: "",
unlinkedProjects: [],
linkedProjects: [],
daemon: false,
mvndHome: "/opt/mvnd",
threads: "2C",
activeProfiles: "",
});
expect(validateSettings({}).languages).toEqual(DEFAULT_LANGUAGES);
expect(validateLanguages({ java: { maven: { threads: 4 } } }).java.maven.threads).toBe("");
});
it("defaults the Maven runner JRE to the project JDK and preserves a chosen JDK", () => {
expect(validateSettings({}).languages.java.maven.runnerJre).toBe("");
expect(validateLanguages({ java: { maven: { runnerJre: 21 } } }).java.maven.runnerJre).toBe("");
const settings = validateSettings({ languages: { java: { maven: { runnerJre: " ./jdks/21 " } } } });
expect(validateSettings(settings).languages.java.maven.runnerJre).toBe("./jdks/21");
});
it("keeps the Ruby interpreter through settings normalization and defaults to Auto", () => {
expect(validateSettings({}).languages.ruby.interpreter).toBe("");
expect(validateLanguages({ ruby: { interpreter: 42 } }).ruby.interpreter).toBe("");
const settings = validateSettings({ languages: { ruby: { interpreter: " /opt/ruby/bin/ruby " } } });
expect(settings.languages.ruby.interpreter).toBe("/opt/ruby/bin/ruby");
expect(validateSettings(settings).languages.ruby.interpreter).toBe("/opt/ruby/bin/ruby");
});
it("defaults the PHP language level to Auto and keeps only known levels", () => {
expect(validateSettings({}).languages.php).toEqual({
runTarget: "",
interpreter: "",
languageLevel: "",
includePaths: [],
stubs: [],
phpstanConfig: "",
});
expect(validateLanguages({ php: { phpstanConfig: " build/phpstan.neon " } }).php.phpstanConfig).toBe(
"build/phpstan.neon",
);
expect(validateLanguages({ php: { phpstanConfig: 3 } }).php.phpstanConfig).toBe("");
const lists = validateLanguages({ php: { includePaths: [" ../platform ", "", 3, "../platform"], stubs: "redis" } });
expect(lists.php.includePaths).toEqual(["../platform"]);
expect(lists.php.stubs).toEqual([]);
expect(validateLanguages({ php: { languageLevel: "7.4" } }).php.languageLevel).toBe("7.4");
for (const level of ["7.4.3", "9.0", 8.1, null]) {
expect(validateLanguages({ php: { languageLevel: level } }).php.languageLevel).toBe("");
}
expect(PHP_LANGUAGE_LEVELS[0]).toBe("");
expect(PHP_LANGUAGE_LEVELS).toContain("5.6");
// Newest first after Auto (#1557).
expect(PHP_LANGUAGE_LEVELS[1]).toBe("8.5");
expect(PHP_LANGUAGE_LEVELS.at(-1)).toBe("5.6");
});
it("finds the PHP page by its language level", () => {
const php = LANGUAGE_PAGES.find((p) => p.id === "languages.php")!;
expect(php.keywords).toContain("language level");
});
it("keeps Prettier opt-in on save and normalizes its enabled languages", () => {
expect(validateLanguages({}).prettier).toMatchObject({ prefer: false, runOnSave: false, path: "" });
expect(
validateLanguages({
prettier: { path: " ./bin/prettier ", languages: ["markdown", 4, "markdown"], prefer: true, runOnSave: true },
}).prettier,
).toEqual({
path: "./bin/prettier",
configurationDirectory: "",
languages: ["markdown"],
prefer: true,
runOnSave: true,
});
expect(validateLanguages({ prettier: { languages: [] } }).prettier.languages).toEqual([]);
});
it("gives oxfmt the same opt-in settings as Prettier, kept apart from them", () => {
expect(validateLanguages({}).oxfmt).toEqual(DEFAULT_LANGUAGES.prettier);
const v = validateLanguages({
prettier: { runOnSave: true },
oxfmt: { path: " ./bin/oxfmt ", languages: ["typescript", null, "typescript"], prefer: true },
});
expect(v.oxfmt).toEqual({
path: "./bin/oxfmt",
configurationDirectory: "",
languages: ["typescript"],
prefer: true,
runOnSave: false,
});
expect(v.prettier).toMatchObject({ runOnSave: true, prefer: false, path: "" });
});
it("enables Ruff for Python by default and keeps its settings separate", () => {
expect(validateLanguages({}).ruff).toMatchObject({
path: "",
configurationDirectory: "",
languages: ["python"],
prefer: false,
runOnSave: false,
});
const v = validateLanguages({
ruff: {
path: " ./bin/ruff ",
configurationDirectory: " ./config/ruff ",
languages: ["python", null, "python", "pyi"],
prefer: true,
runOnSave: true,
},
});
expect(v.ruff).toEqual({
path: "./bin/ruff",
configurationDirectory: "./config/ruff",
languages: ["python", "pyi"],
prefer: true,
runOnSave: true,
});
expect(v.prettier).toEqual(DEFAULT_LANGUAGES.prettier);
});
it("leaves the Markdown preview font size unset (editor font) and keeps a set one in 8..72", () => {
expect(validateLanguages({}).markdown).toEqual({ previewFontSize: null });
expect(validateLanguages({ markdown: { previewFontSize: 90 } }).markdown).toEqual({ previewFontSize: 72 });
expect(validateLanguages({ markdown: { previewFontSize: "x" } }).markdown).toEqual({ previewFontSize: null });
});
it("keeps the Markdown page global, like IDEA's application-level setting", () => {
expect(LANGUAGE_PAGES.find((p) => p.id === "languages.markdown")).not.toHaveProperty("projectScope");
});
it("marks folders with one role each", () => {
expect(normalizeFolder("./src/main/")).toBe("src/main");
let ps = validateProjectStructure({ sourceRoots: ["src/", "src", 3], excluded: ["/dist"] });
expect(ps.sourceRoots).toEqual(["src"]);
expect(ps.excluded).toEqual(["dist"]);
ps = markFolder(ps, "src", "test");
expect(ps.sourceRoots).toEqual([]);
expect(folderRole(ps, "src/")).toBe("test");
ps = markFolder(ps, "src", null);
expect(folderRole(ps, "src")).toBeNull();
});
it("defaults shared JDT LS to off and accepts only boolean values", () => {
expect(DEFAULT_LANGUAGES.java.jdtlsShared).toBe(false);
expect(validateLanguages({}).java.jdtlsShared).toBe(false);
expect(validateSettings({ languages: { java: { jdtlsShared: true } } }).languages.java.jdtlsShared).toBe(true);
expect(validateLanguages({ java: { jdtlsShared: false } }).java.jdtlsShared).toBe(false);
for (const invalid of ["true", 1, null, []])
expect(validateLanguages({ java: { jdtlsShared: invalid } }).java.jdtlsShared).toBe(false);
});
it("defaults Java language level to SDK default and keeps only supported levels", () => {
expect(validateLanguages({}).java.languageLevel).toBe("");
expect(validateLanguages({ java: { languageLevel: "8" } }).java.languageLevel).toBe("8");
expect(validateLanguages({ java: { languageLevel: "21" } }).java.languageLevel).toBe("21");
for (const invalid of ["6", "26", 17, null]) {
expect(validateLanguages({ java: { languageLevel: invalid } }).java.languageLevel).toBe("");
}
expect(JAVA_LANGUAGE_LEVELS[0]).toBe("");
expect(JAVA_LANGUAGE_LEVELS).toContain("8");
expect(JAVA_LANGUAGE_LEVELS).toContain("25");
});
it("normalizes project structure modules, libraries, facets, and artifacts", () => {
const ps = validateProjectStructure({
compilerOutput: " out/production ",
modules: {
" ./modules/core/ ": {
jdk: " /opt/jdk-21 ",
languageLevel: "17",
compilerOutput: " target/classes ",
testCompilerOutput: " target/test-classes ",
dependencies: [
{ target: " common-lib ", kind: "library", scope: "provided", exported: true },
{ target: " ", kind: "module", scope: "invalid" },
],
},
},
libraries: [
{
name: " servlet-api ",
classes: [" lib/servlet-api.jar ", "lib/servlet-api.jar", ""],
sources: [" lib/servlet-api-sources.jar "],
javadocs: [],
scope: "provided",
},
{ name: " ", classes: [], sources: [] },
],
facets: [
{
kind: "web",
module: " ./modules/web/ ",
descriptor: " src/main/webapp/WEB-INF/web.xml ",
webRoot: " src/main/webapp ",
},
],
artifacts: [
{
name: " app:war exploded ",
kind: "warExploded",
module: " ./modules/web/ ",
outputDirectory: " target/app-exploded ",
mainClass: " com.example.Main ",
includeLibraries: [" servlet-api ", "servlet-api", ""],
},
],
});
expect(ps.compilerOutput).toBe("out/production");
expect(ps.modules).toEqual({
"modules/core": {
jdk: "/opt/jdk-21",
languageLevel: "17",
compilerOutput: "target/classes",
testCompilerOutput: "target/test-classes",
dependencies: [{ target: "common-lib", kind: "library", scope: "provided", exported: true }],
},
});
expect(ps.libraries).toEqual([
{
name: "servlet-api",
classes: ["lib/servlet-api.jar"],
sources: ["lib/servlet-api-sources.jar"],
javadocs: [],
scope: "provided",
},
]);
expect(ps.facets).toEqual([
{
kind: "web",
module: "modules/web",
descriptor: "src/main/webapp/WEB-INF/web.xml",
webRoot: "src/main/webapp",
},
]);
expect(ps.artifacts).toEqual([
{
name: "app:war exploded",
kind: "warExploded",
module: "modules/web",
outputDirectory: "target/app-exploded",
mainClass: "com.example.Main",
includeLibraries: ["servlet-api"],
},
]);
});
});
describe("language pages", () => {
it("keeps every language under Languages & Frameworks, as in IntelliJ IDEA", () => {
const tree = buildPageTree(LANGUAGE_PAGES.map((p) => ({ ...p, component: p.component! })));
expect(tree.map((n) => n.title)).toEqual(["Project Structure", "Languages & Frameworks"]);
const langs = tree.find((n) => n.title === "Languages & Frameworks")!;
expect(langs.children.map((n) => n.title)).toEqual([
"Go",
"Java",
"Markdown",
"Node.js",
"Python Interpreter",
"PHP",
"Prettier",
"oxfmt",
"Ruff",
"Ruby",
"Rust",
"TypeScript",
"Plugin Formatters",
"Language server targets",
]);
});
it("filters packages and shortens home paths", () => {
const pkgs = [
{ name: "Django", version: "5.1" },
{ name: "requests", version: "2.32.0" },
];
expect(filterPackages(pkgs, "dj").map((p) => p.name)).toEqual(["Django"]);
expect(filterPackages(pkgs, "")).toHaveLength(2);
expect(tildify("/Users/me/p/.venv/bin/python")).toBe("~/p/.venv/bin/python");
expect(tildify("C:/Users/me/.m2/wrapper/dists/apache-maven-3.9.16")).toBe(
"~/.m2/wrapper/dists/apache-maven-3.9.16",
);
expect(tildify("C:/Program Files/Java/jdk-21")).toBe("C:/Program Files/Java/jdk-21");
});
});
describe("Go module settings", () => {
it("keeps automatic vendoring by default and normalizes malformed environment entries", () => {
expect(validateLanguages({ go: {} }).go.modules).toEqual({ env: {}, autoVendor: true });
const modules = validateLanguages({
go: {
modules: {
autoVendor: false,
env: {
GOPROXY: "https://proxy.example",
GOPRIVATE: "example.com/private",
GOFLAGS: "-race",
INVALID: 3,
"BAD KEY": "value",
NULL: "x\0y",
},
},
},
}).go.modules;
expect(modules).toEqual({
autoVendor: false,
env: { GOPROXY: "https://proxy.example", GOPRIVATE: "example.com/private", GOFLAGS: "-race" },
});
expect(validateLanguages({ go: { modules: { autoVendor: "no", env: [] } } }).go.modules).toEqual({
env: {},
autoVendor: true,
});
});
});