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

package/test/github.js

@@ -1,6 +1,7 @@
-import test from 'ava';
-import sinon from 'sinon';
+import test, { describe, before, after, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
 import { RequestError } from '@octokit/request-error';
+import { MockServer, FetchMocker } from 'mentoss';
 import GitHub from '../lib/plugin/github/GitHub.js';
 import { getSearchQueries } from '../lib/plugin/github/util.js';
 import { factory, runTasks } from './util/index.js';
@@ -13,535 +14,619 @@ import {
   interceptAsset
 } from './stub/github.js';
 
-const tokenRef = 'GITHUB_TOKEN';
-const pushRepo = 'git://github.com/user/repo';
-const host = 'github.com';
-const git = { changelog: '' };
-const requestErrorOptions = { request: { url: '', headers: {} }, response: { headers: {} } };
+describe('github', () => {
+  const tokenRef = 'GITHUB_TOKEN';
+  const pushRepo = 'git://github.com/user/repo';
+  const host = 'github.com';
+  const git = { changelog: '' };
+  const requestErrorOptions = { request: { url: '', headers: {} }, response: { headers: {} } };
 
-test.serial('should check token and perform checks', async t => {
-  const tokenRef = 'MY_GITHUB_TOKEN';
-  const options = { github: { release: true, tokenRef, pushRepo } };
-  const github = factory(GitHub, { options });
+  const api = new MockServer('https://api.github.com');
+  const assets = new MockServer('https://uploads.github.com');
+  const example = new MockServer('https://github.example.org/api/v3');
+  const custom = new MockServer('https://custom.example.org/api/v3');
 
-  process.env[tokenRef] = '123';
+  const mocker = new FetchMocker({
+    servers: [api, assets, example, custom]
+  });
 
-  interceptAuthentication();
-  interceptCollaborator();
-  await t.notThrowsAsync(github.init());
-});
+  before(() => {
+    mocker.mockGlobal();
+  });
 
-test.serial('should check token and warn', async t => {
-  const tokenRef = 'MY_GITHUB_TOKEN';
-  const options = { github: { release: true, tokenRef, pushRepo } };
-  const github = factory(GitHub, { options });
-  delete process.env[tokenRef];
+  afterEach(() => {
+    mocker.clearAll();
+  });
 
-  await t.notThrowsAsync(github.init());
+  after(() => {
+    mocker.unmockGlobal();
+  });
 
-  t.is(github.log.warn.args[0][0], 'Environment variable "MY_GITHUB_TOKEN" is required for automated GitHub Releases.');
-  t.is(github.log.warn.args[1][0], 'Falling back to web-based GitHub Release.');
-});
+  test('should check token and perform checks', async () => {
+    const tokenRef = 'MY_GITHUB_TOKEN';
+    const options = { github: { release: true, tokenRef, pushRepo } };
+    const github = factory(GitHub, { options });
 
-test('should release and upload assets', async t => {
-  const options = {
-    git,
-    github: {
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      releaseNotes: 'echo Custom notes',
-      assets: 'test/resources/file-v${version}.txt'
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptCreate({ body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes' } });
-  interceptAsset({ body: '*' });
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
-  exec.restore();
-});
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    await assert.doesNotReject(github.init());
+  });
 
-test('should create a pre-release and draft release notes', async t => {
-  const options = {
-    git,
-    github: {
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      preRelease: true,
-      draft: true
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptCreate({ body: { tag_name: '2.0.2', name: 'Release 2.0.2', prerelease: true, draft: true } });
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
-  exec.restore();
-});
+  test('should check token and warn', async () => {
+    const tokenRef = 'MY_GITHUB_TOKEN';
+    const options = { github: { release: true, tokenRef, pushRepo } };
+    const github = factory(GitHub, { options });
+    delete process.env[tokenRef];
 
-test('should create auto-generated release notes', async t => {
-  const options = {
-    git,
-    github: {
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      autoGenerate: true
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
+    await assert.doesNotReject(github.init());
 
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptCreate({ body: { tag_name: '2.0.2', name: 'Release 2.0.2', generate_release_notes: true, body: '' } });
+    assert.equal(
+      github.log.warn.mock.calls[0].arguments[0],
+      'Environment variable "MY_GITHUB_TOKEN" is required for automated GitHub Releases.'
+    );
+    assert.equal(github.log.warn.mock.calls[1].arguments[0], 'Falling back to web-based GitHub Release.');
+  });
 
-  await runTasks(github);
+  test('should release and upload assets', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo Custom notes',
+        assets: 'test/resources/file-v${version}.txt'
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, { body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes' } });
+    interceptAsset(assets, { body: '*' });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
+  });
 
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
-  exec.restore();
-});
+  test('should create a pre-release and draft release notes', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        preRelease: true,
+        draft: true
+      }
+    };
+    const github = factory(GitHub, { options });
 
-test('should update release and upload assets', async t => {
-  const asset = 'file1';
-  const options = {
-    increment: false,
-    git,
-    github: {
-      update: true,
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      releaseNotes: 'echo Custom notes',
-      assets: `test/resources/${asset}`
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-  exec.withArgs('git rev-list 2.0.1 --tags --max-count=1').resolves('a123456');
-  exec.withArgs('git describe --tags --abbrev=0 "a123456^"').resolves('2.0.1');
-
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptListReleases({ tag_name: '2.0.1' });
-  interceptUpdate({ body: { tag_name: '2.0.1', name: 'Release 2.0.1', body: 'Custom notes' } });
-  interceptAsset({ body: asset });
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.1');
-  exec.restore();
-});
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, { body: { tag_name: '2.0.2', name: 'Release 2.0.2', prerelease: true, draft: true } });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
+  });
 
-test('should create custom release notes using releaseNotes function', async t => {
-  const options = {
-    git,
-    github: {
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      releaseNotes(context) {
-        return `Custom notes for tag ${context.tagName}`;
+  test('should create auto-generated release notes', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        autoGenerate: true
       }
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, {
+      body: { tag_name: '2.0.2', name: 'Release 2.0.2', generate_release_notes: true, body: '' }
+    });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
+  });
 
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptCreate({ body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes for tag 2.0.2' } });
+  test('should update release and upload assets', async t => {
+    const asset = 'file1';
+    const options = {
+      increment: false,
+      git,
+      github: {
+        update: true,
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo Custom notes',
+        assets: `test/resources/${asset}`
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      if (args[0] === 'git rev-list 2.0.1 --tags --max-count=1') return Promise.resolve('a123456');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptListReleases(api, { tag_name: '2.0.1' });
+    interceptUpdate(api, { body: { tag_name: '2.0.1', name: 'Release 2.0.1', body: 'Custom notes' } });
+    interceptAsset(assets, { body: asset });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.1');
+  });
 
-  await runTasks(github);
+  test('should create custom release notes using releaseNotes function', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes(context) {
+          return `Custom notes for tag ${context.tagName}`;
+        }
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, {
+      body: { tag_name: '2.0.2', name: 'Release 2.0.2', body: 'Custom notes for tag 2.0.2' }
+    });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
+  });
 
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
-  exec.restore();
-});
+  test('should create new release for unreleased tag', async t => {
+    const options = {
+      increment: false,
+      git,
+      github: {
+        update: true,
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo Custom notes'
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      if (args[0] === 'git rev-list 2.0.1 --tags --max-count=1') return Promise.resolve('b123456');
+      if (args[0] === 'git describe --tags --abbrev=0 "b123456^"') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptListReleases(api, { tag_name: '2.0.0' });
+    interceptCreate(api, { body: { tag_name: '2.0.1', name: 'Release 2.0.1', body: 'Custom notes' } });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.1');
+  });
 
-test('should create new release for unreleased tag', async t => {
-  const options = {
-    increment: false,
-    git,
-    github: {
-      update: true,
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      releaseNotes: 'echo Custom notes'
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-  exec.withArgs('git rev-list 2.0.1 --tags --max-count=1').resolves('b123456');
-  exec.withArgs('git describe --tags --abbrev=0 "b123456^"').resolves('2.0.1');
-
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptListReleases({ tag_name: '2.0.0' });
-  interceptCreate({ body: { tag_name: '2.0.1', name: 'Release 2.0.1', body: 'Custom notes' } });
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.1');
-  exec.restore();
-});
+  test('should release to enterprise host', async t => {
+    const options = { git, github: { tokenRef, pushRepo: 'git://github.example.org/user/repo' } };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git remote get-url origin') return Promise.resolve(`https://github.example.org/user/repo`);
+      if (args[0] === 'git config --get remote.origin.url')
+        return Promise.resolve('https://github.example.org/user/repo');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('1.0.0');
+      return original(...args);
+    });
+
+    interceptAuthentication(example);
+    interceptCollaborator(example);
+    interceptCreate(example, {
+      api: 'https://github.example.org/api/v3',
+      host: 'github.example.org',
+      body: { tag_name: '1.0.1' }
+    });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.example.org/user/repo/releases/tag/1.0.1');
+  });
 
-test('should release to enterprise host', async t => {
-  const options = { git, github: { tokenRef, pushRepo: 'git://github.example.org/user/repo' } };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git remote get-url origin').resolves(`https://github.example.org/user/repo`);
-  exec.withArgs('git config --get remote.origin.url').resolves(`https://github.example.org/user/repo`);
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves(`1.0.0`);
-
-  const remote = { api: 'https://github.example.org/api/v3', host: 'github.example.org' };
-  interceptAuthentication(remote);
-  interceptCollaborator(remote);
-  interceptCreate(Object.assign({ body: { tag_name: '1.0.1' } }, remote));
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, `https://github.example.org/user/repo/releases/tag/1.0.1`);
-  exec.restore();
-});
+  test('should release to alternative host and proxy', async t => {
+    const options = {
+      git,
+      github: {
+        tokenRef,
+        pushRepo: `git://custom.example.org/user/repo`,
+        host: 'custom.example.org',
+        proxy: 'http://proxy:8080'
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('1.0.0');
+      return original(...args);
+    });
+
+    interceptAuthentication(custom);
+    interceptCollaborator(custom);
+    interceptCreate(custom, {
+      api: 'https://custom.example.org/api/v3',
+      host: 'custom.example.org',
+      body: { tag_name: '1.0.1' }
+    });
+
+    await runTasks(github);
 
-test('should release to alternative host and proxy', async t => {
-  const remote = { api: 'https://custom.example.org/api/v3', host: 'custom.example.org' };
-  interceptAuthentication(remote);
-  interceptCollaborator(remote);
-  interceptCreate(Object.assign({ body: { tag_name: '1.0.1' } }, remote));
-  const options = {
-    git,
-    github: {
-      tokenRef,
-      pushRepo: `git://custom.example.org/user/repo`,
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://custom.example.org/user/repo/releases/tag/1.0.1');
+    assert.equal(github.options.proxy, 'http://proxy:8080');
+  });
+
+  test('should release to git.pushRepo', async t => {
+    const options = { git: { pushRepo: 'upstream', changelog: '' }, github: { tokenRef, skipChecks: true } };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('1.0.0');
+      if (args[0] === 'git remote get-url upstream') return Promise.resolve('https://custom.example.org/user/repo');
+      return original(...args);
+    });
+
+    interceptCreate(custom, {
+      api: 'https://custom.example.org/api/v3',
       host: 'custom.example.org',
-      proxy: 'http://proxy:8080'
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('1.0.0');
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, `https://custom.example.org/user/repo/releases/tag/1.0.1`);
-  t.is(github.options.proxy, 'http://proxy:8080');
-  exec.restore();
-});
+      body: { tag_name: '1.0.1' }
+    });
 
-test('should release to git.pushRepo', async t => {
-  const remote = { api: 'https://custom.example.org/api/v3', host: 'custom.example.org' };
-  interceptCreate(Object.assign({ body: { tag_name: '1.0.1' } }, remote));
-  const options = { git: { pushRepo: 'upstream', changelog: '' }, github: { tokenRef, skipChecks: true } };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('1.0.0');
-  exec.withArgs('git remote get-url upstream').resolves('https://custom.example.org/user/repo');
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://custom.example.org/user/repo/releases/tag/1.0.1');
-  exec.restore();
-});
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://custom.example.org/user/repo/releases/tag/1.0.1');
+  });
+
+  const testSkipOnActions = process.env.GITHUB_ACTIONS ? test.skip : test;
+
+  testSkipOnActions('should throw for unauthenticated user', async t => {
+    const options = { github: { tokenRef, pushRepo, host } };
+    const github = factory(GitHub, { options });
 
-const testSkipOnActions = process.env.GITHUB_ACTIONS ? test.skip : test;
+    const getAuthenticated = t.mock.method(github.client.users, 'getAuthenticated', () => {
+      throw new RequestError('Bad credentials', 401, requestErrorOptions);
+    });
 
-testSkipOnActions('should throw for unauthenticated user', async t => {
-  const options = { github: { tokenRef, pushRepo, host } };
-  const github = factory(GitHub, { options });
-  const stub = sinon.stub(github.client.users, 'getAuthenticated');
-  stub.throws(new RequestError('Bad credentials', 401, requestErrorOptions));
+    await assert.rejects(runTasks(github), {
+      message: /Could not authenticate with GitHub using environment variable "GITHUB_TOKEN"/
+    });
 
-  await t.throwsAsync(runTasks(github), {
-    message: /^Could not authenticate with GitHub using environment variable "GITHUB_TOKEN"/
+    assert.equal(getAuthenticated.mock.callCount(), 1);
   });
 
-  t.is(stub.callCount, 1);
-  stub.restore();
-});
+  testSkipOnActions('should throw for non-collaborator', async t => {
+    const options = { github: { tokenRef, pushRepo, host } };
+    const github = factory(GitHub, { options });
 
-testSkipOnActions('should throw for non-collaborator', async t => {
-  interceptAuthentication({ username: 'john' });
-  const options = { github: { tokenRef, pushRepo, host } };
-  const github = factory(GitHub, { options });
-  const stub = sinon.stub(github.client.repos, 'checkCollaborator');
-  stub.throws(new RequestError('HttpError', 401, requestErrorOptions));
+    t.mock.method(github.client.repos, 'checkCollaborator', () => {
+      throw new RequestError('HttpError', 401, requestErrorOptions);
+    });
 
-  await t.throwsAsync(runTasks(github), { message: /^User john is not a collaborator for user\/repo/ });
+    interceptAuthentication(api, { username: 'john' });
 
-  stub.restore();
-});
+    await assert.rejects(runTasks(github), /User john is not a collaborator for user\/repo/);
+  });
 
-test.serial('should skip authentication and collaborator checks when running on GitHub Actions', async t => {
-  const { GITHUB_ACTIONS, GITHUB_ACTOR } = process.env;
-  if (!GITHUB_ACTIONS) {
-    process.env.GITHUB_ACTIONS = 1;
-    process.env.GITHUB_ACTOR = 'webpro';
-  }
+  test('should skip authentication and collaborator checks when running on GitHub Actions', async t => {
+    const { GITHUB_ACTIONS, GITHUB_ACTOR } = process.env;
+    if (!GITHUB_ACTIONS) {
+      process.env.GITHUB_ACTIONS = 1;
+      process.env.GITHUB_ACTOR = 'webpro';
+    }
 
-  const options = { github: { tokenRef } };
-  const github = factory(GitHub, { options });
-  const authStub = sinon.stub(github, 'isAuthenticated');
-  const collaboratorStub = sinon.stub(github, 'isCollaborator');
+    const options = { github: { tokenRef } };
+    const github = factory(GitHub, { options });
+    const authStub = t.mock.method(github, 'isAuthenticated');
+    const collaboratorStub = t.mock.method(github, 'isCollaborator');
 
-  await t.notThrowsAsync(github.init());
+    await assert.doesNotReject(github.init());
 
-  t.is(authStub.callCount, 0);
-  t.is(collaboratorStub.callCount, 0);
-  t.is(github.getContext('username'), process.env.GITHUB_ACTOR);
+    assert.equal(authStub.mock.callCount(), 0);
+    assert.equal(collaboratorStub.mock.callCount(), 0);
+    assert.equal(github.getContext('username'), process.env.GITHUB_ACTOR);
 
-  authStub.restore();
-  collaboratorStub.restore();
+    if (!GITHUB_ACTIONS) {
+      process.env.GITHUB_ACTIONS = GITHUB_ACTIONS || '';
+      process.env.GITHUB_ACTOR = GITHUB_ACTOR || '';
+    }
+  });
 
-  if (!GITHUB_ACTIONS) {
-    process.env.GITHUB_ACTIONS = GITHUB_ACTIONS || '';
-    process.env.GITHUB_ACTOR = GITHUB_ACTOR || '';
-  }
-});
+  test('should handle octokit client error (without retries)', async t => {
+    const github = factory(GitHub, { options: { github: { tokenRef, pushRepo, host } } });
+    const createRelease = t.mock.method(github.client.repos, 'createRelease', () => {
+      throw new RequestError('Not found', 404, requestErrorOptions);
+    });
 
-test('should handle octokit client error (without retries)', async t => {
-  const github = factory(GitHub, { options: { github: { tokenRef, pushRepo, host } } });
-  const stub = sinon.stub(github.client.repos, 'createRelease');
-  stub.throws(new RequestError('Not found', 404, requestErrorOptions));
-  interceptAuthentication();
-  interceptCollaborator();
+    interceptAuthentication(api);
+    interceptCollaborator(api);
 
-  await t.throwsAsync(runTasks(github), { message: /^404 \(Not found\)/ });
+    await assert.rejects(runTasks(github), /404 \(Not found\)/);
 
-  t.is(stub.callCount, 1);
-  stub.restore();
-});
+    assert.equal(createRelease.mock.callCount(), 1);
+  });
 
-test('should handle octokit client error (with retries)', async t => {
-  const options = { github: { tokenRef, pushRepo, host, retryMinTimeout: 0 } };
-  const github = factory(GitHub, { options });
-  const stub = sinon.stub(github.client.repos, 'createRelease');
-  stub.throws(new RequestError('Request failed', 500, requestErrorOptions));
-  interceptAuthentication();
-  interceptCollaborator();
+  test('should handle octokit client error (with retries)', async t => {
+    const options = { github: { tokenRef, pushRepo, host, retryMinTimeout: 0 } };
+    const github = factory(GitHub, { options });
 
-  await t.throwsAsync(runTasks(github), { message: /^500 \(Request failed\)/ });
+    const createRelease = t.mock.method(github.client.repos, 'createRelease', () => {
+      throw new RequestError('Request failed', 500, requestErrorOptions);
+    });
 
-  t.is(stub.callCount, 3);
-  stub.restore();
-});
+    interceptAuthentication(api);
+    interceptCollaborator(api);
 
-test('should not call octokit client in dry run', async t => {
-  const options = { 'dry-run': true, git, github: { tokenRef, pushRepo, releaseName: 'R ${version}', assets: ['*'] } };
-  const github = factory(GitHub, { options });
-  const spy = sinon.spy(github, 'client', ['get']);
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('v1.0.0');
-
-  await runTasks(github);
-
-  t.is(spy.get.callCount, 0);
-  t.is(github.log.exec.args[1][0], 'octokit repos.createRelease "R 1.0.1" (v1.0.1)');
-  t.is(github.log.exec.lastCall.args[0], 'octokit repos.uploadReleaseAssets');
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/v1.0.1');
-  spy.get.restore();
-  exec.restore();
-});
+    await assert.rejects(runTasks(github), /500 \(Request failed\)/);
 
-test('should skip checks', async t => {
-  const options = { github: { tokenRef, skipChecks: true } };
-  const github = factory(GitHub, { options });
-  await t.notThrowsAsync(github.init());
-});
+    assert.equal(createRelease.mock.callCount(), 3);
+  });
 
-test('should generate GitHub web release url', async t => {
-  const options = {
-    github: {
-      pushRepo,
-      release: true,
-      web: true,
-      releaseName: 'Release ${tagName}',
-      releaseNotes: 'echo Custom notes'
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(
-    releaseUrl,
-    'https://github.com/user/repo/releases/new?tag=2.0.2&title=Release+2.0.2&body=Custom+notes&prerelease=false'
-  );
-  exec.restore();
-});
+  test('should not call octokit client in dry run', async t => {
+    const options = {
+      'dry-run': true,
+      git,
+      github: { tokenRef, pushRepo, releaseName: 'R ${version}', assets: ['*'] }
+    };
+    const github = factory(GitHub, { options });
+
+    const get = t.mock.getter(github, 'client');
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('v1.0.0');
+      return original(...args);
+    });
+
+    await runTasks(github);
+
+    assert.equal(get.mock.callCount(), 0);
+    assert.equal(github.log.exec.mock.calls[1].arguments[0], 'octokit repos.createRelease "R 1.0.1" (v1.0.1)');
+    assert.equal(github.log.exec.mock.calls.at(-1).arguments[0], 'octokit repos.uploadReleaseAssets');
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/v1.0.1');
+  });
 
-test('should generate GitHub web release url for enterprise host', async t => {
-  const options = {
-    git,
-    github: {
-      pushRepo: 'git@custom.example.org:user/repo',
-      release: true,
-      web: true,
-      host: 'custom.example.org',
-      releaseName: 'The Launch',
-      releaseNotes: 'echo It happened'
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(
-    releaseUrl,
-    'https://custom.example.org/user/repo/releases/new?tag=2.0.2&title=The+Launch&body=It+happened&prerelease=false'
-  );
-  exec.restore();
-});
+  test('should generate GitHub web release url', async t => {
+    const options = {
+      github: {
+        pushRepo,
+        release: true,
+        web: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo Custom notes'
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(
+      releaseUrl,
+      'https://github.com/user/repo/releases/new?tag=2.0.2&title=Release+2.0.2&body=Custom+notes&prerelease=false'
+    );
+  });
 
-// eslint-disable-next-line ava/no-skip-test
-test.skip('should truncate long body', async t => {
-  const releaseNotes = 'a'.repeat(125001);
-  const body = 'a'.repeat(124000) + '...';
-  const options = {
-    git,
-    github: {
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      releaseNotes: 'echo ' + releaseNotes
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git log --pretty=format:"* %s (%h)" ${from}...${to}').resolves('');
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptCreate({ body: { tag_name: '2.0.2', name: 'Release 2.0.2', body } });
-
-  await runTasks(github);
-
-  const { isReleased, releaseUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
-  exec.restore();
-});
+  test('should generate GitHub web release url for enterprise host', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo: 'git@custom.example.org:user/repo',
+        release: true,
+        web: true,
+        host: 'custom.example.org',
+        releaseName: 'The Launch',
+        releaseNotes: 'echo It happened'
+      }
+    };
+    const github = factory(GitHub, { options });
+
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(
+      releaseUrl,
+      'https://custom.example.org/user/repo/releases/new?tag=2.0.2&title=The+Launch&body=It+happened&prerelease=false'
+    );
+  });
 
-test('should generate search queries correctly', t => {
-  const generateCommit = () => Math.random().toString(36).substring(2, 9);
-  const base = 'repo:owner/repo+type:pr+is:merged';
-  const commits = Array.from({ length: 5 }, generateCommit);
-  const separator = '+';
-
-  const result = getSearchQueries(base, commits, separator);
-
-  // Test case 1: Check if all commits are included in the search queries
-  const allCommitsIncluded = commits.every(commit => result.some(query => query.includes(commit)));
-  t.true(allCommitsIncluded, 'All commits should be included in the search queries');
-
-  // Test case 2: Check if the function respects the 256 character limit
-  const manyCommits = Array.from({ length: 100 }, generateCommit);
-  const longResult = getSearchQueries(base, manyCommits, separator);
-  t.true(longResult.length > 1, 'Many commits should be split into multiple queries');
-  t.true(
-    longResult.every(query => encodeURIComponent(query).length <= 256),
-    'Each query should not exceed 256 characters after encoding'
-  );
-});
+  test.skip('should truncate long body', async t => {
+    const releaseNotes = 'a'.repeat(125001);
+    const body = 'a'.repeat(124000) + '...';
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        releaseNotes: 'echo ' + releaseNotes
+      }
+    };
+    const github = factory(GitHub, { options });
 
-test('should create auto-generated discussion', async t => {
-  const options = {
-    git,
-    github: {
-      pushRepo,
-      tokenRef,
-      release: true,
-      releaseName: 'Release ${tagName}',
-      autoGenerate: false,
-      discussionCategoryName: 'Announcement'
-    }
-  };
-  const github = factory(GitHub, { options });
-  const exec = sinon.stub(github.shell, 'exec').callThrough();
-  exec.withArgs('git describe --tags --match=* --abbrev=0').resolves('2.0.1');
-
-  interceptAuthentication();
-  interceptCollaborator();
-  interceptCreate({
-    body: {
-      tag_name: '2.0.2',
-      name: 'Release 2.0.2',
-      generate_release_notes: false,
-      body: null,
-      discussion_category_name: 'Announcement'
-    }
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git log --pretty=format:"* %s (%h)" ${from}...${to}') return Promise.resolve('');
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, { body: { tag_name: '2.0.2', name: 'Release 2.0.2', body } });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
   });
 
-  await runTasks(github);
+  test('should generate search queries correctly', () => {
+    const generateCommit = () => Math.random().toString(36).substring(2, 9);
+    const base = 'repo:owner/repo+type:pr+is:merged';
+    const commits = Array.from({ length: 5 }, generateCommit);
+    const separator = '+';
+
+    const result = getSearchQueries(base, commits, separator);
+
+    // Test case 1: Check if all commits are included in the search queries
+    const allCommitsIncluded = commits.every(commit => result.some(query => query.includes(commit)));
+    assert(allCommitsIncluded, 'All commits should be included in the search queries');
+
+    assert.equal(
+      commits.every(commit => result.some(query => query.includes(commit))),
+      true
+    );
+
+    // Test case 2: Check if the function respects the 256 character limit
+    const manyCommits = Array.from({ length: 100 }, generateCommit);
+    const longResult = getSearchQueries(base, manyCommits, separator);
+    assert(longResult.length > 1, 'Many commits should be split into multiple queries');
+    assert(
+      longResult.every(query => encodeURIComponent(query).length <= 256),
+      'Each query should not exceed 256 characters after encoding'
+    );
+  });
 
-  const { isReleased, releaseUrl, discussionUrl } = github.getContext();
-  t.true(isReleased);
-  t.is(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
-  t.is(discussionUrl, 'https://github.com/user/repo/discussions/1');
-  exec.restore();
+  test('should create auto-generated discussion', async t => {
+    const options = {
+      git,
+      github: {
+        pushRepo,
+        tokenRef,
+        release: true,
+        releaseName: 'Release ${tagName}',
+        autoGenerate: false,
+        discussionCategoryName: 'Announcement'
+      }
+    };
+    const github = factory(GitHub, { options });
+    const original = github.shell.exec.bind(github.shell);
+    t.mock.method(github.shell, 'exec', (...args) => {
+      if (args[0] === 'git describe --tags --match=* --abbrev=0') return Promise.resolve('2.0.1');
+      return original(...args);
+    });
+
+    interceptAuthentication(api);
+    interceptCollaborator(api);
+    interceptCreate(api, {
+      body: {
+        tag_name: '2.0.2',
+        name: 'Release 2.0.2',
+        generate_release_notes: false,
+        body: null,
+        discussion_category_name: 'Announcement'
+      }
+    });
+
+    await runTasks(github);
+
+    const { isReleased, releaseUrl, discussionUrl } = github.getContext();
+    assert(isReleased);
+    assert.equal(releaseUrl, 'https://github.com/user/repo/releases/tag/2.0.2');
+    assert.equal(discussionUrl, 'https://github.com/user/repo/discussions/1');
+  });
 });