apify-test-tools 0.10.2-beta.2 → 0.10.2-beta.20

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

@@ -1,326 +1,24 @@
-import type { MockInstance } from 'vitest';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
-    getBranchOnlyChangedFiles,
-    getChangedFiles,
-    getCommits,
+    findCommitSha,
+    getChangedFilesBetween,
+    getCommitsBetween,
     getCurrentBranch,
-    getReleaseChanges,
     getRepoName,
-    hasMergeFromTarget,
     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', `${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', `${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([]);
-    });
-});
-
-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' });
-
-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');
         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',
         });
     });
 
@@ -393,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',
@@ -462,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`,
         );
     });
@@ -474,71 +172,88 @@ 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' },
-        );
-        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');
+
+        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('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',
+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',
         });
     });
+});
 
-    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('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');
     });
 });