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

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

package/test/unit/github-scripts/mask-config-secrets.test.ts

@@ -0,0 +1,61 @@
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+const SCRIPT = fileURLToPath(new URL('../../../.github/scripts/mask-config-secrets.sh', import.meta.url));
+
+const run = (configSecrets?: string) =>
+    spawnSync('bash', [SCRIPT], {
+        encoding: 'utf8',
+        env: { PATH: process.env.PATH, ...(configSecrets === undefined ? {} : { CONFIG_SECRETS: configSecrets }) },
+    });
+
+const masks = (stdout: string) => stdout.split('\n').filter((line) => line !== '');
+
+describe('mask-config-secrets.sh', () => {
+    it('registers every value as a mask', () => {
+        const { status, stdout, stderr } = run(JSON.stringify({ TOKEN_ONE: 'one', TOKEN_TWO: 'two' }));
+        expect(status, stderr).toBe(0);
+        expect(masks(stdout)).toStrictEqual(['::add-mask::one', '::add-mask::two']);
+    });
+
+    it('registers a multi-line value line by line, skipping empty lines', () => {
+        const { status, stdout, stderr } = run(
+            JSON.stringify({ DEPLOY_KEY: '-----BEGIN KEY-----\nabc\n\n-----END KEY-----\n' }),
+        );
+        expect(status, stderr).toBe(0);
+        expect(masks(stdout)).toStrictEqual([
+            '::add-mask::-----BEGIN KEY-----',
+            '::add-mask::abc',
+            '::add-mask::-----END KEY-----',
+        ]);
+    });
+
+    it('skips values that are not strings', () => {
+        const { status, stdout, stderr } = run(JSON.stringify({ TOKEN_ONE: 'one', COUNT: 1 }));
+        expect(status, stderr).toBe(0);
+        expect(masks(stdout)).toStrictEqual(['::add-mask::one']);
+    });
+
+    it.each([
+        ['is unset', undefined],
+        ['is empty', ''],
+    ])('does nothing when CONFIG_SECRETS %s', (_, configSecrets) => {
+        const { status, stdout, stderr } = run(configSecrets);
+        expect(status, stderr).toBe(0);
+        expect(stdout).toBe('');
+    });
+
+    it.each([
+        ['is not JSON', 'apify_api_xyzzy'],
+        ['is a JSON string', '"apify_api_xyzzy"'],
+        ['is a JSON array', '["apify_api_xyzzy"]'],
+    ])('fails without printing the value when the secret %s', (_, configSecrets) => {
+        const { status, stdout, stderr } = run(configSecrets);
+        expect(status).toBe(1);
+        expect(stdout).toContain('::error::The CONFIG_SECRETS secret must be a JSON object.');
+        expect(stdout + stderr).not.toContain('xyzzy');
+    });
+});

package/test/unit/github-scripts/run-with-apify-tokens.test.ts

@@ -0,0 +1,115 @@
+import { spawnSync } from 'node:child_process';
+import { 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';
+
+const SCRIPT = fileURLToPath(new URL('../../../.github/scripts/run-with-apify-tokens.mjs', import.meta.url));
+
+// Three Actors, each with its own token, so a test can leave any of them out.
+const CONFIG = {
+    actors: [
+        { actorFullName: 'team/one', tokenEnvVar: 'TOKEN_ONE' },
+        { actorFullName: 'team/two', tokenEnvVar: 'TOKEN_TWO' },
+        { actorFullName: 'team/three', tokenEnvVar: 'TOKEN_THREE' },
+    ],
+};
+
+// The command the wrapper runs prints what it was handed, so a test sees exactly what got through.
+const PRINT_ENV = `console.log(JSON.stringify({
+    TOKEN_ONE: process.env.TOKEN_ONE,
+    TOKEN_TWO: process.env.TOKEN_TWO,
+    TOKEN_THREE: process.env.TOKEN_THREE,
+    NPM_TOKEN: process.env.NPM_TOKEN,
+    WORKFLOW_SECRETS: process.env.WORKFLOW_SECRETS,
+}))`;
+
+let cwd: string;
+
+// `workflowSecrets` is what the step's `toJSON(secrets)` holds inside the reusable workflow.
+const run = (workflowSecrets: Record<string, string>) => {
+    const result = spawnSync(process.execPath, [SCRIPT, process.execPath, '-e', PRINT_ENV], {
+        cwd,
+        encoding: 'utf8',
+        env: { PATH: process.env.PATH, WORKFLOW_SECRETS: JSON.stringify(workflowSecrets) },
+    });
+    return { ...result, env: result.status === 0 ? JSON.parse(result.stdout) : undefined };
+};
+
+describe('run-with-apify-tokens.mjs', () => {
+    beforeAll(async () => {
+        cwd = await mkdtemp(path.join(os.tmpdir(), 'run-with-apify-tokens-'));
+        await writeFile(path.join(cwd, 'apify-test-tools.config.json'), JSON.stringify(CONFIG));
+    });
+
+    afterAll(async () => {
+        await rm(cwd, { recursive: true, force: true });
+    });
+
+    it('passes on inherited secrets, as `secrets: inherit` sends them', () => {
+        const { status, stderr, env } = run({
+            TOKEN_ONE: 'one',
+            TOKEN_TWO: 'two',
+            TOKEN_THREE: 'three',
+            NPM_TOKEN: 'npm',
+        });
+        expect(status, stderr).toBe(0);
+        expect(env).toStrictEqual({ TOKEN_ONE: 'one', TOKEN_TWO: 'two', TOKEN_THREE: 'three' });
+    });
+
+    it('unpacks the tokens from the CONFIG_SECRETS secret', () => {
+        const { status, stderr, env } = run({
+            CONFIG_SECRETS: JSON.stringify({ TOKEN_ONE: 'one', TOKEN_TWO: 'two', TOKEN_THREE: 'three' }),
+            NPM_TOKEN: 'npm',
+        });
+        expect(status, stderr).toBe(0);
+        expect(env).toStrictEqual({ TOKEN_ONE: 'one', TOKEN_TWO: 'two', TOKEN_THREE: 'three' });
+    });
+
+    it('passes on only the config names when CONFIG_SECRETS holds every secret of the caller', () => {
+        const { status, stderr, env } = run({
+            CONFIG_SECRETS: JSON.stringify({
+                TOKEN_ONE: 'one',
+                TOKEN_TWO: 'two',
+                TOKEN_THREE: 'three',
+                NPM_TOKEN: 'npm',
+                github_token: 'gh',
+            }),
+        });
+        expect(status, stderr).toBe(0);
+        expect(env).toStrictEqual({ TOKEN_ONE: 'one', TOKEN_TWO: 'two', TOKEN_THREE: 'three' });
+    });
+
+    it('prefers CONFIG_SECRETS over an inherited secret of the same name', () => {
+        const { status, stderr, env } = run({
+            CONFIG_SECRETS: JSON.stringify({ TOKEN_ONE: 'from-config-secrets' }),
+            TOKEN_ONE: 'inherited',
+            TOKEN_TWO: 'inherited',
+        });
+        expect(status, stderr).toBe(0);
+        expect(env).toStrictEqual({ TOKEN_ONE: 'from-config-secrets', TOKEN_TWO: 'inherited' });
+    });
+
+    it('warns about a token the config declares but nothing passes, and runs anyway', () => {
+        const { status, stderr, env } = run({
+            CONFIG_SECRETS: JSON.stringify({ TOKEN_ONE: 'one', TOKEN_TWO: 'two' }),
+        });
+        expect(status, stderr).toBe(0);
+        expect(stderr).toContain('declares TOKEN_THREE, but no such secret was passed');
+        expect(env).toStrictEqual({ TOKEN_ONE: 'one', TOKEN_TWO: 'two' });
+    });
+
+    it.each([
+        ['is not JSON', 'apify_api_xyzzy', 'The CONFIG_SECRETS secret is not valid JSON.'],
+        ['is a JSON string', '"apify_api_xyzzy"', 'The CONFIG_SECRETS secret must be a JSON object.'],
+        ['is a JSON array', '["apify_api_xyzzy"]', 'The CONFIG_SECRETS secret must be a JSON object.'],
+    ])('fails without printing the value when CONFIG_SECRETS %s', (_, packed, message) => {
+        const { status, stdout, stderr } = run({ CONFIG_SECRETS: packed });
+        expect(status).toBe(1);
+        expect(stderr).toContain(message);
+        expect(stdout + stderr).not.toContain('xyzzy');
+    });
+});

package/test/unit/run-checks.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+
+import { checkRun } from '../../lib/run-checks.js';
+import type { RunTestResult } from '../../lib/run-test-result.js';
+
+const fakeRun = (overrides: { status?: string; log?: string; stats?: object; chargedEventCounts?: object } = {}) =>
+    ({
+        status: overrides.status ?? 'SUCCEEDED',
+        getRunInfo: async () => ({
+            stats: { durationMillis: 5_000 },
+            chargedEventCounts: overrides.chargedEventCounts,
+        }),
+        getDataset: async () => ({ items: new Array(10) }),
+        getStatistics: async () => ({
+            requestsFailed: 0,
+            requestsRetries: 1,
+            requestRetryHistogram: [5, 1],
+            ...overrides.stats,
+        }),
+        getLog: async () => overrides.log ?? 'all good',
+    }) as unknown as RunTestResult;
+
+const failures = async (run: RunTestResult, options: Parameters<typeof checkRun>[1]) =>
+    (await checkRun(run, options)).filter(({ pass }) => !pass).map(({ name }) => name);
+
+describe('checkRun()', () => {
+    it('passes a run matching the defaults', async () => {
+        expect(await failures(fakeRun(), { datasetItemCount: 10 })).toEqual([]);
+    });
+
+    it('reports every failing check at once', async () => {
+        const run = fakeRun({ status: 'FAILED', log: 'TypeError: x', stats: { requestsFailed: 2 } });
+        expect(await failures(run, { datasetItemCount: { min: 11 } })).toEqual([
+            'status',
+            'datasetItemCount',
+            'failedRequests',
+            'forbiddenLogs',
+        ]);
+    });
+
+    it('disables a check with null', async () => {
+        const run = fakeRun({ stats: { requestsFailed: 2 } });
+        expect(await failures(run, { datasetItemCount: 10, failedRequests: null })).toEqual([]);
+    });
+
+    it('treats explicitly undefined options as disabled checks', async () => {
+        const options = { datasetItemCount: 10, duration: undefined, maxRetriesPerRequest: undefined };
+        expect(await failures(fakeRun(), options)).toEqual([]);
+    });
+
+    it('checks the longest retry chain only when asked to', async () => {
+        expect(await failures(fakeRun(), { datasetItemCount: 10, maxRetriesPerRequest: 0 })).toEqual([
+            'maxRetriesPerRequest',
+        ]);
+        expect(await failures(fakeRun(), { datasetItemCount: 10, maxRetriesPerRequest: 1 })).toEqual([]);
+    });
+
+    describe('chargedEventCounts', () => {
+        const run = fakeRun({ chargedEventCounts: { start: 1, item: 7 } });
+
+        it('passes matching counts and intervals', async () => {
+            const options = { datasetItemCount: 10, chargedEventCounts: { start: 1, item: { min: 5 } } };
+            expect(await failures(run, options)).toEqual([]);
+        });
+
+        it('expects unlisted charged events to not happen', async () => {
+            const options = { datasetItemCount: 10, chargedEventCounts: { start: 1 } as Record<string, number> };
+            expect(await failures(run, options)).toEqual(['chargedEventCounts.item']);
+        });
+
+        it('fails an expected event that was never charged', async () => {
+            const options = { datasetItemCount: 10, chargedEventCounts: { start: 1, item: 7, extra: { min: 0 } } };
+            expect(await failures(run, options)).toEqual(['chargedEventCounts.extra']);
+        });
+    });
+});

package/test/unit/run-test-result.test.ts

@@ -0,0 +1,44 @@
+import type { ActorRun, ApifyClient } from 'apify-client';
+import { describe, expect, it, vi } from 'vitest';
+
+import { RunTestResult } from '../../lib/run-test-result.js';
+
+const run = { id: 'run', status: 'SUCCEEDED', defaultDatasetId: 'ds', defaultKeyValueStoreId: 'kvs' } as ActorRun;
+
+describe('RunTestResult', () => {
+    it('fetches the log once, even when empty or requested concurrently', async () => {
+        const get = vi.fn(async () => '');
+        const client = { run: () => ({ log: () => ({ get }) }) } as unknown as ApifyClient;
+        const result = new RunTestResult(client, run);
+
+        await Promise.all([result.getLog(), result.getLog()]);
+        await result.getLog();
+
+        expect(get).toHaveBeenCalledTimes(1);
+    });
+
+    it('retries after a failed fetch', async () => {
+        const get = vi.fn().mockRejectedValueOnce(new Error('boom')).mockResolvedValueOnce('log');
+        const client = { run: () => ({ log: () => ({ get }) }) } as unknown as ApifyClient;
+        const result = new RunTestResult(client, run);
+
+        await expect(result.getLog()).rejects.toThrow('boom');
+        expect(await result.getLog()).toBe('log');
+    });
+
+    it('pages through the dataset instead of listing it in one response', async () => {
+        const total = 25_000;
+        const listItems = vi.fn(async ({ offset, limit }: { offset: number; limit: number }) => ({
+            total,
+            items: Array.from({ length: Math.min(limit, total - offset) }, (_, i) => offset + i),
+        }));
+        const client = { dataset: () => ({ listItems }) } as unknown as ApifyClient;
+        const result = new RunTestResult(client, run);
+
+        const { items } = await result.getDataset<number>();
+
+        expect(items).toHaveLength(total);
+        expect(items[24_999]).toBe(24_999);
+        expect(listItems).toHaveBeenCalledTimes(25);
+    });
+});

package/test/unit/should-built-and-test.test.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { afterAll, describe, expect, test } from 'vitest';
 
 import { getChangedActors } from '../../bin/diff-changes.js';
-import type { ActorConfig, Commit } from '../../bin/types.js';
+import type { ActorConfig } from '../../bin/types.js';
 import { ExistingDir, ExistingFile, RelativeDir, RelativeFile } from '../../bin/utils/path/repo-relative.js';
 
 const originalCwd = process.cwd();
@@ -41,6 +41,16 @@ const actorConfig = (
     };
 };
 
+// What a PR (functional changes only) or a release (isLatest, all changes) builds, in config order
+const changedActorsFor = async ({
+    isLatest = false,
+    ...options
+}: Parameters<typeof getChangedActors>[0] & { isLatest?: boolean }): Promise<ActorConfig[]> => {
+    const { functional, cosmetic } = await getChangedActors(options);
+    const changed = isLatest ? [...functional, ...cosmetic] : functional;
+    return options.actorConfigs.filter((config) => changed.includes(config));
+};
+
 describe('Should build and test parser', () => {
     // From https://github.com/apify-store/testing-repo-for-github-actions
     const ACTOR_CONFIGS: ActorConfig[] = [
@@ -62,19 +72,16 @@ describe('Should build and test parser', () => {
         ),
     ];
 
-    const commits: Commit[] = [
-        { sha: 'Commit1', author: '', date: '', message: '' },
-        { sha: 'Commit3', author: '', date: '', message: '' },
-    ];
+    const range = { fromRef: 'Commit0', toRef: 'Commit3' };
 
     test('Ignores dev-only readme', async () => {
         const FILES = ['README.md', 'code/README.md', 'shared/README.md'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([]);
@@ -83,11 +90,11 @@ describe('Should build and test parser', () => {
     test('Ignores other ignored files and folders', async () => {
         const FILES = ['.vscode/settings.json', '.gitignore', '.husky/pre-commit', '.eslintrc', '.editorconfig'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([]);
@@ -96,11 +103,11 @@ describe('Should build and test parser', () => {
     test('.actor/ changes trigger builds for broad-context actors', async () => {
         const FILES = ['.actor/actor.json'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -109,19 +116,19 @@ describe('Should build and test parser', () => {
     test('Configured changelog is cosmetic for every actor, only on latest', async () => {
         const FILES = ['CHANGELOG.md'];
 
-        const actorsChangedNotLatest = await getChangedActors({
+        const actorsChangedNotLatest = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
         expect(actorsChangedNotLatest).toEqual([]);
 
-        const actorsChangedLatest = await getChangedActors({
+        const actorsChangedLatest = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
         expect(actorsChangedLatest).toEqual(ACTOR_CONFIGS);
     });
@@ -129,11 +136,11 @@ describe('Should build and test parser', () => {
     test('A changelog nested inside one actor own folder is excluded for sibling actors', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/CHANGELOG.md'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -142,11 +149,11 @@ describe('Should build and test parser', () => {
     test('Code updated, tests broad-context actors', async () => {
         const FILES = ['code/src/main.ts', 'package.json'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -158,11 +165,11 @@ describe('Should build and test parser', () => {
             'standalone-actors/lukaskrivka_test-standalone/Dockerfile',
         ];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0], ACTOR_CONFIGS[2]]);
@@ -171,11 +178,11 @@ describe('Should build and test parser', () => {
     test('src/main.ts updated', async () => {
         const FILES = ['src/main.ts'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -188,11 +195,11 @@ describe('Should build and test parser', () => {
             'standalone-actors/lukaskrivka_test-standalone/Dockerfile',
         ];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS);
@@ -204,11 +211,11 @@ describe('Should build and test parser', () => {
             'standalone-actors/lukaskrivka_test-standalone/README.md',
         ];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([]);
@@ -217,11 +224,11 @@ describe('Should build and test parser', () => {
     test('Actor JSON changes in PR context trigger tests', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -230,11 +237,11 @@ describe('Should build and test parser', () => {
     test('Actor JSON changes in latest context trigger builds', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -243,11 +250,11 @@ describe('Should build and test parser', () => {
     test('JSON file with functional changes triggers tests', async () => {
         const FILES = ['actors/lukaskrivka_testing-github-integration-1/.actor/actor.json'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
@@ -259,11 +266,11 @@ describe('Should build and test parser', () => {
             'actors/lukaskrivka_testing-github-integration-2/.actor/input_schema.json',
         ];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
@@ -272,11 +279,11 @@ describe('Should build and test parser', () => {
     test('Narrow-context actor JSON change in PR context triggers tests', async () => {
         const FILES = ['standalone-actors/lukaskrivka_test-standalone/.actor/actor.json'];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[2]]);
@@ -331,11 +338,11 @@ describe('Should build and test parser', () => {
             ),
         ];
 
-        const actorsChanged = await getChangedActors({
+        const actorsChanged = await changedActorsFor({
             actorConfigs: ACTOR_CONFIGS_GOOGLE_MAPS,
             isLatest: false,
             filepathsChanged: FILES,
-            commits,
+            range,
         });
 
         expect(actorsChanged).toEqual(ACTOR_CONFIGS_GOOGLE_MAPS.slice(0, 8));