semantic-release/test/get-config.test.js

import path from "node:path";
import { format } from "node:util";
import test from "ava";
import fsExtra from "fs-extra";
import { omit } from "lodash-es";
import * as td from "testdouble";
import yaml from "js-yaml";
import { gitAddConfig, gitCommits, gitRepo, gitShallowClone, gitTagVersion } from "./helpers/git-utils.js";

const { outputJson, writeFile } = fsExtra;
const pluginsConfig = { foo: "bar", baz: "qux" };
let plugins;

const DEFAULT_PLUGINS = [
  "@semantic-release/commit-analyzer",
  "@semantic-release/release-notes-generator",
  "@semantic-release/npm",
  "@semantic-release/github",
];

test.beforeEach(async (t) => {
  plugins = (await td.replaceEsm("../lib/plugins/index.js")).default;
  t.context.getConfig = (await import("../lib/get-config.js")).default;
});

test.afterEach.always((t) => {
  td.reset();
});

test("Default values, reading repositoryUrl from package.json", async (t) => {
  const pkg = { repository: "https://host.null/owner/package.git" };
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo(true);
  await gitCommits(["First"], { cwd });
  await gitTagVersion("v1.0.0", undefined, { cwd });
  await gitTagVersion("v1.1.0", undefined, { cwd });
  // Add remote.origin.url config
  await gitAddConfig("remote.origin.url", "git@host.null:owner/repo.git", { cwd });
  // Create package.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), pkg);

  const { options: result } = await t.context.getConfig({ cwd });

  // Verify the default options are set
  t.deepEqual(result.branches, [
    "+([0-9])?(.{+([0-9]),x}).x",
    "master",
    "next",
    "next-major",
    { name: "beta", prerelease: true },
    { name: "alpha", prerelease: true },
  ]);
  t.is(result.repositoryUrl, "https://host.null/owner/package.git");
  t.is(result.tagFormat, `v\${version}`);
});

test("Default values, reading repositoryUrl from repo if not set in package.json", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo(true);
  // Add remote.origin.url config
  await gitAddConfig("remote.origin.url", "https://host.null/owner/module.git", { cwd });

  const { options: result } = await t.context.getConfig({ cwd });

  // Verify the default options are set
  t.deepEqual(result.branches, [
    "+([0-9])?(.{+([0-9]),x}).x",
    "master",
    "next",
    "next-major",
    { name: "beta", prerelease: true },
    { name: "alpha", prerelease: true },
  ]);
  t.is(result.repositoryUrl, "https://host.null/owner/module.git");
  t.is(result.tagFormat, `v\${version}`);
});

test("Default values, reading repositoryUrl (http url) from package.json if not set in repo", async (t) => {
  const pkg = { repository: "https://host.null/owner/module.git" };
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  // Create package.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), pkg);

  const { options: result } = await t.context.getConfig({ cwd });

  // Verify the default options are set
  t.deepEqual(result.branches, [
    "+([0-9])?(.{+([0-9]),x}).x",
    "master",
    "next",
    "next-major",
    { name: "beta", prerelease: true },
    { name: "alpha", prerelease: true },
  ]);
  t.is(result.repositoryUrl, "https://host.null/owner/module.git");
  t.is(result.tagFormat, `v\${version}`);
});

test('Convert "ci" option to "noCi"', async (t) => {
  const pkg = { repository: "https://host.null/owner/module.git", release: { ci: false } };
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  // Create package.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), pkg);

  const { options: result } = await t.context.getConfig({ cwd });

  t.is(result.noCi, true);
});

test.serial("Read options from package.json", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    generateNotes: "generateNotes",
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Verify the plugins module is called with the plugin options from package.json
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);
  // Create package.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: options });

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from package.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Read options from .releaserc.yml", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json in repository root
  await writeFile(path.resolve(cwd, ".releaserc.yml"), yaml.dump(options));
  // Verify the plugins module is called with the plugin options from package.json
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from package.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Read options from .releaserc.json", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json in repository root
  await outputJson(path.resolve(cwd, ".releaserc.json"), options);
  // Verify the plugins module is called with the plugin options from package.json
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from package.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Read options from .releaserc.js", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json in repository root
  await writeFile(path.resolve(cwd, ".releaserc.js"), `module.exports = ${JSON.stringify(options)}`);
  // Verify the plugins module is called with the plugin options from package.json
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from package.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Read options from .releaserc.cjs", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create .releaserc.cjs in repository root
  await writeFile(path.resolve(cwd, ".releaserc.cjs"), `module.exports = ${JSON.stringify(options)}`);
  // Verify the plugins module is called with the plugin options from .releaserc.cjs
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from .releaserc.cjs
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Read options from release.config.js", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json in repository root
  await writeFile(path.resolve(cwd, "release.config.js"), `module.exports = ${JSON.stringify(options)}`);
  // Verify the plugins module is called with the plugin options from package.json
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from package.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Read options from release.config.cjs", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Verify the plugins module is called with the plugin options from release.config.cjs
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);
  // Create release.config.cjs in repository root
  await writeFile(path.resolve(cwd, "release.config.cjs"), `module.exports = ${JSON.stringify(options)}`);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from release.config.cjs
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial("Prioritise CLI/API parameters over file configuration and git repo", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  let { cwd, repositoryUrl } = await gitRepo();
  await gitCommits(["First"], { cwd });
  // Create a clone
  cwd = await gitShallowClone(repositoryUrl);
  const pkgOptions = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_pkg" },
    branches: ["branch_pkg"],
  };
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_cli" },
    branches: ["branch_cli"],
    repositoryUrl: "http://cli-url.com/owner/package",
    tagFormat: `cli\${version}`,
    plugins: false,
  };
  // Verify the plugins module is called with the plugin options from CLI/API
  td.when(plugins({ cwd, options }, {})).thenResolve(pluginsConfig);
  const pkg = { release: pkgOptions, repository: "git@host.null:owner/module.git" };
  // Create package.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), pkg);

  const result = await t.context.getConfig({ cwd }, options);

  // Verify the options contains the plugin config from CLI/API
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial('Read configuration from file path in "extends"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = { extends: "./shareable.json" };
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    generateNotes: "generateNotes",
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: ["plugin-1", ["plugin-2", { plugin2Opt: "value" }]],
  };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "shareable.json"), options);
  // Verify the plugins module is called with the plugin options from shareable.json
  td.when(
    plugins(
      { cwd, options },
      {
        analyzeCommits: "./shareable.json",
        generateNotes: "./shareable.json",
        "plugin-1": "./shareable.json",
        "plugin-2": "./shareable.json",
      }
    )
  ).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from shareable.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial('Read configuration from module path in "extends"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = { extends: "shareable" };
  const options = {
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    generateNotes: "generateNotes",
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "node_modules/shareable/index.json"), options);
  // Verify the plugins module is called with the plugin options from shareable.json
  td.when(plugins({ cwd, options }, { analyzeCommits: "shareable", generateNotes: "shareable" })).thenResolve(
    pluginsConfig
  );

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from shareable.json
  t.deepEqual(result, { options, plugins: pluginsConfig });
});

test.serial('Read configuration from an array of paths in "extends"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = { extends: ["./shareable1.json", "./shareable2.json"] };
  const options1 = {
    verifyRelease: "verifyRelease1",
    analyzeCommits: { path: "analyzeCommits1", param: "analyzeCommits_param1" },
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
  };
  const options2 = {
    verifyRelease: "verifyRelease2",
    generateNotes: "generateNotes2",
    analyzeCommits: { path: "analyzeCommits2", param: "analyzeCommits_param2" },
    branches: ["test_branch"],
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "shareable1.json"), options1);
  await outputJson(path.resolve(cwd, "shareable2.json"), options2);
  const expectedOptions = { ...options1, ...options2, branches: ["test_branch"] };
  // Verify the plugins module is called with the plugin options from shareable1.json and shareable2.json
  td.when(
    plugins(
      { options: expectedOptions, cwd },
      {
        verifyRelease1: "./shareable1.json",
        verifyRelease2: "./shareable2.json",
        generateNotes2: "./shareable2.json",
        analyzeCommits1: "./shareable1.json",
        analyzeCommits2: "./shareable2.json",
      }
    )
  ).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from shareable1.json and shareable2.json
  t.deepEqual(result, { options: expectedOptions, plugins: pluginsConfig });
});

test.serial('Prioritize configuration from config file over "extends"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = {
    extends: "./shareable.json",
    branches: ["test_pkg"],
    generateNotes: "generateNotes",
    publish: [{ path: "publishPkg", param: "publishPkg_param" }],
  };
  const options1 = {
    analyzeCommits: "analyzeCommits",
    generateNotes: "generateNotesShareable",
    publish: [{ path: "publishShareable", param: "publishShareable_param" }],
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "shareable.json"), options1);
  const expectedOptions = omit({ ...options1, ...pkgOptions, branches: ["test_pkg"] }, "extends");
  // Verify the plugins module is called with the plugin options from package.json and shareable.json
  td.when(
    plugins(
      { cwd, options: expectedOptions },
      {
        analyzeCommits: "./shareable.json",
        generateNotesShareable: "./shareable.json",
        publishShareable: "./shareable.json",
      }
    )
  ).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from package.json and shareable.json
  t.deepEqual(result, { options: expectedOptions, plugins: pluginsConfig });
});

test.serial('Prioritize configuration from cli/API options over "extends"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const cliOptions = {
    extends: "./shareable2.json",
    branches: ["branch_opts"],
    publish: [{ path: "publishOpts", param: "publishOpts_param" }],
    repositoryUrl: "https://host.null/owner/module.git",
  };
  const pkgOptions = {
    extends: "./shareable1.json",
    branches: ["branch_pkg"],
    generateNotes: "generateNotes",
    publish: [{ path: "publishPkg", param: "publishPkg_param" }],
  };
  const options1 = {
    analyzeCommits: "analyzeCommits1",
    generateNotes: "generateNotesShareable1",
    publish: [{ path: "publishShareable", param: "publishShareable_param1" }],
    branches: ["test_branch1"],
    repositoryUrl: "https://host.null/owner/module.git",
  };
  const options2 = {
    analyzeCommits: "analyzeCommits2",
    publish: [{ path: "publishShareable", param: "publishShareable_param2" }],
    branches: ["test_branch2"],
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create package.json, shareable1.json and shareable2.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "shareable1.json"), options1);
  await outputJson(path.resolve(cwd, "shareable2.json"), options2);
  const expectedOptions = omit({ ...options2, ...pkgOptions, ...cliOptions, branches: ["branch_opts"] }, "extends");
  // Verify the plugins module is called with the plugin options from package.json and shareable2.json
  td.when(
    plugins(
      { cwd, options: expectedOptions },
      { analyzeCommits2: "./shareable2.json", publishShareable: "./shareable2.json" }
    )
  ).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd }, cliOptions);

  // Verify the options contains the plugin config from package.json and shareable2.json
  t.deepEqual(result, { options: expectedOptions, plugins: pluginsConfig });
});

test.serial('Allow to unset properties defined in shareable config with "null"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = {
    extends: "./shareable.json",
    analyzeCommits: null,
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
    plugins: null,
  };
  const options1 = {
    generateNotes: "generateNotes",
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    tagFormat: `v\${version}`,
    plugins: ["test-plugin"],
  };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "shareable.json"), options1);
  // Verify the plugins module is called with the plugin options from shareable.json and the default `plugins`
  td.when(
    plugins(
      {
        options: {
          ...omit(options1, "analyzeCommits"),
          ...omit(pkgOptions, ["extends", "analyzeCommits"]),
          plugins: DEFAULT_PLUGINS,
        },
        cwd,
      },
      {
        generateNotes: "./shareable.json",
        analyzeCommits: "./shareable.json",
        "test-plugin": "./shareable.json",
      }
    )
  ).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from shareable.json and the default `plugins`
  t.deepEqual(result, {
    options: {
      ...omit(options1, ["analyzeCommits"]),
      ...omit(pkgOptions, ["extends", "analyzeCommits"]),
      plugins: DEFAULT_PLUGINS,
    },
    plugins: pluginsConfig,
  });
});

test.serial('Allow to unset properties defined in shareable config with "undefined"', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = {
    extends: "./shareable.json",
    analyzeCommits: undefined,
    branches: ["test_branch"],
    repositoryUrl: "https://host.null/owner/module.git",
  };
  const options1 = {
    generateNotes: "generateNotes",
    analyzeCommits: { path: "analyzeCommits", param: "analyzeCommits_param" },
    tagFormat: `v\${version}`,
    plugins: false,
  };
  // Create release.config.js and shareable.json in repository root
  await writeFile(path.resolve(cwd, "release.config.js"), `module.exports = ${format(pkgOptions)}`);
  await outputJson(path.resolve(cwd, "shareable.json"), options1);
  const expectedOptions = {
    ...omit(options1, "analyzeCommits"),
    ...omit(pkgOptions, ["extends", "analyzeCommits"]),
    branches: ["test_branch"],
  };
  // Verify the plugins module is called with the plugin options from shareable.json
  td.when(
    plugins(
      { options: expectedOptions, cwd },
      { generateNotes: "./shareable.json", analyzeCommits: "./shareable.json" }
    )
  ).thenResolve(pluginsConfig);

  const result = await t.context.getConfig({ cwd });

  // Verify the options contains the plugin config from shareable.json
  t.deepEqual(result, { options: expectedOptions, plugins: pluginsConfig });
});

test("Throw an Error if one of the shareable config cannot be found", async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = { extends: ["./shareable1.json", "non-existing-path"] };
  const options1 = { analyzeCommits: "analyzeCommits" };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "shareable1.json"), options1);

  await t.throwsAsync(t.context.getConfig({ cwd }), {
    message: /Cannot find module 'non-existing-path'/,
    code: "MODULE_NOT_FOUND",
  });
});

test('Convert "ci" option to "noCi" when set from extended config', async (t) => {
  // Create a git repository, set the current working directory at the root of the repo
  const { cwd } = await gitRepo();
  const pkgOptions = { extends: "./no-ci.json" };
  const options = {
    ci: false,
  };
  // Create package.json and shareable.json in repository root
  await outputJson(path.resolve(cwd, "package.json"), { release: pkgOptions });
  await outputJson(path.resolve(cwd, "no-ci.json"), options);

  const { options: result } = await t.context.getConfig({ cwd });

  t.is(result.ci, false);
  t.is(result.noCi, true);
});