release-it 0.0.0-pl.0

package/test/prompt.js

@@ -0,0 +1,97 @@
+import test from 'ava';
+import sinon from 'sinon';
+import Prompt from '../lib/prompt.js';
+import Config from '../lib/config.js';
+import git from '../lib/plugin/git/prompts.js';
+import github from '../lib/plugin/github/prompts.js';
+import gitlab from '../lib/plugin/gitlab/prompts.js';
+import npm from '../lib/plugin/npm/prompts.js';
+import { factory } from './util/index.js';
+
+const prompts = { git, github, gitlab, npm };
+
+const yes = ([options]) => Promise.resolve({ [options.name]: true });
+const no = ([options]) => Promise.resolve({ [options.name]: false });
+
+test.beforeEach(t => {
+  t.context.getInquirer = stub => ({
+    prompt: stub
+  });
+});
+
+test('should not create prompt if disabled', async t => {
+  const task = sinon.spy();
+  const stub = sinon.stub().callsFake(yes);
+  const inquirer = t.context.getInquirer(stub);
+  const prompt = factory(Prompt, { container: { inquirer } });
+  prompt.register(prompts.git);
+  await prompt.show({ enabled: false, prompt: 'push', task });
+  t.is(stub.callCount, 0);
+  t.is(task.callCount, 0);
+});
+
+test('should create prompt', async t => {
+  const stub = sinon.stub().callsFake(yes);
+  const inquirer = t.context.getInquirer(stub);
+  const prompt = factory(Prompt, { container: { inquirer } });
+  prompt.register(prompts.git);
+  await prompt.show({ prompt: 'push' });
+  t.is(stub.callCount, 1);
+  t.deepEqual(stub.firstCall.args[0][0], {
+    type: 'confirm',
+    message: 'Push?',
+    name: 'push',
+    choices: false,
+    transformer: false,
+    default: true
+  });
+});
+
+[
+  ['git', 'commit', 'Commit (Release 1.0.0)?'],
+  ['git', 'tag', 'Tag (1.0.0)?'],
+  ['git', 'push', 'Push?'],
+  ['github', 'release', 'Create a pre-release on GitHub (Release 1.0.0)?'],
+  ['gitlab', 'release', 'Create a release on GitLab (Release 1.0.0)?'],
+  ['npm', 'publish', 'Publish my-pkg@next to npm?'],
+  ['npm', 'otp', 'Please enter OTP for npm:']
+].map(async ([namespace, prompt, message]) => {
+  test(`should create prompt and render template message (${namespace}.${prompt})`, async t => {
+    const stub = sinon.stub().callsFake(yes);
+    const config = new Config({
+      isPreRelease: true,
+      git: { tagName: 'v${version}' },
+      npm: { name: 'my-pkg', tag: 'next' }
+    });
+    config.setContext({ version: '1.0.0', tagName: '1.0.0' });
+    const inquirer = t.context.getInquirer(stub);
+    const p = factory(Prompt, { container: { inquirer } });
+    p.register(prompts[namespace], namespace);
+    await p.show({ namespace, prompt, context: config.getContext() });
+    t.is(stub.callCount, 1);
+    t.is(stub.firstCall.args[0][0].message, message);
+  });
+});
+
+test('should execute task after positive answer', async t => {
+  const task = sinon.spy();
+  const stub = sinon.stub().callsFake(yes);
+  const inquirer = t.context.getInquirer(stub);
+  const prompt = factory(Prompt, { container: { inquirer } });
+  prompt.register(prompts.git);
+  await prompt.show({ prompt: 'push', task });
+  t.is(stub.callCount, 1);
+  t.is(task.callCount, 1);
+  t.is(task.firstCall.args[0], true);
+});
+
+test('should not execute task after negative answer', async t => {
+  const task = sinon.spy();
+  const stub = sinon.stub().callsFake(no);
+  const inquirer = t.context.getInquirer(stub);
+  const prompt = factory(Prompt, { container: { inquirer } });
+  prompt.register(prompts.git);
+  await prompt.show({ prompt: 'push', task });
+  t.is(stub.callCount, 1);
+  t.is(task.callCount, 0);
+});

package/test/resources/file-v2.0.1.txt

@@ -0,0 +1 @@
+*

package/test/resources/file-v2.0.2.txt

@@ -0,0 +1 @@
+*

package/test/resources/file1

@@ -0,0 +1 @@
+file1

package/test/shell.js

@@ -0,0 +1,74 @@
+import test from 'ava';
+import sh from 'shelljs';
+import sinon from 'sinon';
+import Shell from '../lib/shell.js';
+import Log from '../lib/log.js';
+import { factory } from './util/index.js';
+
+const { stdout } = sh.exec('pwd');
+const cwd = stdout.trim();
+
+const shell = factory(Shell);
+
+test('exec', async t => {
+  t.is(await shell.exec('echo bar'), 'bar');
+});
+
+test('exec (with context)', async t => {
+  const exec = cmd => shell.exec(cmd, { verbose: false }, shell.config.getContext());
+  t.is(await exec(''), undefined);
+  t.is(await exec('pwd'), cwd);
+  t.is(await exec('echo ${git.pushArgs}'), '--follow-tags');
+  t.is(await exec('echo -*- ${github.tokenRef} -*-'), '-*- GITHUB_TOKEN -*-');
+});
+
+test('exec (with args)', async t => {
+  t.is(await shell.exec([]), undefined);
+  t.is(await shell.exec(['pwd']), cwd);
+  t.is(await shell.exec(['echo', 'a', 'b']), 'a b');
+  t.is(await shell.exec(['echo', '"a"']), '"a"');
+});
+
+test('exec (dry-run/read-only)', async t => {
+  const shell = factory(Shell, { options: { 'dry-run': true } });
+  {
+    const actual = await shell.exec('pwd', { write: false });
+    t.is(actual, cwd);
+    t.is(shell.log.exec.callCount, 1);
+    t.is(shell.log.exec.firstCall.args[0], 'pwd');
+  }
+  {
+    const actual = await shell.exec('pwd');
+    t.is(actual, undefined);
+    t.is(shell.log.exec.callCount, 2);
+    t.is(shell.log.exec.secondCall.args[0], 'pwd');
+    t.deepEqual(shell.log.exec.secondCall.lastArg, { isDryRun: true });
+  }
+});
+
+test('exec (verbose)', async t => {
+  const shell = factory(Shell, { options: { verbose: true } });
+  const actual = await shell.exec('echo foo');
+  t.is(shell.log.exec.firstCall.args[0], 'echo foo');
+  t.is(shell.log.exec.callCount, 1);
+  t.is(shell.log.verbose.firstCall.args[0], 'foo');
+  t.is(shell.log.verbose.callCount, 1);
+  t.is(actual, 'foo');
+});
+
+test('should cache results of command execution', async t => {
+  const log = sinon.createStubInstance(Log);
+  const shell = factory(Shell, { container: { log } });
+  const result1 = await shell.exec('echo foo');
+  const result2 = await shell.exec('echo foo');
+  t.is(result1, result2);
+  t.deepEqual(log.exec.args, [
+    ['echo foo', { isExternal: false, isCached: false }],
+    ['echo foo', { isExternal: false, isCached: true }]
+  ]);
+});
+
+test('should bail out on failed command execution', async t => {
+  const shell = new Shell({ container: { log: sinon.createStubInstance(Log) } });
+  await t.throwsAsync(shell.exec('foo'));
+});

package/test/spinner.js

@@ -0,0 +1,58 @@
+import test from 'ava';
+import sinon from 'sinon';
+import Spinner from '../lib/spinner.js';
+import Config from '../lib/config.js';
+
+test.beforeEach(t => {
+  t.context.ora = sinon.spy();
+});
+
+const getConfig = options => {
+  const testConfig = {
+    ci: false,
+    config: false
+  };
+  return new Config(Object.assign({}, testConfig, options));
+};
+
+test('should not show spinner and not execute task if disabled', async t => {
+  const { ora } = t.context;
+  const task = sinon.spy();
+  const spinner = new Spinner({ container: { ora } });
+  await spinner.show({ enabled: false, task });
+  t.is(task.callCount, 0);
+  t.is(ora.callCount, 0);
+});
+
+test('should show spinner and run task by default', async t => {
+  const { ora } = t.context;
+  const task = sinon.stub().resolves();
+  const label = 'foo';
+  const config = getConfig({ ci: true });
+  const spinner = new Spinner({ container: { ora, config } });
+  await spinner.show({ task, label });
+  t.is(task.callCount, 1);
+  t.is(ora.callCount, 1);
+  t.is(ora.firstCall.args[0], task.firstCall.returnValue);
+  t.is(ora.firstCall.args[1], label);
+});
+
+test('should run task, but not show spinner if interactive', async t => {
+  const { ora } = t.context;
+  const task = sinon.stub().resolves();
+  const config = getConfig({ ci: false });
+  const spinner = new Spinner({ container: { ora, config } });
+  await spinner.show({ task });
+  t.is(task.callCount, 1);
+  t.is(ora.callCount, 0);
+});
+
+test('should run task and show spinner if interactive, but external', async t => {
+  const { ora } = t.context;
+  const task = sinon.stub().resolves();
+  const config = getConfig({ ci: false });
+  const spinner = new Spinner({ container: { ora, config } });
+  await spinner.show({ task, external: true });
+  t.is(task.callCount, 1);
+  t.is(ora.callCount, 1);
+});

package/test/stub/config/default/.release-it.json

@@ -0,0 +1,5 @@
+{
+  "github": {
+    "release": true
+  }
+}

package/test/stub/config/invalid-config-rc

@@ -0,0 +1 @@
+foo=bar

package/test/stub/config/invalid-config-txt

@@ -0,0 +1,2 @@
+foo
+bar\baz

package/test/stub/config/merge/.release-it.json

@@ -0,0 +1,5 @@
+{
+  "github": {
+    "release": true
+  }
+}

package/test/stub/config/merge/package.json

@@ -0,0 +1,7 @@
+{
+  "release-it": {
+    "git": {
+      "push": false
+    }
+  }
+}

package/test/stub/config/toml/.release-it.toml

@@ -0,0 +1,2 @@
+[foo]
+bar=1

package/test/stub/config/yaml/.release-it.yaml

@@ -0,0 +1,2 @@
+foo:
+  bar: 1

package/test/stub/config/yml/.release-it.yml

@@ -0,0 +1,2 @@
+foo:
+  bar: 1

package/test/stub/github.js

@@ -0,0 +1,130 @@
+import nock from 'nock';
+
+const interceptAuthentication = ({ api = 'https://api.github.com', username = 'john' } = {}) => {
+  nock(api).get('/user').reply(200, {
+    login: username
+  });
+};
+
+const interceptCollaborator = ({
+  api = 'https://api.github.com',
+  owner = 'user',
+  project = 'repo',
+  username = 'john'
+} = {}) => {
+  nock(api).get(`/repos/${owner}/${project}/collaborators/${username}`).reply(204);
+};
+
+const interceptListReleases = ({
+  host = 'github.com',
+  api = 'https://api.github.com',
+  owner = 'user',
+  project = 'repo',
+  tag_name
+} = {}) => {
+  nock(api)
+    .get(`/repos/${owner}/${project}/releases?per_page=1&page=1`)
+    .reply(200, [
+      {
+        id: 1,
+        upload_url: `https://uploads.${host}/repos/${owner}/${project}/releases/1/assets{?name,label}`,
+        html_url: `https://${host}/${owner}/${project}/releases/tag/${tag_name}`,
+        tag_name,
+        target_commitish: 'main',
+        name: `Release ${tag_name}`,
+        body: 'Description of the release',
+        draft: false,
+        prerelease: false
+      }
+    ]);
+};
+
+const interceptCreate = ({
+  api = 'https://api.github.com',
+  host = 'github.com',
+  owner = 'user',
+  project = 'repo',
+  body: { tag_name, name = '', generate_release_notes = false, body = null, prerelease = false, draft = false }
+} = {}) => {
+  nock(api)
+    .post(`/repos/${owner}/${project}/releases`, {
+      tag_name,
+      name,
+      body,
+      prerelease,
+      draft,
+      generate_release_notes
+    })
+    .reply(() => {
+      const id = 1;
+      const responseBody = {
+        id,
+        tag_name,
+        name,
+        body,
+        prerelease,
+        draft,
+        generate_release_notes,
+        upload_url: `https://uploads.${host}/repos/${owner}/${project}/releases/${id}/assets{?name,label}`,
+        html_url: `https://${host}/${owner}/${project}/releases/tag/${tag_name}`
+      };
+      return [200, responseBody, { location: `${api}/repos/${owner}/${project}/releases/${id}` }];
+    });
+};
+
+const interceptUpdate = ({
+  host = 'github.com',
+  api = 'https://api.github.com',
+  owner = 'user',
+  project = 'repo',
+  body: { tag_name, name = '', body = null, prerelease = false, draft = false, generate_release_notes = false }
+} = {}) => {
+  nock(api)
+    .patch(`/repos/${owner}/${project}/releases/1`, { tag_name, name, body, draft, prerelease, generate_release_notes })
+    .reply(200, {
+      id: 1,
+      tag_name,
+      name,
+      body,
+      prerelease,
+      draft,
+      generate_release_notes,
+      upload_url: `https://uploads.${host}/repos/${owner}/${project}/releases/1/assets{?name,label}`,
+      html_url: `https://${host}/${owner}/${project}/releases/tag/${tag_name}`
+    });
+};
+
+const interceptAsset = ({
+  api = 'https://api.github.com',
+  host = 'github.com',
+  owner = 'user',
+  project = 'repo',
+  tagName,
+  body = {}
+} = {}) => {
+  nock(`https://uploads.${host}`)
+    .post(`/repos/${owner}/${project}/releases/1/assets`, body)
+    .query(true)
+    .reply(200, function () {
+      const id = 1;
+      const [, name] = this.req.path.match(/\?name=([^&]+)/);
+      return {
+        id,
+        url: `${api}/repos/${owner}/${project}/releases/assets/${id}`,
+        name,
+        label: '',
+        state: 'uploaded',
+        size: this.req.headers['content-length'],
+        browser_download_url: `https://${host}/${owner}/${project}/releases/download/${tagName}/${name}`
+      };
+    });
+};
+
+export {
+  interceptAuthentication,
+  interceptCollaborator,
+  interceptListReleases,
+  interceptCreate,
+  interceptUpdate,
+  interceptAsset
+};

package/test/stub/gitlab.js

@@ -0,0 +1,44 @@
+import nock from 'nock';
+
+export let interceptUser = ({ host = 'https://gitlab.com', owner = 'user' } = {}, options) =>
+  nock(host, options).get('/api/v4/user').reply(200, { id: 1, username: owner });
+
+export let interceptCollaborator = (
+  { host = 'https://gitlab.com', owner = 'user', project = 'repo', group, userId = 1 } = {},
+  options
+) =>
+  nock(host, options)
+    .get(`/api/v4/projects/${group ? `${group}%2F` : ''}${owner}%2F${project}/members/all/${userId}`)
+    .reply(200, { id: userId, username: owner, access_level: 30 });
+
+export let interceptPublish = ({ host = 'https://gitlab.com', owner = 'user', project = 'repo', body } = {}, options) =>
+  nock(host, options).post(`/api/v4/projects/${owner}%2F${project}/releases`, body).reply(200, {});
+
+export let interceptMilestones = (
+  { host = 'https://gitlab.com', owner = 'user', project = 'repo', query = {}, milestones = [] } = {},
+  options
+) =>
+  nock(host, options)
+    .get(`/api/v4/projects/${owner}%2F${project}/milestones`)
+    .query(
+      Object.assign(
+        {
+          include_parent_milestones: true
+        },
+        query
+      )
+    )
+    .reply(200, JSON.stringify(milestones));
+
+export let interceptAsset = ({ host = 'https://gitlab.com', owner = 'user', project = 'repo' } = {}) =>
+  nock(host)
+    .post(`/api/v4/projects/${owner}%2F${project}/uploads`)
+    .query(true)
+    .reply(200, function (_, requestBody) {
+      const [, name] = requestBody.match(/filename="([^"]+)/);
+      return {
+        alt: name,
+        url: `/uploads/7e8bec1fe27cc46a4bc6a91b9e82a07c/${name}`,
+        markdown: `[${name}](/uploads/7e8bec1fe27cc46a4bc6a91b9e82a07c/${name})`
+      };
+    });

package/test/stub/plugin-context.js

@@ -0,0 +1,36 @@
+import Plugin from '../../lib/plugin/Plugin.js';
+
+class ContextPlugin extends Plugin {
+  init() {
+    const context = this.config.getContext();
+    this.exec(`echo ${context.version.isPreRelease}`);
+    this.exec('echo ${version.isPreRelease}');
+  }
+  beforeBump() {
+    const context = this.config.getContext();
+    this.exec(`echo ${context.name} ${context.repo.owner} ${context.latestVersion} ${context.version}`);
+    this.exec('echo ${name} ${repo.owner} ${latestVersion} ${version}');
+  }
+  bump(version) {
+    const repo = this.config.getContext('repo');
+    this.exec(`echo ${repo.owner} ${repo.project} ${repo.repository} ${version}`);
+    this.exec('echo ${repo.owner} ${repo.project} ${repo.repository} ${version}');
+  }
+  beforeRelease() {
+    const { repo, tagName } = this.config.getContext();
+    this.exec(`echo ${repo.owner} ${repo.project} ${repo.repository} ${tagName}`);
+    this.exec('echo ${repo.owner} ${repo.project} ${repo.repository} ${tagName}');
+  }
+  release() {
+    const { repo, latestVersion, version, tagName } = this.config.getContext();
+    this.exec(`echo ${repo.project} ${latestVersion} ${version} ${tagName}`);
+    this.exec('echo ${repo.project} ${latestVersion} ${version} ${tagName}');
+  }
+  afterRelease() {
+    const { repo, latestVersion, version, tagName } = this.config.getContext();
+    this.exec(`echo ${repo.project} ${latestVersion} ${version} ${tagName}`);
+    this.exec('echo ${repo.project} ${latestVersion} ${version} ${tagName}');
+  }
+}
+
+export default ContextPlugin;

package/test/stub/plugin-replace.js

@@ -0,0 +1,9 @@
+import Plugin from '../../lib/plugin/Plugin.js';
+
+class ReplacePlugin extends Plugin {
+  static disablePlugin() {
+    return ['version', 'git', 'npm'];
+  }
+}
+
+export default ReplacePlugin;

package/test/stub/plugin.js

@@ -0,0 +1,39 @@
+import Plugin from '../../lib/plugin/Plugin.js';
+
+class MyPlugin extends Plugin {
+  init() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:init`);
+  }
+  getName() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:getName`);
+    return 'new-project-name';
+  }
+  getLatestVersion() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:getLatestVersion`);
+    return '1.2.3';
+  }
+  getIncrement() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:getIncrement`);
+    return 'minor';
+  }
+  getIncrementedVersionCI() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:getIncrementedVersionCI`);
+  }
+  beforeBump() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:beforeBump`);
+  }
+  bump(version) {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:bump:${version}`);
+  }
+  beforeRelease() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:beforeRelease`);
+  }
+  release() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:release`);
+  }
+  afterRelease() {
+    this.log.info(`${this.namespace}:${this.getContext('name')}:afterRelease`);
+  }
+}
+
+export default MyPlugin;

package/test/stub/shell.js

@@ -0,0 +1,24 @@
+import util from 'node:util';
+import Shell from '../../lib/shell.js';
+
+const debug = util.debug('release-it:shell-stub');
+
+class ShellStub extends Shell {
+  exec(command) {
+    if (/^(npm (ping|publish|show)|git fetch)/.test(command)) {
+      debug(command);
+      return Promise.resolve();
+    }
+    if (/^npm whoami/.test(command)) {
+      debug(command);
+      return Promise.resolve('john');
+    }
+    if (/^npm access/.test(command)) {
+      debug(command);
+      return Promise.resolve(JSON.stringify({ john: ['write'] }));
+    }
+    return super.exec(...arguments);
+  }
+}
+
+export default ShellStub;