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

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');
+        expect(notify.status, notify.stderr).toBe(0);
+        expect(notify.stderr).toContain('Skipping notification');
+    });
+});

package/test/e2e/helpers.ts

@@ -0,0 +1,82 @@
+import { execFile, type ExecFileException } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+
+// Shared by the e2e suites. They run the shipped CLI bundle against Actors in the isolated
+// `test-tools-testing-sandbox` org, whose token can reach nothing else.
+export const TOKEN_ENV_VAR = 'E2E_TEST_APIFY_TOKEN_DBYPODOIHUZABNQTR';
+export const token = process.env[TOKEN_ENV_VAR];
+
+export const projectRoot = fileURLToPath(new URL('../../', import.meta.url));
+export const bundlePath = path.join(projectRoot, '.github/cli/apify-test-tools.mjs');
+
+// Proxy and CA settings pass through so the API is reachable behind a proxy; no other variable does.
+const networkEnv = Object.fromEntries(
+    ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'NO_PROXY', 'no_proxy', 'NODE_EXTRA_CA_CERTS']
+        .filter((name) => process.env[name] !== undefined)
+        .map((name) => [name, process.env[name]!]),
+);
+const baseEnv = { PATH: process.env.PATH ?? '', HOME: os.tmpdir() };
+// The CLI gets only the sandbox token, under the name the fixture configs point at.
+export const cliEnv = { ...baseEnv, ...networkEnv, [TOKEN_ENV_VAR]: token ?? '' };
+export const gitEnv = {
+    ...baseEnv,
+    ...networkEnv,
+    GIT_AUTHOR_NAME: 'Tester',
+    GIT_AUTHOR_EMAIL: 'tester@example.com',
+    GIT_COMMITTER_NAME: 'Tester',
+    GIT_COMMITTER_EMAIL: 'tester@example.com',
+};
+
+// Processes are spawned asynchronously: a blocking spawn would stall the test worker for the length
+// of a build, long enough for vitest's own worker RPC to time out. The kill timeout still applies on
+// top of vitest's, since apify-client retries an unreachable API for minutes.
+export const PROCESS_TIMEOUT_MS = 8 * 60_000;
+const execFileAsync = promisify(execFile);
+
+export interface ProcessResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+
+export const runProcess = async (
+    command: string,
+    args: string[],
+    { input = '', ...options }: { cwd: string; env: Record<string, string>; input?: string },
+): Promise<ProcessResult> => {
+    try {
+        const promise = execFileAsync(command, args, {
+            ...options,
+            encoding: 'utf8',
+            timeout: PROCESS_TIMEOUT_MS,
+            maxBuffer: 100 * 1024 * 1024,
+        });
+        // Closing stdin hands a command that reads it (e.g. `build`) the input, and one that doesn't never waits
+        promise.child.stdin?.end(input);
+        const { stdout, stderr } = await promise;
+        return { status: 0, stdout, stderr };
+    } catch (error) {
+        // A non-zero exit rejects too, with the output on the error.
+        const { code, stdout = '', stderr = '', message } = error as ExecFileException;
+        // Without an exit code (killed by the timeout, or never started) the message says why.
+        return typeof code === 'number'
+            ? { status: code, stdout, stderr }
+            : { status: null, stdout, stderr: `${stderr}\n${message}` };
+    }
+};
+
+export const runCliWithInput = async (cwd: string, input: string, ...args: string[]) =>
+    runProcess(process.execPath, [bundlePath, ...args], { cwd, env: cliEnv, input });
+
+export const runCli = async (cwd: string, ...args: string[]) => runCliWithInput(cwd, '', ...args);
+
+export interface ActorBuild {
+    buildId: string;
+    actorRawId: string;
+    buildNumber: string;
+    actorFullName: string;
+}

package/test/unit/bin/actor-filtering.test.ts

@@ -36,6 +36,14 @@ describe('selectActors', () => {
         ]);
     });
 
+    it('selects an actor listed twice once, in config order', () => {
+        // build relies on this to build an Actor in both functionallyChangedActors and testChangedActors once
+        expect(names(selectActors({ actors: ['owner/c', 'owner/a', 'owner/c'], ignore: [] }, configs))).toStrictEqual([
+            'owner/a',
+            'owner/c',
+        ]);
+    });
+
     it('drops the actors listed in --ignore', () => {
         expect(names(selectActors({ actors: [], ignore: ['owner/b'] }, configs))).toStrictEqual(['owner/a', 'owner/c']);
     });

package/test/unit/bin/actor-ids.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { withActorIds } from '../../../bin/actor-ids.js';
+
+type Client = NonNullable<Parameters<typeof withActorIds>[1]>;
+
+/** A client that knows one Actor, by its full name and by its raw ID, as the API does */
+const fakeClient = () => {
+    const known = { id: 'rawA', username: 'owner', name: 'a' };
+    const actor = vi.fn((actorId: string) => ({
+        get: async () => (actorId === 'owner/a' || actorId === 'rawA' ? known : undefined),
+    }));
+    return { actor } as unknown as Client & { actor: typeof actor };
+};
+
+describe('withActorIds', () => {
+    it('adds the raw ID to an Actor listed by full name, as get-actor-configs lists them', async () => {
+        expect(await withActorIds([{ actorFullName: 'owner/a' }], fakeClient())).toEqual([
+            { actorFullName: 'owner/a', actorRawId: 'rawA' },
+        ]);
+    });
+
+    it('adds the full name to an Actor listed by raw ID', async () => {
+        const build = { actorRawId: 'rawA', buildId: 'b1', buildNumber: '0.99.1' };
+        expect(await withActorIds([build], fakeClient())).toEqual([{ ...build, actorFullName: 'owner/a' }]);
+    });
+
+    it('keeps the IDs of a build and does not look them up', async () => {
+        const client = fakeClient();
+        const build = { actorFullName: 'owner/a', buildId: 'b1', actorRawId: 'raw1', buildNumber: '0.99.1' };
+        expect(await withActorIds([build], client)).toEqual([build]);
+        expect(client.actor).not.toHaveBeenCalled();
+    });
+
+    it('keeps an Actor the token cannot see as listed, instead of failing the run', async () => {
+        const targets = [
+            { actorFullName: 'owner/missing' },
+            { actorRawId: 'rawMissing' },
+            { actorFullName: 'owner/a' },
+        ];
+        expect(await withActorIds(targets, fakeClient())).toEqual([
+            { actorFullName: 'owner/missing' },
+            { actorRawId: 'rawMissing' },
+            { actorFullName: 'owner/a', actorRawId: 'rawA' },
+        ]);
+    });
+});

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

@@ -0,0 +1,271 @@
+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 names = (actors: { actorFullName: string }[]) =>
+    actors.map(({ actorFullName }) => actorFullName.replace('owner/actor-', '')).sort();
+
+/** All three lists, for the tests about test changes */
+const getAllChangedActors = (...args: string[]) => {
+    const document = runGetAffectedActors(...args);
+    return {
+        functional: names(document.functionallyChangedActors),
+        cosmetic: names(document.cosmeticallyChangedActors),
+        test: names(document.testChangedActors),
+    };
+};
+
+/** Writes the config with actor-a's context also covering `extraContext`. It is committed with the next commit. */
+const writeConfigWithTestsInContext = async (extraContext: string, settings: Record<string, unknown> = {}) => {
+    const actors = CONFIG.actors.map((actor) =>
+        actor.folder === 'actors/a'
+            ? { ...actor, overrideActorContext: [...actor.overrideActorContext!, extraContext] }
+            : actor,
+    );
+    await writeFile(path.join(repoDir, 'apify-test-tools.config.json'), JSON.stringify({ ...settings, actors }));
+};
+
+const getAffectedActors = (...args: string[]) => {
+    const document = runGetAffectedActors(...args);
+    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('counts a moved file for both the Actor it left and the one it joined', async () => {
+        git('mv', 'actors/a/main.ts', 'actors/c/moved.ts');
+        git('commit', '-q', '-m', 'refactor: move a file from a to c');
+
+        // With rename detection, git would list only the new path, and A would look unchanged
+        expect(getAffectedActors('--base', 'main')).toStrictEqual({ functional: ['a', 'c'], 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('lists Actors whose platform tests changed, and a test change alone is not functional', async () => {
+        await writeConfigWithTestsInContext('test');
+        await writeFiles('test/', ['.dockerignore']);
+        // A test and its helper, both under the default platformTestsGlob test/platform/**
+        await commit('test(a): change a test and its helper', 'test/platform/a.test.ts', 'test/platform/utils.ts');
+
+        const testOnly = { functional: [], cosmetic: [], test: ['a'] };
+        // A PR runs the tests
+        expect(getAllChangedActors('--base', 'main')).toStrictEqual(testOnly);
+        // A release builds only the functional and cosmetic lists, so it builds nothing
+        expect(getAllChangedActors('--since', git('rev-parse', 'main'))).toStrictEqual(testOnly);
+    });
+
+    it('lists an Actor in both lists when its source and its tests changed', async () => {
+        await writeConfigWithTestsInContext('test');
+        await commit('feat(a): change and test it', 'actors/a/main.ts', 'test/platform/a.test.ts');
+
+        expect(getAllChangedActors('--base', 'main')).toStrictEqual({ functional: ['a'], cosmetic: [], test: ['a'] });
+    });
+
+    it('lists only the tests changed since the last validated commit', async () => {
+        await writeConfigWithTestsInContext('test');
+        const validated = await commit('feat(a): validated change', 'actors/a/main.ts');
+        await commit('test(a): new test', 'test/platform/a.test.ts');
+
+        // The validated build of A has the branch's code, only the tests changed since
+        expect(getAllChangedActors('--base', 'main', '--since', validated)).toStrictEqual({
+            functional: [],
+            cosmetic: [],
+            test: ['a'],
+        });
+    });
+
+    it('reads which files are platform tests from platformTestsGlob in the config', async () => {
+        await writeConfigWithTestsInContext('e2e', { platformTestsGlob: 'e2e/platform/**' });
+        await commit('test(a): new test', 'e2e/platform/a.test.ts');
+        expect(getAllChangedActors('--base', 'main')).toStrictEqual({ functional: [], cosmetic: [], test: ['a'] });
+
+        // Outside the glob, a file in the context is a source change like any other
+        await commit('feat(a): other file', 'e2e/fixtures/data.json');
+        expect(getAllChangedActors('--base', 'main')).toStrictEqual({ functional: ['a'], cosmetic: [], test: ['a'] });
+    });
+
+    it('reports nothing for an empty range', async () => {
+        const nothing = {
+            commits: [],
+            changedFiles: [],
+            functionallyChangedActors: [],
+            cosmeticallyChangedActors: [],
+            testChangedActors: [],
+        };
+        // 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);
+    });
+});