apify-test-tools 0.10.2-beta.1 → 0.10.2-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.10.2-beta.1",
+  "version": "0.10.2-beta.11",
   "type": "module",
   "description": "TBD",
   "repository": {
@@ -8,7 +8,14 @@
     "url": "https://github.com/apify/apify-test-tools.git"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "npm",
+      "version": ">=11.10.0",
+      "onFail": "warn"
+    }
   },
   "bin": {
     "apify-test-tools": "dist/bin/main.js"
@@ -32,6 +39,7 @@
     "@types/node": "^24.0.0",
     "@types/picomatch": "^4.0.3",
     "@types/yargs": "^17.0.33",
+    "esbuild": "0.25.12",
     "eslint": "^9.29.0",
     "eslint-config-prettier": "^10.1.5",
     "globals": "^17.0.0",
@@ -51,12 +59,14 @@
     "start": "npm run dist/bin/main.js",
     "start:dev": "cd local-clone && tsx ../bin/main.ts",
     "build": "tsc && chmod +x ./dist/bin/main.js",
+    "bundle": "esbuild bin/main.ts --bundle --minify --platform=node --format=esm --target=node24 --log-level=warning --banner:js=\"import{createRequire as __createRequire}from'node:module';const require=__createRequire(import.meta.url);\" --outfile=.github/cli/apify-test-tools.mjs",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "type-check": "tsc --noEmit",
-    "test": "vitest run",
+    "test": "vitest run --exclude 'test/e2e/**'",
+    "test:e2e": "vitest run test/e2e",
     "check-unused": "npx knip",
     "prepare": "husky .husky || true"
   },

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

@@ -0,0 +1,235 @@
+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 { fileURLToPath } from 'node:url';
+
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+// Runs the committed bundle the composite action ships, not the sources, so these catch anything
+// that only breaks once bundled (a dependency loading code at runtime, a missing shim). Everything
+// here works without tokens or network: read-only commands, dry runs that end up with nothing to
+// build, and the missing-token error. The `CLI bundle` check keeps the bundle in sync with bin/.
+const bundlePath = fileURLToPath(new URL('../../.github/cli/apify-test-tools.mjs', import.meta.url));
+
+// Only what node and git need, so no Apify or Slack token from the developer's shell leaks in.
+const cliEnv = { PATH: process.env.PATH ?? '', HOME: os.tmpdir() };
+const gitEnv = {
+    ...cliEnv,
+    GIT_AUTHOR_NAME: 'Tester',
+    GIT_AUTHOR_EMAIL: 'tester@example.com',
+    GIT_COMMITTER_NAME: 'Tester',
+    GIT_COMMITTER_EMAIL: 'tester@example.com',
+};
+
+let repoDir: string;
+let baseSha: string;
+let headSha: string;
+
+const git = (...args: string[]) => execFileSync('git', args, { cwd: repoDir, env: gitEnv, encoding: 'utf8' }).trim();
+
+const writeRepoFile = async (file: string, content: string) => {
+    await mkdir(path.dirname(path.join(repoDir, file)), { recursive: true });
+    await writeFile(path.join(repoDir, file), content);
+};
+
+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', () => {
+    // Two Actors on `main`; `feature` changes only tester/foo and the root README.
+    beforeAll(async () => {
+        repoDir = await mkdtemp(path.join(os.tmpdir(), 'apify-cli-bundle-'));
+        git('init', '-q', '-b', 'main');
+        git('remote', 'add', 'origin', 'https://github.com/apify/fixture-repo.git');
+        for (const name of ['foo', 'bar']) {
+            await writeRepoFile(
+                `actors/${name}/.actor/actor.json`,
+                JSON.stringify({ actorSpecification: 1, name, version: '0.1' }),
+            );
+        }
+        await writeRepoFile(
+            'apify-test-tools.config.json',
+            JSON.stringify({
+                actors: [
+                    { folder: 'actors/foo', actorFullName: 'tester/foo', tokenEnvVar: 'FOO_TOKEN' },
+                    { folder: 'actors/bar', actorFullName: 'tester/bar', tokenEnvVar: 'BAR_TOKEN' },
+                ],
+            }),
+        );
+        git('add', '-A');
+        git('commit', '-q', '-m', 'chore: init');
+        baseSha = git('rev-parse', 'HEAD');
+
+        git('checkout', '-q', '-b', 'feature');
+        await writeRepoFile('actors/foo/main.js', 'console.log("changed");\n');
+        git('add', '-A');
+        git('commit', '-q', '-m', 'fix(foo): change foo');
+        await writeRepoFile('README.md', 'readme\n');
+        git('add', '-A');
+        git('commit', '-q', '-m', 'docs: readme');
+        headSha = git('rev-parse', 'HEAD');
+    });
+
+    afterAll(async () => {
+        if (repoDir) await rm(repoDir, { recursive: true, force: true });
+    });
+
+    it('lists every command in --help', () => {
+        const { status, stdout } = runCli('--help');
+        expect(status).toBe(0);
+        for (const command of [
+            'get-commits',
+            'get-latest-commit',
+            'get-changed-files',
+            'get-actor-configs',
+            'get-affected-actors',
+            'report-tests',
+            'build',
+            'notify-release',
+            'build-from-local',
+            'delete-old-builds',
+        ]) {
+            expect(stdout).toContain(command);
+        }
+    });
+
+    it('get-commits returns the commits on the source branch', () => {
+        const { status, stdout, stderr } = runCli('get-commits', ...gitRange);
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout).map((commit: { message: string }) => commit.message)).toEqual([
+            'fix(foo): change foo',
+            'docs: readme',
+        ]);
+    });
+
+    it('get-latest-commit returns the head of the source branch', () => {
+        const { status, stdout, stderr } = runCli('get-latest-commit', ...gitRange);
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout)).toMatchObject({ sha: headSha, message: 'docs: readme' });
+    });
+
+    it('get-changed-files returns the files changed on the source branch', () => {
+        const { status, stdout, stderr } = runCli('get-changed-files', ...gitRange);
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout)).toEqual(['README.md', 'actors/foo/main.js']);
+    });
+
+    it('get-actor-configs reads both Actors from the config file', () => {
+        const { status, stdout, stderr } = runCli('get-actor-configs');
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout).map((actor: { actorFullName: string }) => actor.actorFullName)).toEqual([
+            'tester/foo',
+            'tester/bar',
+        ]);
+    });
+
+    it('get-affected-actors returns only the Actor whose files changed', () => {
+        // `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({
+            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 } = 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 } = 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('get-affected-actors --since HEAD reports nothing', () => {
+        const { status, stdout, stderr } = runCli('get-affected-actors', '--since', headSha);
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout)).toMatchObject({
+            commits: [],
+            functionallyChangedActors: [],
+            cosmeticallyChangedActors: [],
+        });
+    });
+
+    it('notify-release announces nothing, and needs no token, when there are no new commits', () => {
+        const affected = runCli('get-affected-actors', '--since', headSha).stdout;
+        const { status, stderr } = runCliWithInput(affected, 'notify-release', '--release-slack-channel', '#releases');
+        expect(status, stderr).toBe(0);
+        expect(stderr).toContain('No new commits, so there is no release to announce');
+    });
+
+    it('notify-release skips Slack without a channel', () => {
+        const affected = runCli('get-affected-actors', '--since', baseSha).stdout;
+        const { status, stderr } = runCliWithInput(affected, 'notify-release', '--dry-run');
+        expect(status, stderr).toBe(0);
+        expect(stderr).toContain('Skipping slack notification');
+    });
+
+    it('report-tests summarizes a vitest JSON report', async () => {
+        const assertion = (title: string, status: 'passed' | 'failed', runId: string) => ({
+            ancestorTitles: [],
+            fullName: `foo ${title}`,
+            title,
+            status,
+            failureMessages: status === 'failed' ? ['AssertionError: expected 1 to be 2\n    at foo.test.ts:1:1'] : [],
+            meta: { runId, runLink: `https://console.apify.com/view/runs/${runId}`, actorId: 'tester/foo' },
+        });
+        await writeRepoFile(
+            'test-output.json',
+            JSON.stringify({
+                success: false,
+                testResults: [
+                    {
+                        name: 'test/platform/foo.test.ts',
+                        status: 'failed',
+                        assertionResults: [assertion('works', 'passed', 'run1'), assertion('fails', 'failed', 'run2')],
+                    },
+                ],
+            }),
+        );
+
+        const { status, stderr } = runCli('report-tests', '--report-file', 'test-output.json', '--dry-run');
+        expect(status, stderr).toBe(0);
+        expect(stderr).toContain('PASSED: 1, FAILED: 1');
+        expect(stderr).toContain('1) foo fails ... https://console.apify.com/view/runs/run2');
+        expect(stderr).toContain('Skipping slack notification');
+    });
+});

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

@@ -0,0 +1,207 @@
+import { execFileSync } from 'node:child_process';
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+import { ApifyClient } from 'apify-client';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import type { ActorBuild } from './helpers.js';
+import {
+    cliEnv,
+    gitEnv,
+    projectRoot,
+    runCli as runCliIn,
+    runCliWithInput as runCliWithInputIn,
+    runProcess,
+    token,
+    TOKEN_ENV_VAR,
+} from './helpers.js';
+
+// End-to-end run of the shipped CLI bundle against two dummy Actors in an isolated sandbox account:
+// dry-run plans read the real Actors, `build-from-local` really builds them, the lib runs them
+// through `testActor` on exactly those builds (the ACTOR_BUILDS handoff), `report-tests` reads the
+// result, and `delete-old-builds` cleans up. Git builds of a real repository are in
+// git-build-release.e2e.test.ts.
+//
+// Runs with `npm run test:e2e`, kept out of `npm test`. Skipped without the token, e.g. on fork PRs.
+const ACTORS = ['test-tools-testing-sandbox/dummy-for-testing-1', 'test-tools-testing-sandbox/dummy-for-testing-2'];
+// Only used as the source URL in dry-run plans; nothing is cloned from it.
+const REPO_URL = 'https://github.com/apify/apify-test-tools-e2e-fixture';
+
+const vitestPath = path.join(projectRoot, 'node_modules/vitest/vitest.mjs');
+
+let repoDir: string;
+let baseSha: string;
+
+const git = (...args: string[]) => execFileSync('git', args, { cwd: repoDir, env: gitEnv, encoding: 'utf8' }).trim();
+
+const writeRepoFile = async (file: string, content: string) => {
+    await mkdir(path.dirname(path.join(repoDir, file)), { recursive: true });
+    await writeFile(path.join(repoDir, file), content);
+};
+
+const runCli = async (...args: string[]) => runCliIn(repoDir, ...args);
+const runCliWithInput = async (input: string, ...args: string[]) => runCliWithInputIn(repoDir, input, ...args);
+
+describe.runIf(token)('CLI bundle against real Actors', { timeout: 2 * 60_000 }, () => {
+    let builds: ActorBuild[];
+
+    // Both Actors on `main`; `feature` changes only dummy-for-testing-1.
+    beforeAll(async () => {
+        repoDir = await mkdtemp(path.join(os.tmpdir(), 'apify-cli-e2e-'));
+        git('init', '-q', '-b', 'main');
+        git('remote', 'add', 'origin', `${REPO_URL}.git`);
+        const actors = [];
+        for (const [i, actorFullName] of ACTORS.entries()) {
+            const folder = `actors/dummy-${i + 1}`;
+            await writeRepoFile(
+                `${folder}/.actor/actor.json`,
+                JSON.stringify({
+                    actorSpecification: 1,
+                    name: actorFullName.split('/')[1],
+                    version: '0.0',
+                    dockerfile: '../Dockerfile',
+                }),
+            );
+            await writeRepoFile(
+                `${folder}/Dockerfile`,
+                'FROM apify/actor-node:22\nCOPY . ./\nCMD ["node", "main.js"]\n',
+            );
+            await writeRepoFile(`${folder}/main.js`, `console.log('dummy ${i + 1}');\n`);
+            actors.push({ folder, actorFullName, tokenEnvVar: TOKEN_ENV_VAR });
+        }
+        await writeRepoFile('apify-test-tools.config.json', JSON.stringify({ actors }));
+        git('add', '-A');
+        git('commit', '-q', '-m', 'chore: init');
+        baseSha = git('rev-parse', 'HEAD');
+
+        git('checkout', '-q', '-b', 'feature');
+        await writeRepoFile('actors/dummy-1/main.js', "console.log('dummy 1 changed');\n");
+        git('add', '-A');
+        git('commit', '-q', '-m', 'fix(dummy-1): change');
+    });
+
+    afterAll(async () => {
+        if (repoDir) await rm(repoDir, { recursive: true, force: true });
+    });
+
+    it('build --dry-run plans a test build of the Actors it is given', async () => {
+        const { status, stdout, stderr } = await runCliWithInput(
+            JSON.stringify({ actors: [{ actorFullName: ACTORS[0] }] }),
+            'build',
+            '--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('a release pipeline plans a build of the default version of every changed Actor', async () => {
+        const affected = await runCli('get-affected-actors', '--since', baseSha);
+        expect(affected.status, affected.stderr).toBe(0);
+        const { functionallyChangedActors, cosmeticallyChangedActors } = JSON.parse(affected.stdout);
+
+        const { status, stderr } = await runCliWithInput(
+            JSON.stringify({ actors: [...functionallyChangedActors, ...cosmeticallyChangedActors] }),
+            'build',
+            '--version-number',
+            'default',
+            '--repo-url',
+            REPO_URL,
+            '--dry-run',
+        );
+        expect(status, stderr).toBe(0);
+        expect(stderr).toContain(
+            `[DRY RUN] Would build:\n  ${ACTORS[0]} (0.0) from ${REPO_URL}#feature:actors/dummy-1`,
+        );
+    });
+
+    it('build-from-local --dry-run plans both Actors from the working tree', async () => {
+        const { status, stdout, stderr } = await runCli('build-from-local', '--dry-run');
+        expect(status, stderr).toBe(0);
+        expect(JSON.parse(stdout)).toMatchObject({
+            dryRun: true,
+            builds: ACTORS.map((actorFullName) => ({ actorFullName, versionNumber: '0.98', fileCount: 3 })),
+        });
+    });
+
+    it('build-from-local builds both Actors', { timeout: 10 * 60_000 }, async () => {
+        const { status, stdout, stderr } = await runCli('build-from-local');
+        expect(status, stderr).toBe(0);
+        builds = JSON.parse(stdout);
+        expect(builds.map((build) => build.actorFullName)).toEqual(ACTORS);
+        for (const build of builds) expect(build.buildNumber).toMatch(/^0\.98\.\d+$/);
+    });
+
+    it('runs the builds through testActor and reports the results', { timeout: 10 * 60_000 }, async () => {
+        expect(builds, 'needs the builds from the previous test').toBeDefined();
+
+        // A consumer's platform test, importing the lib from this checkout. The symlink lets it
+        // resolve vitest and the lib's dependencies the way an installed package would.
+        await symlink(path.join(projectRoot, 'node_modules'), path.join(repoDir, 'node_modules'), 'dir');
+        const libPath = path.join(projectRoot, 'index.ts');
+        const actorTests = ACTORS.map(
+            (actorId) => `
+    testActor(${JSON.stringify(actorId)}, 'finishes', async ({ expect, run }) => {
+        const result = await run({ input: {} });
+        expect(result.status).toBe('SUCCEEDED');
+    });`,
+        ).join('\n');
+        await writeRepoFile(
+            'test/platform/dummies.test.ts',
+            `import { describe, testActor } from ${JSON.stringify(libPath)};
+
+describe('sandbox dummies', () => {${actorTests}
+});
+`,
+        );
+
+        const vitest = await runProcess(
+            process.execPath,
+            [vitestPath, 'run', 'test/platform', '--reporter=json', '--outputFile=./test-output.json'],
+            {
+                cwd: repoDir,
+                env: { ...cliEnv, TESTER_APIFY_TOKEN: token!, ACTOR_BUILDS: JSON.stringify(builds) },
+            },
+        );
+        expect(vitest.status, `${vitest.stdout}\n${vitest.stderr}`).toBe(0);
+
+        // Each run used the build from ACTOR_BUILDS, not the Actor's default build.
+        const report = JSON.parse(await readFile(path.join(repoDir, 'test-output.json'), 'utf8'));
+        const assertions = report.testResults.flatMap(
+            (file: { assertionResults: { meta: { runId: string } }[] }) => file.assertionResults,
+        );
+        expect(assertions).toHaveLength(ACTORS.length);
+        const client = new ApifyClient({ token });
+        const runBuildIds = await Promise.all(
+            assertions.map(
+                async ({ meta }: { meta: { runId: string } }) => (await client.run(meta.runId).get())?.buildId,
+            ),
+        );
+        expect(runBuildIds.sort()).toEqual(builds.map((build) => build.buildId).sort());
+
+        const { status, stderr } = await runCli('report-tests', '--report-file', 'test-output.json', '--dry-run');
+        expect(status, stderr).toBe(0);
+        expect(stderr).toContain(`PASSED: ${ACTORS.length}, FAILED: 0`);
+        expect(stderr).toContain('https://console.apify.com/view/runs/');
+    });
+
+    // Last, so builds from earlier runs of this suite don't pile up in the sandbox.
+    it('delete-old-builds keeps the default builds', async () => {
+        const { status, stderr } = await runCli('delete-old-builds');
+        expect(status, stderr).toBe(0);
+        for (const actorFullName of ACTORS) {
+            expect(stderr).toContain(`[DELETE OLD BUILDS][${actorFullName}]: Skipping default build`);
+        }
+    });
+});

package/test/e2e/git-build-release.e2e.test.ts

@@ -0,0 +1,113 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { ApifyClient } from 'apify-client';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import type { ActorBuild } from './helpers.js';
+import { gitEnv, runCli as runCliIn, runCliWithInput as runCliWithInputIn, token } from './helpers.js';
+
+// Real git builds of a real repository: the shipped CLI bundle builds an Actor from a clone of
+// apify-store/testing-repo-for-github-actions, and the Apify builder clones the same repository
+// (over SSH, with the sandbox org's deploy key installed on it).
+//
+// The repo's `e2e/base` and `e2e/feature` branches are fixtures and never change: `e2e/feature`
+// adds one commit touching only dummy-for-testing-1. Like the reusable workflows, the commands run
+// with `e2e/feature` checked out and compare it with `origin/e2e/base`. The release pipeline rebuilds
+// dummy-for-testing-1 under `latest` on every run, which is fine for a sandbox Actor nobody else uses.
+//
+// Runs with `npm run test:e2e`, kept out of `npm test`. Skipped without the token, e.g. on fork PRs.
+const FIXTURE_REPO = 'https://github.com/apify-store/testing-repo-for-github-actions';
+const BASE_BRANCH = 'e2e/base';
+const FEATURE_BRANCH = 'e2e/feature';
+const CHANGED_ACTOR = 'test-tools-testing-sandbox/dummy-for-testing-1';
+const CHANGED_ACTOR_FOLDER = 'actors/dummy-for-testing-1';
+// The CLI builds from the SSH form of the origin URL, which is what lets a deploy key work.
+const BUILD_SOURCE = `git@github.com:apify-store/testing-repo-for-github-actions#${FEATURE_BRANCH}:${CHANGED_ACTOR_FOLDER}`;
+
+let repoDir: string;
+
+const git = (...args: string[]) => execFileSync('git', args, { cwd: repoDir, env: gitEnv, encoding: 'utf8' }).trim();
+const runCli = async (...args: string[]) => runCliIn(repoDir, ...args);
+const runCliWithInput = async (input: string, ...args: string[]) => runCliWithInputIn(repoDir, input, ...args);
+
+const getAffectedActors = async () => {
+    const { status, stdout, stderr } = await runCli('get-affected-actors', '--base', `origin/${BASE_BRANCH}`);
+    expect(status, stderr).toBe(0);
+    return JSON.parse(stdout);
+};
+
+describe.runIf(token)('CLI bundle building a real repository', { timeout: 2 * 60_000 }, () => {
+    const client = new ApifyClient({ token });
+
+    const versionSource = async (versionNumber: string) => {
+        const actor = await client.actor(CHANGED_ACTOR).get();
+        const version = actor?.versions.find(({ versionNumber: number }) => number === versionNumber);
+        return version && 'gitRepoUrl' in version ? version.gitRepoUrl : undefined;
+    };
+
+    // A full clone checked out on the feature branch, like actions/checkout with fetch-depth: 0.
+    beforeAll(async () => {
+        repoDir = await mkdtemp(path.join(os.tmpdir(), 'apify-cli-e2e-git-'));
+        execFileSync('git', ['clone', '-q', FIXTURE_REPO, repoDir], { env: gitEnv });
+        git('checkout', '-q', '-b', FEATURE_BRANCH, `origin/${FEATURE_BRANCH}`);
+    }, 5 * 60_000);
+
+    afterAll(async () => {
+        if (repoDir) await rm(repoDir, { recursive: true, force: true });
+    });
+
+    it('get-affected-actors finds only the Actor the feature branch changed', async () => {
+        expect(await getAffectedActors()).toMatchObject({
+            functionallyChangedActors: [{ actorFullName: CHANGED_ACTOR }],
+            cosmeticallyChangedActors: [],
+        });
+    });
+
+    it('build builds the changed Actor from the feature branch', { timeout: 10 * 60_000 }, async () => {
+        // What the PR workflow does: the functionally changed Actors, piped into a test build
+        const { functionallyChangedActors } = await getAffectedActors();
+        const { status, stdout, stderr } = await runCliWithInput(
+            JSON.stringify({ actors: functionallyChangedActors }),
+            'build',
+            '--version-number',
+            '0.99',
+        );
+        expect(status, stderr).toBe(0);
+        const builds: ActorBuild[] = JSON.parse(stdout);
+        expect(builds).toMatchObject([
+            { actorFullName: CHANGED_ACTOR, buildNumber: expect.stringMatching(/^0\.99\.\d+$/) },
+        ]);
+
+        // The version builds the checked-out branch, as it is on the remote.
+        expect(await versionSource('0.99')).toBe(BUILD_SOURCE);
+        expect((await client.build(builds[0].buildId).get())?.status).toBe('SUCCEEDED');
+    });
+
+    it('the release pipeline rebuilds the default version of the changed Actor', { timeout: 10 * 60_000 }, async () => {
+        // What the release workflow does: every Actor changed since the last release, built into its default version
+        const baseSha = git('rev-parse', `origin/${BASE_BRANCH}`);
+        const affected = await runCli('get-affected-actors', '--since', baseSha);
+        expect(affected.status, affected.stderr).toBe(0);
+        const { functionallyChangedActors, cosmeticallyChangedActors } = JSON.parse(affected.stdout);
+
+        const { status, stderr } = await runCliWithInput(
+            JSON.stringify({ actors: [...functionallyChangedActors, ...cosmeticallyChangedActors] }),
+            'build',
+            '--version-number',
+            'default',
+        );
+        expect(status, stderr).toBe(0);
+        expect(stderr).toMatch(new RegExp(`\\[${CHANGED_ACTOR}\\]: 0\\.0\\.\\d+`));
+
+        // Releasing builds the default version from the branch being released.
+        expect(await versionSource('0.0')).toBe(BUILD_SOURCE);
+
+        // Without a channel the announcement is skipped, so it needs no Slack token
+        const notify = await runCliWithInput(affected.stdout, 'notify-release');
+        expect(notify.status, notify.stderr).toBe(0);
+        expect(notify.stderr).toContain('Skipping slack notification');
+    });
+});