release-it 19.0.0-next.1 → 19.0.0-next.3

package/test/util/helpers.js

@@ -25,9 +25,10 @@ const gitAdd = (content, filePath, message) => {
   return match ? match[1] : null;
 };
 
-const getArgs = (args, prefix) =>
-  args
-    .map(args => (typeof args[0] !== 'string' ? args[0].join(' ') : args[0]))
+const getArgs = (fn, prefix) =>
+  fn.mock.calls
+    .map(call => call.arguments[0])
+    .map(arg => (typeof arg !== 'string' ? arg.join(' ') : arg))
     .filter(cmd => cmd.startsWith(prefix))
     .map(cmd => cmd.trim());
 

package/test/util/index.js

@@ -1,21 +1,48 @@
-import sinon from 'sinon';
+import { mock } from 'node:test';
 import semver from 'semver';
 import { parseVersion } from '../../lib/util.js';
-import Log from '../../lib/log.js';
 import Config from '../../lib/config.js';
 import ShellStub from '../stub/shell.js';
-import Spinner from '../../lib/spinner.js';
 import Prompt from '../../lib/prompt.js';
 
+const noop = Promise.resolve();
+
+export class LogStub {
+  constructor() {
+    this.log = mock.fn();
+    this.error = mock.fn();
+    this.info = mock.fn();
+    this.warn = mock.fn();
+    this.verbose = mock.fn();
+    this.exec = mock.fn();
+    this.obtrusive = mock.fn();
+    this.preview = mock.fn();
+  }
+  resetCalls() {
+    this.log.mock.resetCalls();
+    this.error.mock.resetCalls();
+    this.info.mock.resetCalls();
+    this.warn.mock.resetCalls();
+    this.verbose.mock.resetCalls();
+    this.exec.mock.resetCalls();
+    this.obtrusive.mock.resetCalls();
+    this.preview.mock.resetCalls();
+  }
+}
+
+export class SpinnerStub {
+  show({ enabled = true, task }) {
+    return enabled ? task() : noop;
+  }
+}
+
 export let factory = (Definition, { namespace, options = {}, container = {} } = {}) => {
   options = Object.assign({}, { ci: true, verbose: false, 'dry-run': false, debug: false }, options);
   const ns = namespace || Definition.name.toLowerCase();
   container.config = container.config || new Config(Object.assign({ config: false }, options));
-  container.log = container.log || sinon.createStubInstance(Log);
+  container.log = new LogStub();
 
-  const spinner = container.spinner || sinon.createStubInstance(Spinner);
-  spinner.show.callsFake(({ enabled = true, task }) => (enabled ? task() : () => {}));
-  container.spinner = spinner;
+  container.spinner = new SpinnerStub();
   container.shell = container.shell || new ShellStub({ container });
 
   container.prompt = container.prompt || new Prompt({ container });

package/test/util/mock.js

@@ -0,0 +1,11 @@
+import { MockServer, FetchMocker } from 'mentoss';
+
+export const mockFetch = baseUrls => {
+  const servers = [baseUrls].flat().map(url => new MockServer(url));
+
+  const mocker = new FetchMocker({
+    servers
+  });
+
+  return [mocker, ...servers];
+};

package/test/utils.js

@@ -1,35 +1,36 @@
 import { EOL } from 'node:os';
-import test from 'ava';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { stripVTControlCharacters } from 'node:util';
 import mockStdIo from 'mock-stdio';
-import stripAnsi from 'strip-ansi';
 import { format, truncateLines, parseGitUrl, parseVersion } from '../lib/util.js';
 
-test('format', t => {
-  t.is(format('release v${version}', { version: '1.0.0' }), 'release v1.0.0');
-  t.is(format('release v${version} (${name})', { version: '1.0.0', name: 'foo' }), 'release v1.0.0 (foo)');
-  t.is(format('release v${version} (${name})', { version: '1.0.0', name: 'foo' }), 'release v1.0.0 (foo)');
+test('format', () => {
+  assert.equal(format('release v${version}', { version: '1.0.0' }), 'release v1.0.0');
+  assert.equal(format('release v${version} (${name})', { version: '1.0.0', name: 'foo' }), 'release v1.0.0 (foo)');
+  assert.equal(format('release v${version} (${name})', { version: '1.0.0', name: 'foo' }), 'release v1.0.0 (foo)');
 });
 
-test('format (throw)', t => {
+test('format (throw)', () => {
   mockStdIo.start();
-  t.throws(() => format('release v${foo}', { version: '1.0.0' }), { message: /foo is not defined/ });
+  assert.throws(() => format('release v${foo}', { version: '1.0.0' }), /foo is not defined/);
   const { stdout, stderr } = mockStdIo.end();
-  t.is(stdout, '');
-  t.regex(
-    stripAnsi(stderr),
+  assert.equal(stdout, '');
+  assert.match(
+    stripVTControlCharacters(stderr),
     /ERROR Unable to render template with context:\s+release v\${foo}\s+{"version":"1\.0\.0"}\s+ERROR ReferenceError: foo is not defined/
   );
 });
 
-test('truncateLines', t => {
+test('truncateLines', () => {
   const input = `1${EOL}2${EOL}3${EOL}4${EOL}5${EOL}6`;
-  t.is(truncateLines(input), input);
-  t.is(truncateLines(input, 3), `1${EOL}2${EOL}3${EOL}...and 3 more`);
-  t.is(truncateLines(input, 1, '...'), `1...`);
+  assert.equal(truncateLines(input), input);
+  assert.equal(truncateLines(input, 3), `1${EOL}2${EOL}3${EOL}...and 3 more`);
+  assert.equal(truncateLines(input, 1, '...'), `1...`);
 });
 
-test('parseGitUrl', t => {
-  t.deepEqual(parseGitUrl('https://github.com/webpro/release-it.git'), {
+test('parseGitUrl', () => {
+  assert.deepEqual(parseGitUrl('https://github.com/webpro/release-it.git'), {
     host: 'github.com',
     owner: 'webpro',
     project: 'release-it',
@@ -38,7 +39,7 @@ test('parseGitUrl', t => {
     repository: 'webpro/release-it'
   });
 
-  t.deepEqual(parseGitUrl('git@gitlab.com:org/sub-group/repo-in-sub-group.git'), {
+  assert.deepEqual(parseGitUrl('git@gitlab.com:org/sub-group/repo-in-sub-group.git'), {
     host: 'gitlab.com',
     owner: 'org/sub-group',
     project: 'repo-in-sub-group',
@@ -47,7 +48,7 @@ test('parseGitUrl', t => {
     repository: 'org/sub-group/repo-in-sub-group'
   });
 
-  t.deepEqual(parseGitUrl('git@github.com:org/example.com.git'), {
+  assert.deepEqual(parseGitUrl('git@github.com:org/example.com.git'), {
     host: 'github.com',
     owner: 'org',
     project: 'example.com',
@@ -56,7 +57,7 @@ test('parseGitUrl', t => {
     repository: 'org/example.com'
   });
 
-  t.deepEqual(parseGitUrl('file://Users/john/doe/owner/project'), {
+  assert.deepEqual(parseGitUrl('file://Users/john/doe/owner/project'), {
     host: 'users',
     owner: 'owner',
     project: 'project',
@@ -65,7 +66,7 @@ test('parseGitUrl', t => {
     repository: 'owner/project'
   });
 
-  t.deepEqual(parseGitUrl('/Users/john/doe/owner/project'), {
+  assert.deepEqual(parseGitUrl('/Users/john/doe/owner/project'), {
     host: 'users',
     owner: 'owner',
     project: 'project',
@@ -74,7 +75,7 @@ test('parseGitUrl', t => {
     repository: 'owner/project'
   });
 
-  t.deepEqual(parseGitUrl('C:\\\\Users\\john\\doe\\owner\\project'), {
+  assert.deepEqual(parseGitUrl('C:\\\\Users\\john\\doe\\owner\\project'), {
     host: 'users',
     owner: 'owner',
     project: 'project',
@@ -84,14 +85,14 @@ test('parseGitUrl', t => {
   });
 });
 
-test('parseVersion', t => {
-  t.deepEqual(parseVersion(), { version: undefined, isPreRelease: false, preReleaseId: null });
-  t.deepEqual(parseVersion(0), { version: '0.0.0', isPreRelease: false, preReleaseId: null });
-  t.deepEqual(parseVersion(1), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
-  t.deepEqual(parseVersion('1'), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
-  t.deepEqual(parseVersion('1.0'), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
-  t.deepEqual(parseVersion('1.0.0'), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
-  t.deepEqual(parseVersion('1.0.0-0'), { version: '1.0.0-0', isPreRelease: true, preReleaseId: null });
-  t.deepEqual(parseVersion('1.0.0-next.1'), { version: '1.0.0-next.1', isPreRelease: true, preReleaseId: 'next' });
-  t.deepEqual(parseVersion('21.04.1'), { version: '21.04.1', isPreRelease: false, preReleaseId: null });
+test('parseVersion', () => {
+  assert.deepEqual(parseVersion(), { version: undefined, isPreRelease: false, preReleaseId: null });
+  assert.deepEqual(parseVersion(0), { version: '0.0.0', isPreRelease: false, preReleaseId: null });
+  assert.deepEqual(parseVersion(1), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
+  assert.deepEqual(parseVersion('1'), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
+  assert.deepEqual(parseVersion('1.0'), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
+  assert.deepEqual(parseVersion('1.0.0'), { version: '1.0.0', isPreRelease: false, preReleaseId: null });
+  assert.deepEqual(parseVersion('1.0.0-0'), { version: '1.0.0-0', isPreRelease: true, preReleaseId: null });
+  assert.deepEqual(parseVersion('1.0.0-next.1'), { version: '1.0.0-next.1', isPreRelease: true, preReleaseId: 'next' });
+  assert.deepEqual(parseVersion('21.04.1'), { version: '21.04.1', isPreRelease: false, preReleaseId: null });
 });

package/test/version.js

@@ -1,201 +1,217 @@
-import test from 'ava';
-import sinon from 'sinon';
+import test, { describe } from 'node:test';
+import assert from 'node:assert/strict';
 import Version from '../lib/plugin/version/Version.js';
 import { factory, runTasks } from './util/index.js';
 
-test('isValidVersion', t => {
-  const v = factory(Version);
-  t.is(v.isValid('1.0.0'), true);
-  t.is(v.isValid(1.0), false);
-});
+describe('version', () => {
+  test('isValidVersion', () => {
+    const v = factory(Version);
+    assert.equal(v.isValid('1.0.0'), true);
+    assert.equal(v.isValid(1.0), false);
+  });
 
-test('isPreRelease', t => {
-  const v = factory(Version);
-  t.is(v.isPreRelease('1.0.0-beta.0'), true);
-  t.is(v.isPreRelease('1.0.0'), false);
-});
+  test('isPreRelease', () => {
+    const v = factory(Version);
+    assert.equal(v.isPreRelease('1.0.0-beta.0'), true);
+    assert.equal(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 return the same version in both interactive and ci mode', async () => {
+    const v = factory(Version);
+    const options = { latestVersion: '2.0.0-beta.1', increment: null, preReleaseId: 'rc', isPreRelease: true };
+    const resultInteractiveMode = await v.getIncrementedVersion(options);
+    assert.equal(resultInteractiveMode, '2.0.0-rc.0');
+    const resultCiMode = v.getIncrementedVersionCI(options);
+    assert.equal(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: 'foo' }), undefined);
-  t.is(v.incrementVersion({ latestVersion, increment: 'patsj' }), undefined);
-  t.is(v.incrementVersion({ latestVersion, increment: 'a.b.c' }), undefined);
-  t.is(v.incrementVersion({ latestVersion, increment: '0.9.0' }), undefined);
-  t.is(v.incrementVersion({ latestVersion, increment: '1.1.0' }), '1.1.0');
-  t.is(v.incrementVersion({ latestVersion, increment: 'major' }), '2.0.0');
-  t.is(v.incrementVersion({ latestVersion, increment: '2.0.0-beta.1' }), '2.0.0-beta.1');
-});
+  test('should increment latest version', () => {
+    const v = factory(Version);
+    const latestVersion = '1.0.0';
+    assert.equal(v.incrementVersion({ latestVersion, increment: false }), '1.0.0');
+    assert.equal(v.incrementVersion({ latestVersion, increment: 'foo' }), undefined);
+    assert.equal(v.incrementVersion({ latestVersion, increment: 'patsj' }), undefined);
+    assert.equal(v.incrementVersion({ latestVersion, increment: 'a.b.c' }), undefined);
+    assert.equal(v.incrementVersion({ latestVersion, increment: '0.9.0' }), undefined);
+    assert.equal(v.incrementVersion({ latestVersion, increment: '1.1.0' }), '1.1.0');
+    assert.equal(v.incrementVersion({ latestVersion, increment: 'major' }), '2.0.0');
+    assert.equal(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 not increment latest version in interactive mode', () => {
+    const v = factory(Version, { options: { ci: false } });
+    const latestVersion = '1.0.0';
+    assert.equal(v.incrementVersion({ latestVersion, increment: null }), undefined);
+    assert.equal(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 always set increment version in CI mode', () => {
+    const v = factory(Version, { options: { ci: true } });
+    const latestVersion = '1.0.0';
+    assert.equal(v.getIncrementedVersionCI({ latestVersion, increment: false }), '1.0.0');
+    assert.equal(v.getIncrementedVersionCI({ latestVersion, increment: null }), '1.0.1');
+    assert.equal(v.getIncrementedVersionCI({ latestVersion, increment: '1.1.0' }), '1.1.0');
+    assert.equal(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');
-  t.is(v.incrementVersion({ increment: '1' }), '1.0.0');
-  t.is(v.incrementVersion({ increment: 'v1.2.0.0' }), '1.2.0');
-});
+  test('should increment latest version (coerce)', () => {
+    const v = factory(Version);
+    assert.equal(v.incrementVersion({ increment: '1.2' }), '1.2.0');
+    assert.equal(v.incrementVersion({ increment: '1' }), '1.0.0');
+    assert.equal(v.incrementVersion({ increment: 'v1.2.0.0' }), '1.2.0');
+  });
 
-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.4-0');
-});
+  test('should increment version (pre-release continuation)', () => {
+    const v = factory(Version);
+    assert.equal(v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prepatch' }), '1.2.4-0');
+  });
 
-test('should increment version (prepatch)', t => {
-  const v = factory(Version);
-  t.is(v.incrementVersion({ latestVersion: '1.2.3', increment: 'prepatch', preReleaseId: 'alpha' }), '1.2.4-alpha.0');
-});
+  test('should increment version (prepatch)', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({ latestVersion: '1.2.3', increment: 'prepatch', preReleaseId: 'alpha' }),
+      '1.2.4-alpha.0'
+    );
+  });
 
-test('should increment version (normalized)', t => {
-  const v = factory(Version);
-  t.is(
-    v.incrementVersion({ latestVersion: '1.2.3', increment: 'patch', preReleaseId: 'alpha', isPreRelease: true }),
-    '1.2.4-alpha.0'
-  );
-});
+  test('should increment version (normalized)', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({ latestVersion: '1.2.3', increment: 'patch', preReleaseId: 'alpha', isPreRelease: true }),
+      '1.2.4-alpha.0'
+    );
+  });
 
-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 (prepatch on prerelease version)', () => {
+    const v = factory(Version);
+    assert.equal(
+      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 (normalized on prerelease version)', () => {
+    const v = factory(Version);
+    assert.equal(
+      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');
-});
+  test('should increment version (prerelease)', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({ latestVersion: '1.2.3', increment: 'prerelease', preReleaseId: 'alpha' }),
+      '1.2.4-alpha.0'
+    );
+  });
 
-test('should increment version (prerelease cont.)', t => {
-  const v = factory(Version);
-  t.is(v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prerelease' }), '1.2.3-alpha.1');
-});
+  test('should increment version (prerelease cont.)', () => {
+    const v = factory(Version);
+    assert.equal(v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prerelease' }), '1.2.3-alpha.1');
+  });
 
-test('should increment version (preReleaseId continuation)', t => {
-  const v = factory(Version);
-  t.is(
-    v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prerelease', preReleaseId: 'alpha' }),
-    '1.2.3-alpha.1'
-  );
-});
+  test('should increment version (preReleaseId continuation)', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'prerelease', preReleaseId: 'alpha' }),
+      '1.2.3-alpha.1'
+    );
+  });
 
-test('should increment version (prepatch/preReleaseId continuation)', t => {
-  const v = factory(Version);
-  const options = { latestVersion: '1.2.3-beta.0', increment: 'prerelease', preReleaseId: 'beta', isPreRelease: true };
-  t.is(v.incrementVersion(options), '1.2.3-beta.1');
-});
+  test('should increment version (prepatch/preReleaseId continuation)', () => {
+    const v = factory(Version);
+    const options = {
+      latestVersion: '1.2.3-beta.0',
+      increment: 'prerelease',
+      preReleaseId: 'beta',
+      isPreRelease: true
+    };
+    assert.equal(v.incrementVersion(options), '1.2.3-beta.1');
+  });
 
-test('should increment version (preReleaseId w/o preRelease)', t => {
-  const v = factory(Version);
-  t.is(v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'patch', preReleaseId: 'alpha' }), '1.2.3');
-});
+  test('should increment version (preReleaseId w/o preRelease)', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({ latestVersion: '1.2.3-alpha.0', increment: 'patch', preReleaseId: 'alpha' }),
+      '1.2.3'
+    );
+  });
 
-test('should increment version (non-numeric prepatch continuation)', t => {
-  const v = factory(Version);
-  t.is(v.incrementVersion({ latestVersion: '1.2.3-alpha', increment: 'prerelease' }), '1.2.3-alpha.0');
-});
+  test('should increment version (non-numeric prepatch continuation)', () => {
+    const v = factory(Version);
+    assert.equal(v.incrementVersion({ latestVersion: '1.2.3-alpha', increment: 'prerelease' }), '1.2.3-alpha.0');
+  });
 
-test('should increment version (patch release after pre-release)', t => {
-  const v = factory(Version);
-  t.is(v.incrementVersion({ latestVersion: '1.2.3-alpha.1', increment: 'patch' }), '1.2.3');
-});
+  test('should increment version (patch release after pre-release)', () => {
+    const v = factory(Version);
+    assert.equal(v.incrementVersion({ latestVersion: '1.2.3-alpha.1', increment: 'patch' }), '1.2.3');
+  });
 
-test('should increment version and start at base 1', t => {
-  const v = factory(Version);
-  t.is(
-    v.incrementVersion({
-      latestVersion: '1.3.0',
-      increment: 'major',
-      isPreRelease: true,
-      preReleaseId: 'beta',
-      preReleaseBase: '1'
-    }),
-    '2.0.0-beta.1'
-  );
-});
+  test('should increment version and start at base 1', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({
+        latestVersion: '1.3.0',
+        increment: 'major',
+        isPreRelease: true,
+        preReleaseId: 'beta',
+        preReleaseBase: '1'
+      }),
+      '2.0.0-beta.1'
+    );
+  });
 
-test('should increment prerelease version and ignore prelease base 1', t => {
-  const v = factory(Version);
-  t.is(
-    v.incrementVersion({
-      latestVersion: '1.2.3-alpha.5',
-      increment: 'prerelease',
-      preReleaseId: 'alpha',
-      isPreRelease: true,
-      preReleaseBase: '1'
-    }),
-    '1.2.3-alpha.6'
-  );
-});
+  test('should increment prerelease version and ignore prelease base 1', () => {
+    const v = factory(Version);
+    assert.equal(
+      v.incrementVersion({
+        latestVersion: '1.2.3-alpha.5',
+        increment: 'prerelease',
+        preReleaseId: 'alpha',
+        isPreRelease: true,
+        preReleaseBase: '1'
+      }),
+      '1.2.3-alpha.6'
+    );
+  });
 
-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], { increment: 'minor' });
-  t.is(getIncrementedVersionCI.callCount, 1);
-  t.deepEqual(getIncrementedVersionCI.firstCall.args[0], {
-    latestVersion: '1.0.0',
-    increment: 'minor',
-    isPreRelease: false,
-    preReleaseId: null
-  });
-  t.is(await incrementVersion.firstCall.returnValue, '1.1.0');
-  t.is(incrementVersion.callCount, 1);
-  t.deepEqual(incrementVersion.firstCall.args[0], {
-    latestVersion: '1.0.0',
-    increment: 'minor',
-    isPreRelease: false,
-    preReleaseId: null
-  });
-  t.is(incrementVersion.firstCall.returnValue, '1.1.0');
-  const { latestVersion, version, isPreRelease, preReleaseId } = v.config.getContext();
-  t.is(latestVersion, '1.0.0');
-  t.is(version, '1.1.0');
-  t.is(isPreRelease, false);
-  t.is(preReleaseId, null);
+  test('should run tasks without errors', async t => {
+    const options = { version: { increment: 'minor' } };
+    const v = factory(Version, { options });
+    const getIncrement = t.mock.method(v, 'getIncrement');
+    const getIncrementedVersionCI = t.mock.method(v, 'getIncrementedVersionCI');
+    const incrementVersion = t.mock.method(v, 'incrementVersion');
+
+    await runTasks(v);
+
+    assert.equal(getIncrement.mock.callCount(), 1);
+    assert.deepEqual(getIncrement.mock.calls[0].arguments[0], { increment: 'minor' });
+    assert.equal(getIncrementedVersionCI.mock.callCount(), 1);
+    assert.deepEqual(getIncrementedVersionCI.mock.calls[0].arguments[0], {
+      latestVersion: '1.0.0',
+      increment: 'minor',
+      isPreRelease: false,
+      preReleaseId: null
+    });
+    assert.equal(await incrementVersion.mock.calls[0].result, '1.1.0');
+    assert.equal(incrementVersion.mock.callCount(), 1);
+    assert.deepEqual(incrementVersion.mock.calls[0].arguments[0], {
+      latestVersion: '1.0.0',
+      increment: 'minor',
+      isPreRelease: false,
+      preReleaseId: null
+    });
+    assert.equal(incrementVersion.mock.calls[0].result, '1.1.0');
+    const { latestVersion, version, isPreRelease, preReleaseId } = v.config.getContext();
+    assert.equal(latestVersion, '1.0.0');
+    assert.equal(version, '1.1.0');
+    assert.equal(isPreRelease, false);
+    assert.equal(preReleaseId, null);
+  });
 });

package/test/util/setup.js

@@ -1,3 +0,0 @@
-import nock from 'nock';
-
-nock.disableNetConnect();