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

package/test/unit/bin/affected-actors.test.ts

@@ -1,7 +1,7 @@
 import type { MockInstance } from 'vitest';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { getAffectedActors, toAffectedActorsDocument } from '../../../bin/affected-actors.js';
+import { getAffectedActors } from '../../../bin/affected-actors.js';
 import * as DiffChanges from '../../../bin/diff-changes.js';
 import * as Git from '../../../bin/git.js';
 import type { ActorConfig, Commit } from '../../../bin/types.js';
@@ -40,84 +40,113 @@ describe('getAffectedActors', () => {
     });
 
     describe('with --base', () => {
-        let getCommitsSpy: MockInstance;
+        const mergeBaseSha = 'b'.repeat(40);
+        let commitsBetweenSpy: MockInstance;
 
         beforeEach(() => {
-            vi.spyOn(Git, 'hasMergeFromTarget').mockResolvedValue(false);
-            getCommitsSpy = vi.spyOn(Git, 'getCommits').mockResolvedValue(commits);
+            vi.spyOn(Git, 'getMergeBase').mockResolvedValue(mergeBaseSha);
+            commitsBetweenSpy = vi.spyOn(Git, 'getCommitsBetween').mockResolvedValue(commits);
         });
 
-        it('inspects the branch commits after --since', async () => {
-            const result = await getAffectedActors({
-                base: 'origin/master',
-                since: sinceSha,
-                ...selection,
-            });
+        it("inspects the branch's own changes, from where it forked from or last merged --base", async () => {
+            const findCommitSpy = vi.spyOn(Git, 'findCommitSha');
+
+            const result = await getAffectedActors({ base: 'origin/master', ...selection });
 
             expect(result).toStrictEqual({
-                headSha,
+                version: 1,
+                head: headSha,
                 commits,
                 changedFiles,
                 changelog: '- Added foo',
-                functionallyChangedActors: [actorA],
-                cosmeticallyChangedActors: [actorB],
-            });
-            expect(getCommitsSpy).toHaveBeenCalledWith({
-                sourceBranch: 'HEAD',
-                targetBranch: 'origin/master',
-                baseCommit: sinceSha,
+                // Only the names, the config file stays the source of truth for the rest
+                functionallyChangedActors: [{ actorFullName: 'owner/a' }],
+                cosmeticallyChangedActors: [{ actorFullName: 'owner/b' }],
             });
-            // From the parent of the oldest commit to the newest one, for the files and the changelog alike
-            expect(Git.getChangedFilesBetween).toHaveBeenCalledWith(`${commits[0].sha}~`, commits[1].sha);
-            expect(Git.getChangelogAdditions).toHaveBeenCalledWith(`${commits[0].sha}~`, commits[1].sha, changedFiles);
+            expect(Git.getMergeBase).toHaveBeenCalledWith('origin/master', 'HEAD');
+            expect(Git.getChangedFilesBetween).toHaveBeenCalledWith(mergeBaseSha, headSha);
+            expect(Git.getChangelogAdditions).toHaveBeenCalledWith(mergeBaseSha, headSha, changedFiles);
+            expect(commitsBetweenSpy).toHaveBeenCalledWith(mergeBaseSha, headSha);
             expect(changedActorsSpy).toHaveBeenCalledWith({
                 filepathsChanged: changedFiles,
                 actorConfigs: [actorA, actorB],
-                commits,
+                range: { fromRef: mergeBaseSha, toRef: headSha },
             });
+            expect(findCommitSpy).not.toHaveBeenCalled();
         });
 
-        describe('when the branch merged --base in', () => {
+        describe('and --since', () => {
+            const sinceFiles = ['README.md'];
+
             beforeEach(() => {
-                vi.spyOn(Git, 'hasMergeFromTarget').mockResolvedValue(true);
-                vi.spyOn(Git, 'getBranchOnlyChangedFiles').mockResolvedValue(['own-file']);
+                vi.spyOn(Git, 'findCommitSha').mockResolvedValue(sinceSha);
+                vi.spyOn(Git, 'getChangedFilesBetween').mockImplementation(async (fromRef) =>
+                    fromRef === sinceSha ? sinceFiles : changedFiles,
+                );
             });
 
-            const getWithOwnChanges = async (own: DiffChanges.ChangedActors) => {
-                changedActorsSpy.mockImplementation(async ({ filepathsChanged }) =>
-                    filepathsChanged[0] === 'own-file' ? own : { functional: [actorA], cosmetic: [actorB] },
+            const getNarrowed = async (
+                branch: DiffChanges.ChangedActors,
+                sinceValidated: DiffChanges.ChangedActors,
+            ) => {
+                changedActorsSpy.mockImplementation(async ({ range }) =>
+                    range.fromRef === sinceSha ? sinceValidated : branch,
                 );
-                return getAffectedActors({ base: 'master', since: sinceSha, ...selection });
+                const result = await getAffectedActors({ base: 'origin/master', since: sinceSha, ...selection });
+                return {
+                    functional: result.functionallyChangedActors.map(({ actorFullName }) => actorFullName),
+                    cosmetic: result.cosmeticallyChangedActors.map(({ actorFullName }) => actorFullName),
+                };
             };
 
-            it("classifies the branch's own files against the whole branch, ignoring --since", async () => {
-                await getWithOwnChanges({ functional: [actorA], cosmetic: [] });
+            it('classifies the changes since --since separately', async () => {
+                await getNarrowed({ functional: [actorA], cosmetic: [] }, { functional: [actorA], cosmetic: [] });
                 expect(changedActorsSpy).toHaveBeenCalledWith({
-                    filepathsChanged: ['own-file'],
+                    filepathsChanged: sinceFiles,
                     actorConfigs: [actorA, actorB],
-                    commits,
+                    range: { fromRef: sinceSha, toRef: headSha },
                 });
-                expect(getCommitsSpy).toHaveBeenCalledWith({ sourceBranch: 'HEAD', targetBranch: 'master' });
             });
 
-            it('reports everything when the branch has functional changes of its own', async () => {
-                const result = await getWithOwnChanges({ functional: [actorA], cosmetic: [] });
-                expect(result.functionallyChangedActors).toStrictEqual([actorA]);
-                expect(result.cosmeticallyChangedActors).toStrictEqual([actorB]);
+            it('still describes the whole branch', async () => {
+                const result = await getAffectedActors({ base: 'origin/master', since: sinceSha, ...selection });
+                expect(result.commits).toStrictEqual(commits);
+                expect(result.changedFiles).toStrictEqual(changedFiles);
+            });
+
+            it('retests an Actor whose validated change meets a new functional change', async () => {
+                await expect(
+                    getNarrowed({ functional: [actorA], cosmetic: [] }, { functional: [actorA], cosmetic: [] }),
+                ).resolves.toStrictEqual({ functional: ['owner/a'], cosmetic: [] });
             });
 
-            it('reports only cosmetic Actors when its own changes are only cosmetic', async () => {
-                const result = await getWithOwnChanges({ functional: [], cosmetic: [actorB] });
-                expect(result.functionallyChangedActors).toStrictEqual([]);
-                expect(result.cosmeticallyChangedActors).toStrictEqual([actorB]);
+            it('leaves out Actors that only the branch changed before --since or only --base changed', async () => {
+                await expect(
+                    getNarrowed({ functional: [actorA], cosmetic: [] }, { functional: [actorB], cosmetic: [] }),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: [] });
             });
 
-            it('reports nothing when it has no changes of its own', async () => {
-                const result = await getWithOwnChanges({ functional: [], cosmetic: [] });
-                expect(result.functionallyChangedActors).toStrictEqual([]);
-                expect(result.cosmeticallyChangedActors).toStrictEqual([]);
-                // The range is still reported
-                expect(result.commits).toStrictEqual(commits);
+            it('takes the less impactful change when the two disagree', async () => {
+                // A validated functional change, then only cosmetic changes (e.g. a README merged in from base)
+                await expect(
+                    getNarrowed({ functional: [actorA], cosmetic: [] }, { functional: [], cosmetic: [actorA] }),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: ['owner/a'] });
+                // A functional change merged in from base, while the branch only changes the README
+                await expect(
+                    getNarrowed({ functional: [], cosmetic: [actorA] }, { functional: [actorA], cosmetic: [] }),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: ['owner/a'] });
+            });
+
+            it.each([
+                ['is HEAD (a rerun)', headSha],
+                ['is not in the local history', undefined],
+            ])('checks the whole branch when --since %s', async (_, found) => {
+                vi.spyOn(Git, 'findCommitSha').mockResolvedValue(found);
+                const result = await getAffectedActors({ base: 'origin/master', since: sinceSha, ...selection });
+                expect(result.functionallyChangedActors).toStrictEqual([{ actorFullName: 'owner/a' }]);
+                // With no usable validated commit, the "since" diff falls back to the same range as the
+                // base diff, so getChangedActors runs twice for identical ranges instead of once.
+                expect(changedActorsSpy).toHaveBeenCalledTimes(2);
             });
         });
     });
@@ -131,54 +160,23 @@ describe('getAffectedActors', () => {
             commitsBetweenSpy = vi.spyOn(Git, 'getCommitsBetween').mockResolvedValue(commits);
         });
 
-        it('inspects everything after --since up to --head', async () => {
+        it('inspects everything after --since up to HEAD', async () => {
             const result = await getAffectedActors({ since: 'HEAD~2', ...selection });
 
             expect(result).toStrictEqual({
-                headSha,
+                version: 1,
+                head: headSha,
                 commits,
                 changedFiles,
                 changelog: '- Added foo',
-                functionallyChangedActors: [actorA],
-                cosmeticallyChangedActors: [actorB],
+                // Only the names, the config file stays the source of truth for the rest
+                functionallyChangedActors: [{ actorFullName: 'owner/a' }],
+                cosmeticallyChangedActors: [{ actorFullName: 'owner/b' }],
             });
             expect(resolveBaseSpy).toHaveBeenCalledWith('HEAD~2');
             expect(commitsBetweenSpy).toHaveBeenCalledWith(sinceSha, headSha);
             expect(Git.getChangedFilesBetween).toHaveBeenCalledWith(sinceSha, headSha);
             expect(Git.getChangelogAdditions).toHaveBeenCalledWith(sinceSha, headSha, changedFiles);
         });
-
-        it('has no commits when head is the --since commit', async () => {
-            resolveBaseSpy.mockResolvedValue(headSha);
-
-            const result = await getAffectedActors({ since: headSha, ...selection });
-
-            expect(result.commits).toStrictEqual([]);
-            // Empty `git log x..x` output doesn't parse as a commit, so it's never run
-            expect(commitsBetweenSpy).not.toHaveBeenCalled();
-        });
-    });
-});
-
-describe('toAffectedActorsDocument', () => {
-    it('keeps only the Actor names, the config file stays the source of truth for the rest', () => {
-        expect(
-            toAffectedActorsDocument({
-                headSha,
-                commits,
-                changedFiles: ['src/main.ts'],
-                changelog: null,
-                functionallyChangedActors: [actorA],
-                cosmeticallyChangedActors: [actorB],
-            }),
-        ).toStrictEqual({
-            version: 1,
-            head: headSha,
-            commits,
-            changedFiles: ['src/main.ts'],
-            changelog: null,
-            functionallyChangedActors: [{ actorFullName: 'owner/a' }],
-            cosmeticallyChangedActors: [{ actorFullName: 'owner/b' }],
-        });
     });
 });

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

@@ -1,15 +1,12 @@
-import { execFileSync, spawnSync } from 'node:child_process';
-import { chmod, mkdtemp, rm } from 'node:fs/promises';
-import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import process from 'node:process';
-import { fileURLToPath } from 'node:url';
 
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
-const projectRoot = fileURLToPath(new URL('../../../', import.meta.url));
-const compilerPath = fileURLToPath(new URL('../../../node_modules/typescript/bin/tsc', import.meta.url));
+import { compileCli } from './compiled-cli.js';
+
 let cliPath: string;
-let buildDir: string | undefined;
+let cleanup: (() => Promise<void>) | undefined;
 
 const run = (command: string[], input: string, env: NodeJS.ProcessEnv = process.env) =>
     spawnSync(cliPath, command, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'pipe'], env });
@@ -17,14 +14,11 @@ const runBuild = (input: string, args: string[] = ['--version-number', '0.99'])
 
 describe('build and notify-release CLI', () => {
     beforeAll(async () => {
-        buildDir = await mkdtemp(path.join(projectRoot, '.cli-test-'));
-        execFileSync(process.execPath, [compilerPath, '--outDir', buildDir], { cwd: projectRoot });
-        cliPath = path.join(buildDir, 'bin/main.js');
-        await chmod(cliPath, 0o755);
+        ({ cliPath, cleanup } = await compileCli());
     });
 
     afterAll(async () => {
-        if (buildDir) await rm(buildDir, { recursive: true, force: true });
+        await cleanup?.();
     });
 
     it('builds nothing for an empty list and prints an empty build list', () => {

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

@@ -0,0 +1,17 @@
+import { execFileSync } from 'node:child_process';
+import { chmod, mkdtemp, rm } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const projectRoot = fileURLToPath(new URL('../../../', import.meta.url));
+const compilerPath = fileURLToPath(new URL('../../../node_modules/typescript/bin/tsc', import.meta.url));
+
+/** Compiles the CLI from the sources into a temporary directory, so tests run it the way users do. */
+export const compileCli = async () => {
+    const buildDir = await mkdtemp(path.join(projectRoot, '.cli-test-'));
+    execFileSync(process.execPath, [compilerPath, '--outDir', buildDir], { cwd: projectRoot });
+    const cliPath = path.join(buildDir, 'bin/main.js');
+    await chmod(cliPath, 0o755);
+    return { cliPath, cleanup: async () => rm(buildDir, { recursive: true, force: true }) };
+};