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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.10.2-beta.2",
+  "version": "0.10.2-beta.4",
   "type": "module",
   "description": "TBD",
   "repository": {

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

@@ -34,11 +34,18 @@ const writeRepoFile = async (file: string, content: string) => {
     await writeFile(path.join(repoDir, file), content);
 };
 
-const runCli = (...args: string[]) => {
-    const result = spawnSync(process.execPath, [bundlePath, ...args], { cwd: repoDir, env: cliEnv, encoding: 'utf8' });
+const runCliWithInput = (input: string, ...args: string[]) => {
+    const result = spawnSync(process.execPath, [bundlePath, ...args], {
+        cwd: repoDir,
+        env: cliEnv,
+        encoding: 'utf8',
+        input,
+    });
     return { status: result.status, stdout: result.stdout, stderr: result.stderr };
 };
 
+const runCli = (...args: string[]) => runCliWithInput('', ...args);
+
 const gitRange = ['--source-branch', 'feature', '--target-branch', 'main'];
 
 describe('CLI bundle', () => {
@@ -91,7 +98,9 @@ describe('CLI bundle', () => {
             'get-affected-actors',
             'report-tests',
             'build',
+            'build-for-test',
             'release',
+            'notify-release',
             'build-from-local',
             'delete-old-builds',
         ]) {
@@ -130,19 +139,63 @@ describe('CLI bundle', () => {
     });
 
     it('get-affected-actors returns only the Actor whose files changed', () => {
-        const { status, stdout, stderr } = runCli('get-affected-actors', ...gitRange);
+        // `feature` is checked out, and the range always ends at HEAD
+        const { status, stdout, stderr } = runCli('get-affected-actors', '--base', 'main');
         expect(status, stderr).toBe(0);
-        expect(JSON.parse(stdout)).toMatchObject([{ actorFullName: 'tester/foo', folder: 'actors/foo' }]);
+        expect(JSON.parse(stdout)).toMatchObject({
+            version: 1,
+            head: headSha,
+            functionallyChangedActors: [{ actorFullName: 'tester/foo' }],
+            // The root README isn't in tester/bar's folder, so it doesn't count for it
+            cosmeticallyChangedActors: [],
+        });
     });
 
     it('build --dry-run with nothing to build needs no token', () => {
-        const { status, stdout, stderr } = runCli('build', ...gitRange, '--actors', 'tester/bar', '--dry-run');
+        const { status, stdout, stderr } = runCliWithInput(
+            JSON.stringify({ actors: [] }),
+            'build',
+            '--version-number',
+            '0.99',
+            '--dry-run',
+        );
         expect(status, stderr).toBe(0);
         expect(JSON.parse(stdout)).toEqual({ dryRun: true, builds: [] });
     });
 
     it('build --dry-run fails cleanly when the Actor token is missing', () => {
-        const { status, stderr } = runCli('build', ...gitRange, '--dry-run');
+        const { status, stderr } = runCliWithInput(
+            JSON.stringify({ actors: [{ actorFullName: 'tester/foo' }] }),
+            'build',
+            '--version-number',
+            '0.99',
+            '--dry-run',
+        );
+        expect(status).toBe(1);
+        expect(stderr).toContain('Env var FOO_TOKEN is not set (needed for actor "tester/foo")');
+    });
+
+    it('build fails on empty input instead of building nothing', () => {
+        const { status, stderr } = runCli('build', '--version-number', '0.99', '--dry-run');
+        expect(status).toBe(1);
+        expect(stderr).toContain('got nothing');
+    });
+
+    it('build-for-test --dry-run with nothing to build needs no token', () => {
+        const { status, stdout, stderr } = runCli(
+            'build-for-test',
+            '--target-branch',
+            'main',
+            '--actors',
+            'tester/bar',
+            '--dry-run',
+        );
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout)).toEqual({ dryRun: true, builds: [] });
+    });
+
+    it('build-for-test --dry-run fails cleanly when the Actor token is missing', () => {
+        const { status, stderr } = runCli('build-for-test', '--target-branch', 'main', '--dry-run');
         expect(status).toBe(1);
         expect(stderr).toContain('Env var FOO_TOKEN is not set (needed for actor "tester/foo")');
     });

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

@@ -57,17 +57,20 @@ const writeRepoFile = async (file: string, content: string) => {
 // retries an unreachable API for minutes, so a hang is killed here and fails with a clear error.
 const PROCESS_TIMEOUT_MS = 8 * 60_000;
 
-const runCli = (...args: string[]) => {
+const runCliWithInput = (input: string, ...args: string[]) => {
     const result = spawnSync(process.execPath, [bundlePath, ...args], {
         cwd: repoDir,
         env: cliEnv,
         encoding: 'utf8',
         timeout: PROCESS_TIMEOUT_MS,
+        input,
     });
     const error = result.error ? `\n${result.error.message}` : '';
     return { status: result.status, stdout: result.stdout, stderr: result.stderr + error };
 };
 
+const runCli = (...args: string[]) => runCliWithInput('', ...args);
+
 interface ActorBuild {
     buildId: string;
     actorRawId: string;
@@ -117,11 +120,28 @@ describe.runIf(token)('CLI bundle against real Actors', { timeout: 2 * 60_000 },
         if (repoDir) await rm(repoDir, { recursive: true, force: true });
     });
 
-    it('build --dry-run plans a test build of the changed Actor only', () => {
-        const { status, stdout, stderr } = runCli(
+    it('build --dry-run plans a test build of the Actors it is given', () => {
+        const { status, stdout, stderr } = runCliWithInput(
+            JSON.stringify({ actors: [{ actorFullName: ACTORS[0] }] }),
             'build',
-            '--source-branch',
-            'feature',
+            '--version-number',
+            '0.99',
+            '--repo-url',
+            REPO_URL,
+            '--dry-run',
+        );
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout)).toEqual({
+            dryRun: true,
+            builds: [
+                { actorFullName: ACTORS[0], versionNumber: '0.99', gitRepoUrl: `${REPO_URL}#feature:actors/dummy-1` },
+            ],
+        });
+    });
+
+    it('build-for-test --dry-run plans a test build of the changed Actor only', () => {
+        const { status, stdout, stderr } = runCli(
+            'build-for-test',
             '--target-branch',
             'main',
             '--repo-url',
@@ -132,12 +152,7 @@ describe.runIf(token)('CLI bundle against real Actors', { timeout: 2 * 60_000 },
         expect(JSON.parse(stdout)).toEqual({
             dryRun: true,
             builds: [
-                {
-                    actorFullName: ACTORS[0],
-                    versionNumber: '0.99',
-                    gitRepoUrl: `${REPO_URL}#feature:actors/dummy-1`,
-                    useDockerCache: false,
-                },
+                { actorFullName: ACTORS[0], versionNumber: '0.99', gitRepoUrl: `${REPO_URL}#feature:actors/dummy-1` },
             ],
         });
     });

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

@@ -0,0 +1,184 @@
+import type { MockInstance } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getAffectedActors, toAffectedActorsDocument } 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';
+import * as LoadConfig from '../../../bin/utils/config/load-config.js';
+
+// Everything that reads the configs is mocked, so only the identity and name of an Actor matter here
+const actorA = { actorFullName: 'owner/a' } as ActorConfig;
+const actorB = { actorFullName: 'owner/b' } as ActorConfig;
+
+const headSha = 'f'.repeat(40);
+const sinceSha = '5'.repeat(40);
+const commit = (sha: string): Commit => ({ sha, author: 'Dev<dev@example.com>', date: 'Date', message: 'msg' });
+const commits = [commit('1'.repeat(40)), commit('2'.repeat(40))];
+const changedFiles = ['src/main.ts', 'CHANGELOG.md'];
+
+const selection = { actors: [], ignore: [] };
+
+describe('getAffectedActors', () => {
+    let changedActorsSpy: MockInstance;
+
+    beforeEach(() => {
+        vi.spyOn(LoadConfig, 'readConfigFile').mockResolvedValue([actorA, actorB]);
+        changedActorsSpy = vi
+            .spyOn(DiffChanges, 'getChangedActors')
+            .mockResolvedValue({ functional: [actorA], cosmetic: [actorB] });
+        vi.spyOn(Git, 'resolveCommitSha').mockResolvedValue(headSha);
+        vi.spyOn(Git, 'getChangedFilesBetween').mockResolvedValue(changedFiles);
+        vi.spyOn(Git, 'getChangelogAdditions').mockResolvedValue('- Added foo');
+    });
+
+    it('requires --base or --since', async () => {
+        const options = { ...selection };
+        await expect(getAffectedActors(options)).rejects.toThrow('Pass --base, --since, or both');
+        // An empty --since (e.g. from an empty cache file) counts as not passed
+        await expect(getAffectedActors({ ...options, since: '' })).rejects.toThrow('Pass --base, --since, or both');
+    });
+
+    describe('with --base', () => {
+        let getCommitsSpy: MockInstance;
+
+        beforeEach(() => {
+            vi.spyOn(Git, 'hasMergeFromTarget').mockResolvedValue(false);
+            getCommitsSpy = vi.spyOn(Git, 'getCommits').mockResolvedValue(commits);
+        });
+
+        it('inspects the branch commits after --since', async () => {
+            const result = await getAffectedActors({
+                base: 'origin/master',
+                since: sinceSha,
+                ...selection,
+            });
+
+            expect(result).toStrictEqual({
+                headSha,
+                commits,
+                changedFiles,
+                changelog: '- Added foo',
+                functionallyChangedActors: [actorA],
+                cosmeticallyChangedActors: [actorB],
+            });
+            expect(getCommitsSpy).toHaveBeenCalledWith({
+                sourceBranch: 'HEAD',
+                targetBranch: 'origin/master',
+                baseCommit: sinceSha,
+            });
+            // 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(changedActorsSpy).toHaveBeenCalledWith({
+                filepathsChanged: changedFiles,
+                actorConfigs: [actorA, actorB],
+                commits,
+            });
+        });
+
+        describe('when the branch merged --base in', () => {
+            beforeEach(() => {
+                vi.spyOn(Git, 'hasMergeFromTarget').mockResolvedValue(true);
+                vi.spyOn(Git, 'getBranchOnlyChangedFiles').mockResolvedValue(['own-file']);
+            });
+
+            const getWithOwnChanges = async (own: DiffChanges.ChangedActors) => {
+                changedActorsSpy.mockImplementation(async ({ filepathsChanged }) =>
+                    filepathsChanged[0] === 'own-file' ? own : { functional: [actorA], cosmetic: [actorB] },
+                );
+                return getAffectedActors({ base: 'master', since: sinceSha, ...selection });
+            };
+
+            it("classifies the branch's own files against the whole branch, ignoring --since", async () => {
+                await getWithOwnChanges({ functional: [actorA], cosmetic: [] });
+                expect(changedActorsSpy).toHaveBeenCalledWith({
+                    filepathsChanged: ['own-file'],
+                    actorConfigs: [actorA, actorB],
+                    commits,
+                });
+                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('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('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);
+            });
+        });
+    });
+
+    describe('with --since only', () => {
+        let resolveBaseSpy: MockInstance;
+        let commitsBetweenSpy: MockInstance;
+
+        beforeEach(() => {
+            resolveBaseSpy = vi.spyOn(Git, 'resolveReleaseBaseCommit').mockResolvedValue(sinceSha);
+            commitsBetweenSpy = vi.spyOn(Git, 'getCommitsBetween').mockResolvedValue(commits);
+        });
+
+        it('inspects everything after --since up to --head', async () => {
+            const result = await getAffectedActors({ since: 'HEAD~2', ...selection });
+
+            expect(result).toStrictEqual({
+                headSha,
+                commits,
+                changedFiles,
+                changelog: '- Added foo',
+                functionallyChangedActors: [actorA],
+                cosmeticallyChangedActors: [actorB],
+            });
+            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

@@ -0,0 +1,61 @@
+import { execFileSync, spawnSync } 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';
+
+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));
+let cliPath: string;
+let buildDir: string | undefined;
+
+const run = (command: string[], input: string, env: NodeJS.ProcessEnv = process.env) =>
+    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', () => {
+    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);
+    });
+
+    afterAll(async () => {
+        if (buildDir) await rm(buildDir, { recursive: true, force: true });
+    });
+
+    it('builds nothing for an empty list and prints an empty build list', () => {
+        const result = runBuild('{"actors":[]}');
+        expect(result.status, result.stderr).toBe(0);
+        expect(JSON.parse(result.stdout)).toStrictEqual([]);
+    });
+
+    it('fails on empty stdin instead of building nothing', () => {
+        const result = runBuild('');
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('Expected the Actors to build as JSON on stdin, got nothing');
+        expect(result.stdout).toBe('');
+    });
+
+    it('rejects a malformed --version-number', () => {
+        const result = runBuild('{"actors":[]}', ['--version-number', 'latest']);
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('--version-number must look like 0.1 or be "default"');
+    });
+
+    it('requires --version-number', () => {
+        const result = runBuild('{"actors":[]}', []);
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('Missing required argument: version-number');
+    });
+
+    it('notify-release announces nothing when there are no new commits', () => {
+        const document = { commits: [], changedFiles: [], changelog: null, functionallyChangedActors: [] };
+        const result = run(['notify-release'], 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/build.test.ts

@@ -7,11 +7,15 @@ import { ActorSourceType, ApifyClient } from 'apify-client';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
+    ApifyBuilder,
     assertRepoUrlMatchesDefaultVersion,
+    buildActors,
     deleteOldBuilds,
     resolveDefaultVersion,
     runBuilds,
 } from '../../../bin/build.js';
+import * as Git from '../../../bin/git.js';
+import { logger } from '../../../bin/logger.js';
 import type { ActorConfig } from '../../../bin/types.js';
 import { ExistingDir, ExistingFile, RelativeDir } from '../../../bin/utils/path/repo-relative.js';
 
@@ -84,6 +88,71 @@ describe('assertRepoUrlMatchesDefaultVersion', () => {
     });
 });
 
+describe('runBuilds version number', () => {
+    // Only the name and folder of the Actor matter here, the builder is stubbed
+    const actorConfig = { actorFullName: ACTOR, folder: { isRoot: () => true } } as unknown as ActorConfig;
+    // Restored after each test, so the stub never reaches the tests that run the real builder
+    afterEach(() => {
+        vi.mocked(ApifyBuilder.fromActorConfig).mockRestore();
+    });
+
+    const dryRunBuild = async (versionNumber: string, actorInfo = makeActorInfo()) => {
+        vi.spyOn(ApifyBuilder, 'fromActorConfig').mockReturnValue({
+            getActorInfo: async () => actorInfo,
+        } as unknown as ApifyBuilder);
+        const result = await runBuilds({
+            actorConfigs: [actorConfig],
+            versionNumber,
+            repoUrl: REPO_URL,
+            shouldVerifyRepoUrl: false,
+            branch: 'master',
+            dryRun: true,
+        });
+        if (Array.isArray(result)) throw new Error('A dry run must return a plan, not builds');
+        return result.builds[0].versionNumber;
+    };
+
+    it('builds the version it is given', async () => {
+        await expect(dryRunBuild('0.99')).resolves.toBe('0.99');
+    });
+
+    it("resolves default to the version the Actor's default build tag points to", async () => {
+        await expect(dryRunBuild('default')).resolves.toBe('0.1');
+    });
+
+    it('warns when the default version does not give its builds the default build tag', async () => {
+        const warnSpy = vi.spyOn(logger, 'warn').mockImplementation(() => undefined);
+        await dryRunBuild('default');
+        // The fixture's version 0.1 has no build tag of its own
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('users keep running the previous build'));
+    });
+
+    it('does not warn when the default version gives its builds the default build tag', async () => {
+        const warnSpy = vi.spyOn(logger, 'warn').mockImplementation(() => undefined);
+        const versions = [{ versionNumber: '0.1', buildTag: 'latest', sourceType: ActorSourceType.GitRepo }];
+        await dryRunBuild('default', makeActorInfo({ versions } as Partial<ApifyClientTypes.Actor>));
+        expect(warnSpy).not.toHaveBeenCalled();
+    });
+});
+
+describe('buildActors', () => {
+    it('builds nothing and needs no branch or repository when there are no Actors', async () => {
+        const branchSpy = vi.spyOn(Git, 'getCurrentBranch');
+        const repoSpy = vi.spyOn(Git, 'resolveRepoUrl');
+
+        await expect(buildActors({ actorConfigs: [], versionNumber: '0.99', dryRun: false })).resolves.toStrictEqual(
+            [],
+        );
+        // A dry run keeps the dry-run shape even with nothing to build
+        await expect(buildActors({ actorConfigs: [], versionNumber: '0.99', dryRun: true })).resolves.toStrictEqual({
+            dryRun: true,
+            builds: [],
+        });
+        expect(branchSpy).not.toHaveBeenCalled();
+        expect(repoSpy).not.toHaveBeenCalled();
+    });
+});
+
 describe('dry run', () => {
     const TOKEN_ENV_VAR = 'APIFY_TOKEN_OWNER';
     const originalCwd = process.cwd();
@@ -150,7 +219,7 @@ describe('dry run', () => {
             shouldVerifyRepoUrl: true,
             branch: 'feature',
             dryRun: true,
-            useDockerCache: false,
+            versionNumber: '0.99',
         });
 
     it('should return a build plan without creating versions or builds', async () => {
@@ -161,7 +230,6 @@ describe('dry run', () => {
                     actorFullName: ACTOR,
                     versionNumber: '0.99',
                     gitRepoUrl: `${REPO_URL}#feature:actors/a`,
-                    useDockerCache: false,
                 },
             ],
         });
@@ -182,7 +250,7 @@ describe('dry run', () => {
                 shouldVerifyRepoUrl: true,
                 branch: 'feature',
                 dryRun: true,
-                useDockerCache: false,
+                versionNumber: '0.99',
             }),
         ).rejects.toThrow('Repository mismatch');
     });