apify-test-tools 0.10.2-beta.0 → 0.10.2-beta.10

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

@@ -4,10 +4,7 @@ import { beforeEach, describe, expect, it, test, vi } from 'vitest';
 import { isCosmeticOnlyJsonSchemaChange } from '../../../bin/diff-json-schema.js';
 import * as Utils from '../../../bin/utils.js';
 
-const commits = [
-    { sha: 'Commit1', author: '', date: '', message: '' },
-    { sha: 'Commit3', author: '', date: '', message: '' },
-];
+const range = { fromRef: 'Commit0', toRef: 'Commit3' };
 
 describe('isCosmeticOnlyJsonSchemaChange', () => {
     let gitCommandSpy: MockInstance;
@@ -23,7 +20,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
     test('returns true when nothing changed', async () => {
         const json = JSON.stringify({ type: 'string', title: 'My field' });
         mockGitCalls(json, json);
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when only title changes', async () => {
@@ -31,7 +28,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ type: 'string', title: 'Old title' }),
             JSON.stringify({ type: 'string', title: 'New title' }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when only description changes', async () => {
@@ -39,7 +36,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ type: 'string', description: 'Old desc' }),
             JSON.stringify({ type: 'string', description: 'New desc' }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when only example changes', async () => {
@@ -47,7 +44,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ type: 'string', example: 'foo' }),
             JSON.stringify({ type: 'string', example: 'bar' }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when only enumTitles changes', async () => {
@@ -55,7 +52,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ type: 'string', enum: ['a', 'b'], enumTitles: ['Option A', 'Option B'] }),
             JSON.stringify({ type: 'string', enum: ['a', 'b'], enumTitles: ['Choice A', 'Choice B'] }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when only sectionCaption changes', async () => {
@@ -63,12 +60,12 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ sectionCaption: 'Old caption' }),
             JSON.stringify({ sectionCaption: 'New caption' }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when only sectionDescription changes', async () => {
         mockGitCalls(JSON.stringify({ sectionDescription: 'Old' }), JSON.stringify({ sectionDescription: 'New' }));
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns false when a functional field (type) changes', async () => {
@@ -76,17 +73,17 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ type: 'string', title: 'My field' }),
             JSON.stringify({ type: 'integer', title: 'My field' }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when a functional field is added', async () => {
         mockGitCalls(JSON.stringify({ title: 'My field' }), JSON.stringify({ title: 'My field', type: 'string' }));
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when a functional field is removed', async () => {
         mockGitCalls(JSON.stringify({ type: 'string', title: 'My field' }), JSON.stringify({ title: 'My field' }));
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns true when non-functional fields change at nested level (input schema properties)', async () => {
@@ -104,7 +101,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 },
             }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns false when a functional nested field changes alongside non-functional ones', async () => {
@@ -118,7 +115,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 properties: { myField: { type: 'integer', title: 'New title' } },
             }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when a new property is added to input schema', async () => {
@@ -126,7 +123,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ properties: { fieldA: { type: 'string' } } }),
             JSON.stringify({ properties: { fieldA: { type: 'string' }, fieldB: { type: 'integer' } } }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when a property is removed from input schema', async () => {
@@ -134,27 +131,27 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ properties: { fieldA: { type: 'string' }, fieldB: { type: 'integer' } } }),
             JSON.stringify({ properties: { fieldA: { type: 'string' } } }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when invalid JSON in old content', async () => {
         mockGitCalls('not json', '{}');
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when invalid JSON in new content', async () => {
         mockGitCalls('{}', 'not json');
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when git cannot read a schema version', async () => {
         gitCommandSpy.mockRejectedValueOnce(new Error('missing schema'));
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns false when array content changes (not under a non-functional key)', async () => {
         mockGitCalls(JSON.stringify({ enum: [1, 2, 3] }), JSON.stringify({ enum: [1, 2, 4] }));
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     test('returns true when example array changes (non-functional key)', async () => {
@@ -162,7 +159,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ type: 'array', example: [1, 2, 3] }),
             JSON.stringify({ type: 'array', example: [4, 5, 6] }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true for a realistic actor.json with only title/description change', async () => {
@@ -182,7 +179,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 version: '1.0',
             }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns true when fields under properties are reordered', async () => {
@@ -196,7 +193,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
                 properties: { fieldC: { type: 'boolean' }, fieldA: { type: 'string' }, fieldB: { type: 'integer' } },
             }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(true);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(true);
     });
 
     test('returns false for a realistic actor.json with version change', async () => {
@@ -204,14 +201,14 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
             JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'My Actor', version: '1.0' }),
             JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'My Actor', version: '1.1' }),
         );
-        await expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).resolves.toBe(false);
+        await expect(isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json')).resolves.toBe(false);
     });
 
     it('uses correct git refs: first-commit parent for old, last commit for new', async () => {
         const json = JSON.stringify({});
         mockGitCalls(json, json);
-        await isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json');
-        expect(gitCommandSpy).toHaveBeenCalledWith(['show', 'Commit1~:actors/foo/actor.json']);
+        await isCosmeticOnlyJsonSchemaChange(range, 'actors/foo/actor.json');
+        expect(gitCommandSpy).toHaveBeenCalledWith(['show', 'Commit0:actors/foo/actor.json']);
         expect(gitCommandSpy).toHaveBeenCalledWith(['show', 'Commit3:actors/foo/actor.json']);
     });
 });

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

@@ -2,15 +2,16 @@ import type { MockInstance } from 'vitest';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
-    getBranchOnlyChangedFiles,
+    findCommitSha,
     getChangedFiles,
+    getChangedFilesBetween,
     getCommits,
+    getCommitsBetween,
     getCurrentBranch,
-    getReleaseChanges,
     getRepoName,
-    hasMergeFromTarget,
     normalizeRepoUrl,
     parseBaseCommit,
+    resolveCommitSha,
     resolveReleaseBaseCommit,
     resolveRepoUrl,
 } from '../../../bin/git.js';
@@ -123,9 +124,12 @@ describe('getChangedFiles', () => {
         expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', `${firstSha}~..${lastSha}`], {
-            operation: 'get the list of changed files between commits',
-        });
+        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 () => {
@@ -146,7 +150,7 @@ describe('getChangedFiles', () => {
         expect(changedFiles).toStrictEqual(['file1.txt', 'folder/file2.txt']);
 
         expect(gitCommandSpy).toHaveBeenCalledTimes(1);
-        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', `${onlySha}~..${onlySha}`], {
+        expect(gitCommandSpy).toHaveBeenCalledWith(['diff', '--name-only', '--no-renames', `${onlySha}~..${onlySha}`], {
             operation: 'get the list of changed files between commits',
         });
     });
@@ -167,124 +171,6 @@ describe('getChangedFiles', () => {
     });
 });
 
-describe('hasMergeFromTarget', () => {
-    const sourceBranch = 'feature-branch';
-    const targetBranch = 'main';
-    const mergeSha = 'f'.repeat(40);
-    const branchParentSha = 'b'.repeat(40);
-    const targetParentSha = 't'.repeat(40);
-    const differentMergeBase = '0'.repeat(40);
-
-    let gitCommandSpy: MockInstance;
-
-    beforeEach(() => {
-        gitCommandSpy = vi.spyOn(Utils, 'runGitCommand');
-    });
-
-    it('should return false when there are no merge commits on the branch', async () => {
-        gitCommandSpy.mockImplementation(async (args: string[]) => {
-            if (args.includes('--merges')) return '';
-            return '';
-        });
-
-        await expect(hasMergeFromTarget(sourceBranch, targetBranch)).resolves.toBe(false);
-        expect(gitCommandSpy).toHaveBeenCalledWith(
-            ['log', '--merges', '--pretty=format:%H', `${targetBranch}..${sourceBranch}`],
-            { operation: 'find merge commits on the source branch that are absent from the target branch' },
-        );
-    });
-
-    it('should return true when a merge commit has a parent reachable from targetBranch', async () => {
-        gitCommandSpy.mockImplementation(async (args: string[]) => {
-            if (args.includes('--merges')) return mergeSha;
-            if (args.includes('--pretty=format:%P')) return `${branchParentSha} ${targetParentSha}`;
-            if (args[0] === 'merge-base' && args[1] === branchParentSha) return differentMergeBase;
-            if (args[0] === 'merge-base' && args[1] === targetParentSha) return targetParentSha;
-            return '';
-        });
-
-        await expect(hasMergeFromTarget(sourceBranch, targetBranch)).resolves.toBe(true);
-        expect(gitCommandSpy).toHaveBeenCalledWith(['merge-base', targetParentSha, targetBranch], {
-            operation: 'check whether a merge parent is reachable from the target branch',
-        });
-    });
-
-    it('should return false when the merge commit parent is not reachable from targetBranch (unrelated branch merge)', async () => {
-        const unrelatedSha = 'e'.repeat(40);
-        gitCommandSpy.mockImplementation(async (args: string[]) => {
-            if (args.includes('--merges')) return mergeSha;
-            if (args.includes('--pretty=format:%P')) return `${branchParentSha} ${unrelatedSha}`;
-            // merge-base returns something other than the parent — not an ancestor
-            if (args[0] === 'merge-base') return differentMergeBase;
-            return '';
-        });
-
-        await expect(hasMergeFromTarget(sourceBranch, targetBranch)).resolves.toBe(false);
-    });
-
-    it('continues after merge-base reports unrelated histories', async () => {
-        gitCommandSpy.mockImplementation(async (args: string[]) => {
-            if (args.includes('--merges')) return mergeSha;
-            if (args.includes('--pretty=format:%P')) return `${branchParentSha} ${targetParentSha}`;
-            if (args[0] === 'merge-base' && args[1] === branchParentSha) {
-                throw new Utils.GitCommandError(args, Object.assign(new Error('no common ancestor'), { code: 1 }));
-            }
-            if (args[0] === 'merge-base' && args[1] === targetParentSha) return targetParentSha;
-            return '';
-        });
-
-        await expect(hasMergeFromTarget(sourceBranch, targetBranch)).resolves.toBe(true);
-    });
-
-    it('propagates unexpected Git failures', async () => {
-        gitCommandSpy.mockImplementation(
-            async (args: string[], options?: Parameters<typeof Utils.runGitCommand>[1]) => {
-                if (args.includes('--merges')) return mergeSha;
-                if (args.includes('--pretty=format:%P')) return `${branchParentSha} ${targetParentSha}`;
-                throw new Utils.GitCommandError(
-                    args,
-                    Object.assign(new Error('Git failed'), { code: 128 }),
-                    options?.operation,
-                );
-            },
-        );
-
-        await expect(hasMergeFromTarget(sourceBranch, targetBranch)).rejects.toThrow(
-            'Failed to check whether a merge parent is reachable from the target branch.\n' +
-                'Command: git "merge-base"',
-        );
-    });
-});
-
-describe('getBranchOnlyChangedFiles', () => {
-    const sourceBranch = 'feature-branch';
-    const targetBranch = 'main';
-
-    let gitCommandSpy: MockInstance;
-
-    beforeEach(() => {
-        gitCommandSpy = vi.spyOn(Utils, 'runGitCommand');
-    });
-
-    it('should return files touched by non-merge commits', async () => {
-        gitCommandSpy.mockResolvedValue('README.md\n\nactors/foo_bar/src/main.ts\n');
-
-        const result = await getBranchOnlyChangedFiles(sourceBranch, targetBranch);
-
-        expect(result).toStrictEqual(['README.md', 'actors/foo_bar/src/main.ts']);
-        expect(gitCommandSpy).toHaveBeenCalledWith(
-            ['log', '--no-merges', '--name-only', '--pretty=format:', `${targetBranch}..${sourceBranch}`],
-            { operation: 'list files changed by non-merge commits on the source branch' },
-        );
-    });
-
-    it('should return empty array when there are no non-merge commits', async () => {
-        gitCommandSpy.mockResolvedValue('');
-
-        await expect(getBranchOnlyChangedFiles(sourceBranch, targetBranch)).resolves.toStrictEqual([]);
-    });
-});
-
 const VALID_SHA = 'a'.repeat(40);
 const VALID_JSON = JSON.stringify({ sha: VALID_SHA, author: 'test', date: 'now', message: 'msg' });
 
@@ -320,7 +206,7 @@ describe('getCurrentBranch', () => {
         const gitCommandSpy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue('master');
         await expect(getCurrentBranch()).resolves.toBe('master');
         expect(gitCommandSpy).toHaveBeenCalledWith(['rev-parse', '--abbrev-ref', 'HEAD'], {
-            operation: 'determine the current branch for release',
+            operation: 'determine the checked-out branch',
         });
     });
 
@@ -474,71 +360,94 @@ describe('resolveReleaseBaseCommit', () => {
     it('should throw on an invalid SHA', async () => {
         await expect(resolveReleaseBaseCommit('not-a-sha')).rejects.toThrow('Invalid base commit SHA');
     });
+
+    it('checks ancestry against a custom head', async () => {
+        const gitCommandSpy = vi.spyOn(Utils, 'runGitCommand').mockImplementation(async (args: string[]) => {
+            if (args[0] === 'rev-parse') return baseSha;
+            if (args[0] === 'merge-base') return 'c'.repeat(40);
+            return '';
+        });
+        await expect(resolveReleaseBaseCommit(baseSha, 'origin/release')).rejects.toThrow(
+            'is not an ancestor of origin/release',
+        );
+        expect(gitCommandSpy).toHaveBeenCalledWith(['merge-base', baseSha, 'origin/release'], {
+            operation: 'check whether the release base commit is an ancestor of origin/release',
+        });
+    });
 });
 
-describe('getReleaseChanges', () => {
-    const baseSha = 'b'.repeat(40);
-    const headSha = 'd'.repeat(40);
-    const mergedBranchCommit = `${'1'.repeat(40)}»¦«Dev<dev@example.com>»¦«Date1»¦«feat: branch change`;
-    const mergeCommit = `${headSha}»¦«Dev<dev@example.com>»¦«Date2»¦«Merge pull request #1`;
+describe('getCommitsBetween', () => {
+    it('lists the commits after fromRef up to toRef, oldest first', async () => {
+        const older = `${'1'.repeat(40)}»¦«Dev<dev@example.com>»¦«Date1»¦«first`;
+        const newer = `${'2'.repeat(40)}»¦«Dev<dev@example.com>»¦«Date2»¦«second`;
+        const spy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue(`${newer}\n${older}`);
 
-    let gitRunSpy: MockInstance;
+        const commits = await getCommitsBetween('base-sha', 'head-sha');
 
-    beforeEach(() => {
-        gitRunSpy = vi.spyOn(Utils, 'runGitCommand').mockImplementation(async (args: string[]) => {
-            if (args[0] === 'rev-parse') return headSha;
-            if (args[0] === 'log') return `${mergeCommit}\n${mergedBranchCommit}`;
-            if (args.includes('--name-only')) return 'actors/foo/src/main.ts\nCHANGELOG.md';
-            if (args[0] === 'diff')
-                return 'diff --git a/CHANGELOG.md b/CHANGELOG.md\n--- a/CHANGELOG.md\n+++ b/CHANGELOG.md\n@@ -1 +1,2 @@\n+- Added foo\n # Changelog';
-            return '';
+        expect(commits.map((c) => c.message)).toStrictEqual(['first', 'second']);
+        expect(spy).toHaveBeenCalledWith(['log', '--pretty=format:%H»¦«%aN<%aE>»¦«%aD»¦«%s', 'base-sha..head-sha'], {
+            operation: 'list commits reachable from the source ref but absent from the target ref',
         });
     });
+});
+describe('empty commit ranges', () => {
+    // Real git on this repository's own history: HEAD..HEAD has no commits
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
 
-    it('should diff the range directly and return the commits oldest first', async () => {
-        const changes = await getReleaseChanges(baseSha);
+    it('getCommitsBetween returns no commits', async () => {
+        await expect(getCommitsBetween('HEAD', 'HEAD')).resolves.toStrictEqual([]);
+    });
 
-        expect(changes).toStrictEqual({
-            commits: [
-                { sha: '1'.repeat(40), author: 'Dev<dev@example.com>', date: 'Date1', message: 'feat: branch change' },
-                { sha: headSha, author: 'Dev<dev@example.com>', date: 'Date2', message: 'Merge pull request #1' },
-            ],
-            changedFiles: ['actors/foo/src/main.ts', 'CHANGELOG.md'],
-            changelog: '- Added foo',
-        });
-        // Not from the parent of the oldest commit, which may predate the base commit for merge commits
-        expect(gitRunSpy).toHaveBeenCalledWith(['rev-parse', 'HEAD'], {
-            operation: 'identify the current release commit',
-        });
-        expect(gitRunSpy).toHaveBeenCalledWith(['diff', '--name-only', baseSha, 'HEAD'], {
-            operation: 'list files changed since the last release',
-        });
-        expect(gitRunSpy).toHaveBeenCalledWith(
-            ['log', '--pretty=format:%H»¦«%aN<%aE>»¦«%aD»¦«%s', `${baseSha}..HEAD`],
-            { operation: 'list commits reachable from the source ref but absent from the target ref' },
+    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.',
         );
-        expect(gitRunSpy).toHaveBeenCalledWith(['diff', baseSha, 'HEAD', '--', 'CHANGELOG.md'], {
-            operation: 'read changelog changes since the last release',
-        });
     });
+});
+
+describe('getChangedFilesBetween', () => {
+    it('diffs the two endpoints directly', async () => {
+        const spy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue('src/main.ts\nCHANGELOG.md');
 
-    it('should return null when HEAD is the base commit', async () => {
-        await expect(getReleaseChanges(headSha)).resolves.toBeNull();
-        expect(gitRunSpy).toHaveBeenCalledOnce();
-        expect(gitRunSpy).toHaveBeenCalledWith(['rev-parse', 'HEAD'], {
-            operation: 'identify the current release commit',
+        await expect(getChangedFilesBetween('base-sha', 'head-sha')).resolves.toStrictEqual([
+            'src/main.ts',
+            'CHANGELOG.md',
+        ]);
+        expect(spy).toHaveBeenCalledWith(['diff', '--name-only', '--no-renames', 'base-sha..head-sha'], {
+            operation: 'get the list of changed files between commits',
         });
     });
+});
 
-    it('skips the changelog diff when CHANGELOG.md did not change', async () => {
-        gitRunSpy.mockImplementation(async (args: string[]) => {
-            if (args[0] === 'rev-parse') return headSha;
-            if (args[0] === 'log') return `${mergeCommit}\n${mergedBranchCommit}`;
-            if (args.includes('--name-only')) return 'actors/foo/src/main.ts';
-            return '';
+describe('resolveCommitSha', () => {
+    it('resolves a ref to the commit it points to', async () => {
+        const sha = 'a'.repeat(40);
+        const spy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue(sha);
+        await expect(resolveCommitSha('origin/feature')).resolves.toBe(sha);
+        expect(spy).toHaveBeenCalledWith(['rev-parse', '--verify', 'origin/feature^{commit}'], {
+            operation: 'resolve origin/feature to a commit',
         });
+    });
+});
+
+describe('findCommitSha', () => {
+    // Real git on this repository's own history, since what matters is how git answers
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('resolves a ref in the local history to its commit', async () => {
+        await expect(findCommitSha('HEAD')).resolves.toMatch(/^[0-9a-f]{40}$/);
+    });
+
+    it('returns undefined for a commit missing from the local history', async () => {
+        await expect(findCommitSha('d'.repeat(40))).resolves.toBeUndefined();
+    });
 
-        await expect(getReleaseChanges(baseSha)).resolves.toMatchObject({ changelog: null });
-        expect(gitRunSpy).not.toHaveBeenCalledWith(['diff', baseSha, 'HEAD', '--', 'CHANGELOG.md']);
+    it('rethrows other git failures', async () => {
+        vi.spyOn(Utils, 'runGitCommand').mockRejectedValue(new Error('not a git repository'));
+        await expect(findCommitSha('HEAD')).rejects.toThrow('not a git repository');
     });
 });

package/test/unit/bin/slack.test.ts

@@ -0,0 +1,84 @@
+import { WebClient } from '@slack/web-api';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { notifyToSlack } from '../../../bin/slack.js';
+
+vi.mock('@slack/web-api', () => ({ WebClient: vi.fn() }));
+
+const TOKEN_ENV_VAR = 'SLACK_TOKEN_RELEASES_BOT';
+const postMessage = vi.fn();
+const authTest = vi.fn();
+
+const notify = async (overrides: Partial<Parameters<typeof notifyToSlack>[0]> = {}) =>
+    notifyToSlack({
+        repoUrl: 'git@github.com:owner/repo',
+        changedFiles: ['src/main.ts'],
+        changelog: '- Fixed a bug',
+        commits: [{ sha: '1', author: 'Test<test@example.com>', date: '', message: 'fix: bug' }],
+        dryRun: true,
+        releaseSlackChannel: '#releases',
+        reportSlackChannel: '#notif',
+        ...overrides,
+    });
+
+describe('notifyToSlack', () => {
+    beforeEach(() => {
+        vi.stubEnv(TOKEN_ENV_VAR, 'token');
+        vi.mocked(WebClient).mockImplementation(function () {
+            return { chat: { postMessage }, auth: { test: authTest } };
+        } as never);
+    });
+
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.clearAllMocks();
+    });
+
+    it('should verify the token but post nothing in a dry run', async () => {
+        await notify();
+        expect(authTest).toHaveBeenCalledTimes(1);
+        expect(postMessage).not.toHaveBeenCalled();
+    });
+
+    it('should still require the token in a dry run', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await expect(notify()).rejects.toThrow(`${TOKEN_ENV_VAR} not defined`);
+    });
+
+    it('should fail a dry run when Slack rejects the token', async () => {
+        authTest.mockRejectedValueOnce(new Error('An API error occurred: invalid_auth'));
+        await expect(notify()).rejects.toThrow(`${TOKEN_ENV_VAR} was rejected by Slack`);
+    });
+
+    it('should not need a token when no channel is passed', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await notify({ dryRun: false, releaseSlackChannel: undefined, reportSlackChannel: undefined });
+        expect(WebClient).not.toHaveBeenCalled();
+    });
+
+    it('should post to both channels outside of a dry run', async () => {
+        await notify({ dryRun: false });
+        expect(authTest).not.toHaveBeenCalled();
+        expect(postMessage).toHaveBeenCalledTimes(2);
+    });
+
+    it('should announce nothing, and need no token, when there are no new commits', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await notify({ commits: [], dryRun: false });
+        expect(WebClient).not.toHaveBeenCalled();
+    });
+
+    it('should announce the release by the author of the newest commit, named after the repository', async () => {
+        const commit = (author: string, message: string) => ({ sha: '1', author, date: '', message });
+        await notify({
+            commits: [commit('Old<old@example.com>', 'fix: older'), commit('New<new@example.com>', 'feat: newer')],
+            repoUrl: 'git@github.com:owner/my-repo',
+            dryRun: false,
+            releaseSlackChannel: undefined,
+        });
+        expect(postMessage).toHaveBeenCalledWith({
+            channel: '#notif',
+            text: expect.stringContaining('*my-repo* – New release (by New)'),
+        });
+    });
+});