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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.10.2-beta.3",
+  "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',
         ]) {
@@ -143,13 +152,50 @@ describe('CLI bundle', () => {
     });
 
     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

@@ -28,13 +28,12 @@ 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');
@@ -50,7 +49,6 @@ describe('getAffectedActors', () => {
 
         it('inspects the branch commits after --since', async () => {
             const result = await getAffectedActors({
-                head: 'origin/feature',
                 base: 'origin/master',
                 since: sinceSha,
                 ...selection,
@@ -58,7 +56,6 @@ describe('getAffectedActors', () => {
 
             expect(result).toStrictEqual({
                 headSha,
-                ref: 'feature',
                 commits,
                 changedFiles,
                 changelog: '- Added foo',
@@ -66,7 +63,7 @@ describe('getAffectedActors', () => {
                 cosmeticallyChangedActors: [actorB],
             });
             expect(getCommitsSpy).toHaveBeenCalledWith({
-                sourceBranch: 'origin/feature',
+                sourceBranch: 'HEAD',
                 targetBranch: 'origin/master',
                 baseCommit: sinceSha,
             });
@@ -90,7 +87,7 @@ describe('getAffectedActors', () => {
                 changedActorsSpy.mockImplementation(async ({ filepathsChanged }) =>
                     filepathsChanged[0] === 'own-file' ? own : { functional: [actorA], cosmetic: [actorB] },
                 );
-                return getAffectedActors({ head: 'feature', base: 'master', since: sinceSha, ...selection });
+                return getAffectedActors({ base: 'master', since: sinceSha, ...selection });
             };
 
             it("classifies the branch's own files against the whole branch, ignoring --since", async () => {
@@ -100,7 +97,7 @@ describe('getAffectedActors', () => {
                     actorConfigs: [actorA, actorB],
                     commits,
                 });
-                expect(getCommitsSpy).toHaveBeenCalledWith({ sourceBranch: 'feature', targetBranch: 'master' });
+                expect(getCommitsSpy).toHaveBeenCalledWith({ sourceBranch: 'HEAD', targetBranch: 'master' });
             });
 
             it('reports everything when the branch has functional changes of its own', async () => {
@@ -135,18 +132,17 @@ describe('getAffectedActors', () => {
         });
 
         it('inspects everything after --since up to --head', async () => {
-            const result = await getAffectedActors({ head: 'release', since: 'HEAD~2', ...selection });
+            const result = await getAffectedActors({ since: 'HEAD~2', ...selection });
 
             expect(result).toStrictEqual({
                 headSha,
-                ref: 'feature',
                 commits,
                 changedFiles,
                 changelog: '- Added foo',
                 functionallyChangedActors: [actorA],
                 cosmeticallyChangedActors: [actorB],
             });
-            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);
@@ -155,7 +151,7 @@ describe('getAffectedActors', () => {
         it('has no commits when head is the --since commit', async () => {
             resolveBaseSpy.mockResolvedValue(headSha);
 
-            const result = await getAffectedActors({ head: 'HEAD', since: headSha, ...selection });
+            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
@@ -169,7 +165,6 @@ describe('toAffectedActorsDocument', () => {
         expect(
             toAffectedActorsDocument({
                 headSha,
-                ref: null,
                 commits,
                 changedFiles: ['src/main.ts'],
                 changelog: null,
@@ -178,7 +173,6 @@ describe('toAffectedActorsDocument', () => {
             }),
         ).toStrictEqual({
             version: 1,
-            ref: null,
             head: headSha,
             commits,
             changedFiles: ['src/main.ts'],

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

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

@@ -12,7 +12,6 @@ import {
     hasMergeFromTarget,
     normalizeRepoUrl,
     parseBaseCommit,
-    resolveBranchName,
     resolveCommitSha,
     resolveReleaseBaseCommit,
     resolveRepoUrl,
@@ -323,7 +322,7 @@ describe('getCurrentBranch', () => {
         const gitCommandSpy = vi.spyOn(Utils, 'runGitCommand').mockResolvedValue('master');
         await expect(getCurrentBranch()).resolves.toBe('master');
         expect(gitCommandSpy).toHaveBeenCalledWith(['rev-parse', '--abbrev-ref', 'HEAD'], {
-            operation: 'determine the current branch for release',
+            operation: 'determine the checked-out branch',
         });
     });
 
@@ -532,16 +531,3 @@ describe('resolveCommitSha', () => {
         });
     });
 });
-
-describe('resolveBranchName', () => {
-    it.each([
-        ['a local branch', 'refs/heads/feature/foo', 'feature/foo'],
-        ['a remote branch, dropping the remote', 'refs/remotes/origin/feature/foo', 'feature/foo'],
-        ['a tag', 'refs/tags/v1.0.0', null],
-        ['a detached HEAD', 'HEAD', null],
-        ['a SHA', '', null],
-    ])('handles %s', async (_, fullName, expected) => {
-        vi.spyOn(Utils, 'runGitCommand').mockResolvedValue(fullName);
-        await expect(resolveBranchName('some-ref')).resolves.toBe(expected);
-    });
-});

package/test/unit/bin/slack.test.ts

@@ -1,7 +1,7 @@
 import { WebClient } from '@slack/web-api';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { notifyToSlack } from '../../../bin/slack.js';
+import { announceRelease, notifyToSlack } from '../../../bin/slack.js';
 
 vi.mock('@slack/web-api', () => ({ WebClient: vi.fn() }));
 
@@ -63,3 +63,46 @@ describe('notifyToSlack', () => {
         expect(postMessage).toHaveBeenCalledTimes(2);
     });
 });
+
+describe('announceRelease', () => {
+    const commit = (author: string, message: string) => ({ sha: '1', author, date: '', message });
+
+    beforeEach(() => {
+        vi.stubEnv(TOKEN_ENV_VAR, 'token');
+        vi.mocked(WebClient).mockImplementation(function () {
+            return { chat: { postMessage }, auth: { test: authTest } };
+        } as never);
+    });
+
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.clearAllMocks();
+    });
+
+    it('should announce nothing, and need no token, when there are no new commits', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await announceRelease({
+            commits: [],
+            changedFiles: [],
+            changelog: null,
+            dryRun: false,
+            reportSlackChannel: '#notif',
+        });
+        expect(WebClient).not.toHaveBeenCalled();
+    });
+
+    it('should announce the release by the author of the newest commit, named after the repository', async () => {
+        await announceRelease({
+            commits: [commit('Old<old@example.com>', 'fix: older'), commit('New<new@example.com>', 'feat: newer')],
+            changedFiles: ['src/main.ts'],
+            changelog: '- Added foo',
+            repoUrl: 'git@github.com:owner/my-repo',
+            dryRun: false,
+            reportSlackChannel: '#notif',
+        });
+        expect(postMessage).toHaveBeenCalledWith({
+            channel: '#notif',
+            text: expect.stringContaining('*my-repo* – New release (by New)'),
+        });
+    });
+});

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

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