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

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

@@ -1,8 +1,25 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
 import type * as ApifyClientTypes from 'apify-client';
-import { ActorSourceType } from 'apify-client';
-import { describe, expect, it } from 'vitest';
+import { ActorSourceType, ApifyClient } from 'apify-client';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+    assertRepoUrlMatchesDefaultVersion,
+    deleteOldBuilds,
+    resolveDefaultVersion,
+    runBuilds,
+} from '../../../bin/build.js';
+import type { ActorConfig } from '../../../bin/types.js';
+import { ExistingDir, ExistingFile, RelativeDir } from '../../../bin/utils/path/repo-relative.js';
 
-import { assertRepoUrlMatchesDefaultVersion, resolveDefaultVersion } from '../../../bin/build.js';
+// Only the client is faked, so the tests exercise the real builder code against a stubbed API
+vi.mock('apify-client', async (importOriginal) => {
+    const actual = await importOriginal<typeof ApifyClientTypes>();
+    return { ...actual, ApifyClient: vi.fn() };
+});
 
 const ACTOR = 'owner/actor';
 const REPO_URL = 'git@github.com:owner/repo';
@@ -66,3 +83,118 @@ describe('assertRepoUrlMatchesDefaultVersion', () => {
         expect(() => assertRepoUrlMatchesDefaultVersion(ACTOR, undefined, REPO_URL)).toThrow('no longer exists');
     });
 });
+
+describe('dry run', () => {
+    const TOKEN_ENV_VAR = 'APIFY_TOKEN_OWNER';
+    const originalCwd = process.cwd();
+    let fixtureRoot: string;
+    let actorConfig: ActorConfig;
+
+    // ExistingDir checks the folder exists, so the config is built inside a throwaway repo root
+    beforeAll(() => {
+        fixtureRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'apify-build-dry-run-'));
+        process.chdir(fixtureRoot);
+        fs.mkdirSync('actors/a/.actor', { recursive: true });
+        fs.writeFileSync('actors/a/.actor/actor.json', '{}');
+        actorConfig = {
+            actorFullName: ACTOR,
+            folder: new ExistingDir('actors/a'),
+            tokenEnvVar: TOKEN_ENV_VAR,
+            actorJson: {
+                file: new ExistingFile('actors/a/.actor/actor.json'),
+                dockerContextDir: new RelativeDir('actors/a'),
+            },
+            dockerContextDir: new RelativeDir('actors/a'),
+            contextPaths: [new RelativeDir('actors/a')],
+        };
+    });
+
+    afterAll(() => {
+        process.chdir(originalCwd);
+        fs.rmSync(fixtureRoot, { recursive: true, force: true });
+    });
+    const deleteBuild = vi.fn();
+    const startBuild = vi.fn();
+    const createVersion = vi.fn();
+    const buildClient = vi.fn(() => ({ delete: deleteBuild }));
+
+    beforeEach(() => {
+        vi.stubEnv(TOKEN_ENV_VAR, 'token');
+        const fakeClient = {
+            actor: () => ({
+                get: async () => makeActorInfo(),
+                // 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) }] }),
+                }),
+                versions: () => ({ create: createVersion }),
+                version: () => ({ update: createVersion }),
+                build: startBuild,
+            }),
+            build: buildClient,
+        };
+        vi.mocked(ApifyClient).mockImplementation(function () {
+            return fakeClient;
+        } as never);
+    });
+
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.clearAllMocks();
+    });
+
+    const runDryBuilds = async () =>
+        runBuilds({
+            actorConfigs: [actorConfig],
+            repoUrl: REPO_URL,
+            shouldVerifyRepoUrl: true,
+            branch: 'feature',
+            dryRun: true,
+            useDockerCache: false,
+        });
+
+    it('should return a build plan without creating versions or builds', async () => {
+        expect(await runDryBuilds()).toEqual({
+            dryRun: true,
+            builds: [
+                {
+                    actorFullName: ACTOR,
+                    versionNumber: '0.99',
+                    gitRepoUrl: `${REPO_URL}#feature:actors/a`,
+                    useDockerCache: false,
+                },
+            ],
+        });
+        expect(createVersion).not.toHaveBeenCalled();
+        expect(startBuild).not.toHaveBeenCalled();
+    });
+
+    it('should still require the Apify token', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await expect(runDryBuilds()).rejects.toThrow(`Env var ${TOKEN_ENV_VAR} is not set`);
+    });
+
+    it('should still check the repository URL', async () => {
+        await expect(
+            runBuilds({
+                actorConfigs: [actorConfig],
+                repoUrl: 'git@github.com:fork/repo',
+                shouldVerifyRepoUrl: true,
+                branch: 'feature',
+                dryRun: true,
+                useDockerCache: false,
+            }),
+        ).rejects.toThrow('Repository mismatch');
+    });
+
+    it('should not delete old builds', async () => {
+        await deleteOldBuilds([actorConfig], { dryRun: true });
+        expect(deleteBuild).not.toHaveBeenCalled();
+    });
+
+    it('should delete old builds outside of a dry run', async () => {
+        await deleteOldBuilds([actorConfig], { dryRun: false });
+        expect(buildClient).toHaveBeenCalledWith('old-build');
+        expect(deleteBuild).toHaveBeenCalledTimes(1);
+    });
+});

package/test/unit/bin/diff-changes.test.ts

@@ -63,6 +63,7 @@ const commits = [{ sha: 'Commit1', author: '', date: '', message: '' }];
 
 describe('getChangedActors', () => {
     beforeEach(() => {
+        vi.restoreAllMocks();
         vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(false);
     });
 
@@ -393,6 +394,72 @@ describe('getChangedActors', () => {
         expect(result).toEqual([miniActor]);
     });
 
+    it('test file listed in .dockerignore triggers a build when it matches the test files glob', async () => {
+        vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.startsWith('test/'));
+        const result = await getChangedActors({
+            filepathsChanged: ['test/platform/daily/foo.test.ts'],
+            actorConfigs: [miniActor],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('test file listed in .dockerignore stays ignored without a test files glob', async () => {
+        vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue((filePath) => filePath.startsWith('test/'));
+        const result = await getChangedActors({
+            filepathsChanged: ['test/platform/daily/foo.test.ts'],
+            actorConfigs: [miniActor],
+            commits,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('test files glob matches case-insensitively and does not bypass .dockerignore for other files', async () => {
+        vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(() => true);
+        const result = await getChangedActors({
+            filepathsChanged: ['Test/Platform/Foo.test.ts'],
+            actorConfigs: [miniActor],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+        expect(result).toEqual([miniActor]);
+        expect(
+            await getChangedActors({
+                filepathsChanged: ['actors/foo_bar/node_modules/foo.js'],
+                actorConfigs: [miniActor],
+                commits,
+                testFilesGlob: 'test/platform/**',
+            }),
+        ).toEqual([]);
+    });
+
+    it('test file outside an actor context still does not trigger it', async () => {
+        vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(() => true);
+        const result = await getChangedActors({
+            filepathsChanged: ['test/platform/daily/foo.test.ts'],
+            actorConfigs: [standaloneActor],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('test file listed in .dockerignore triggers an actor whose overrideActorContext includes it', async () => {
+        vi.spyOn(Dockerignore, 'loadDockerIgnore').mockReturnValue(() => true);
+        const actorWithTests = {
+            ...standaloneActor,
+            contextPaths: [...standaloneActor.contextPaths, new RelativeDir('test')],
+        };
+        const result = await getChangedActors({
+            filepathsChanged: ['test/platform/standalone.test.ts'],
+            actorConfigs: [actorWithTests],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+        expect(result).toEqual([actorWithTests]);
+    });
+
     it('JSON file in context but outside actor folder is functional (not checked for cosmetic)', async () => {
         const result = await getChangedActors({
             filepathsChanged: ['lib/config.json'],
@@ -473,6 +540,7 @@ describe('getChangedActors logging', () => {
     beforeEach(() => {
         vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockResolvedValue(false);
         vi.spyOn(logger, 'info').mockImplementation(() => undefined);
+        vi.spyOn(logger, 'warn').mockImplementation(() => undefined);
     });
 
     it('logs a single "specific" group for a single actor with one functional file', async () => {
@@ -525,6 +593,44 @@ describe('getChangedActors logging', () => {
         ]);
     });
 
+    const outsideContextWarning = (testFile: string) =>
+        `[DIFF]: Test file ${testFile} is outside every Actor's context, so changing only it builds and tests nothing. ` +
+        'Add its folder to "overrideActorContext" of the Actors it tests.';
+
+    it('warns about a changed test file outside every Actor context', async () => {
+        await getChangedActors({
+            filepathsChanged: ['test/platform/standalone.test.ts'],
+            actorConfigs: [standaloneActor],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+
+        expect(logger.warn).toHaveBeenCalledWith(outsideContextWarning('test/platform/standalone.test.ts'));
+    });
+
+    it('still warns when the same push also rebuilds an Actor', async () => {
+        const result = await getChangedActors({
+            filepathsChanged: ['test/platform/standalone.test.ts', 'standalone-actors/standalone/src/main.ts'],
+            actorConfigs: [standaloneActor],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+
+        expect(result).toEqual([standaloneActor]);
+        expect(logger.warn).toHaveBeenCalledWith(outsideContextWarning('test/platform/standalone.test.ts'));
+    });
+
+    it('does not warn about test files inside an Actor context, even cosmetic ones', async () => {
+        await getChangedActors({
+            filepathsChanged: ['test/platform/foo.test.ts', 'test/platform/README.md', 'test/platform/CHANGELOG.md'],
+            actorConfigs: [miniActor],
+            commits,
+            testFilesGlob: 'test/platform/**',
+        });
+
+        expect(logger.warn).not.toHaveBeenCalled();
+    });
+
     it('logs no group lines when zero actors changed', async () => {
         await getChangedActors({
             filepathsChanged: ['.gitignore', '.prettierrc'],

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

@@ -0,0 +1,65 @@
+import { WebClient } from '@slack/web-api';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { notifyToSlack } from '../../../bin/slack.js';
+
+vi.mock('@slack/web-api', () => ({ WebClient: vi.fn() }));
+
+const TOKEN_ENV_VAR = 'SLACK_TOKEN_RELEASES_BOT';
+const postMessage = vi.fn();
+const authTest = vi.fn();
+
+const notify = async (overrides: Partial<Parameters<typeof notifyToSlack>[0]> = {}) =>
+    notifyToSlack({
+        repository: 'owner/repo',
+        changedFiles: ['src/main.ts'],
+        changelog: '- Fixed a bug',
+        commits: [{ sha: '1', author: 'Test<test@example.com>', date: '', message: 'fix: bug' }],
+        author: 'Test<test@example.com>',
+        dryRun: true,
+        releaseSlackChannel: '#releases',
+        reportSlackChannel: '#notif',
+        ...overrides,
+    });
+
+describe('notifyToSlack', () => {
+    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 verify the token but post nothing in a dry run', async () => {
+        await notify();
+        expect(authTest).toHaveBeenCalledTimes(1);
+        expect(postMessage).not.toHaveBeenCalled();
+    });
+
+    it('should still require the token in a dry run', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await expect(notify()).rejects.toThrow(`${TOKEN_ENV_VAR} not defined`);
+    });
+
+    it('should fail a dry run when Slack rejects the token', async () => {
+        authTest.mockRejectedValueOnce(new Error('An API error occurred: invalid_auth'));
+        await expect(notify()).rejects.toThrow(`${TOKEN_ENV_VAR} was rejected by Slack`);
+    });
+
+    it('should not need a token when no channel is passed', async () => {
+        vi.stubEnv(TOKEN_ENV_VAR, '');
+        await notify({ dryRun: false, releaseSlackChannel: undefined, reportSlackChannel: undefined });
+        expect(WebClient).not.toHaveBeenCalled();
+    });
+
+    it('should post to both channels outside of a dry run', async () => {
+        await notify({ dryRun: false });
+        expect(authTest).not.toHaveBeenCalled();
+        expect(postMessage).toHaveBeenCalledTimes(2);
+    });
+});

package/.github/scripts/check-package-version-bump.mjs

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-// Reads changed file paths on stdin (one per line) and fails if a PR changes both a consumer-facing
-// workflow and the package code it calls, without repinning in workflows-package-version.
-//
-// The case this catches: a workflow starts using a CLI feature from the same PR. On merge the tag
-// moves, the workflow goes live, and it calls something that is not on npm yet — breaking every
-// consumer's CI at once. Pinning the unreleased version instead holds the tag until it publishes.
-//
-// It deliberately only looks at one PR. A workflow could also start depending on package code that
-// landed in an *earlier*, still-unreleased PR, which this will not see — that needs someone to ship
-// a breaking CLI change and then sit on it unreleased, and catching it means flagging every workflow
-// edit made while any package change is unreleased, which is far more noise than the case is worth.
-
-const PUBLIC_WORKFLOW = /^\.github\/workflows\/public_.*\.ya?ml$/;
-// The composite action is consumer-facing too, and it is what installs the package.
-const PUBLIC_ACTION = /^\.github\/actions\//;
-// What `npx apify-test-tools ...` runs, and the library the platform tests import.
-const PACKAGE_CODE = /^(bin\/|lib\/|index\.ts$)/;
-const PIN_FILE = '.github/workflows-package-version';
-const OVERRIDE_LABEL = 'no-version-bump-needed';
-
-const changed = await new Promise((resolve) => {
-    let buffer = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => (buffer += chunk));
-    process.stdin.on('end', () =>
-        resolve(
-            buffer
-                .split('\n')
-                .map((l) => l.trim())
-                .filter(Boolean),
-        ),
-    );
-});
-
-const publicSurface = changed.filter((f) => PUBLIC_WORKFLOW.test(f) || PUBLIC_ACTION.test(f));
-const packageCode = changed.filter((f) => PACKAGE_CODE.test(f));
-const versionRepinned = changed.includes(PIN_FILE);
-
-if (publicSurface.length === 0 || packageCode.length === 0) {
-    console.log('No consumer-facing workflow and package change in the same PR; nothing to check.');
-    process.exit(0);
-}
-
-if (versionRepinned) {
-    console.log(`Both sides changed and ${PIN_FILE} was repinned. The tag will hold until that version ships.`);
-    process.exit(0);
-}
-
-if (
-    (process.env.PR_LABELS ?? '')
-        .split(',')
-        .map((l) => l.trim())
-        .includes(OVERRIDE_LABEL)
-) {
-    console.log(`Both sides changed without a version bump, allowed by the "${OVERRIDE_LABEL}" label.`);
-    process.exit(0);
-}
-
-console.error(`This PR changes consumer-facing workflows and the package code they call:
-
-  workflows: ${publicSurface.join(', ')}
-  package:   ${packageCode.join(', ')}
-
-On merge the tag moves and those workflows go live immediately, against whatever is on npm today.
-If they rely on anything from the package change in this PR, that is not published yet and every
-consumer's CI breaks.
-
-If they do rely on it, set ${PIN_FILE} to the version that will contain it. The tag is then held
-until you cut that release, and moves on its own once it is published.
-
-If they do not rely on it — the two changes just happen to be in one PR — add the
-"${OVERRIDE_LABEL}" label.`);
-process.exit(1);

package/.github/workflows-package-version

@@ -1 +0,0 @@
-0.10.1