apify-test-tools 0.10.2-beta.13 → 0.10.2-beta.14

package/test/bundle/cli-bundle.test.ts

@@ -46,8 +46,6 @@ const runCliWithInput = (input: string, ...args: string[]) => {
 
 const runCli = (...args: string[]) => runCliWithInput('', ...args);
 
-const gitRange = ['--source-branch', 'feature', '--target-branch', 'main'];
-
 describe('CLI bundle', () => {
     // Two Actors on `main`; `feature` changes only tester/foo and the root README.
     beforeAll(async () => {
@@ -91,14 +89,11 @@ describe('CLI bundle', () => {
         const { status, stdout } = runCli('--help');
         expect(status).toBe(0);
         for (const command of [
-            'get-commits',
-            'get-latest-commit',
-            'get-changed-files',
             'get-actor-configs',
             'get-affected-actors',
-            'report-tests',
+            'test [filters..]',
+            'notify',
             'build',
-            'notify-release',
             'build-from-local',
             'delete-old-builds',
         ]) {
@@ -106,27 +101,6 @@ describe('CLI bundle', () => {
         }
     });
 
-    it('get-commits returns the commits on the source branch', () => {
-        const { status, stdout, stderr } = runCli('get-commits', ...gitRange);
-        expect(status, stderr).toBe(0);
-        expect(JSON.parse(stdout).map((commit: { message: string }) => commit.message)).toEqual([
-            'fix(foo): change foo',
-            'docs: readme',
-        ]);
-    });
-
-    it('get-latest-commit returns the head of the source branch', () => {
-        const { status, stdout, stderr } = runCli('get-latest-commit', ...gitRange);
-        expect(status, stderr).toBe(0);
-        expect(JSON.parse(stdout)).toMatchObject({ sha: headSha, message: 'docs: readme' });
-    });
-
-    it('get-changed-files returns the files changed on the source branch', () => {
-        const { status, stdout, stderr } = runCli('get-changed-files', ...gitRange);
-        expect(status, stderr).toBe(0);
-        expect(JSON.parse(stdout)).toEqual(['README.md', 'actors/foo/main.js']);
-    });
-
     it('get-actor-configs reads both Actors from the config file', () => {
         const { status, stdout, stderr } = runCli('get-actor-configs');
         expect(status, stderr).toBe(0);
@@ -149,6 +123,14 @@ describe('CLI bundle', () => {
         });
     });
 
+    it.each(['info', 'silent'])('keeps JSON results intact with --log-level %s', (level) => {
+        const { status, stdout, stderr } = runCli('get-affected-actors', '--base', 'main', '--log-level', level);
+        expect(status, stderr).toBe(0);
+        expect(stderr).toEqual(level === 'silent' ? '' : expect.stringContaining('Changed files'));
+        expect(JSON.parse(stdout)).toMatchObject({ head: headSha });
+        expect(stdout.endsWith('\n')).toBe(true);
+    });
+
     it('build --dry-run with nothing to build needs no token', () => {
         const { status, stdout, stderr } = runCliWithInput(
             JSON.stringify({ actors: [] }),
@@ -189,47 +171,52 @@ describe('CLI bundle', () => {
         });
     });
 
-    it('notify-release announces nothing, and needs no token, when there are no new commits', () => {
+    it('notify announces no release, and needs no token, when there are no new commits', () => {
         const affected = runCli('get-affected-actors', '--since', headSha).stdout;
-        const { status, stderr } = runCliWithInput(affected, 'notify-release', '--release-slack-channel', '#releases');
+        const { status, stderr } = runCliWithInput(affected, 'notify', '--slack-channel', '#releases');
         expect(status, stderr).toBe(0);
         expect(stderr).toContain('No new commits, so there is no release to announce');
     });
 
-    it('notify-release skips Slack without a channel', () => {
+    it('notify skips a release without a channel', () => {
         const affected = runCli('get-affected-actors', '--since', baseSha).stdout;
-        const { status, stderr } = runCliWithInput(affected, 'notify-release', '--dry-run');
+        const { status, stderr } = runCliWithInput(affected, 'notify', '--dry-run');
         expect(status, stderr).toBe(0);
-        expect(stderr).toContain('Skipping slack notification');
+        expect(stderr).toContain('Skipping notification, no --slack-channel passed');
     });
 
-    it('report-tests summarizes a vitest JSON report', async () => {
-        const assertion = (title: string, status: 'passed' | 'failed', runId: string) => ({
-            ancestorTitles: [],
-            fullName: `foo ${title}`,
-            title,
-            status,
-            failureMessages: status === 'failed' ? ['AssertionError: expected 1 to be 2\n    at foo.test.ts:1:1'] : [],
-            meta: { runId, runLink: `https://console.apify.com/view/runs/${runId}`, actorId: 'tester/foo' },
-        });
-        await writeRepoFile(
-            'test-output.json',
-            JSON.stringify({
-                success: false,
-                testResults: [
-                    {
-                        name: 'test/platform/foo.test.ts',
-                        status: 'failed',
-                        assertionResults: [assertion('works', 'passed', 'run1'), assertion('fails', 'failed', 'run2')],
-                    },
-                ],
-            }),
-        );
+    it('test fails without TESTER_APIFY_TOKEN instead of passing with every test skipped', () => {
+        // Every Actor in the config, on its default build, as the scheduled tests pipe them in
+        const { status, stdout, stderr } = runCliWithInput(runCli('get-actor-configs').stdout, 'test');
+        expect(status).toBe(1);
+        expect(stderr).toContain('TESTER_APIFY_TOKEN is not set');
+        expect(stdout).toBe('');
+    });
 
-        const { status, stderr } = runCli('report-tests', '--report-file', 'test-output.json', '--dry-run');
-        expect(status, stderr).toBe(0);
-        expect(stderr).toContain('PASSED: 1, FAILED: 1');
-        expect(stderr).toContain('1) foo fails ... https://console.apify.com/view/runs/run2');
-        expect(stderr).toContain('Skipping slack notification');
+    it('notify needs the Slack token to post a failed report, even in a dry run', () => {
+        const report = {
+            kind: 'test-report',
+            version: 1,
+            success: false,
+            summary: { total: 1, passed: 0, failed: 1, skipped: 0 },
+            tests: [
+                {
+                    name: 'tester/foo: fails',
+                    file: 'test/platform/foo.test.ts',
+                    status: 'failed',
+                    durationMs: 1,
+                    failureMessages: ['AssertionError: expected 1 to be 2'],
+                    run: { actorId: 'tester/foo', runId: 'run2', runLink: 'https://console.apify.com/view/runs/run2' },
+                },
+            ],
+            errors: [],
+        };
+        const withChannel = runCliWithInput(JSON.stringify(report), 'notify', '--slack-channel', '#notif', '--dry-run');
+        expect(withChannel.status).toBe(1);
+        expect(withChannel.stderr).toContain('SLACK_BOT_TOKEN not defined');
+
+        const withoutChannel = runCliWithInput(JSON.stringify(report), 'notify', '--dry-run');
+        expect(withoutChannel.status, withoutChannel.stderr).toBe(0);
+        expect(withoutChannel.stderr).toContain('Skipping notification');
     });
 });

package/test/e2e/cli-bundle.e2e.test.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
@@ -9,6 +9,7 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
 import type { ActorBuild } from './helpers.js';
 import {
+    bundlePath,
     cliEnv,
     gitEnv,
     projectRoot,
@@ -21,8 +22,8 @@ import {
 
 // End-to-end run of the shipped CLI bundle against two dummy Actors in an isolated sandbox account:
 // dry-run plans read the real Actors, `build-from-local` really builds them, the lib runs them
-// through `testActor` on exactly those builds (the ACTOR_BUILDS handoff), `report-tests` reads the
-// result, and `delete-old-builds` cleans up. Git builds of a real repository are in
+// through `testActor` on exactly those builds (`build-from-local | test`), `notify` reads the
+// report, and `delete-old-builds` cleans up. Git builds of a real repository are in
 // git-build-release.e2e.test.ts.
 //
 // Runs with `npm run test:e2e`, kept out of `npm test`. Skipped without the token, e.g. on fork PRs.
@@ -30,8 +31,6 @@ const ACTORS = ['test-tools-testing-sandbox/dummy-for-testing-1', 'test-tools-te
 // Only used as the source URL in dry-run plans; nothing is cloned from it.
 const REPO_URL = 'https://github.com/apify/apify-test-tools-e2e-fixture';
 
-const vitestPath = path.join(projectRoot, 'node_modules/vitest/vitest.mjs');
-
 let repoDir: string;
 let baseSha: string;
 
@@ -166,34 +165,28 @@ describe('sandbox dummies', () => {${actorTests}
 `,
         );
 
-        const vitest = await runProcess(
-            process.execPath,
-            [vitestPath, 'run', 'test/platform', '--reporter=json', '--outputFile=./test-output.json'],
-            {
-                cwd: repoDir,
-                env: { ...cliEnv, TESTER_APIFY_TOKEN: token!, ACTOR_BUILDS: JSON.stringify(builds) },
-            },
-        );
-        expect(vitest.status, `${vitest.stdout}\n${vitest.stderr}`).toBe(0);
+        const tested = await runProcess(process.execPath, [bundlePath, 'test', 'test/platform'], {
+            cwd: repoDir,
+            env: { ...cliEnv, TESTER_APIFY_TOKEN: token! },
+            input: JSON.stringify(builds),
+        });
+        expect(tested.status, tested.stderr).toBe(0);
+        expect(tested.stderr).toContain('https://console.apify.com/view/runs/');
 
-        // Each run used the build from ACTOR_BUILDS, not the Actor's default build.
-        const report = JSON.parse(await readFile(path.join(repoDir, 'test-output.json'), 'utf8'));
-        const assertions = report.testResults.flatMap(
-            (file: { assertionResults: { meta: { runId: string } }[] }) => file.assertionResults,
-        );
-        expect(assertions).toHaveLength(ACTORS.length);
+        // Each run used the build piped into `test`, not the Actor's default build.
+        const report = JSON.parse(tested.stdout);
+        expect(report).toMatchObject({ success: true, summary: { passed: ACTORS.length, failed: 0 } });
         const client = new ApifyClient({ token });
         const runBuildIds = await Promise.all(
-            assertions.map(
-                async ({ meta }: { meta: { runId: string } }) => (await client.run(meta.runId).get())?.buildId,
+            report.tests.map(
+                async ({ run }: { run: { runId: string } }) => (await client.run(run.runId).get())?.buildId,
             ),
         );
         expect(runBuildIds.sort()).toEqual(builds.map((build) => build.buildId).sort());
 
-        const { status, stderr } = await runCli('report-tests', '--report-file', 'test-output.json', '--dry-run');
+        const { status, stderr } = await runCliWithInput(tested.stdout, 'notify', '--dry-run');
         expect(status, stderr).toBe(0);
-        expect(stderr).toContain(`PASSED: ${ACTORS.length}, FAILED: 0`);
-        expect(stderr).toContain('https://console.apify.com/view/runs/');
+        expect(stderr).toContain('Skipping notification');
     });
 
     // Last, so builds from earlier runs of this suite don't pile up in the sandbox.

package/test/e2e/git-build-release.e2e.test.ts

@@ -106,8 +106,8 @@ describe.runIf(token)('CLI bundle building a real repository', { timeout: 2 * 60
         expect(await versionSource('0.0')).toBe(BUILD_SOURCE);
 
         // Without a channel the announcement is skipped, so it needs no Slack token
-        const notify = await runCliWithInput(affected.stdout, 'notify-release');
+        const notify = await runCliWithInput(affected.stdout, 'notify');
         expect(notify.status, notify.stderr).toBe(0);
-        expect(notify.stderr).toContain('Skipping slack notification');
+        expect(notify.stderr).toContain('Skipping notification');
     });
 });

package/test/unit/bin/actor-ids.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { withActorIds } from '../../../bin/actor-ids.js';
+
+type Client = NonNullable<Parameters<typeof withActorIds>[1]>;
+
+/** A client that knows one Actor, by its full name and by its raw ID, as the API does */
+const fakeClient = () => {
+    const known = { id: 'rawA', username: 'owner', name: 'a' };
+    const actor = vi.fn((actorId: string) => ({
+        get: async () => (actorId === 'owner/a' || actorId === 'rawA' ? known : undefined),
+    }));
+    return { actor } as unknown as Client & { actor: typeof actor };
+};
+
+describe('withActorIds', () => {
+    it('adds the raw ID to an Actor listed by full name, as get-actor-configs lists them', async () => {
+        expect(await withActorIds([{ actorFullName: 'owner/a' }], fakeClient())).toEqual([
+            { actorFullName: 'owner/a', actorRawId: 'rawA' },
+        ]);
+    });
+
+    it('adds the full name to an Actor listed by raw ID', async () => {
+        const build = { actorRawId: 'rawA', buildId: 'b1', buildNumber: '0.99.1' };
+        expect(await withActorIds([build], fakeClient())).toEqual([{ ...build, actorFullName: 'owner/a' }]);
+    });
+
+    it('keeps the IDs of a build and does not look them up', async () => {
+        const client = fakeClient();
+        const build = { actorFullName: 'owner/a', buildId: 'b1', actorRawId: 'raw1', buildNumber: '0.99.1' };
+        expect(await withActorIds([build], client)).toEqual([build]);
+        expect(client.actor).not.toHaveBeenCalled();
+    });
+
+    it('fails for an Actor the token cannot see, instead of skipping its tests', async () => {
+        await expect(withActorIds([{ actorFullName: 'owner/missing' }], fakeClient())).rejects.toThrow(
+            'Actor owner/missing not found',
+        );
+        await expect(withActorIds([{ actorRawId: 'rawMissing' }], fakeClient())).rejects.toThrow(
+            'Actor rawMissing not found',
+        );
+    });
+});

package/test/unit/bin/build-cli.test.ts

@@ -12,7 +12,7 @@ const run = (command: string[], input: string, env: NodeJS.ProcessEnv = process.
     spawnSync(cliPath, command, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'pipe'], env });
 const runBuild = (input: string, args: string[] = ['--version-number', '0.99']) => run(['build', ...args], input);
 
-describe('build and notify-release CLI', () => {
+describe('build and notify CLI', () => {
     beforeAll(async () => {
         ({ cliPath, cleanup } = await compileCli());
     });
@@ -46,9 +46,15 @@ describe('build and notify-release CLI', () => {
         expect(result.stderr).toContain('Missing required argument: version-number');
     });
 
-    it('notify-release announces nothing when there are no new commits', () => {
+    it('notify takes one channel per call', () => {
+        const result = run(['notify', '--slack-channel', '#a', '--slack-channel', '#b'], '{}');
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('--slack-channel takes one channel, call notify once for each channel');
+    });
+
+    it('notify announces no release when there are no new commits', () => {
         const document = { commits: [], changedFiles: [], changelog: null, functionallyChangedActors: [] };
-        const result = run(['notify-release'], JSON.stringify(document));
+        const result = run(['notify', '--slack-channel', '#notif'], JSON.stringify(document));
         expect(result.status, result.stderr).toBe(0);
         expect(result.stderr).toContain('No new commits, so there is no release to announce');
     });

package/test/unit/bin/diff-changes.test.ts

@@ -508,7 +508,7 @@ describe('getChangedActors', () => {
         expect(result).toEqual([]);
     });
 
-    it('does not special-case code/ and shared/ prefixes anymore — must be declared via overrideActorContext', async () => {
+    it('does not special-case code/ and shared/ prefixes — they must be declared via overrideActorContext', async () => {
         const result = await changedActorsFor({
             filepathsChanged: ['code/some/code.ts'],
             actorConfigs: [miniActor],

package/test/unit/bin/git.test.ts

@@ -1,206 +1,18 @@
-import type { MockInstance } from 'vitest';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
     findCommitSha,
-    getChangedFiles,
     getChangedFilesBetween,
-    getCommits,
     getCommitsBetween,
     getCurrentBranch,
     getRepoName,
     normalizeRepoUrl,
-    parseBaseCommit,
     resolveCommitSha,
     resolveReleaseBaseCommit,
     resolveRepoUrl,
 } from '../../../bin/git.js';
 import * as Utils from '../../../bin/utils.js';
 
-describe('getCommits', () => {
-    const sourceBranch = 'feature-branch';
-    const targetBranch = 'main';
-
-    const sha1 = '1'.repeat(40);
-    const sha2 = '2'.repeat(40);
-    const sha3 = '3'.repeat(40);
-
-    const commit1 = `${sha1}»¦«Author1»¦«Date1»¦«First Change On Feature`;
-    const commit2 = `${sha2}»¦«Author1»¦«Date2»¦«Second Change On Feature`;
-    const commit3 = `${sha3}»¦«Author1»¦«Date3»¦«Third Change On Feature`;
-
-    let gitCommandSpy: MockInstance;
-
-    beforeEach(() => {
-        gitCommandSpy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue(`${commit3}\n${commit2}\n${commit1}`);
-    });
-
-    it('should return commits between source and target branches', async () => {
-        // Act
-        const commits = await getCommits({ sourceBranch, targetBranch });
-
-        // Assert
-        expect(commits).toStrictEqual([
-            { sha: sha1, author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
-            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
-        ]);
-
-        expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(
-            ['log', '--pretty=format:%H»¦«%aN<%aE>»¦«%aD»¦«%s', 'main..feature-branch'],
-            { operation: 'list commits reachable from the source ref but absent from the target ref' },
-        );
-    });
-
-    it('should return commits after the base commit if provided', async () => {
-        // Act
-        const commits = await getCommits({ sourceBranch, targetBranch, baseCommit: sha1 });
-
-        // Assert
-        expect(commits).toStrictEqual([
-            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
-        ]);
-
-        expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(
-            ['log', '--pretty=format:%H»¦«%aN<%aE>»¦«%aD»¦«%s', 'main..feature-branch'],
-            { operation: 'list commits reachable from the source ref but absent from the target ref' },
-        );
-    });
-
-    it('should ignore the base commit and return all commits when it is the branch HEAD (rerun or force push)', async () => {
-        // Act
-        const commits = await getCommits({ sourceBranch, targetBranch, baseCommit: sha3 });
-
-        // Assert
-        expect(commits).toStrictEqual([
-            { sha: sha1, author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
-            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
-        ]);
-    });
-
-    it('should return all commits if base commit is not found', async () => {
-        // Act
-        const commits = await getCommits({ sourceBranch, targetBranch, baseCommit: 'a'.repeat(40) });
-
-        // Assert
-        expect(commits).toStrictEqual([
-            { sha: sha1, author: 'Author1', date: 'Date1', message: 'First Change On Feature' },
-            { sha: sha2, author: 'Author1', date: 'Date2', message: 'Second Change On Feature' },
-            { sha: sha3, author: 'Author1', date: 'Date3', message: 'Third Change On Feature' },
-        ]);
-
-        expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(
-            ['log', '--pretty=format:%H»¦«%aN<%aE>»¦«%aD»¦«%s', 'main..feature-branch'],
-            { operation: 'list commits reachable from the source ref but absent from the target ref' },
-        );
-    });
-});
-
-describe('getChangedFiles', () => {
-    let gitCommandSpy: MockInstance;
-
-    beforeEach(() => {
-        gitCommandSpy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue('file1.txt\nfolder/file2.txt');
-    });
-
-    it('should return changed files between commits', async () => {
-        // Arrange
-        const firstSha = '1'.repeat(40);
-        const lastSha = '3'.repeat(40);
-        const commits = [
-            { sha: firstSha, author: '', date: '', message: '' },
-            { sha: lastSha, author: '', date: '', message: '' },
-        ];
-
-        // Act
-        const changedFiles = await getChangedFiles(commits);
-
-        // Assert
-        expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
-
-        expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(
-            ['diff', '--name-only', '--no-renames', `${firstSha}~..${lastSha}`],
-            {
-                operation: 'get the list of changed files between commits',
-            },
-        );
-    });
-
-    it('should throw without running git when the commit list is empty', async () => {
-        // Act & Assert
-        await expect(getChangedFiles([])).rejects.toThrow('Cannot get changed files: the commit list is empty');
-        expect(gitCommandSpy).not.toHaveBeenCalled();
-    });
-
-    it('should handle only one commit', async () => {
-        // Arrange
-        const onlySha = '1'.repeat(40);
-        const commits = [{ sha: onlySha, author: '', date: '', message: '' }];
-
-        // Act
-        const changedFiles = await getChangedFiles(commits);
-
-        // Assert
-        expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
-
-        expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', '--no-renames', `${onlySha}~..${onlySha}`], {
-            operation: 'get the list of changed files between commits',
-        });
-    });
-
-    it('should return an empty list when the net diff is empty (e.g. a commit and its revert)', async () => {
-        // Arrange
-        gitCommandSpy.mockResolvedValue('');
-        const commits = [
-            { sha: '1'.repeat(40), author: '', date: '', message: '' },
-            { sha: '2'.repeat(40), author: '', date: '', message: '' },
-        ];
-
-        // Act
-        const changedFiles = await getChangedFiles(commits);
-
-        // Assert
-        expect(changedFiles).toStrictEqual([]);
-    });
-});
-
-const VALID_SHA = 'a'.repeat(40);
-const VALID_JSON = JSON.stringify({ sha: VALID_SHA, author: 'test', date: 'now', message: 'msg' });
-
-describe('parseBaseCommit', () => {
-    it('should return undefined for undefined input', () => {
-        expect(parseBaseCommit(undefined)).toBeUndefined();
-    });
-
-    it('should return undefined for empty string', () => {
-        expect(parseBaseCommit('')).toBeUndefined();
-    });
-
-    it('should accept a plain SHA string', () => {
-        expect(parseBaseCommit(VALID_SHA)).toBe(VALID_SHA);
-    });
-
-    it('should extract sha from a JSON commit object', () => {
-        expect(parseBaseCommit(VALID_JSON)).toBe(VALID_SHA);
-    });
-
-    it('should throw on an invalid SHA string', () => {
-        expect(() => parseBaseCommit('not-a-sha')).toThrow('Invalid base commit SHA');
-    });
-
-    it('should throw when JSON contains an invalid sha field', () => {
-        const badJson = JSON.stringify({ sha: 'bad', author: 'test', date: 'now', message: 'msg' });
-        expect(() => parseBaseCommit(badJson)).toThrow('Invalid base commit SHA');
-    });
-});
-
 describe('getCurrentBranch', () => {
     it('should return the checked-out branch', async () => {
         const gitCommandSpy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue('master');
@@ -279,7 +91,7 @@ describe('resolveReleaseBaseCommit', () => {
         });
         await expect(resolveReleaseBaseCommit(baseSha)).resolves.toBe(baseSha);
         expect(gitCommandSpy).toHaveBeenCalledWith(['rev-parse', '--verify', '--quiet', `${baseSha}^{commit}`], {
-            operation: 'verify the release base commit in local Git history',
+            operation: `look up ${baseSha} in local Git history`,
         });
         expect(gitCommandSpy).toHaveBeenCalledWith(['merge-base', baseSha, 'HEAD'], {
             operation: 'check whether the release base commit is an ancestor of HEAD',
@@ -348,11 +160,11 @@ describe('resolveReleaseBaseCommit', () => {
             new Utils.GitCommandError(
                 ['rev-parse', '--verify', '--quiet', `${baseSha}^{commit}`],
                 Object.assign(new Error('Git failed'), { code: 128 }),
-                'verify the release base commit in local Git history',
+                `look up ${baseSha} in local Git history`,
             ),
         );
         await expect(resolveReleaseBaseCommit(baseSha)).rejects.toThrow(
-            'Failed to verify the release base commit in local Git history.\n' +
+            `Failed to look up ${baseSha} in local Git history.\n` +
                 `Command: git "rev-parse" "--verify" "--quiet" "${baseSha}^{commit}"\nGit error: Git failed`,
         );
     });
@@ -399,12 +211,6 @@ describe('empty commit ranges', () => {
     it('getCommitsBetween returns no commits', async () => {
         await expect(getCommitsBetween('HEAD', 'HEAD')).resolves.toStrictEqual([]);
     });
-
-    it('getCommits fails clearly, since the commands built on it need at least one commit', async () => {
-        await expect(getCommits({ sourceBranch: 'HEAD', targetBranch: 'HEAD' })).rejects.toThrow(
-            'HEAD has no commits that are not on HEAD.',
-        );
-    });
 });
 
 describe('getChangedFilesBetween', () => {