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

package/test/unit/bin/build-from-local.test.ts

@@ -4,11 +4,13 @@ import path from 'node:path';
 
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
+import { ApifyBuilder } from '../../../bin/build.js';
 import {
     collectNonIgnoredFiles,
     collectSourceFiles,
     flattenMonorepoContext,
     rewriteActorJsonPaths,
+    runBuildsFromLocal,
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore: editor-only TS6059 — test/tsconfig.json's rootDir doesn't span bin/, but the root
     // tsconfig (used for the real build and for eslint's type-aware linting) has no such restriction.
@@ -235,4 +237,57 @@ describe('build-from-local helpers', () => {
             expect(rewritten.changelog).toBe('./CHANGELOG.md');
         });
     });
+
+    describe('runBuildsFromLocal dry run', () => {
+        it('looks the Actor up and zips its sources, but builds nothing', async () => {
+            const repoRoot = await mkTempDir('apify-test-tools-dry-run-');
+            tempDirs.push(repoRoot);
+            const actorDir = path.join(repoRoot, 'actors', 'owner_actor');
+            await fs.mkdir(path.join(actorDir, '.actor'), { recursive: true });
+            await fs.writeFile(path.join(actorDir, '.actor', 'actor.json'), JSON.stringify({ name: 'actor' }));
+            await fs.writeFile(path.join(actorDir, 'main.js'), '');
+            vi.spyOn(Utils, 'listRepoFilePaths').mockResolvedValue([
+                'actors/owner_actor/.actor/actor.json',
+                'actors/owner_actor/main.js',
+            ]);
+            vi.spyOn(Utils, 'getGitignoredPaths').mockResolvedValue(new Set());
+
+            const getActorInfo = vi.fn(async () => ({}));
+            const fromActorConfig = vi
+                .spyOn(ApifyBuilder, 'fromActorConfig')
+                .mockReturnValue({ getActorInfo } as unknown as ApifyBuilder);
+
+            const originalCwd = process.cwd();
+            process.chdir(repoRoot);
+            try {
+                const plan = await runBuildsFromLocal({
+                    actorConfigs: [
+                        {
+                            actorFullName: 'owner/actor',
+                            folder: new ExistingDir('actors/owner_actor'),
+                            tokenEnvVar: 'APIFY_TOKEN_OWNER',
+                            actorJson: {
+                                file: new ExistingFile('actors/owner_actor/.actor/actor.json'),
+                                dockerContextDir: new RelativeDir('actors/owner_actor'),
+                            },
+                            dockerContextDir: new RelativeDir('actors/owner_actor'),
+                            contextPaths: [new RelativeDir('actors/owner_actor')],
+                        },
+                    ],
+                    dryRun: true,
+                });
+                expect(plan).toEqual({
+                    dryRun: true,
+                    builds: [
+                        expect.objectContaining({ actorFullName: 'owner/actor', versionNumber: '0.98', fileCount: 2 }),
+                    ],
+                });
+            } finally {
+                process.chdir(originalCwd);
+            }
+            expect(getActorInfo).toHaveBeenCalledTimes(1);
+            // Only the read-only lookup ran: builders for uploads and builds are created after the dry-run cutoff
+            expect(fromActorConfig).toHaveBeenCalledTimes(1);
+        });
+    });
 });

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