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

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

@@ -0,0 +1,193 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { compileCli } from './compiled-cli.js';
+
+// `get-affected-actors --base` on real git histories. Actors a and c share `src/`, b is standalone.
+// `main` is the base branch and `feature` the PR branch, checked out like in the PR workflow.
+const CONFIG = {
+    actors: [
+        {
+            folder: 'actors/a',
+            actorFullName: 'owner/actor-a',
+            tokenEnvVar: 'T',
+            overrideActorContext: ['actors/a', 'src'],
+        },
+        {
+            folder: 'actors/c',
+            actorFullName: 'owner/actor-c',
+            tokenEnvVar: 'T',
+            overrideActorContext: ['actors/c', 'src'],
+        },
+        { folder: 'actors/b', actorFullName: 'owner/actor-b', tokenEnvVar: 'T' },
+    ],
+};
+
+// Only what node and git need, so nothing from the developer's git config leaks in
+const env = { PATH: process.env.PATH ?? '', HOME: os.tmpdir() };
+const gitEnv = {
+    ...env,
+    GIT_AUTHOR_NAME: 'Tester',
+    GIT_AUTHOR_EMAIL: 'tester@example.com',
+    GIT_COMMITTER_NAME: 'Tester',
+    GIT_COMMITTER_EMAIL: 'tester@example.com',
+};
+
+let cliPath: string;
+let cleanup: (() => Promise<void>) | undefined;
+let repoDir: string;
+
+const git = (...args: string[]) => execFileSync('git', args, { cwd: repoDir, env: gitEnv, encoding: 'utf8' }).trim();
+
+const writeFiles = async (content: string, files: string[]) => {
+    for (const file of files) {
+        await mkdir(path.dirname(path.join(repoDir, file)), { recursive: true });
+        await writeFile(path.join(repoDir, file), `${content}\n`);
+    }
+};
+
+/** Commits a change to each file and returns the commit. */
+const commit = async (message: string, ...files: string[]) => {
+    await writeFiles(message, files);
+    git('add', '-A');
+    git('commit', '-q', '-m', message);
+    return git('rev-parse', 'HEAD');
+};
+
+/** Commits on `main`, then checks `feature` out again. */
+const commitOnMain = async (message: string, ...files: string[]) => {
+    git('checkout', '-q', 'main');
+    await commit(message, ...files);
+    git('checkout', '-q', 'feature');
+};
+
+const runGetAffectedActors = (...args: string[]) => {
+    const result = spawnSync(cliPath, ['get-affected-actors', ...args], { cwd: repoDir, env, encoding: 'utf8' });
+    expect(result.status, result.stderr).toBe(0);
+    return JSON.parse(result.stdout);
+};
+
+const getAffectedActors = (...args: string[]) => {
+    const document = runGetAffectedActors(...args);
+    const names = (actors: { actorFullName: string }[]) =>
+        actors.map(({ actorFullName }) => actorFullName.replace('owner/actor-', '')).sort();
+    return {
+        functional: names(document.functionallyChangedActors),
+        cosmetic: names(document.cosmeticallyChangedActors),
+    };
+};
+
+describe('get-affected-actors CLI on real git histories', () => {
+    beforeAll(async () => {
+        ({ cliPath, cleanup } = await compileCli());
+    });
+
+    afterAll(async () => {
+        await cleanup?.();
+    });
+
+    beforeEach(async () => {
+        repoDir = await mkdtemp(path.join(os.tmpdir(), 'apify-affected-actors-'));
+        git('init', '-q', '-b', 'main');
+        await writeFile(path.join(repoDir, 'apify-test-tools.config.json'), JSON.stringify(CONFIG));
+        for (const { folder } of CONFIG.actors) {
+            await mkdir(path.join(repoDir, folder, '.actor'), { recursive: true });
+            await writeFile(
+                path.join(repoDir, folder, '.actor/actor.json'),
+                JSON.stringify({ actorSpecification: 1, name: `actor-${path.basename(folder)}`, version: '0.1' }),
+            );
+        }
+        await commit('chore: init', 'src/shared.ts', 'actors/a/main.ts', 'actors/b/main.ts', 'actors/c/main.ts');
+        git('checkout', '-q', '-b', 'feature');
+    });
+
+    afterEach(async () => {
+        if (repoDir) await rm(repoDir, { recursive: true, force: true });
+    });
+
+    it("tests only what changed since the last validated commit, on the branch's own commits", async () => {
+        const validated = await commit('feat(a): validated change', 'actors/a/main.ts');
+        await commit('feat(c): new change, docs for a', 'actors/c/main.ts', 'actors/a/README.md');
+
+        // A is still the validated code, only its README changed since
+        expect(getAffectedActors('--base', 'main', '--since', validated)).toStrictEqual({
+            functional: ['c'],
+            cosmetic: ['a'],
+        });
+    });
+
+    it('tests nothing after merging cosmetic changes from base', async () => {
+        const validated = await commit('feat(a): validated change', 'actors/a/main.ts');
+        await commitOnMain('docs: readme and changelog', 'actors/a/README.md', 'CHANGELOG.md');
+        git('merge', '-q', '--no-edit', 'main');
+
+        expect(getAffectedActors('--base', 'main', '--since', validated)).toStrictEqual({
+            functional: [],
+            cosmetic: ['a'],
+        });
+    });
+
+    it("tests the Actors where base's functional change meets the branch's after a merge", async () => {
+        const validated = await commit('feat(a): validated change', 'actors/a/main.ts');
+        await commitOnMain('feat: shared change', 'src/shared.ts');
+        git('merge', '-q', '--no-edit', 'main');
+
+        // Base changed A and C. A can interact with the branch's change, C only has base's, which base validated
+        expect(getAffectedActors('--base', 'main', '--since', validated)).toStrictEqual({
+            functional: ['a'],
+            cosmetic: [],
+        });
+    });
+
+    it('leaves out Actors that only base changed', async () => {
+        await commit('feat: shared change', 'src/shared.ts');
+        await commitOnMain('feat(b): base change', 'actors/b/main.ts');
+        git('merge', '-q', '--no-edit', 'main');
+
+        expect(getAffectedActors('--base', 'main')).toStrictEqual({ functional: ['a', 'c'], cosmetic: [] });
+    });
+
+    it('counts code changed in the merge commit itself', async () => {
+        await commit('docs(a): readme', 'actors/a/README.md');
+        await commitOnMain('feat(b): base change', 'actors/b/main.ts');
+        git('merge', '-q', '--no-commit', '--no-ff', 'main');
+        await writeFiles('changed while merging', ['actors/c/main.ts']);
+        git('add', '-A');
+        git('commit', '-q', '--no-edit');
+
+        expect(getAffectedActors('--base', 'main')).toStrictEqual({ functional: ['c'], cosmetic: ['a'] });
+    });
+
+    it('tests nothing after a rebase onto base changes to other Actors', async () => {
+        const validated = await commit('feat(a): validated change', 'actors/a/main.ts');
+        await commitOnMain('feat(b): base change', 'actors/b/main.ts');
+        git('rebase', '-q', 'main');
+
+        expect(getAffectedActors('--base', 'main', '--since', validated)).toStrictEqual({
+            functional: [],
+            cosmetic: [],
+        });
+    });
+
+    it('checks the whole branch on a rerun or when --since is not in the history', async () => {
+        await commit('feat(a): validated change', 'actors/a/main.ts');
+        const head = await commit('docs(a): readme', 'actors/a/README.md');
+
+        const wholeBranch = { functional: ['a'], cosmetic: [] };
+        expect(getAffectedActors('--base', 'main', '--since', head)).toStrictEqual(wholeBranch);
+        expect(getAffectedActors('--base', 'main', '--since', 'e'.repeat(40))).toStrictEqual(wholeBranch);
+    });
+
+    it('reports nothing for an empty range', async () => {
+        const nothing = { commits: [], changedFiles: [], functionallyChangedActors: [], cosmeticallyChangedActors: [] };
+        // The branch has no commits of its own yet
+        expect(runGetAffectedActors('--base', 'main')).toMatchObject(nothing);
+        // A release with nothing new since the last one
+        expect(runGetAffectedActors('--since', git('rev-parse', 'HEAD'))).toMatchObject(nothing);
+    });
+});

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';
@@ -28,99 +28,125 @@ describe('getAffectedActors', () => {
             .spyOn(DiffChanges, 'getChangedActors')
             .mockResolvedValue({ functional: [actorA], cosmetic: [actorB] });
         vi.spyOn(Git, 'resolveCommitSha').mockResolvedValue(headSha);
-        vi.spyOn(Git, 'resolveBranchName').mockResolvedValue('feature');
         vi.spyOn(Git, 'getChangedFilesBetween').mockResolvedValue(changedFiles);
         vi.spyOn(Git, 'getChangelogAdditions').mockResolvedValue('- Added foo');
     });
 
     it('requires --base or --since', async () => {
-        const options = { head: 'HEAD', ...selection };
+        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;
+        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({
-                head: 'origin/feature',
-                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,
-                ref: 'feature',
+                version: 1,
+                head: headSha,
                 commits,
                 changedFiles,
                 changelog: '- Added foo',
-                functionallyChangedActors: [actorA],
-                cosmeticallyChangedActors: [actorB],
-            });
-            expect(getCommitsSpy).toHaveBeenCalledWith({
-                sourceBranch: 'origin/feature',
-                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({ head: 'feature', 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: 'feature', 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);
             });
         });
     });
@@ -134,57 +160,23 @@ describe('getAffectedActors', () => {
             commitsBetweenSpy = vi.spyOn(Git, 'getCommitsBetween').mockResolvedValue(commits);
         });
 
-        it('inspects everything after --since up to --head', async () => {
-            const result = await getAffectedActors({ head: 'release', since: 'HEAD~2', ...selection });
+        it('inspects everything after --since up to HEAD', async () => {
+            const result = await getAffectedActors({ since: 'HEAD~2', ...selection });
 
             expect(result).toStrictEqual({
-                headSha,
-                ref: 'feature',
+                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', 'release');
+            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({ head: 'HEAD', 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,
-                ref: null,
-                commits,
-                changedFiles: ['src/main.ts'],
-                changelog: null,
-                functionallyChangedActors: [actorA],
-                cosmeticallyChangedActors: [actorB],
-            }),
-        ).toStrictEqual({
-            version: 1,
-            ref: null,
-            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,55 @@
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import { compileCli } from './compiled-cli.js';
+
+let cliPath: string;
+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 });
+const runBuild = (input: string, args: string[] = ['--version-number', '0.99']) => run(['build', ...args], input);
+
+describe('build and notify-release CLI', () => {
+    beforeAll(async () => {
+        ({ cliPath, cleanup } = await compileCli());
+    });
+
+    afterAll(async () => {
+        await cleanup?.();
+    });
+
+    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');
     });

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 }) };
+};