Skip to content

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.

13.6 KB
Raw Blame
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,
    });
  });
});