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

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

@@ -0,0 +1,221 @@
+import type { MockInstance } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getAffectedActors } from '../../../bin/affected-actors.js';
+import * as DiffChanges from '../../../bin/diff-changes.js';
+import * as Git from '../../../bin/git.js';
+import type { ActorConfig, Commit } from '../../../bin/types.js';
+import * as LoadConfig from '../../../bin/utils/config/load-config.js';
+
+// Everything that reads the configs is mocked, so only the identity and name of an Actor matter here
+const actorA = { actorFullName: 'owner/a' } as ActorConfig;
+const actorB = { actorFullName: 'owner/b' } as ActorConfig;
+
+const headSha = 'f'.repeat(40);
+const sinceSha = '5'.repeat(40);
+const commit = (sha: string): Commit => ({ sha, author: 'Dev<dev@example.com>', date: 'Date', message: 'msg' });
+const commits = [commit('1'.repeat(40)), commit('2'.repeat(40))];
+const changedFiles = ['src/main.ts', 'CHANGELOG.md'];
+
+const selection = { actors: [], ignore: [] };
+
+describe('getAffectedActors', () => {
+    let changedActorsSpy: MockInstance;
+
+    beforeEach(() => {
+        vi.spyOn(LoadConfig, 'readConfigFile').mockResolvedValue([actorA, actorB]);
+        vi.spyOn(LoadConfig, 'readRepoSettings').mockResolvedValue({ platformTestsGlob: 'test/platform/**' });
+        changedActorsSpy = vi
+            .spyOn(DiffChanges, 'getChangedActors')
+            .mockResolvedValue({ functional: [actorA], cosmetic: [actorB], test: [] });
+        vi.spyOn(Git, 'resolveCommitSha').mockResolvedValue(headSha);
+        vi.spyOn(Git, 'getChangedFilesBetween').mockResolvedValue(changedFiles);
+        vi.spyOn(Git, 'getChangelogAdditions').mockResolvedValue('- Added foo');
+    });
+
+    it('requires --base or --since', async () => {
+        const options = { ...selection };
+        await expect(getAffectedActors(options)).rejects.toThrow('Pass --base, --since, or both');
+        // An empty --since (e.g. from an empty cache file) counts as not passed
+        await expect(getAffectedActors({ ...options, since: '' })).rejects.toThrow('Pass --base, --since, or both');
+    });
+
+    describe('with --base', () => {
+        const mergeBaseSha = 'b'.repeat(40);
+        let commitsBetweenSpy: MockInstance;
+
+        beforeEach(() => {
+            vi.spyOn(Git, 'getMergeBase').mockResolvedValue(mergeBaseSha);
+            commitsBetweenSpy = vi.spyOn(Git, 'getCommitsBetween').mockResolvedValue(commits);
+        });
+
+        it("inspects the branch's own changes, from where it forked from or last merged --base", async () => {
+            const findCommitSpy = vi.spyOn(Git, 'findCommitSha');
+
+            const result = await getAffectedActors({ base: 'origin/master', ...selection });
+
+            expect(result).toStrictEqual({
+                version: 1,
+                head: headSha,
+                commits,
+                changedFiles,
+                changelog: '- Added foo',
+                // Only the names, the config file stays the source of truth for the rest
+                functionallyChangedActors: [{ actorFullName: 'owner/a' }],
+                cosmeticallyChangedActors: [{ actorFullName: 'owner/b' }],
+                testChangedActors: [],
+            });
+            expect(Git.getMergeBase).toHaveBeenCalledWith('origin/master', 'HEAD');
+            expect(Git.getChangedFilesBetween).toHaveBeenCalledWith(mergeBaseSha, headSha);
+            expect(Git.getChangelogAdditions).toHaveBeenCalledWith(mergeBaseSha, headSha, changedFiles);
+            expect(commitsBetweenSpy).toHaveBeenCalledWith(mergeBaseSha, headSha);
+            expect(changedActorsSpy).toHaveBeenCalledWith({
+                filepathsChanged: changedFiles,
+                actorConfigs: [actorA, actorB],
+                range: { fromRef: mergeBaseSha, toRef: headSha },
+                platformTestsGlob: 'test/platform/**',
+            });
+            expect(findCommitSpy).not.toHaveBeenCalled();
+        });
+
+        describe('and --since', () => {
+            const sinceFiles = ['README.md'];
+
+            beforeEach(() => {
+                vi.spyOn(Git, 'findCommitSha').mockResolvedValue(sinceSha);
+                vi.spyOn(Git, 'getChangedFilesBetween').mockImplementation(async (fromRef) =>
+                    fromRef === sinceSha ? sinceFiles : changedFiles,
+                );
+            });
+
+            const getNarrowed = async (
+                branch: DiffChanges.ChangedActors,
+                sinceValidated: DiffChanges.ChangedActors,
+            ) => {
+                changedActorsSpy.mockImplementation(async ({ range }) =>
+                    range.fromRef === sinceSha ? sinceValidated : branch,
+                );
+                const result = await getAffectedActors({ base: 'origin/master', since: sinceSha, ...selection });
+                return {
+                    functional: result.functionallyChangedActors.map(({ actorFullName }) => actorFullName),
+                    cosmetic: result.cosmeticallyChangedActors.map(({ actorFullName }) => actorFullName),
+                    test: result.testChangedActors.map(({ actorFullName }) => actorFullName),
+                };
+            };
+
+            it('classifies the changes since --since separately', async () => {
+                await getNarrowed(
+                    { functional: [actorA], cosmetic: [], test: [] },
+                    { functional: [actorA], cosmetic: [], test: [] },
+                );
+                expect(changedActorsSpy).toHaveBeenCalledWith({
+                    filepathsChanged: sinceFiles,
+                    actorConfigs: [actorA, actorB],
+                    range: { fromRef: sinceSha, toRef: headSha },
+                    platformTestsGlob: 'test/platform/**',
+                });
+            });
+
+            it('still describes the whole branch', async () => {
+                const result = await getAffectedActors({ base: 'origin/master', since: sinceSha, ...selection });
+                expect(result.commits).toStrictEqual(commits);
+                expect(result.changedFiles).toStrictEqual(changedFiles);
+            });
+
+            it('retests an Actor whose validated change meets a new functional change', async () => {
+                await expect(
+                    getNarrowed(
+                        { functional: [actorA], cosmetic: [], test: [] },
+                        { functional: [actorA], cosmetic: [], test: [] },
+                    ),
+                ).resolves.toStrictEqual({ functional: ['owner/a'], cosmetic: [], test: [] });
+            });
+
+            it('leaves out Actors that only the branch changed before --since or only --base changed', async () => {
+                await expect(
+                    getNarrowed(
+                        { functional: [actorA], cosmetic: [], test: [] },
+                        { functional: [actorB], cosmetic: [], test: [] },
+                    ),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: [], test: [] });
+            });
+
+            it('takes the less impactful change when the two disagree', async () => {
+                // A validated functional change, then only cosmetic changes (e.g. a README merged in from base)
+                await expect(
+                    getNarrowed(
+                        { functional: [actorA], cosmetic: [], test: [] },
+                        { functional: [], cosmetic: [actorA], test: [] },
+                    ),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: ['owner/a'], test: [] });
+                // A functional change merged in from base, while the branch only changes the README
+                await expect(
+                    getNarrowed(
+                        { functional: [], cosmetic: [actorA], test: [] },
+                        { functional: [actorA], cosmetic: [], test: [] },
+                    ),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: ['owner/a'], test: [] });
+            });
+
+            it('runs the tests of an Actor whose tests the branch changed and changed again since --since', async () => {
+                await expect(
+                    getNarrowed(
+                        { functional: [actorA], cosmetic: [], test: [actorA, actorB] },
+                        { functional: [], cosmetic: [], test: [actorA] },
+                    ),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: [], test: ['owner/a'] });
+            });
+
+            it('leaves out test changes that only --base or only the validated part of the branch has', async () => {
+                await expect(
+                    getNarrowed(
+                        { functional: [], cosmetic: [], test: [actorA] },
+                        { functional: [], cosmetic: [], test: [actorB] },
+                    ),
+                ).resolves.toStrictEqual({ functional: [], cosmetic: [], test: [] });
+            });
+
+            it.each([
+                ['is HEAD (a rerun)', headSha],
+                ['is not in the local history', undefined],
+            ])('checks the whole branch when --since %s', async (_, found) => {
+                vi.spyOn(Git, 'findCommitSha').mockResolvedValue(found);
+                const result = await getAffectedActors({ base: 'origin/master', since: sinceSha, ...selection });
+                expect(result.functionallyChangedActors).toStrictEqual([{ actorFullName: 'owner/a' }]);
+                // With no usable validated commit, the "since" diff falls back to the same range as the
+                // base diff, so getChangedActors runs twice for identical ranges instead of once.
+                expect(changedActorsSpy).toHaveBeenCalledTimes(2);
+            });
+        });
+    });
+
+    describe('with --since only', () => {
+        let resolveBaseSpy: MockInstance;
+        let commitsBetweenSpy: MockInstance;
+
+        beforeEach(() => {
+            resolveBaseSpy = vi.spyOn(Git, 'resolveReleaseBaseCommit').mockResolvedValue(sinceSha);
+            commitsBetweenSpy = vi.spyOn(Git, 'getCommitsBetween').mockResolvedValue(commits);
+        });
+
+        it('inspects everything after --since up to HEAD', async () => {
+            const result = await getAffectedActors({ since: 'HEAD~2', ...selection });
+
+            expect(result).toStrictEqual({
+                version: 1,
+                head: headSha,
+                commits,
+                changedFiles,
+                changelog: '- Added foo',
+                // Only the names, the config file stays the source of truth for the rest
+                functionallyChangedActors: [{ actorFullName: 'owner/a' }],
+                cosmeticallyChangedActors: [{ actorFullName: 'owner/b' }],
+                testChangedActors: [],
+            });
+            expect(resolveBaseSpy).toHaveBeenCalledWith('HEAD~2');
+            expect(commitsBetweenSpy).toHaveBeenCalledWith(sinceSha, headSha);
+            expect(Git.getChangedFilesBetween).toHaveBeenCalledWith(sinceSha, headSha);
+            expect(Git.getChangelogAdditions).toHaveBeenCalledWith(sinceSha, headSha, changedFiles);
+        });
+    });
+});

package/test/unit/bin/build-cli.test.ts

@@ -0,0 +1,61 @@
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import { compileCli } from './compiled-cli.js';
+
+let cliPath: string;
+let cleanup: (() => Promise<void>) | undefined;
+
+const run = (command: string[], input: string, env: NodeJS.ProcessEnv = process.env) =>
+    spawnSync(cliPath, command, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'pipe'], env });
+const runBuild = (input: string, args: string[] = ['--version-number', '0.99']) => run(['build', ...args], input);
+
+describe('build and notify CLI', () => {
+    beforeAll(async () => {
+        ({ cliPath, cleanup } = await compileCli());
+    });
+
+    afterAll(async () => {
+        await cleanup?.();
+    });
+
+    it('builds nothing for an empty list and prints an empty build list', () => {
+        const result = runBuild('{"actors":[]}');
+        expect(result.status, result.stderr).toBe(0);
+        expect(JSON.parse(result.stdout)).toStrictEqual([]);
+    });
+
+    it('fails on empty stdin instead of building nothing', () => {
+        const result = runBuild('');
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('Expected the Actors to build as JSON on stdin, got nothing');
+        expect(result.stdout).toBe('');
+    });
+
+    it('rejects a malformed --version-number', () => {
+        const result = runBuild('{"actors":[]}', ['--version-number', 'latest']);
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('--version-number must look like 0.1 or be "default"');
+    });
+
+    it('requires --version-number', () => {
+        const result = runBuild('{"actors":[]}', []);
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('Missing required argument: version-number');
+    });
+
+    it('notify takes one channel per call', () => {
+        const result = run(['notify', '--slack-channel', '#a', '--slack-channel', '#b'], '{}');
+        expect(result.status).toBe(1);
+        expect(result.stderr).toContain('--slack-channel takes one channel, call notify once for each channel');
+    });
+
+    it('notify announces no release when there are no new commits', () => {
+        const document = { commits: [], changedFiles: [], changelog: null, functionallyChangedActors: [] };
+        const result = run(['notify', '--slack-channel', '#notif'], 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-from-local.test.ts

@@ -289,5 +289,21 @@ describe('build-from-local helpers', () => {
             // Only the read-only lookup ran: builders for uploads and builds are created after the dry-run cutoff
             expect(fromActorConfig).toHaveBeenCalledTimes(1);
         });
+
+        it('fails before zipping anything when asked to require env vars in sync and they are not', async () => {
+            vi.spyOn(ApifyBuilder, 'fromActorConfig').mockReturnValue({
+                getActorInfo: async () => ({
+                    defaultRunOptions: { build: 'latest' },
+                    taggedBuilds: { latest: { buildNumber: '0.1.5' } },
+                    versions: [{ versionNumber: '0.1', sourceType: 'GIT_REPO', envVars: [{ name: 'API_KEY' }] }],
+                }),
+            } as unknown as ApifyBuilder);
+            // Only the name matters, the check runs before the sources are read
+            const actorConfig = { actorFullName: 'owner/actor' } as unknown as ActorConfig;
+
+            await expect(
+                runBuildsFromLocal({ actorConfigs: [actorConfig], dryRun: true, requireEnvVarsInSync: true }),
+            ).rejects.toThrow('Env vars of version 0.98 are out of sync with default version 0.1 (missing API_KEY)');
+        });
     });
 });

package/test/unit/bin/build.test.ts

@@ -7,11 +7,16 @@ import { ActorSourceType, ApifyClient } from 'apify-client';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
+    ApifyBuilder,
+    assertEnvVarsMatchDefaultVersion,
     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 +89,119 @@ 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('assertEnvVarsMatchDefaultVersion', () => {
+    const makeVersion = (versionNumber: string, names: string[]): ApifyClientTypes.ActorVersion => ({
+        versionNumber,
+        sourceType: ActorSourceType.GitRepo,
+        gitRepoUrl: REPO_URL,
+        envVars: names.map((name) => ({ name, isSecret: true })),
+    });
+    const makeActorInfoWithEnvVars = (defaultNames: string[], testNames?: string[]) =>
+        makeActorInfo({
+            versions: [makeVersion('0.1', defaultNames), ...(testNames ? [makeVersion('0.99', testNames)] : [])],
+        });
+    const check = (actorInfo: ApifyClientTypes.Actor, versionNumber = '0.99') =>
+        assertEnvVarsMatchDefaultVersion(
+            ACTOR,
+            actorInfo,
+            resolveDefaultVersion(ACTOR, actorInfo).defaultVersion,
+            versionNumber,
+        );
+
+    it('should pass when the names match in any order, whatever the values', () => {
+        expect(() => check(makeActorInfoWithEnvVars(['A', 'B'], ['B', 'A']))).not.toThrow();
+    });
+
+    it('should pass for the default version itself', () => {
+        expect(() => check(makeActorInfoWithEnvVars(['A']), '0.1')).not.toThrow();
+    });
+
+    it('should pass when neither version has env vars', () => {
+        expect(() => check(makeActorInfo())).not.toThrow();
+    });
+
+    it('should list the missing and extra names', () => {
+        expect(() => check(makeActorInfoWithEnvVars(['A', 'B'], ['B', 'C']))).toThrow(
+            'Env vars of version 0.99 are out of sync with default version 0.1 (missing A; extra C)',
+        );
+    });
+
+    it('should ask to create the version when it does not exist yet', () => {
+        expect(() => check(makeActorInfoWithEnvVars(['A']))).toThrow("Version 0.99 doesn't exist yet");
+    });
+
+    it('should throw when the default version no longer exists', () => {
+        expect(() => assertEnvVarsMatchDefaultVersion(ACTOR, makeActorInfo(), undefined, '0.99')).toThrow(
+            'no longer exists',
+        );
+    });
+});
+
 describe('dry run', () => {
     const TOKEN_ENV_VAR = 'APIFY_TOKEN_OWNER';
     const originalCwd = process.cwd();
@@ -118,11 +236,14 @@ describe('dry run', () => {
     const createVersion = vi.fn();
     const buildClient = vi.fn(() => ({ delete: deleteBuild }));
 
+    let actorInfo: ApifyClientTypes.Actor;
+
     beforeEach(() => {
         vi.stubEnv(TOKEN_ENV_VAR, 'token');
+        actorInfo = makeActorInfo();
         const fakeClient = {
             actor: () => ({
-                get: async () => makeActorInfo(),
+                get: async () => actorInfo,
                 // Old enough to be deleted, and not the default build 0.1.5
                 builds: () => ({
                     list: async () => ({ items: [{ id: 'old-build', buildNumber: '0.0.1', startedAt: new Date(0) }] }),
@@ -143,14 +264,15 @@ describe('dry run', () => {
         vi.clearAllMocks();
     });
 
-    const runDryBuilds = async () =>
+    const runDryBuilds = async (requireEnvVarsInSync = false) =>
         runBuilds({
             actorConfigs: [actorConfig],
             repoUrl: REPO_URL,
             shouldVerifyRepoUrl: true,
             branch: 'feature',
             dryRun: true,
-            useDockerCache: false,
+            versionNumber: '0.99',
+            requireEnvVarsInSync,
         });
 
     it('should return a build plan without creating versions or builds', async () => {
@@ -161,7 +283,6 @@ describe('dry run', () => {
                     actorFullName: ACTOR,
                     versionNumber: '0.99',
                     gitRepoUrl: `${REPO_URL}#feature:actors/a`,
-                    useDockerCache: false,
                 },
             ],
         });
@@ -182,11 +303,34 @@ describe('dry run', () => {
                 shouldVerifyRepoUrl: true,
                 branch: 'feature',
                 dryRun: true,
-                useDockerCache: false,
+                versionNumber: '0.99',
             }),
         ).rejects.toThrow('Repository mismatch');
     });
 
+    describe('with the default version holding an env var the test version lacks', () => {
+        beforeEach(() => {
+            actorInfo = makeActorInfo({
+                versions: [
+                    {
+                        versionNumber: '0.1',
+                        sourceType: ActorSourceType.GitRepo,
+                        gitRepoUrl: REPO_URL,
+                        envVars: [{ name: 'API_KEY', isSecret: true }],
+                    },
+                ],
+            });
+        });
+
+        it('should still check the env vars when asked to', async () => {
+            await expect(runDryBuilds(true)).rejects.toThrow('missing API_KEY');
+        });
+
+        it('should not check the env vars unless asked to', async () => {
+            await expect(runDryBuilds()).resolves.toMatchObject({ dryRun: true });
+        });
+    });
+
     it('should not delete old builds', async () => {
         await deleteOldBuilds([actorConfig], { dryRun: true });
         expect(deleteBuild).not.toHaveBeenCalled();

package/test/unit/bin/compiled-cli.ts

@@ -0,0 +1,23 @@
+import { execFileSync } from 'node:child_process';
+import { chmod, mkdtemp, rm } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const projectRoot = fileURLToPath(new URL('../../../', import.meta.url));
+const compilerPath = fileURLToPath(new URL('../../../node_modules/typescript/bin/tsc', import.meta.url));
+
+/** Compiles the CLI from the sources into a temporary directory, so tests run it the way npm users do. */
+export const compileCli = async () => {
+    const buildDir = await mkdtemp(path.join(projectRoot, '.cli-test-'));
+    const cleanup = async () => rm(buildDir, { recursive: true, force: true });
+    try {
+        execFileSync(process.execPath, [compilerPath, '--outDir', buildDir], { cwd: projectRoot });
+        const cliPath = path.join(buildDir, 'bin/main.js');
+        await chmod(cliPath, 0o755);
+        return { cliPath, cleanup };
+    } catch (error) {
+        await cleanup();
+        throw error;
+    }
+};