release-it 14.1.0-next.0 → 14.2.2

package/README.md

@@ -241,8 +241,8 @@ The "Releases" tab on GitHub projects links to a page to store the changelog cq.
 [GitHub releases](https://help.github.com/articles/creating-releases) in your release-it flow:
 
 - Configure `github.release: true`
-- Obtain a [personal access token](https://github.com/settings/tokens) (release-it only needs "repo" access; no "admin"
-  or other scopes).
+- Obtain a [personal access token](https://github.com/settings/tokens/new?scopes=repo&description=release-it)
+  (release-it only needs "repo" access; no "admin" or other scopes).
 - Make sure the token is [available as an environment variable](./docs/environment-variables.md).
 
 → See [GitHub Releases](./docs/github-releases.md) for more details.

package/lib/plugin/GitBase.js

@@ -49,7 +49,8 @@ class GitBase extends Plugin {
 
   bump(version) {
     const { tagTemplate } = this.getContext();
-    const tagName = format(tagTemplate, { version }) || version;
+    const context = Object.assign(this.config.getContext(), { version });
+    const tagName = format(tagTemplate, context) || version;
     this.setContext({ version, tagName });
     this.config.setContext({ tagName });
   }

package/lib/plugin/Plugin.js

@@ -30,6 +30,7 @@ class Plugin {
   getName() {}
   getLatestVersion() {}
   getChangelog() {}
+  getIncrement() {}
   getIncrementedVersionCI() {}
   getIncrementedVersion() {}
   beforeBump() {}

package/lib/plugin/version/Version.js

@@ -57,9 +57,11 @@ class Version extends Plugin {
     return '0.0.0';
   }
 
+  getIncrement(options) {
+    return options.increment;
+  }
+
   getIncrementedVersionCI(options) {
-    const { isCI } = this.config;
-    options.increment = options.increment == null && isCI ? 'patch' : options.increment;
     return this.incrementVersion(options);
   }
 
@@ -103,12 +105,15 @@ class Version extends Plugin {
       return increment;
     }
 
-    const _isPreRelease = isPreRelease || (increment || '').startsWith('pre');
-    if (_isPreRelease && latestIsPreRelease) {
+    if (isPreRelease && !increment && latestIsPreRelease) {
       return semver.inc(latestVersion, 'prerelease', preReleaseId);
     }
 
-    const normalizedType = RELEASE_TYPES.includes(increment) && _isPreRelease ? `pre${increment}` : increment;
+    if (this.config.isCI && !increment) {
+      return semver.inc(latestVersion, 'patch');
+    }
+
+    const normalizedType = RELEASE_TYPES.includes(increment) && isPreRelease ? `pre${increment}` : increment;
     if (ALL_RELEASE_TYPES.includes(normalizedType)) {
       return semver.inc(latestVersion, normalizedType, preReleaseId);
     }

package/lib/tasks.js

@@ -68,6 +68,8 @@ const runTasks = async (opts, di) => {
     const changelog = await reduceUntil(plugins, plugin => plugin.getChangelog(latestVersion));
 
     const incrementBase = { latestVersion, increment, isPreRelease, preReleaseId };
+    incrementBase.increment = await reduceUntil(plugins, plugin => plugin.getIncrement(incrementBase));
+
     let version = await reduceUntil(plugins, plugin => plugin.getIncrementedVersionCI(incrementBase));
 
     config.setContext({ name, latestVersion, version, changelog });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-it",
-  "version": "14.1.0-next.0",
+  "version": "14.2.2",
   "description": "Generic CLI tool to automate versioning and package publishing related tasks.",
   "keywords": [
     "build",
@@ -56,18 +56,18 @@
   "license": "MIT",
   "dependencies": {
     "@iarna/toml": "2.2.5",
-    "@octokit/rest": "18.0.6",
+    "@octokit/rest": "18.0.9",
     "async-retry": "1.3.1",
     "chalk": "4.1.0",
     "cosmiconfig": "7.0.0",
-    "debug": "4.1.1",
+    "debug": "4.3.1",
     "deprecated-obj": "2.0.0",
-    "execa": "4.0.3",
+    "execa": "4.1.0",
     "find-up": "5.0.0",
     "form-data": "3.0.0",
-    "git-url-parse": "11.2.0",
+    "git-url-parse": "11.4.0",
     "globby": "11.0.1",
-    "got": "11.6.2",
+    "got": "11.8.0",
     "import-cwd": "3.0.0",
     "inquirer": "7.3.3",
     "is-ci": "2.0.0",
@@ -78,29 +78,29 @@
     "parse-json": "5.1.0",
     "semver": "7.3.2",
     "shelljs": "0.8.4",
-    "update-notifier": "4.1.1",
+    "update-notifier": "5.0.1",
     "url-join": "4.0.1",
-    "uuid": "8.3.0",
+    "uuid": "8.3.1",
     "yaml": "1.10.0",
-    "yargs-parser": "20.0.0"
+    "yargs-parser": "20.2.4"
   },
   "devDependencies": {
-    "@octokit/request-error": "2.0.2",
-    "ava": "3.12.1",
-    "codecov": "3.7.2",
-    "eslint": "7.9.0",
-    "eslint-config-prettier": "6.11.0",
+    "@octokit/request-error": "2.0.3",
+    "ava": "3.13.0",
+    "codecov": "3.8.1",
+    "eslint": "7.14.0",
+    "eslint-config-prettier": "6.15.0",
     "eslint-plugin-ava": "11.0.0",
-    "eslint-plugin-import": "2.22.0",
+    "eslint-plugin-import": "2.22.1",
     "eslint-plugin-prettier": "3.1.4",
     "markdown-toc": "1.2.0",
     "mock-fs": "4.13.0",
     "mock-stdio": "1.0.3",
-    "nock": "13.0.4",
+    "nock": "13.0.5",
     "nyc": "15.1.0",
-    "prettier": "2.1.1",
+    "prettier": "2.2.0",
     "proxyquire": "2.1.3",
-    "sinon": "9.0.3",
+    "sinon": "9.2.1",
     "strip-ansi": "6.0.0"
   },
   "engines": {

package/test/git.init.js

@@ -21,32 +21,32 @@ test.serial('should throw if on wrong branch', async t => {
   const options = { git: { requireBranch: 'dev' } };
   const gitClient = factory(Git, { options });
   sh.exec('git remote remove origin');
-  await t.throwsAsync(gitClient.init(), null, 'Must be on branch dev');
+  await t.throwsAsync(gitClient.init(), { message: /^Must be on branch dev/ });
 });
 
 test.serial('should throw if there is no remote Git url', async t => {
   const gitClient = factory(Git, { options: { git } });
   sh.exec('git remote remove origin');
-  await t.throwsAsync(gitClient.init(), null, 'Could not get remote Git url');
+  await t.throwsAsync(gitClient.init(), { message: /^Could not get remote Git url/ });
 });
 
 test.serial('should throw if working dir is not clean', async t => {
   const gitClient = factory(Git, { options: { git } });
   sh.exec('rm file');
-  await t.throwsAsync(gitClient.init(), { message: /Working dir must be clean/ });
+  await t.throwsAsync(gitClient.init(), { message: /^Working dir must be clean/ });
 });
 
 test.serial('should throw if no upstream is configured', async t => {
   const gitClient = factory(Git, { options: { git } });
   sh.exec('git checkout -b foo');
-  await t.throwsAsync(gitClient.init(), null, 'No upstream configured for current branch');
+  await t.throwsAsync(gitClient.init(), { message: /^No upstream configured for current branch/ });
 });
 
 test.serial('should throw if there are no commits', async t => {
   const options = { git: { requireCommits: true } };
   const gitClient = factory(Git, { options });
   sh.exec('git tag 1.0.0');
-  await t.throwsAsync(gitClient.init(), null, 'There are no commits since the latest tag');
+  await t.throwsAsync(gitClient.init(), { message: /^There are no commits since the latest tag/ });
 });
 
 test.serial('should not throw if there are commits', async t => {
@@ -95,11 +95,12 @@ test.serial('should detect and exclude version prefix (configured)', async t =>
 });
 
 test.serial('should honor custom tagName configuration', async t => {
-  const gitClient = factory(Git, { options: { git: { tagName: 'TAGNAME-v${version}' } } });
+  const gitClient = factory(Git, { options: { git: { tagName: 'TAGNAME-${repo.project}-v${version}' } } });
   sh.exec('git tag 1.0.0');
   await gitClient.init();
   await gitClient.bump('1.0.1');
-  t.is(gitClient.getContext('tagName'), 'TAGNAME-v1.0.1');
+  const { project } = gitClient.getContext('repo');
+  t.is(gitClient.getContext('tagName'), `TAGNAME-${project}-v1.0.1`);
 });
 
 test.serial('should get the latest tag after fetch', async t => {

package/test/github.js

@@ -24,7 +24,7 @@ test.serial('should validate token', async t => {
   delete process.env[tokenRef];
 
   await t.throwsAsync(github.init(), {
-    message: /Environment variable "MY_GITHUB_TOKEN" is required for GitHub releases/
+    message: /^Environment variable "MY_GITHUB_TOKEN" is required for GitHub releases/
   });
   process.env[tokenRef] = '123'; // eslint-disable-line require-atomic-updates
 
@@ -193,11 +193,9 @@ test('should throw for unauthenticated user', async t => {
   const stub = sinon.stub(github.client.users, 'getAuthenticated');
   stub.throws(new RequestError('Bad credentials', 401, { request: { url: '', headers: {} } }));
 
-  await t.throwsAsync(
-    runTasks(github),
-    null,
-    'Could not authenticate with GitHub using environment variable "GITHUB_TOKEN". Generate a new token at https://github.com/settings/tokens'
-  );
+  await t.throwsAsync(runTasks(github), {
+    message: /^Could not authenticate with GitHub using environment variable "GITHUB_TOKEN"/
+  });
 
   t.is(stub.callCount, 1);
   stub.restore();
@@ -210,7 +208,7 @@ test('should throw for non-collaborator', async t => {
   const stub = sinon.stub(github.client.repos, 'checkCollaborator');
   stub.throws(new RequestError('HttpError', 401, { request: { url: '', headers: {} } }));
 
-  await t.throwsAsync(runTasks(github), null, 'User john is not a collaborator for user/repo.');
+  await t.throwsAsync(runTasks(github), { message: /^User john is not a collaborator for user\/repo/ });
 
   stub.restore();
 });
@@ -243,7 +241,7 @@ test('should handle octokit client error (without retries)', async t => {
   interceptAuthentication();
   interceptCollaborator();
 
-  await t.throwsAsync(runTasks(github), null, '404 (Not found)');
+  await t.throwsAsync(runTasks(github), { message: /^404 \(Not found\)/ });
 
   t.is(stub.callCount, 1);
   stub.restore();
@@ -257,7 +255,7 @@ test('should handle octokit client error (with retries)', async t => {
   interceptAuthentication();
   interceptCollaborator();
 
-  await t.throwsAsync(runTasks(github), null, '500 (Request failed)');
+  await t.throwsAsync(runTasks(github), { message: /^500 \(Request failed\)/ });
 
   t.is(stub.callCount, 3);
   stub.restore();

package/test/gitlab.js

@@ -20,7 +20,9 @@ test.serial('should validate token', async t => {
   const gitlab = factory(GitLab, { options });
   delete process.env[tokenRef];
 
-  await t.throwsAsync(gitlab.init(), null, 'Environment variable "MY_GITLAB_TOKEN" is required for GitLab releases');
+  await t.throwsAsync(gitlab.init(), {
+    message: /^Environment variable "MY_GITLAB_TOKEN" is required for GitLab releases/
+  });
   process.env[tokenRef] = '123'; // eslint-disable-line require-atomic-updates
 
   interceptUser();
@@ -115,11 +117,9 @@ test.serial('should throw for unauthenticated user', async t => {
   const scope = nock(host);
   scope.get(`/api/v4/user`).reply(401);
 
-  await t.throwsAsync(
-    runTasks(gitlab),
-    null,
-    'Could not authenticate with GitLab using environment variable "GITLAB_TOKEN".'
-  );
+  await t.throwsAsync(runTasks(gitlab), {
+    message: /^Could not authenticate with GitLab using environment variable "GITLAB_TOKEN"/
+  });
 });
 
 test.serial('should throw for non-collaborator', async t => {
@@ -131,7 +131,7 @@ test.serial('should throw for non-collaborator', async t => {
   scope.get(`/api/v4/projects/john%2Frepo/members/all/1`).reply(200, { username: 'emma' });
   interceptUser({ owner: 'john' });
 
-  await t.throwsAsync(runTasks(gitlab), null, 'User john is not a collaborator for john/repo.');
+  await t.throwsAsync(runTasks(gitlab), { message: /^User john is not a collaborator for john\/repo/ });
 });
 
 test.serial('should throw for insufficient access level', async t => {
@@ -143,7 +143,7 @@ test.serial('should throw for insufficient access level', async t => {
   scope.get(`/api/v4/projects/john%2Frepo/members/all/1`).reply(200, { username: 'john', access_level: 10 });
   interceptUser({ owner: 'john' });
 
-  await t.throwsAsync(runTasks(gitlab), null, 'User john is not a collaborator for john/repo.');
+  await t.throwsAsync(runTasks(gitlab), { message: /^User john is not a collaborator for john\/repo/ });
 });
 
 test.serial('should fallback for gitlab < v12.4', async t => {

package/test/npm.js

@@ -129,7 +129,7 @@ test('should throw if npm is down', async t => {
   const npmClient = factory(npm);
   const exec = sinon.stub(npmClient.shell, 'exec').resolves();
   exec.withArgs('npm ping').rejects();
-  await t.throwsAsync(runTasks(npmClient), { message: /Unable to reach npm registry/ });
+  await t.throwsAsync(runTasks(npmClient), { message: /^Unable to reach npm registry/ });
   exec.restore();
 });
 
@@ -177,7 +177,7 @@ test('should throw if user is not authenticated', async t => {
   const npmClient = factory(npm);
   const exec = sinon.stub(npmClient.shell, 'exec').resolves();
   exec.withArgs('npm whoami').rejects();
-  await t.throwsAsync(runTasks(npmClient), { message: /Not authenticated with npm/ });
+  await t.throwsAsync(runTasks(npmClient), { message: /^Not authenticated with npm/ });
   exec.restore();
 });
 
@@ -186,7 +186,7 @@ test('should throw if user is not a collaborator', async t => {
   const exec = sinon.stub(npmClient.shell, 'exec').resolves();
   exec.withArgs('npm whoami').resolves('ada');
   exec.withArgs('npm access ls-collaborators release-it').resolves(JSON.stringify({ john: ['write'] }));
-  await t.throwsAsync(runTasks(npmClient), { message: /User ada is not a collaborator for release-it/ });
+  await t.throwsAsync(runTasks(npmClient), { message: /^User ada is not a collaborator for release-it/ });
   exec.restore();
 });
 

package/test/plugins.js

@@ -1,3 +1,4 @@
+const path = require('path');
 const test = require('ava');
 const sh = require('shelljs');
 const proxyquire = require('proxyquire');
@@ -94,6 +95,7 @@ test.serial('should instantiate plugins and execute all release-cycle methods',
     'init',
     'getName',
     'getLatestVersion',
+    'getIncrement',
     'getIncrementedVersionCI',
     'beforeBump',
     'bump',
@@ -105,7 +107,8 @@ test.serial('should instantiate plugins and execute all release-cycle methods',
     t.is(myLocalPlugin[method].callCount, 1);
   });
 
-  const incrementBase = { latestVersion: '0.0.0', increment: 'patch', isPreRelease: false, preReleaseId: undefined };
+  const incrementBase = { latestVersion: '0.0.0', increment: undefined, isPreRelease: false, preReleaseId: undefined };
+  t.deepEqual(myPlugin.getIncrement.firstCall.args[0], incrementBase);
   t.deepEqual(myPlugin.getIncrementedVersionCI.firstCall.args[0], incrementBase);
   t.deepEqual(myLocalPlugin.getIncrementedVersionCI.firstCall.args[0], incrementBase);
   t.is(myPlugin.bump.firstCall.args[0], '0.0.1');
@@ -129,3 +132,69 @@ test.serial('should disable core plugins', async t => {
     version: undefined
   });
 });
+
+test.serial('should expose context to execute commands', async t => {
+  const { bare } = t.context;
+  const latestVersion = '1.0.0';
+  const project = path.basename(bare);
+  const pkgName = 'plugin-context';
+  const owner = path.basename(path.dirname(bare));
+  gitAdd(`{"name":"${pkgName}","version":"${latestVersion}"}`, 'package.json', 'Add package.json');
+
+  class MyPlugin extends Plugin {
+    init() {
+      this.exec('echo ${version.isPreRelease}');
+    }
+    beforeBump() {
+      const context = this.config.getContext();
+      t.is(context.name, pkgName);
+      this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version}');
+    }
+    bump() {
+      const repo = this.config.getContext('repo');
+      t.is(repo.owner, owner);
+      t.is(repo.project, project);
+      t.is(repo.repository, `${owner}/${project}`);
+      this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version}');
+    }
+    beforeRelease() {
+      const context = this.config.getContext();
+      t.is(context.name, pkgName);
+      this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version} ${tagName}');
+    }
+    release() {
+      const context = this.config.getContext();
+      t.is(context.latestVersion, latestVersion);
+      t.is(context.version, '1.0.1');
+      this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version} ${tagName}');
+    }
+    afterRelease() {
+      const context = this.config.getContext();
+      t.is(context.tagName, '1.0.1');
+      this.exec('echo ${name} ${repo.owner} ${repo.project} ${latestVersion} ${version} ${tagName}');
+    }
+  }
+  const statics = { isEnabled: () => true, disablePlugin: () => null };
+  const options = { '@global': true, '@noCallThru': true };
+  const runTasks = proxyquire('../lib/tasks', {
+    'my-plugin': Object.assign(MyPlugin, statics, options)
+  });
+
+  const container = getContainer({ plugins: { 'my-plugin': {} } });
+  const exec = sinon.spy(container.shell, 'execFormattedCommand');
+
+  await runTasks({}, container);
+
+  const pluginExecArgs = exec.args
+    .map(args => args[0])
+    .filter(arg => typeof arg === 'string' && arg.startsWith('echo'));
+
+  t.deepEqual(pluginExecArgs, [
+    'echo false',
+    `echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1`,
+    `echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1`,
+    `echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1 1.0.1`,
+    `echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1 1.0.1`,
+    `echo ${pkgName} ${owner} ${project} ${latestVersion} 1.0.1 1.0.1`
+  ]);
+});

package/test/stub/shell.js

@@ -1,7 +1,7 @@
 const debug = require('debug')('release-it:shell-stub');
 const Shell = require('../../lib/shell');
 
-module.exports = class ShellStub extends Shell {
+class ShellStub extends Shell {
   exec(command) {
     if (/^(npm (ping|publish|show)|git fetch)/.test(command)) {
       debug(command);
@@ -17,4 +17,6 @@ module.exports = class ShellStub extends Shell {
     }
     return super.exec(...arguments);
   }
-};
+}
+
+module.exports = ShellStub;

package/test/tasks.js

@@ -398,22 +398,11 @@ test.serial('should propagate errors', async t => {
 });
 
 {
-  const myPlugin = sandbox.createStubInstance(Plugin);
-  myPlugin.namespace = 'my-plugin';
-  const MyPlugin = sandbox.stub().callsFake(() => myPlugin);
-  const myLocalPlugin = sandbox.createStubInstance(Plugin);
-  const MyLocalPlugin = sandbox.stub().callsFake(() => myLocalPlugin);
-  const replacePlugin = sandbox.createStubInstance(Plugin);
-  const ReplacePlugin = sandbox.stub().callsFake(() => replacePlugin);
-
+  class MyPlugin extends Plugin {}
   const statics = { isEnabled: () => true, disablePlugin: () => null };
   const options = { '@global': true, '@noCallThru': true };
   const runTasks = proxyquire('../lib/tasks', {
-    'my-plugin': Object.assign(MyPlugin, statics, options),
-    '/my/plugin': Object.assign(MyLocalPlugin, statics, options),
-    'replace-plugin': Object.assign(ReplacePlugin, statics, options, {
-      disablePlugin: () => ['version', 'git']
-    })
+    'my-plugin': Object.assign(MyPlugin, statics, options)
   });
 
   test.serial('should run all hooks', async t => {
@@ -421,9 +410,9 @@ test.serial('should propagate errors', async t => {
     const hooks = {};
     ['before', 'after'].forEach(prefix => {
       ['version', 'git', 'npm', 'my-plugin'].forEach(ns => {
-        ['init', 'beforeBump', 'bump', 'beforeRelease', 'release', 'afterRelease'].forEach(lifecycle => {
-          hooks[`${prefix}:${lifecycle}`] = `echo ${prefix}:${lifecycle}`;
-          hooks[`${prefix}:${ns}:${lifecycle}`] = `echo ${prefix}:${ns}:${lifecycle}`;
+        ['init', 'beforeBump', 'bump', 'beforeRelease', 'release', 'afterRelease'].forEach(cycle => {
+          hooks[`${prefix}:${cycle}`] = `echo ${prefix}:${cycle}`;
+          hooks[`${prefix}:${ns}:${cycle}`] = `echo ${prefix}:${ns}:${cycle}`;
         });
       });
     });

package/test/util/index.js

@@ -30,19 +30,39 @@ module.exports.factory = (Definition, { namespace, options = {}, container = {}
   });
 };
 
+const getIncrement = (plugin, { latestVersion }) => {
+  return (
+    plugin.getIncrement({
+      latestVersion,
+      increment: plugin.options.increment,
+      isPreRelease: false,
+      preReleaseId: null
+    }) ||
+    plugin.getContext('increment') ||
+    plugin.config.getContext('increment')
+  );
+};
+
+const getVersion = async (plugin, { latestVersion, increment }) => {
+  return (
+    (await plugin.getIncrementedVersionCI({ latestVersion, increment })) ||
+    (await plugin.getIncrementedVersion({ latestVersion, increment })) ||
+    (increment !== false ? semver.inc(latestVersion, increment || 'patch') : latestVersion)
+  );
+};
+
 module.exports.runTasks = async plugin => {
   await plugin.init();
 
   const name = (await plugin.getName()) || '__test__';
   const latestVersion = (await plugin.getLatestVersion()) || '1.0.0';
   const changelog = (await plugin.getChangelog(latestVersion)) || null;
-  const increment = plugin.getContext('increment') || plugin.config.getContext('increment');
+  const increment = getIncrement(plugin, { latestVersion });
+
   plugin.config.setContext({ name, latestVersion, latestTag: latestVersion, changelog });
 
-  const version =
-    plugin.getIncrementedVersionCI({ latestVersion, increment }) ||
-    (await plugin.getIncrementedVersion({ latestVersion, increment })) ||
-    (increment !== false ? semver.inc(latestVersion, increment || 'patch') : latestVersion);
+  const version = await getVersion(plugin, { latestVersion, increment });
+
   plugin.config.setContext(parseVersion(version));
 
   await plugin.beforeBump();

package/test/version.js

@@ -15,11 +15,19 @@ test('isPreRelease', t => {
   t.is(v.isPreRelease('1.0.0'), false);
 });
 
+test('should return the same version in both interactive and ci mode', async t => {
+  const v = factory(Version);
+  const options = { latestVersion: '2.0.0-beta.1', increment: null, preReleaseId: 'rc', isPreRelease: true };
+  const resultInteractiveMode = await v.getIncrementedVersion(options);
+  t.is(resultInteractiveMode, '2.0.0-rc.0');
+  const resultCiMode = v.getIncrementedVersionCI(options);
+  t.is(resultInteractiveMode, resultCiMode);
+});
+
 test('should increment latest version', t => {
   const v = factory(Version);
   const latestVersion = '1.0.0';
   t.is(v.incrementVersion({ latestVersion, increment: false }), '1.0.0');
-  t.is(v.incrementVersion({ latestVersion, increment: null }), undefined);
   t.is(v.incrementVersion({ latestVersion, increment: 'foo' }), undefined);
   t.is(v.incrementVersion({ latestVersion, increment: 'patsj' }), undefined);
   t.is(v.incrementVersion({ latestVersion, increment: 'a.b.c' }), undefined);
@@ -29,6 +37,22 @@ test('should increment latest version', t => {
   t.is(v.incrementVersion({ latestVersion, increment: '2.0.0-beta.1' }), '2.0.0-beta.1');
 });
 
+test('should not increment latest version in interactive mode', t => {
+  const v = factory(Version, { options: { ci: false } });
+  const latestVersion = '1.0.0';
+  t.is(v.incrementVersion({ latestVersion, increment: null }), undefined);
+  t.is(v.incrementVersion({ latestVersion, increment: false }), '1.0.0');
+});
+
+test('should always set increment version in CI mode', t => {
+  const v = factory(Version, { options: { ci: true } });
+  const latestVersion = '1.0.0';
+  t.is(v.getIncrementedVersionCI({ latestVersion, increment: false }), '1.0.0');
+  t.is(v.getIncrementedVersionCI({ latestVersion, increment: null }), '1.0.1');
+  t.is(v.getIncrementedVersionCI({ latestVersion, increment: '1.1.0' }), '1.1.0');
+  t.is(v.getIncrementedVersionCI({ latestVersion, increment: 'major' }), '2.0.0');
+});
+
 test('should increment latest version (coerce)', t => {
   const v = factory(Version);
   t.is(v.incrementVersion({ increment: '1.2' }), '1.2.0');
@@ -38,7 +62,7 @@ test('should increment latest version (coerce)', t => {
 
 test('should increment version (pre-release continuation)', t => {
   const v = factory(Version);
-  t.is(v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prepatch' }), '1.2.3-alpha.1');
+  t.is(v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prepatch' }), '1.2.4-0');
 });
 
 test('should increment version (prepatch)', t => {
@@ -54,6 +78,27 @@ test('should increment version (normalized)', t => {
   );
 });
 
+test('should increment version (prepatch on prerelease version)', t => {
+  const v = factory(Version);
+  t.is(
+    v.incrementVersion({ latestVersion: '1.2.3-alpha.5', increment: 'prepatch', preReleaseId: 'next' }),
+    '1.2.4-next.0'
+  );
+});
+
+test('should increment version (normalized on prerelease version)', t => {
+  const v = factory(Version);
+  t.is(
+    v.incrementVersion({
+      latestVersion: '1.2.3-alpha.5',
+      increment: 'patch',
+      preReleaseId: 'next',
+      isPreRelease: true
+    }),
+    '1.2.4-next.0'
+  );
+});
+
 test('should increment version (prerelease)', t => {
   const v = factory(Version);
   t.is(v.incrementVersion({ latestVersion: '1.2.3', increment: 'prerelease', preReleaseId: 'alpha' }), '1.2.4-alpha.0');
@@ -96,9 +141,19 @@ test('should increment version (patch release after pre-release)', t => {
 test('should run tasks without errors', async t => {
   const options = { version: { increment: 'minor' } };
   const v = factory(Version, { options });
+  const getIncrement = sinon.spy(v, 'getIncrement');
   const getIncrementedVersionCI = sinon.spy(v, 'getIncrementedVersionCI');
   const incrementVersion = sinon.spy(v, 'incrementVersion');
+
   await runTasks(v);
+
+  t.is(getIncrement.callCount, 1);
+  t.deepEqual(getIncrement.firstCall.args[0], {
+    latestVersion: '0.0.0',
+    increment: 'minor',
+    isPreRelease: false,
+    preReleaseId: null
+  });
   t.is(getIncrementedVersionCI.callCount, 1);
   t.deepEqual(getIncrementedVersionCI.firstCall.args[0], { latestVersion: '0.0.0', increment: 'minor' });
   t.is(await incrementVersion.firstCall.returnValue, '0.1.0');