apify-test-tools 0.10.2-beta.3 → 0.10.2-beta.5

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

@@ -2,17 +2,15 @@ import type { MockInstance } from 'vitest';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
-    getBranchOnlyChangedFiles,
+    findCommitSha,
     getChangedFiles,
     getChangedFilesBetween,
     getCommits,
     getCommitsBetween,
     getCurrentBranch,
     getRepoName,
-    hasMergeFromTarget,
     normalizeRepoUrl,
     parseBaseCommit,
-    resolveBranchName,
     resolveCommitSha,
     resolveReleaseBaseCommit,
     resolveRepoUrl,
@@ -170,124 +168,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' });
 
@@ -323,7 +203,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',
         });
     });
 
@@ -507,6 +387,22 @@ describe('getCommitsBetween', () => {
         });
     });
 });
+describe('empty commit ranges', () => {
+    // Real git on this repository's own history: HEAD..HEAD has no commits
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    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', () => {
     it('diffs the two endpoints directly', async () => {
@@ -533,15 +429,22 @@ describe('resolveCommitSha', () => {
     });
 });
 
-describe('resolveBranchName', () => {
-    it.each([
-        ['a local branch', 'refs/heads/feature/foo', 'feature/foo'],
-        ['a remote branch, dropping the remote', 'refs/remotes/origin/feature/foo', 'feature/foo'],
-        ['a tag', 'refs/tags/v1.0.0', null],
-        ['a detached HEAD', 'HEAD', null],
-        ['a SHA', '', null],
-    ])('handles %s', async (_, fullName, expected) => {
-        vi.spyOn(Utils, 'runGitCommand').mockResolvedValue(fullName);
-        await expect(resolveBranchName('some-ref')).resolves.toBe(expected);
+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();
+    });
+
+    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

@@ -11,11 +11,10 @@ const authTest = vi.fn();
 
 const notify = async (overrides: Partial<Parameters<typeof notifyToSlack>[0]> = {}) =>
     notifyToSlack({
-        repository: 'owner/repo',
+        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' }],
-        author: 'Test<test@example.com>',
         dryRun: true,
         releaseSlackChannel: '#releases',
         reportSlackChannel: '#notif',
@@ -62,4 +61,24 @@ describe('notifyToSlack', () => {
         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)'),
+        });
+    });
 });

package/test/unit/bin/stdin-input.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseBuildInput, parseReleaseChanges } from '../../../bin/stdin-input.js';
+
+describe('parseBuildInput', () => {
+    it('reads the Actors', () => {
+        expect(parseBuildInput('{"actors":[{"actorFullName":"owner/a"}]}')).toStrictEqual({
+            actors: [{ actorFullName: 'owner/a' }],
+        });
+    });
+
+    it('ignores the other fields, so whole get-affected-actors fields can be passed along', () => {
+        const input = { head: 'f'.repeat(40), ref: 'feature', actors: [{ actorFullName: 'owner/a', extra: 1 }] };
+        expect(parseBuildInput(JSON.stringify(input))).toStrictEqual({ actors: [{ actorFullName: 'owner/a' }] });
+    });
+
+    it('accepts an empty list, which builds nothing', () => {
+        expect(parseBuildInput('{"actors":[]}')).toStrictEqual({ actors: [] });
+    });
+
+    it('rejects empty input, which is what a failed command earlier in a pipe leaves behind', () => {
+        expect(() => parseBuildInput('  \n')).toThrow('Expected the Actors to build as JSON on stdin, got nothing');
+    });
+
+    it('rejects input that is not JSON', () => {
+        expect(() => parseBuildInput('owner/a')).toThrow('not valid JSON');
+    });
+
+    it('rejects JSON that is not a list of Actors, e.g. a whole get-affected-actors document', () => {
+        expect(() => parseBuildInput('{"functionallyChangedActors":[{"actorFullName":"owner/a"}]}')).toThrow(
+            'is not the Actors to build',
+        );
+    });
+});
+
+describe('parseReleaseChanges', () => {
+    const commit = { sha: '1'.repeat(40), author: 'Dev<dev@example.com>', date: 'Date', message: 'feat: foo' };
+
+    it('reads what changed from a get-affected-actors document, ignoring the rest', () => {
+        const document = {
+            version: 1,
+            ref: 'master',
+            head: '1'.repeat(40),
+            commits: [commit],
+            changedFiles: ['src/main.ts'],
+            changelog: '- Added foo',
+            functionallyChangedActors: [{ actorFullName: 'owner/a' }],
+            cosmeticallyChangedActors: [],
+        };
+        expect(parseReleaseChanges(JSON.stringify(document))).toStrictEqual({
+            commits: [commit],
+            changedFiles: ['src/main.ts'],
+            changelog: '- Added foo',
+        });
+    });
+
+    it('rejects empty input and input that is not a get-affected-actors document', () => {
+        expect(() => parseReleaseChanges('')).toThrow('got nothing');
+        expect(() => parseReleaseChanges('{"actors":[]}')).toThrow('not the output of get-affected-actors');
+    });
+});

package/test/unit/should-built-and-test.test.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { afterAll, describe, expect, test } from 'vitest';
 
 import { getChangedActors } from '../../bin/diff-changes.js';
-import type { ActorConfig, Commit } from '../../bin/types.js';
+import type { ActorConfig } from '../../bin/types.js';
 import { ExistingDir, ExistingFile, RelativeDir, RelativeFile } from '../../bin/utils/path/repo-relative.js';
 
 const originalCwd = process.cwd();
@@ -72,10 +72,7 @@ describe('Should build and test parser', () => {
         ),
     ];
 
-    const commits: Commit[] = [
-        { sha: 'Commit1', author: '', date: '', message: '' },
-        { sha: 'Commit3', author: '', date: '', message: '' },
-    ];
+    const range = { fromRef: 'Commit0', toRef: 'Commit3' };
 
     test('Ignores dev-only readme', async () => {
         const FILES = ['README.md', 'code/README.md', 'shared/README.md'];
@@ -84,7 +81,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([]);
@@ -97,7 +94,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([]);
@@ -110,7 +107,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -123,7 +120,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
         expect(actorsChangedNotLatest).toEqual([]);
 
@@ -131,7 +128,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
         expect(actorsChangedLatest).toEqual(ACTOR_CONFIGS);
     });
@@ -143,7 +140,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -156,7 +153,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -172,7 +169,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0], ACTOR_CONFIGS[2]]);
@@ -185,7 +182,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -202,7 +199,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS);
@@ -218,7 +215,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([]);
@@ -231,7 +228,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -244,7 +241,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -257,7 +254,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -273,7 +270,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -286,7 +283,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[2]]);
@@ -345,7 +342,7 @@ describe('Should build and test parser', () => {
             actorConfigs: ACTOR_CONFIGS_GOOGLE_MAPS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS_GOOGLE_MAPS.slice(0, 8));