feat: add the prepare plugin hook

BREAKING CHANGE: Committing or creating files in the `publish` plugin hook is not supported anymore and now must be done in the `prepare` hook

Plugins with a `publish` hook that makes a commit or create a file that can be committed must use the `prepare` hook.

README.md

@@ -86,6 +86,7 @@ After running the tests the command `semantic-release` will execute the followin
 | Verify release    | Verify the release conformity with the [verify release plugins](docs/usage/plugins.md#verifyrelease-plugin).                                                          |
 | Generate notes    | Generate release notes with the [generate notes plugin](docs/usage/plugins.md#generatenotes-plugin) for the commits added since the last release.                     |
 | Create Git tag    | Create a Git tag corresponding the new release version                                                                                                                |
+| Prepare           | Prepare the release with the [prepare plugins](docs/usage/plugins.md#prepare-plugin).                                                                                 |
 | Publish           | Publish the release with the [publish plugins](docs/usage/plugins.md#publish-plugin).                                                                                 |
 | Notify            | Notify of new releases or errors with the [success](docs/usage/plugins.md#success-plugin) and [fail](docs/usage/plugins.md#fail-plugin) plugins.                      |
 

cli.js

@@ -1,64 +1,66 @@
-const program = require('commander');
 const {pickBy, isUndefined} = require('lodash');
 
-function list(values) {
-  return values
-    .split(',')
-    .map(value => value.trim())
-    .filter(value => value && value !== 'false');
-}
+const stringList = {
+  type: 'string',
+  array: true,
+  coerce: values =>
+    values.length === 1 && values[0].trim() === 'false'
+      ? []
+      : values.reduce((values, value) => values.concat(value.split(',').map(value => value.trim())), []),
+};
 
 module.exports = async () => {
-  program
-    .name('semantic-release')
-    .description('Run automated package publishing')
-    .option('-b, --branch <branch>', 'Branch to release from')
-    .option('-r, --repository-url <repositoryUrl>', 'Git repository URL')
-    .option('-t, --tag-format <tagFormat>', `Git tag format`)
-    .option('-e, --extends <paths>', 'Comma separated list of shareable config paths or packages name', list)
-    .option(
-      '--verify-conditions <paths>',
-      'Comma separated list of paths or packages name for the verifyConditions plugin(s)',
-      list
-    )
-    .option('--analyze-commits <path>', 'Path or package name for the analyzeCommits plugin')
-    .option(
-      '--verify-release <paths>',
-      'Comma separated list of paths or packages name for the verifyRelease plugin(s)',
-      list
-    )
-    .option('--generate-notes <path>', 'Path or package name for the generateNotes plugin')
-    .option('--publish <paths>', 'Comma separated list of paths or packages name for the publish plugin(s)', list)
-    .option('--success <paths>', 'Comma separated list of paths or packages name for the success plugin(s)', list)
-    .option('--fail <paths>', 'Comma separated list of paths or packages name for the fail plugin(s)', list)
-    .option(
-      '--no-ci',
-      'Skip Continuous Integration environment verifications, allowing to make releases from a local machine'
-    )
-    .option('--debug', 'Output debugging information')
-    .option(
-      '-d, --dry-run',
-      'Dry-run mode, skipping verifyConditions, publishing and release, printing next version and release notes'
-    )
-    .parse(process.argv);
-
-  if (program.debug) {
-    // Debug must be enabled before other requires in order to work
-    require('debug').enable('semantic-release:*');
-  }
+  const cli = require('yargs')
+    .command('$0', 'Run automated package publishing', yargs => {
+      yargs.demandCommand(0, 0).usage(`Run automated package publishing
+Usage:
+  semantic-release [options] [plugins]`);
+    })
+    .option('b', {alias: 'branch', describe: 'Git branch to release from', type: 'string', group: 'Options'})
+    .option('r', {alias: 'repository-url', describe: 'Git repository URL', type: 'string', group: 'Options'})
+    .option('t', {alias: 'tag-format', describe: 'Git tag format', type: 'string', group: 'Options'})
+    .option('e', {alias: 'extends', describe: 'Shareable configurations', ...stringList, group: 'Options'})
+    .option('ci', {describe: 'Toggle CI verifications', default: undefined, type: 'boolean', group: 'Options'})
+    .option('verify-conditions', {...stringList, group: 'Plugins'})
+    .option('analyze-commits', {type: 'string', group: 'Plugins'})
+    .option('verify-release', {...stringList, group: 'Plugins'})
+    .option('generate-notes', {type: 'string', group: 'Plugins'})
+    .option('prepare', {...stringList, group: 'Plugins'})
+    .option('publish', {...stringList, group: 'Plugins'})
+    .option('success', {...stringList, group: 'Plugins'})
+    .option('fail', {...stringList, group: 'Plugins'})
+    .option('debug', {describe: 'Output debugging information', default: undefined, type: 'boolean', group: 'Options'})
+    .option('d', {alias: 'dry-run', describe: 'Skip publishing', default: undefined, type: 'boolean', group: 'Options'})
+    .option('h', {alias: 'help', default: undefined, group: 'Options'})
+    .option('v', {alias: 'version', default: undefined, group: 'Options'})
+    .strict(false)
+    .exitProcess(false);
 
   try {
-    if (program.args.length > 0) {
-      program.outputHelp();
-      process.exitCode = 1;
-    } else {
-      const opts = program.opts();
-      // Set the `noCi` options as commander.js sets the `ci` options instead (because args starts with `--no`)
-      opts.noCi = opts.ci === false ? true : undefined;
-      // Remove option with undefined values, as commander.js sets non defined options as `undefined`
-      await require('.')(pickBy(opts, value => !isUndefined(value)));
+    // Remove option with undefined values, as yargs sets non defined options as `undefined`
+    const {help, version, ...opts} = pickBy(cli.argv, value => !isUndefined(value));
+
+    if (Boolean(help) || Boolean(version)) {
+      process.exitCode = 0;
+      return;
     }
+
+    // Set the `noCi` options as yargs sets the `ci` options instead (because arg starts with `--no`)
+    if (opts.ci === false) {
+      opts.noCi = true;
+    }
+
+    if (opts.debug) {
+      // Debug must be enabled before other requires in order to work
+      require('debug').enable('semantic-release:*');
+    }
+
+    await require('.')(opts);
+    process.exitCode = 0;
   } catch (err) {
+    if (err.name !== 'YError') {
+      console.error(err);
+    }
     process.exitCode = 1;
   }
 };

docs/extending/plugins-list.md

@@ -9,6 +9,7 @@
   - [fail](https://github.com/semantic-release/github#fail): Open a GitHub issue when a release fails
 - [@semantic-release/npm](https://github.com/semantic-release/npm)
   - [verifyConditions](https://github.com/semantic-release/npm#verifyconditions): Verify the presence and the validity of the npm authentication and release configuration
+  - [prepare](https://github.com/semantic-release/npm#prepare): Update the package.json version and create the npm package tarball
   - [publish](https://github.com/semantic-release/npm#publish): Publish the package on the npm registry
 
 ## Official plugins
@@ -18,15 +19,16 @@
   - [publish](https://github.com/semantic-release/gitlab#publish): Publish a [GitLab release](https://docs.gitlab.com/ce/workflow/releases.html)
 - [@semantic-release/git](https://github.com/semantic-release/git)
   - [verifyConditions](https://github.com/semantic-release/git#verifyconditions): Verify the presence and the validity of the Git authentication and release configuration
-  - [publish](https://github.com/semantic-release/git#publish): Push a release commit and tag, including configurable files
+  - [prepare](https://github.com/semantic-release/git#prepare): Push a release commit and tag, including configurable files
 - [@semantic-release/changelog](https://github.com/semantic-release/changelog)
   - [verifyConditions](https://github.com/semantic-release/changelog#verifyconditions): Verify the presence and the validity of the configuration
-  - [publish](https://github.com/semantic-release/changelog#publish): Create or update the changelog file in the local project repository
+  - [prepare](https://github.com/semantic-release/changelog#prepare): Create or update the changelog file in the local project repository
 - [@semantic-release/exec](https://github.com/semantic-release/exec)
   - [verifyConditions](https://github.com/semantic-release/exec#verifyconditions): Execute a shell command to verify if the release should happen
   - [analyzeCommits](https://github.com/semantic-release/exec#analyzecommits): Execute a shell command to determine the type of release
   - [verifyRelease](https://github.com/semantic-release/exec#verifyrelease): Execute a shell command to verifying a release that was determined before and is about to be published.
   - [generateNotes](https://github.com/semantic-release/exec#analyzecommits): Execute a shell command to generate the release note
+  - [prepare](https://github.com/semantic-release/exec#prepare): Execute a shell command to prepare the release
   - [publish](https://github.com/semantic-release/exec#publish): Execute a shell command to publish the release
   - [success](https://github.com/semantic-release/exec#success): Execute a shell command to notify of a new release
   - [fail](https://github.com/semantic-release/exec#fail): Execute a shell command to notify of a failed release

docs/usage/configuration.md

@@ -155,6 +155,18 @@ Define the [generate notes plugin](plugins.md#generatenotes-plugin).
 
 See [Plugins configuration](plugins.md#configuration) for more details.
 
+### prepare
+
+Type: `Array`, `String`, `Object`
+
+Default: `['@semantic-release/npm']`
+
+CLI argument: `--prepare`
+
+Define the list of [prepare plugins](plugins.md#prepare-plugin). Plugins will run in series, in the order defined in the `Array`.
+
+See [Plugins configuration](plugins.md#configuration) for more details.
+
 ### publish
 
 Type: `Array`, `String`, `Object`
@@ -166,3 +178,27 @@ CLI argument: `--publish`
 Define the list of [publish plugins](plugins.md#publish-plugin). Plugins will run in series, in the order defined in the `Array`.
 
 See [Plugins configuration](plugins.md#configuration) for more details.
+
+### success
+
+Type: `Array`, `String`, `Object`
+
+Default: `['@semantic-release/github']`
+
+CLI argument: `--success`
+
+Define the list of [success plugins](plugins.md#success-plugin). Plugins will run in series, in the order defined in the `Array`.
+
+See [Plugins configuration](plugins.md#configuration) for more details.
+
+### fail
+
+Type: `Array`, `String`, `Object`
+
+Default: `['@semantic-release/github']`
+
+CLI argument: `--fail`
+
+Define the list of [fail plugins](plugins.md#fail-plugin). Plugins will run in series, in the order defined in the `Array`.
+
+See [Plugins configuration](plugins.md#configuration) for more details.

docs/usage/plugins.md

@@ -28,6 +28,14 @@ Plugin responsible for generating release notes.
 
 Default implementation: [@semantic-release/release-notes-generator](https://github.com/semantic-release/release-notes-generator).
 
+### prepare plugin
+
+Plugin responsible for preparing the release, including:
+- Creating or updating files such as `package.json`, `CHANGELOG.md`, documentation or compiled assets.
+- Create and push commits
+
+Default implementation: [npm](https://github.com/semantic-release/npm#prepare).
+
 ### publish plugin
 
 Plugin responsible for publishing the release.

index.js

@@ -3,6 +3,7 @@ const marked = require('marked');
 const TerminalRenderer = require('marked-terminal');
 const envCi = require('env-ci');
 const hookStd = require('hook-std');
+const pkg = require('./package.json');
 const hideSensitive = require('./lib/hide-sensitive');
 const getConfig = require('./lib/get-config');
 const verify = require('./lib/verify');
@@ -11,7 +12,7 @@ const getCommits = require('./lib/get-commits');
 const getLastRelease = require('./lib/get-last-release');
 const {extractErrors} = require('./lib/utils');
 const logger = require('./lib/logger');
-const {unshallow, gitHead: getGitHead, tag, push, deleteTag} = require('./lib/git');
+const {unshallow, gitHead: getGitHead, tag, push} = require('./lib/git');
 
 marked.setOptions({renderer: new TerminalRenderer()});
 
@@ -28,12 +29,19 @@ async function run(options, plugins) {
     return;
   }
 
-  if (!await verify(options, branch, logger)) {
-    return;
+  if (branch !== options.branch) {
+    logger.log(
+      `This test run was triggered on the branch ${branch}, while semantic-release is configured to only publish from ${
+        options.branch
+      }, therefore a new version won’t be published.`
+    );
+    return false;
   }
 
-  logger.log('Run automated release from branch %s', options.branch);
+  await verify(options);
 
+  logger.log('Run automated release from branch %s', options.branch);
+  console.log(options);
   logger.log('Call plugin %s', 'verify-conditions');
   await plugins.verifyConditions({options, logger}, {settleAll: true});
 
@@ -71,26 +79,14 @@ async function run(options, plugins) {
     logger.log('Call plugin %s', 'generateNotes');
     nextRelease.notes = await plugins.generateNotes(generateNotesParam);
 
-    // Create the tag before calling the publish plugins as some require the tag to exists
-    logger.log('Create tag %s', nextRelease.gitTag);
-    await tag(nextRelease.gitTag);
-    await push(options.repositoryUrl, branch);
-
-    logger.log('Call plugin %s', 'publish');
-    const releases = await plugins.publish(
+    logger.log('Call plugin %s', 'prepare');
+    await plugins.prepare(
       {options, logger, lastRelease, commits, nextRelease},
       {
         getNextInput: async lastResult => {
           const newGitHead = await getGitHead();
-          // If previous publish plugin has created a commit (gitHead changed)
+          // If previous prepare plugin has created a commit (gitHead changed)
           if (lastResult.nextRelease.gitHead !== newGitHead) {
-            // Delete the previously created tag
-            await deleteTag(options.repositoryUrl, nextRelease.gitTag);
-            // Recreate the tag, referencing the new gitHead
-            logger.log('Create tag %s', nextRelease.gitTag);
-            await tag(nextRelease.gitTag);
-            await push(options.repositoryUrl, branch);
-
             nextRelease.gitHead = newGitHead;
             // Regenerate the release notes
             logger.log('Call plugin %s', 'generateNotes');
@@ -99,11 +95,21 @@ async function run(options, plugins) {
           // Call the next publish plugin with the updated `nextRelease`
           return {options, logger, lastRelease, commits, nextRelease};
         },
-        // Add nextRelease and plugin properties to published release
-        transform: (release, step) => ({...(isPlainObject(release) ? release : {}), ...nextRelease, ...step}),
       }
     );
 
+    // Create the tag before calling the publish plugins as some require the tag to exists
+    logger.log('Create tag %s', nextRelease.gitTag);
+    await tag(nextRelease.gitTag);
+    await push(options.repositoryUrl, branch);
+
+    logger.log('Call plugin %s', 'publish');
+    const releases = await plugins.publish(
+      {options, logger, lastRelease, commits, nextRelease},
+      // Add nextRelease and plugin properties to published release
+      {transform: (release, step) => ({...(isPlainObject(release) ? release : {}), ...nextRelease, ...step})}
+    );
+
     await plugins.success(
       {options, logger, lastRelease, commits, nextRelease, releases: castArray(releases)},
       {settleAll: true}
@@ -140,6 +146,7 @@ async function callFail(plugins, options, error) {
 }
 
 module.exports = async opts => {
+  logger.log(`Running %s version %s`, pkg.name, pkg.version);
   const unhook = hookStd({silent: false}, hideSensitive);
   try {
     const config = await getConfig(opts, logger);

lib/definitions/plugins.js

@@ -36,6 +36,12 @@ module.exports = {
       error: 'ERELEASENOTESOUTPUT',
     },
   },
+  prepare: {
+    default: ['@semantic-release/npm'],
+    config: {
+      validator: conf => !conf || (isArray(conf) ? conf : [conf]).every(conf => validatePluginConfig(conf)),
+    },
+  },
   publish: {
     default: ['@semantic-release/npm', '@semantic-release/github'],
     config: {

lib/get-config.js

@@ -3,7 +3,7 @@ const readPkgUp = require('read-pkg-up');
 const cosmiconfig = require('cosmiconfig');
 const resolveFrom = require('resolve-from');
 const debug = require('debug')('semantic-release:config');
-const {repoUrl} = require('./git');
+const {repoUrl, verifyAuth} = require('./git');
 const PLUGINS_DEFINITIONS = require('./definitions/plugins');
 const plugins = require('./plugins');
 const getGitAuthUrl = require('./get-git-auth-url');
@@ -42,17 +42,19 @@ module.exports = async (opts, logger) => {
     };
   }
 
-  const repositoryUrl = (await pkgRepoUrl()) || (await repoUrl());
-
   // Set default options values if not defined yet
   options = {
     branch: 'master',
-    repositoryUrl: repositoryUrl ? getGitAuthUrl(repositoryUrl) : repositoryUrl,
+    repositoryUrl: (await pkgRepoUrl()) || (await repoUrl()),
     tagFormat: `v\${version}`,
     // Remove `null` and `undefined` options so they can be replaced with default ones
     ...pickBy(options, option => !isUndefined(option) && !isNull(option)),
   };
 
+  if (!await verifyAuth(options.repositoryUrl, options.branch)) {
+    options.repositoryUrl = options.repositoryUrl ? getGitAuthUrl(options.repositoryUrl) : options.repositoryUrl;
+  }
+
   debug('options values: %O', options);
 
   return {options, plugins: await plugins(options, pluginsPath, logger)};

lib/git.js

@@ -115,22 +115,6 @@ async function push(origin, branch) {
   await execa('git', ['push', '--tags', origin, `HEAD:${branch}`]);
 }
 
-/**
- * Delete a tag locally and remotely.
- *
- * @param {String} origin The remote repository URL.
- * @param {String} tagName The tag name to delete.
- */
-async function deleteTag(origin, tagName) {
-  // Delete the local tag
-  let shell = await execa('git', ['tag', '-d', tagName], {reject: false});
-  debug('delete local tag', shell);
-
-  // Delete the tag remotely
-  shell = await execa('git', ['push', '--delete', origin, tagName], {reject: false});
-  debug('delete remote tag', shell);
-}
-
 /**
  * Verify a tag name is a valid Git reference.
  *
@@ -157,6 +141,5 @@ module.exports = {
   verifyAuth,
   tag,
   push,
-  deleteTag,
   verifyTagName,
 };

lib/hide-sensitive.js

@@ -1,6 +1,9 @@
 const {escapeRegExp} = require('lodash');
 
-const toReplace = Object.keys(process.env).filter(envVar => /token|password|credential|secret|private/i.test(envVar));
+const toReplace = Object.keys(process.env).filter(
+  envVar => /token|password|credential|secret|private/i.test(envVar) && process.env[envVar].trim()
+);
+
 const regexp = new RegExp(toReplace.map(envVar => escapeRegExp(process.env[envVar])).join('|'), 'g');
 
 module.exports = output => {

lib/verify.js

@@ -3,7 +3,7 @@ const AggregateError = require('aggregate-error');
 const {isGitRepo, verifyAuth, verifyTagName} = require('./git');
 const getError = require('./get-error');
 
-module.exports = async (options, branch, logger) => {
+module.exports = async options => {
   const errors = [];
 
   if (!await isGitRepo()) {
@@ -29,15 +29,4 @@ module.exports = async (options, branch, logger) => {
   if (errors.length > 0) {
     throw new AggregateError(errors);
   }
-
-  if (branch !== options.branch) {
-    logger.log(
-      `This test run was triggered on the branch ${branch}, while semantic-release is configured to only publish from ${
-        options.branch
-      }, therefore a new version won’t be published.`
-    );
-    return false;
-  }
-
-  return true;
 };

package.json

@@ -22,7 +22,7 @@
     "@semantic-release/commit-analyzer": "^5.0.0",
     "@semantic-release/error": "^2.2.0",
     "@semantic-release/github": "^4.1.0",
-    "@semantic-release/npm": "^3.1.0",
+    "@semantic-release/npm": "^3.2.0",
     "@semantic-release/release-notes-generator": "^6.0.0",
     "aggregate-error": "^1.0.0",
     "chalk": "^2.3.0",
@@ -42,7 +42,8 @@
     "p-reduce": "^1.0.0",
     "read-pkg-up": "^3.0.0",
     "resolve-from": "^4.0.0",
-    "semver": "^5.4.1"
+    "semver": "^5.4.1",
+    "yargs": "^11.0.0"
   },
   "devDependencies": {
     "ava": "^0.25.0",
@@ -52,8 +53,6 @@
     "cz-conventional-changelog": "^2.0.0",
     "delay": "^2.0.0",
     "dockerode": "^2.5.2",
-    "eslint-config-prettier": "^2.5.0",
-    "eslint-plugin-prettier": "^2.3.0",
     "file-url": "^2.0.2",
     "fs-extra": "^5.0.0",
     "got": "^8.0.0",
@@ -62,11 +61,10 @@
     "nock": "^9.0.2",
     "nyc": "^11.2.1",
     "p-retry": "^1.0.0",
-    "prettier": "~1.10.0",
     "proxyquire": "^1.8.0",
     "sinon": "^4.0.0",
     "tempy": "^0.2.1",
-    "xo": "^0.18.2"
+    "xo": "^0.20.0"
   },
   "engines": {
     "node": ">=8.3"
@@ -106,10 +104,7 @@
     "all": true
   },
   "prettier": {
-    "printWidth": 120,
-    "singleQuote": true,
-    "bracketSpacing": false,
-    "trailingComma": "es5"
+    "printWidth": 120
   },
   "publishConfig": {
     "tag": "next"
@@ -130,14 +125,7 @@
     "test": "nyc ava -v"
   },
   "xo": {
-    "extends": [
-      "prettier"
-    ],
-    "plugins": [
-      "prettier"
-    ],
-    "rules": {
-      "prettier/prettier": 2
-    }
+    "prettier": true,
+    "space": true
   }
 }

test/cli.test.js

@@ -0,0 +1,237 @@
+import test from 'ava';
+import proxyquire from 'proxyquire';
+import clearModule from 'clear-module';
+import {stub} from 'sinon';
+
+// Save the current process.env and process.argv
+const envBackup = Object.assign({}, process.env);
+const argvBackup = Object.assign({}, process.argv);
+
+test.beforeEach(t => {
+  clearModule('yargs');
+  t.context.logs = '';
+  t.context.errors = '';
+  t.context.stdout = stub(process.stdout, 'write').callsFake(val => {
+    t.context.logs += val.toString();
+  });
+  t.context.stderr = stub(process.stderr, 'write').callsFake(val => {
+    t.context.errors += val.toString();
+  });
+});
+
+test.afterEach.always(t => {
+  process.env = envBackup;
+  process.argv = argvBackup;
+  t.context.stdout.restore();
+  t.context.stderr.restore();
+  delete process.exitCode;
+});
+
+test.serial('Pass options to semantic-release API', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = [
+    '',
+    '',
+    '-b',
+    'master',
+    '-r',
+    'https://github/com/owner/repo.git',
+    '-t',
+    `v\${version}`,
+    '-e',
+    'config1',
+    'config2',
+    '--verify-conditions',
+    'condition1',
+    'condition2',
+    '--analyze-commits',
+    'analyze',
+    '--verify-release',
+    'verify1',
+    'verify2',
+    '--generate-notes',
+    'notes',
+    '--prepare',
+    'prepare1',
+    'prepare2',
+    '--publish',
+    'publish1',
+    'publish2',
+    '--success',
+    'success1',
+    'success2',
+    '--fail',
+    'fail1',
+    'fail2',
+    '--debug',
+    '-d',
+  ];
+
+  await cli();
+
+  t.is(run.args[0][0].branch, 'master');
+  t.is(run.args[0][0].repositoryUrl, 'https://github/com/owner/repo.git');
+  t.is(run.args[0][0].tagFormat, `v\${version}`);
+  t.deepEqual(run.args[0][0].extends, ['config1', 'config2']);
+  t.deepEqual(run.args[0][0].verifyConditions, ['condition1', 'condition2']);
+  t.is(run.args[0][0].analyzeCommits, 'analyze');
+  t.deepEqual(run.args[0][0].verifyRelease, ['verify1', 'verify2']);
+  t.is(run.args[0][0].generateNotes, 'notes');
+  t.deepEqual(run.args[0][0].prepare, ['prepare1', 'prepare2']);
+  t.deepEqual(run.args[0][0].publish, ['publish1', 'publish2']);
+  t.deepEqual(run.args[0][0].success, ['success1', 'success2']);
+  t.deepEqual(run.args[0][0].fail, ['fail1', 'fail2']);
+  t.is(run.args[0][0].debug, true);
+  t.is(run.args[0][0].dryRun, true);
+
+  t.is(process.exitCode, 0);
+});
+
+test.serial('Pass options to semantic-release API with alias arguments', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = [
+    '',
+    '',
+    '--branch',
+    'master',
+    '--repository-url',
+    'https://github/com/owner/repo.git',
+    '--tag-format',
+    `v\${version}`,
+    '--extends',
+    'config1',
+    'config2',
+    '--dry-run',
+  ];
+
+  await cli();
+
+  t.is(run.args[0][0].branch, 'master');
+  t.is(run.args[0][0].repositoryUrl, 'https://github/com/owner/repo.git');
+  t.is(run.args[0][0].tagFormat, `v\${version}`);
+  t.deepEqual(run.args[0][0].extends, ['config1', 'config2']);
+  t.is(run.args[0][0].dryRun, true);
+
+  t.is(process.exitCode, 0);
+});
+
+test.serial('Pass unknown options to semantic-release API', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = [
+    '',
+    '',
+    '--bool',
+    '--first-option',
+    'value1',
+    '--second-option',
+    'value2',
+    '--second-option',
+    'value3',
+  ];
+
+  await cli();
+
+  t.is(run.args[0][0].bool, true);
+  t.is(run.args[0][0].firstOption, 'value1');
+  t.deepEqual(run.args[0][0].secondOption, ['value2', 'value3']);
+
+  t.is(process.exitCode, 0);
+});
+
+test.serial('Pass empty Array to semantic-release API for list option set to "false"', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', '', '--publish', 'false'];
+
+  await cli();
+
+  t.deepEqual(run.args[0][0].publish, []);
+
+  t.is(process.exitCode, 0);
+});
+
+test.serial('Do not set properties in option for which arg is not in command line', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', '', '-b', 'master'];
+
+  await cli();
+
+  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'ci'));
+  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'd'));
+  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'dry-run'));
+  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'debug'));
+  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 'r'));
+  t.false(Object.prototype.hasOwnProperty.call(run.args[0][0], 't'));
+});
+
+test.serial('Set "noCi" options to "true" with "--no-ci"', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', '', '--no-ci'];
+
+  await cli();
+
+  t.is(run.args[0][0].noCi, true);
+
+  t.is(process.exitCode, 0);
+});
+
+test.serial('Display help', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', '', '--help'];
+
+  await cli();
+
+  t.regex(t.context.logs, /Run automated package publishing/);
+  t.is(process.exitCode, 0);
+});
+
+test.serial('Returns error code and prints help if called with a command', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', '', 'pre'];
+
+  await cli();
+
+  t.regex(t.context.errors, /Run automated package publishing/);
+  t.regex(t.context.errors, /Too many non-option arguments/);
+  t.is(process.exitCode, 1);
+});
+
+test.serial('Return error code if multiple plugin are set for single plugin', async t => {
+  const run = stub().resolves(true);
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', '', '--analyze-commits', 'analyze1', 'analyze2'];
+
+  await cli();
+
+  t.regex(t.context.errors, /Run automated package publishing/);
+  t.regex(t.context.errors, /Too many non-option arguments/);
+  t.is(process.exitCode, 1);
+});
+
+test.serial('Return error code if semantic-release throw error', async t => {
+  const run = stub().rejects(new Error('semantic-release error'));
+  const cli = proxyquire('../cli', {'.': run});
+
+  process.argv = ['', ''];
+
+  await cli();
+
+  t.regex(t.context.errors, /semantic-release error/);
+  t.is(process.exitCode, 1);
+});

test/definitions/plugins.test.js

@@ -46,6 +46,17 @@ test('The "generateNotes" plugin, if defined, must be a single plugin definition
   t.true(plugins.generateNotes.config.validator(() => {}));
 });
 
+test('The "prepare" plugin, if defined, must be a single or an array of plugins definition', t => {
+  t.false(plugins.verifyRelease.config.validator({}));
+  t.false(plugins.verifyRelease.config.validator({path: null}));
+
+  t.true(plugins.verifyRelease.config.validator({path: 'plugin-path.js'}));
+  t.true(plugins.verifyRelease.config.validator());
+  t.true(plugins.verifyRelease.config.validator('plugin-path.js'));
+  t.true(plugins.verifyRelease.config.validator(() => {}));
+  t.true(plugins.verifyRelease.config.validator([{path: 'plugin-path.js'}, 'plugin-path.js', () => {}]));
+});
+
 test('The "publish" plugin is mandatory, and must be a single or an array of plugins definition', t => {
   t.false(plugins.publish.config.validator({}));
   t.false(plugins.publish.config.validator({path: null}));

test/get-config.test.js

@@ -31,7 +31,8 @@ test.afterEach.always(() => {
 });
 
 test.serial('Default values, reading repositoryUrl from package.json', async t => {
-  const pkg = {repository: 'git@package.com:owner/module.git'};
+  process.env.GIT_CREDENTIALS = 'user:pass';
+  const pkg = {repository: 'https://package.com/owner/module.git'};
   // Create a git repository, set the current working directory at the root of the repo
   await gitRepo();
   await gitCommits(['First']);
@@ -44,25 +45,27 @@ test.serial('Default values, reading repositoryUrl from package.json', async t =
 
   // Verify the default options are set
   t.is(options.branch, 'master');
-  t.is(options.repositoryUrl, 'git@package.com:owner/module.git');
+  t.is(options.repositoryUrl, 'https://user:pass@package.com/owner/module.git');
   t.is(options.tagFormat, `v\${version}`);
 });
 
 test.serial('Default values, reading repositoryUrl from repo if not set in package.json', async t => {
+  process.env.GIT_CREDENTIALS = 'user:pass';
   // Create a git repository, set the current working directory at the root of the repo
   await gitRepo();
   // Add remote.origin.url config
-  await gitAddConfig('remote.origin.url', 'git@repo.com:owner/module.git');
+  await gitAddConfig('remote.origin.url', 'https://hostname.com/owner/module.git');
 
   const {options} = await t.context.getConfig();
 
   // Verify the default options are set
   t.is(options.branch, 'master');
-  t.is(options.repositoryUrl, 'git@repo.com:owner/module.git');
+  t.is(options.repositoryUrl, 'https://user:pass@hostname.com/owner/module.git');
   t.is(options.tagFormat, `v\${version}`);
 });
 
 test.serial('Default values, reading repositoryUrl (http url) from package.json if not set in repo', async t => {
+  process.env.GIT_CREDENTIALS = 'user:pass';
   const pkg = {repository: 'https://hostname.com/owner/module.git'};
   // Create a git repository, set the current working directory at the root of the repo
   await gitRepo();
@@ -73,10 +76,23 @@ test.serial('Default values, reading repositoryUrl (http url) from package.json
 
   // Verify the default options are set
   t.is(options.branch, 'master');
-  t.is(options.repositoryUrl, pkg.repository);
+  t.is(options.repositoryUrl, 'https://user:pass@hostname.com/owner/module.git');
   t.is(options.tagFormat, `v\${version}`);
 });
 
+test.serial('Do not add git credential to repositoryUrl if push is allowed', async t => {
+  process.env.GIT_CREDENTIALS = 'user:pass';
+  // Create a git repository, set the current working directory at the root of the repo
+  const repositoryUrl = await gitRepo(true);
+  const pkg = {repository: repositoryUrl};
+  // Create package.json in repository root
+  await outputJson('./package.json', pkg);
+
+  const {options} = await t.context.getConfig();
+
+  t.is(options.repositoryUrl, repositoryUrl);
+});
+
 test.serial('Read options from package.json', async t => {
   const release = {
     analyzeCommits: {path: 'analyzeCommits', param: 'analyzeCommits_param'},

test/git.test.js

@@ -10,7 +10,6 @@ import {
   push,
   gitTags,
   isGitRepo,
-  deleteTag,
   verifyTagName,
 } from '../lib/git';
 import {
@@ -139,18 +138,6 @@ test.serial('Add tag on head commit', async t => {
   await t.is(await gitCommitTag(commits[0].hash), 'tag_name');
 });
 
-test.serial('Delete a tag', async t => {
-  // Create a git repository with a remote, set the current working directory at the root of the repo
-  const repo = await gitRepo(true);
-  await gitCommits(['Test commit']);
-  await tag('tag_name');
-  await push(repo, 'master');
-
-  await deleteTag(repo, 'tag_name');
-  t.falsy(await gitTagHead('tag_name'));
-  t.falsy(await gitRemoteTagHead(repo, 'tag_name'));
-});
-
 test.serial('Push tag and commit to remote repository', async t => {
   // Create a git repository with a remote, set the current working directory at the root of the repo
   const repo = await gitRepo(true);

test/hide-sensitive.test.js

@@ -40,3 +40,18 @@ test.serial('Accept "undefined" input', t => {
 test.serial('Return same string if no environment variable has to be replaced', t => {
   t.is(require('../lib/hide-sensitive')('test'), 'test');
 });
+
+test.serial('Exclude empty environment variables from the regexp', t => {
+  process.env.SOME_PASSWORD = 'password';
+  process.env.SOME_TOKEN = '';
+  t.is(
+    require('../lib/hide-sensitive')(`https://user:${process.env.SOME_PASSWORD}@host.com?token=`),
+    'https://user:[secure]@host.com?token='
+  );
+});
+
+test.serial('Exclude empty environment variables from the regexp if there is only empty ones', t => {
+  process.env.SOME_PASSWORD = '';
+  process.env.SOME_TOKEN = ' \n ';
+  t.is(require('../lib/hide-sensitive')(`https://host.com?token=`), 'https://host.com?token=');
+});

test/index.test.js

@@ -67,6 +67,7 @@ test.serial('Plugins are called with expected values', async t => {
   const verifyRelease = stub().resolves();
   const generateNotes = stub().resolves(notes);
   const release1 = {name: 'Release 1', url: 'https://release1.com'};
+  const prepare = stub().resolves();
   const publish1 = stub().resolves(release1);
   const success = stub().resolves();
 
@@ -77,6 +78,7 @@ test.serial('Plugins are called with expected values', async t => {
     analyzeCommits,
     verifyRelease,
     generateNotes,
+    prepare,
     publish: [publish1, pluginNoop],
     success,
   };
@@ -119,6 +121,15 @@ test.serial('Plugins are called with expected values', async t => {
   t.deepEqual(generateNotes.args[0][1].commits[0].message, commits[0].message);
   t.deepEqual(generateNotes.args[0][1].nextRelease, nextRelease);
 
+  t.is(prepare.callCount, 1);
+  t.deepEqual(prepare.args[0][0], config);
+  t.deepEqual(prepare.args[0][1].options, options);
+  t.deepEqual(prepare.args[0][1].logger, t.context.logger);
+  t.deepEqual(prepare.args[0][1].lastRelease, lastRelease);
+  t.deepEqual(prepare.args[0][1].commits[0].hash, commits[0].hash);
+  t.deepEqual(prepare.args[0][1].commits[0].message, commits[0].message);
+  t.deepEqual(prepare.args[0][1].nextRelease, {...nextRelease, ...{notes}});
+
   t.is(publish1.callCount, 1);
   t.deepEqual(publish1.args[0][0], config);
   t.deepEqual(publish1.args[0][1].options, options);
@@ -161,6 +172,7 @@ test.serial('Use custom tag format', async t => {
     analyzeCommits: stub().resolves(nextRelease.type),
     verifyRelease: stub().resolves(),
     generateNotes: stub().resolves(notes),
+    prepare: stub().resolves(),
     publish: stub().resolves(),
     success: stub().resolves(),
     fail: stub().resolves(),
@@ -177,7 +189,7 @@ test.serial('Use custom tag format', async t => {
   t.is(await gitRemoteTagHead(repositoryUrl, nextRelease.gitTag), nextRelease.gitHead);
 });
 
-test.serial('Use new gitHead, and recreate release notes if a publish plugin create a commit', async t => {
+test.serial('Use new gitHead, and recreate release notes if a prepare plugin create a commit', async t => {
   // Create a git repository, set the current working directory at the root of the repo
   const repositoryUrl = await gitRepo(true);
   // Add commits to the master branch
@@ -191,10 +203,11 @@ test.serial('Use new gitHead, and recreate release notes if a publish plugin cre
   const notes = 'Release notes';
 
   const generateNotes = stub().resolves(notes);
-  const publish1 = stub().callsFake(async () => {
+  const prepare1 = stub().callsFake(async () => {
     commits = (await gitCommits(['Third'])).concat(commits);
   });
-  const publish2 = stub().resolves();
+  const prepare2 = stub().resolves();
+  const publish = stub().resolves();
 
   const options = {
     branch: 'master',
@@ -203,7 +216,8 @@ test.serial('Use new gitHead, and recreate release notes if a publish plugin cre
     analyzeCommits: stub().resolves(nextRelease.type),
     verifyRelease: stub().resolves(),
     generateNotes,
-    publish: [publish1, publish2],
+    prepare: [prepare1, prepare2],
+    publish,
     success: stub().resolves(),
     fail: stub().resolves(),
   };
@@ -217,14 +231,17 @@ test.serial('Use new gitHead, and recreate release notes if a publish plugin cre
 
   t.is(generateNotes.callCount, 2);
   t.deepEqual(generateNotes.args[0][1].nextRelease, nextRelease);
-  t.is(publish1.callCount, 1);
-  t.deepEqual(publish1.args[0][1].nextRelease, {...nextRelease, ...{notes}});
+  t.is(prepare1.callCount, 1);
+  t.deepEqual(prepare1.args[0][1].nextRelease, {...nextRelease, ...{notes}});
 
   nextRelease.gitHead = await getGitHead();
 
-  t.deepEqual(generateNotes.secondCall.args[1].nextRelease, {...nextRelease, ...{notes}});
-  t.is(publish2.callCount, 1);
-  t.deepEqual(publish2.args[0][1].nextRelease, {...nextRelease, ...{notes}});
+  t.deepEqual(generateNotes.args[1][1].nextRelease, {...nextRelease, ...{notes}});
+  t.is(prepare2.callCount, 1);
+  t.deepEqual(prepare2.args[0][1].nextRelease, {...nextRelease, ...{notes}});
+
+  t.is(publish.callCount, 1);
+  t.deepEqual(publish.args[0][1].nextRelease, {...nextRelease, ...{notes}});
 
   // Verify the tag has been created on the local and remote repo and reference the last gitHead
   t.is(await gitTagHead(nextRelease.gitTag), commits[0].hash);
@@ -258,6 +275,7 @@ test.serial('Call all "success" plugins even if one errors out', async t => {
     verifyConditions: [verifyConditions1, verifyConditions2],
     analyzeCommits,
     generateNotes,
+    prepare: stub().resolves(),
     publish,
     success: [success1, success2],
   };
@@ -302,9 +320,9 @@ test.serial('Log all "verifyConditions" errors', async t => {
     './lib/logger': t.context.logger,
     'env-ci': () => ({isCi: true, branch: 'master', isPr: false}),
   });
-  const errors = await t.throws(semanticRelease(options));
+  const errors = [...(await t.throws(semanticRelease(options)))];
 
-  t.deepEqual(Array.from(errors), [error1, error2, error3]);
+  t.deepEqual(errors, [error1, error2, error3]);
   t.deepEqual(t.context.log.args[t.context.log.args.length - 2], ['%s error 2', 'ERR2']);
   t.deepEqual(t.context.log.args[t.context.log.args.length - 1], ['%s error 3', 'ERR3']);
   t.deepEqual(t.context.error.args[t.context.error.args.length - 1], [
@@ -345,9 +363,9 @@ test.serial('Log all "verifyRelease" errors', async t => {
     './lib/logger': t.context.logger,
     'env-ci': () => ({isCi: true, branch: 'master', isPr: false}),
   });
-  const errors = await t.throws(semanticRelease(options));
+  const errors = [...(await t.throws(semanticRelease(options)))];
 
-  t.deepEqual(Array.from(errors), [error1, error2]);
+  t.deepEqual(errors, [error1, error2]);
   t.deepEqual(t.context.log.args[t.context.log.args.length - 2], ['%s error 1', 'ERR1']);
   t.deepEqual(t.context.log.args[t.context.log.args.length - 1], ['%s error 2', 'ERR2']);
   t.is(fail.callCount, 1);
@@ -383,6 +401,7 @@ test.serial('Dry-run skips publish and success', async t => {
     analyzeCommits,
     verifyRelease,
     generateNotes,
+    prepare: stub().resolves(),
     publish,
     success,
   };
@@ -428,9 +447,9 @@ test.serial('Dry-run skips fail', async t => {
     './lib/logger': t.context.logger,
     'env-ci': () => ({isCi: true, branch: 'master', isPr: false}),
   });
-  const errors = await t.throws(semanticRelease(options));
+  const errors = [...(await t.throws(semanticRelease(options)))];
 
-  t.deepEqual(Array.from(errors), [error1, error2]);
+  t.deepEqual(errors, [error1, error2]);
   t.deepEqual(t.context.log.args[t.context.log.args.length - 2], ['%s error 1', 'ERR1']);
   t.deepEqual(t.context.log.args[t.context.log.args.length - 1], ['%s error 2', 'ERR2']);
   t.is(fail.callCount, 0);
@@ -464,6 +483,7 @@ test.serial('Force a dry-run if not on a CI and "noCi" is not explicitly set', a
     analyzeCommits,
     verifyRelease,
     generateNotes,
+    prepare: stub().resolves(),
     publish,
     success,
     fail: stub().resolves(),
@@ -475,7 +495,7 @@ test.serial('Force a dry-run if not on a CI and "noCi" is not explicitly set', a
   });
   t.truthy(await semanticRelease(options));
 
-  t.is(t.context.log.args[0][0], 'This run was not triggered in a known CI environment, running in dry-run mode.');
+  t.is(t.context.log.args[1][0], 'This run was not triggered in a known CI environment, running in dry-run mode.');
   t.is(verifyConditions.callCount, 1);
   t.is(analyzeCommits.callCount, 1);
   t.is(verifyRelease.callCount, 1);
@@ -512,6 +532,7 @@ test.serial('Allow local releases with "noCi" option', async t => {
     analyzeCommits,
     verifyRelease,
     generateNotes,
+    prepare: stub().resolves(),
     publish,
     success,
     fail: stub().resolves(),
@@ -560,6 +581,7 @@ test.serial('Accept "undefined" value returned by the "generateNotes" plugins',
     analyzeCommits,
     verifyRelease,
     generateNotes,
+    prepare: stub().resolves(),
     publish,
     success: stub().resolves(),
     fail: stub().resolves(),
@@ -596,7 +618,7 @@ test.serial('Returns falsy value if triggered by a PR', async t => {
 
   t.falsy(await semanticRelease({repositoryUrl}));
   t.is(
-    t.context.log.args[8][0],
+    t.context.log.args[t.context.log.args.length - 1][0],
     "This run was triggered by a pull request and therefore a new version won't be published."
   );
 });
@@ -611,6 +633,7 @@ test.serial('Returns falsy value if not running from the configured branch', asy
     analyzeCommits: stub().resolves(),
     verifyRelease: stub().resolves(),
     generateNotes: stub().resolves(),
+    prepare: stub().resolves(),
     publish: stub().resolves(),
     success: stub().resolves(),
     fail: stub().resolves(),
@@ -623,7 +646,7 @@ test.serial('Returns falsy value if not running from the configured branch', asy
 
   t.falsy(await semanticRelease(options));
   t.is(
-    t.context.log.args[0][0],
+    t.context.log.args[1][0],
     'This test run was triggered on the branch other-branch, while semantic-release is configured to only publish from master, therefore a new version won’t be published.'
   );
 });
@@ -646,6 +669,7 @@ test.serial('Returns falsy value if there is no relevant changes', async t => {
     analyzeCommits,
     verifyRelease,
     generateNotes,
+    prepare: stub().resolves(),
     publish,
     success: stub().resolves(),
     fail: stub().resolves(),
@@ -661,7 +685,7 @@ test.serial('Returns falsy value if there is no relevant changes', async t => {
   t.is(verifyRelease.callCount, 0);
   t.is(generateNotes.callCount, 0);
   t.is(publish.callCount, 0);
-  t.is(t.context.log.args[6][0], 'There are no relevant changes, so no new version is released.');
+  t.is(t.context.log.args[7][0], 'There are no relevant changes, so no new version is released.');
 });
 
 test.serial('Exclude commits with [skip release] or [release skip] from analysis', async t => {
@@ -686,6 +710,7 @@ test.serial('Exclude commits with [skip release] or [release skip] from analysis
     analyzeCommits,
     verifyRelease: stub().resolves(),
     generateNotes: stub().resolves(),
+    prepare: stub().resolves(),
     publish: stub().resolves(),
     success: stub().resolves(),
     fail: stub().resolves(),
@@ -723,8 +748,8 @@ test.serial('Hide sensitive environment variable values from the logs', async t
 
   await t.throws(semanticRelease(options));
 
-  t.regex(t.context.stdout.args[8][0], /Console: The token \[secure\] is invalid/);
-  t.regex(t.context.stdout.args[9][0], /Log: The token \[secure\] is invalid/);
+  t.regex(t.context.stdout.args[t.context.stdout.args.length - 2][0], /Console: The token \[secure\] is invalid/);
+  t.regex(t.context.stdout.args[t.context.stdout.args.length - 1][0], /Log: The token \[secure\] is invalid/);
   t.regex(t.context.stderr.args[0][0], /Error: The token \[secure\] is invalid/);
   t.regex(t.context.stderr.args[1][0], /Invalid token \[secure\]/);
 });
@@ -785,7 +810,7 @@ test.serial('Throw SemanticReleaseError if repositoryUrl is not set and cannot b
     './lib/logger': t.context.logger,
     'env-ci': () => ({isCi: true, branch: 'master', isPr: false}),
   });
-  const errors = Array.from(await t.throws(semanticRelease()));
+  const errors = [...(await t.throws(semanticRelease()))];
 
   // Verify error code and type
   t.is(errors[0].code, 'ENOREPOURL');
@@ -844,6 +869,7 @@ test.serial('Get all commits including the ones not in the shallow clone', async
     analyzeCommits,
     verifyRelease: stub().resolves(),
     generateNotes: stub().resolves(notes),
+    prepare: stub().resolves(),
     publish: stub().resolves(),
     success: stub().resolves(),
     fail: stub().resolves(),

test/integration.test.js

@@ -603,11 +603,11 @@ test.serial('Exit with 1 if missing permission to push to the remote repository'
 
   // Create a git repository, set the current working directory at the root of the repo
   t.log('Create git repository');
-  const {repositoryUrl} = await gitbox.createRepo(packageName);
+  await gitbox.createRepo(packageName);
   await writeJson('./package.json', {
     name: packageName,
     version: '0.0.0-dev',
-    repository: {url: repositoryUrl},
+    repository: {url: 'http://user:wrong_pass@localhost:2080/git/unauthorized.git'},
   });
 
   /* Initial release */
@@ -619,24 +619,3 @@ test.serial('Exit with 1 if missing permission to push to the remote repository'
   t.regex(stdout, /EGITNOPERMISSION/);
   t.is(code, 1);
 });
-
-test.serial('CLI returns error code and prints help if called with a command', async t => {
-  t.log('$ semantic-release pre');
-  const {stdout, code} = await execa(cli, ['pre'], {env, reject: false});
-  t.regex(stdout, /Usage: semantic-release/);
-  t.is(code, 1);
-});
-
-test.serial('CLI prints help if called with --help', async t => {
-  t.log('$ semantic-release --help');
-  const {stdout, code} = await execa(cli, ['--help'], {env});
-  t.regex(stdout, /Usage: semantic-release/);
-  t.is(code, 0);
-});
-
-test.serial('CLI returns error code with invalid option', async t => {
-  t.log('$ semantic-release --unknown-option');
-  const {stderr, code} = await execa(cli, ['--unknown-option'], {env, reject: false});
-  t.regex(stderr, /unknown option/);
-  t.is(code, 1);
-});

test/plugins/pipeline.test.js

@@ -118,7 +118,7 @@ test('Throw all errors from the first step throwing an AggregateError', async t
 
   const errors = await t.throws(pipeline([step1, step2, step3])(0));
 
-  t.deepEqual(Array.from(errors), [error1, error2]);
+  t.deepEqual([...errors], [error1, error2]);
   t.true(step1.calledWith(0));
   t.true(step2.calledWith(0));
   t.true(step3.notCalled);
@@ -133,7 +133,7 @@ test('Execute all even if a Promise rejects', async t => {
 
   const errors = await t.throws(pipeline([step1, step2, step3])(0, {settleAll: true}));
 
-  t.deepEqual(Array.from(errors), [error1, error2]);
+  t.deepEqual([...errors], [error1, error2]);
   t.true(step1.calledWith(0));
   t.true(step2.calledWith(0));
   t.true(step3.calledWith(0));
@@ -149,7 +149,7 @@ test('Throw all errors from all steps throwing an AggregateError', async t => {
 
   const errors = await t.throws(pipeline([step1, step2])(0, {settleAll: true}));
 
-  t.deepEqual(Array.from(errors), [error1, error2, error3, error4]);
+  t.deepEqual([...errors], [error1, error2, error3, error4]);
   t.true(step1.calledWith(0));
   t.true(step2.calledWith(0));
 });
@@ -165,7 +165,7 @@ test('Execute each function in series passing a transformed input even if a step
 
   const errors = await t.throws(pipeline([step1, step2, step3, step4])(0, {settleAll: true, getNextInput}));
 
-  t.deepEqual(Array.from(errors), [error2, error3]);
+  t.deepEqual([...errors], [error2, error3]);
   t.true(step1.calledWith(0));
   t.true(step2.calledWith(0 + 1));
   t.true(step3.calledWith(0 + 1 + error2));

test/plugins/plugins.test.js

@@ -27,6 +27,7 @@ test('Export default plugins', t => {
   t.is(typeof plugins.analyzeCommits, 'function');
   t.is(typeof plugins.verifyRelease, 'function');
   t.is(typeof plugins.generateNotes, 'function');
+  t.is(typeof plugins.prepare, 'function');
   t.is(typeof plugins.publish, 'function');
   t.is(typeof plugins.success, 'function');
   t.is(typeof plugins.fail, 'function');
@@ -49,6 +50,7 @@ test('Export plugins based on config', t => {
   t.is(typeof plugins.analyzeCommits, 'function');
   t.is(typeof plugins.verifyRelease, 'function');
   t.is(typeof plugins.generateNotes, 'function');
+  t.is(typeof plugins.prepare, 'function');
   t.is(typeof plugins.publish, 'function');
   t.is(typeof plugins.success, 'function');
   t.is(typeof plugins.fail, 'function');
@@ -79,6 +81,7 @@ test.serial('Export plugins loaded from the dependency of a shareable config mod
   t.is(typeof plugins.analyzeCommits, 'function');
   t.is(typeof plugins.verifyRelease, 'function');
   t.is(typeof plugins.generateNotes, 'function');
+  t.is(typeof plugins.prepare, 'function');
   t.is(typeof plugins.publish, 'function');
   t.is(typeof plugins.success, 'function');
   t.is(typeof plugins.fail, 'function');
@@ -106,6 +109,7 @@ test.serial('Export plugins loaded from the dependency of a shareable config fil
   t.is(typeof plugins.analyzeCommits, 'function');
   t.is(typeof plugins.verifyRelease, 'function');
   t.is(typeof plugins.generateNotes, 'function');
+  t.is(typeof plugins.prepare, 'function');
   t.is(typeof plugins.publish, 'function');
   t.is(typeof plugins.success, 'function');
   t.is(typeof plugins.fail, 'function');
@@ -136,16 +140,16 @@ test('Merge global options with plugin options', async t => {
 });
 
 test('Throw an error if plugins configuration are missing a path for plugin pipeline', t => {
-  const errors = Array.from(t.throws(() => getPlugins({verifyConditions: {}}, {}, t.context.logger)));
+  const errors = [...t.throws(() => getPlugins({verifyConditions: {}}, {}, t.context.logger))];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'EPLUGINCONF');
 });
 
 test('Throw an error if an array of plugin configuration is missing a path for plugin pipeline', t => {
-  const errors = Array.from(
-    t.throws(() => getPlugins({verifyConditions: [{path: '@semantic-release/npm'}, {}]}, {}, t.context.logger))
-  );
+  const errors = [
+    ...t.throws(() => getPlugins({verifyConditions: [{path: '@semantic-release/npm'}, {}]}, {}, t.context.logger)),
+  ];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'EPLUGINCONF');

test/verify.test.js

@@ -1,5 +1,4 @@
 import test from 'ava';
-import {stub} from 'sinon';
 import tempy from 'tempy';
 import verify from '../lib/verify';
 import {gitRepo} from './helpers/git-utils';
@@ -9,17 +8,13 @@ const envBackup = Object.assign({}, process.env);
 // Save the current working diretory
 const cwd = process.cwd();
 
-test.beforeEach(t => {
+test.beforeEach(() => {
   // Delete environment variables that could have been set on the machine running the tests
   delete process.env.GIT_CREDENTIALS;
   delete process.env.GH_TOKEN;
   delete process.env.GITHUB_TOKEN;
   delete process.env.GL_TOKEN;
   delete process.env.GITLAB_TOKEN;
-  // Stub the logger functions
-  t.context.log = stub();
-  t.context.error = stub();
-  t.context.logger = {log: t.context.log, error: t.context.error};
 });
 
 test.afterEach.always(() => {
@@ -32,7 +27,7 @@ test.afterEach.always(() => {
 test.serial('Throw a AggregateError', async t => {
   await gitRepo();
 
-  const errors = Array.from(await t.throws(verify({}, 'master', t.context.logger)));
+  const errors = [...(await t.throws(verify({})))];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'ENOREPOURL');
@@ -46,7 +41,7 @@ test.serial('Throw a SemanticReleaseError if does not run on a git repository',
   const dir = tempy.directory();
   process.chdir(dir);
 
-  const errors = Array.from(await t.throws(verify({}, 'master', t.context.logger)));
+  const errors = [...(await t.throws(verify({})))];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'ENOGITREPO');
@@ -56,7 +51,7 @@ test.serial('Throw a SemanticReleaseError if the "tagFormat" is not valid', asyn
   const repositoryUrl = await gitRepo(true);
   const options = {repositoryUrl, tagFormat: `?\${version}`};
 
-  const errors = Array.from(await t.throws(verify(options, 'master', t.context.logger)));
+  const errors = [...(await t.throws(verify(options, 'master', t.context.logger)))];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'EINVALIDTAGFORMAT');
@@ -66,7 +61,7 @@ test.serial('Throw a SemanticReleaseError if the "tagFormat" does not contains t
   const repositoryUrl = await gitRepo(true);
   const options = {repositoryUrl, tagFormat: 'test'};
 
-  const errors = Array.from(await t.throws(verify(options, 'master', t.context.logger)));
+  const errors = [...(await t.throws(verify(options, 'master', t.context.logger)))];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'ETAGNOVERSION');
@@ -76,22 +71,15 @@ test.serial('Throw a SemanticReleaseError if the "tagFormat" contains multiple "
   const repositoryUrl = await gitRepo(true);
   const options = {repositoryUrl, tagFormat: `\${version}v\${version}`};
 
-  const errors = Array.from(await t.throws(verify(options, 'master', t.context.logger)));
+  const errors = [...(await t.throws(verify(options)))];
 
   t.is(errors[0].name, 'SemanticReleaseError');
   t.is(errors[0].code, 'ETAGNOVERSION');
 });
 
-test.serial('Return "false" if the current branch is not the once configured', async t => {
-  const repositoryUrl = await gitRepo(true);
-  const options = {repositoryUrl, tagFormat: `v\${version}`, branch: 'master'};
-
-  t.false(await verify(options, 'other', t.context.logger));
-});
-
 test.serial('Return "true" if all verification pass', async t => {
   const repositoryUrl = await gitRepo(true);
   const options = {repositoryUrl, tagFormat: `v\${version}`, branch: 'master'};
 
-  t.true(await verify(options, 'master', t.context.logger));
+  await t.notThrows(verify(options));
 });