apify-test-tools 0.8.6 → 0.9.0-beta.0

package/test/unit/bin/utils.test.ts

@@ -0,0 +1,342 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { CONFIG_FILE_NAME, readConfigFile } from '../../../bin/utils.js';
+
+const { fsMock } = vi.hoisted(() => ({
+    fsMock: {
+        readFile: vi.fn(),
+    },
+}));
+
+vi.mock('node:fs/promises', () => ({ default: fsMock }));
+
+afterEach(() => vi.restoreAllMocks());
+
+const validConfig = (actors: object[]) => JSON.stringify({ actors });
+const actorJson = (fields: Record<string, unknown> = {}) => JSON.stringify(fields);
+
+const expectFileRead = (filePath: string) => {
+    expect(fsMock.readFile).toHaveBeenCalledWith(filePath, expect.anything());
+};
+
+const mockFiles = (files: Record<string, string>) => {
+    fsMock.readFile.mockImplementation(async (filePath: string) => {
+        if (filePath in files) return Promise.resolve(files[filePath]);
+        return Promise.reject(new Error(`ENOENT: ${filePath}`));
+    });
+};
+
+describe('readConfigFile', () => {
+    it('returns correct ActorConfig[] for a valid config', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify-scraper',
+                    tokenEnvVar: 'APIFY_TOKEN_MYTEAM',
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '../../..' }),
+        });
+
+        const result = await readConfigFile();
+        expectFileRead('actors/shopify/.actor/actor.json');
+        expect(result).toEqual([
+            {
+                actorFullName: 'myteam/shopify-scraper',
+                folder: 'actors/shopify',
+                tokenEnvVar: 'APIFY_TOKEN_MYTEAM',
+                dockerContextDir: '',
+                contextPaths: [''],
+            },
+        ]);
+    });
+
+    it('normalizes folder "." to ""', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: '.', actorFullName: 'apify/my-actor', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+            ]),
+            '.actor/actor.json': actorJson({}),
+        });
+
+        const result = await readConfigFile();
+        expect(result[0].folder).toBe('');
+        expectFileRead('.actor/actor.json');
+    });
+
+    it('defaults dockerContextDir to actor folder when absent from actor.json', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/web-scraper', actorFullName: 'apify/web-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+            ]),
+            'actors/web-scraper/.actor/actor.json': actorJson({}),
+        });
+
+        const result = await readConfigFile();
+        expect(result[0].dockerContextDir).toBe('actors/web-scraper');
+        expect(result[0].contextPaths).toEqual(['actors/web-scraper']);
+    });
+
+    it('resolves dockerContextDir relative to .actor/ folder', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '../../..' }),
+        });
+
+        const result = await readConfigFile();
+        expect(result[0].dockerContextDir).toBe('');
+    });
+
+    it('resolves contextPaths from overrideActorContext', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['actors/shopify', 'packages'],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '../../..' }),
+        });
+
+        const result = await readConfigFile();
+        expect(result[0].contextPaths).toEqual(['actors/shopify', 'packages']);
+    });
+
+    it('handles multiple actors', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/web-scraper', actorFullName: 'apify/web-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+                {
+                    folder: 'actors/email-sender',
+                    actorFullName: 'other-team/email-sender',
+                    tokenEnvVar: 'APIFY_TOKEN_OTHER_TEAM',
+                },
+            ]),
+            'actors/web-scraper/.actor/actor.json': actorJson({}),
+            'actors/email-sender/.actor/actor.json': actorJson({}),
+        });
+
+        const result = await readConfigFile();
+        expect(result).toHaveLength(2);
+        expect(result[0].actorFullName).toBe('apify/web-scraper');
+        expect(result[1].actorFullName).toBe('other-team/email-sender');
+    });
+
+    it('throws when config file is missing', async () => {
+        fsMock.readFile.mockRejectedValue(new Error('ENOENT'));
+        await expect(readConfigFile()).rejects.toThrow('not found');
+    });
+
+    it('throws when config file contains invalid JSON', async () => {
+        fsMock.readFile.mockResolvedValue('{bad json');
+        await expect(readConfigFile()).rejects.toThrow('invalid JSON');
+    });
+
+    it('throws when actors array is missing', async () => {
+        fsMock.readFile.mockResolvedValue(JSON.stringify({ notActors: [] }));
+        await expect(readConfigFile()).rejects.toThrow('"actors" array');
+    });
+
+    it('throws on duplicate folders', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+                { folder: 'actors/shopify', actorFullName: 'other/shopify', tokenEnvVar: 'APIFY_TOKEN_OTHER' },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Duplicate folder');
+    });
+
+    it('throws on duplicate folders after normalization ("." and "")', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: '.', actorFullName: 'apify/actor-a', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+                { folder: '', actorFullName: 'other/actor-b', tokenEnvVar: 'APIFY_TOKEN_OTHER' },
+            ]),
+            '.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Duplicate folder');
+    });
+
+    it('throws when actor.json is missing', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+            ]),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Cannot read');
+    });
+
+    it('throws when folder is missing', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([{ actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' }]),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow(/Invalid "folder"/);
+    });
+
+    it('throws when folder is not a string', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 123, actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+            ]),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow(/Invalid "folder"/);
+    });
+
+    it('throws when actorFullName is missing', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([{ folder: 'actors/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' }]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Invalid "actorFullName"');
+    });
+
+    it('throws when actorFullName has no slash', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: 'shopify-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Invalid "actorFullName"');
+    });
+
+    it('throws when actorFullName has empty parts', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: '/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Invalid "actorFullName"');
+    });
+
+    it('throws when overrideActorContext is not an array', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: 'packages',
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Invalid "overrideActorContext"');
+    });
+
+    it('throws when overrideActorContext contains non-strings', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: [123],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('Invalid "overrideActorContext"');
+    });
+
+    it('throws when overrideActorContext entries overlap (one is a prefix of another)', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['actors/shopify', 'actors'],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow(/overlap/);
+    });
+
+    it('throws when overrideActorContext contains the repo root alongside another entry', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['', 'actors/shopify'],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow(/overlap/);
+    });
+
+    it('throws when overrideActorContext does not include the actor own folder', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['code', 'shared'],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile()).rejects.toThrow('not reachable through its own context paths');
+    });
+
+    it('strips trailing slashes from folder and overrideActorContext entries', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify/',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['actors/shopify/', 'packages/'],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        const result = await readConfigFile();
+        expect(result[0].folder).toBe('actors/shopify');
+        expect(result[0].contextPaths).toEqual(['actors/shopify', 'packages']);
+    });
+
+    it('allows overrideActorContext with disjoint sibling paths that all reach the actor folder via one entry', async () => {
+        mockFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                {
+                    folder: 'actors/shopify',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['actors/shopify', 'code', 'shared'],
+                },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        const result = await readConfigFile();
+        expect(result[0].contextPaths).toEqual(['actors/shopify', 'code', 'shared']);
+    });
+});

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

@@ -9,19 +9,25 @@ describe('Should build and test parser', () => {
     // From https://github.com/apify-store/testing-repo-for-github-actions
     const ACTOR_CONFIGS: ActorConfig[] = [
         {
-            actorName: 'lukaskrivka/testing-github-integration-1',
+            actorFullName: 'lukaskrivka/testing-github-integration-1',
             folder: 'actors/lukaskrivka_testing-github-integration-1',
-            isStandalone: false,
+            tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
+            dockerContextDir: '',
+            contextPaths: [''],
         },
         {
-            actorName: 'lukaskrivka/testing-github-integration-2',
+            actorFullName: 'lukaskrivka/testing-github-integration-2',
             folder: 'actors/lukaskrivka_testing-github-integration-2',
-            isStandalone: false,
+            tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
+            dockerContextDir: '',
+            contextPaths: [''],
         },
         {
-            actorName: 'lukaskrivka/test-standalone',
+            actorFullName: 'lukaskrivka/test-standalone',
             folder: 'standalone-actors/lukaskrivka_test-standalone',
-            isStandalone: true,
+            tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
+            dockerContextDir: 'standalone-actors/lukaskrivka_test-standalone',
+            contextPaths: ['standalone-actors/lukaskrivka_test-standalone'],
         },
     ];
 
@@ -51,7 +57,7 @@ describe('Should build and test parser', () => {
     });
 
     test('Ignores other ignored files and folders', () => {
-        const FILES = ['.vscode/', '.gitignore', '.husky/', '.eslintrc', '.editorconfig', '.actor/'];
+        const FILES = ['.vscode/', '.gitignore', '.husky/', '.eslintrc', '.editorconfig'];
 
         const actorsChanged = getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
@@ -63,9 +69,42 @@ describe('Should build and test parser', () => {
         expect(actorsChanged).toEqual([]);
     });
 
-    test('Only builds latest for all Actors', () => {
+    test('.actor/ changes trigger builds for broad-context actors', () => {
+        const FILES = ['.actor/actor.json'];
+
+        const actorsChanged = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: false,
+            filepathsChanged: FILES,
+            commits,
+        });
+
+        expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
+    });
+
+    test('Root-level changelog is cosmetic for every actor, only on latest', () => {
         const FILES = ['shared/CHANGELOG.md', 'CHANGELOG.md'];
 
+        const actorsChangedNotLatest = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: false,
+            filepathsChanged: FILES,
+            commits,
+        });
+        expect(actorsChangedNotLatest).toEqual([]);
+
+        const actorsChangedLatest = getChangedActors({
+            actorConfigs: ACTOR_CONFIGS,
+            isLatest: true,
+            filepathsChanged: FILES,
+            commits,
+        });
+        expect(actorsChangedLatest).toEqual(ACTOR_CONFIGS);
+    });
+
+    test('A changelog nested inside one actor own folder is excluded for sibling actors, only triggers that actor', () => {
+        const FILES = ['actors/lukaskrivka_testing-github-integration-1/CHANGELOG.md'];
+
         const actorsChanged = getChangedActors({
             actorConfigs: ACTOR_CONFIGS,
             isLatest: true,
@@ -73,10 +112,10 @@ describe('Should build and test parser', () => {
             commits,
         });
 
-        expect(actorsChanged).toEqual(ACTOR_CONFIGS.filter(({ isStandalone }) => !isStandalone));
+        expect(actorsChanged).toEqual([ACTOR_CONFIGS[0]]);
     });
 
-    test('Code updated, tests miniactors', () => {
+    test('Code updated, tests broad-context actors', () => {
         const FILES = ['code/src/main.ts', 'package.json'];
 
         const actorsChanged = getChangedActors({
@@ -86,7 +125,7 @@ describe('Should build and test parser', () => {
             commits,
         });
 
-        expect(actorsChanged).toEqual(ACTOR_CONFIGS.filter(({ isStandalone }) => !isStandalone));
+        expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
     });
 
     test('Specific Actor functionality configs updated', () => {
@@ -119,7 +158,7 @@ describe('Should build and test parser', () => {
         expect(actorsChanged).toEqual(ACTOR_CONFIGS.slice(0, 2));
     });
 
-    test('Miniactor, Code and standalone actor updated,', () => {
+    test('Actor folder, shared code and narrow-context actor updated', () => {
         const FILES = [
             'actors/lukaskrivka_testing-github-integration-1/.actor/actor.json',
             'code/src/main.ts',
@@ -216,7 +255,7 @@ describe('Should build and test parser', () => {
         expect(actorsChanged).toEqual([ACTOR_CONFIGS[1]]);
     });
 
-    test('Standalone actor with cosmetic-only JSON change in PR context skips tests', () => {
+    test('Narrow-context actor with cosmetic-only JSON change in PR context skips tests', () => {
         const FILES = ['standalone-actors/lukaskrivka_test-standalone/.actor/actor.json'];
         isCosmeticOnlyJsonSchemaSpy.mockReturnValue(true);
 
@@ -249,49 +288,67 @@ describe('Should build and test parser', () => {
         const ACTOR_CONFIGS_GOOGLE_MAPS: ActorConfig[] = [
             {
                 // Edge case of capitals in actor name :)
-                actorName: 'compass/Google-Maps-Reviews-Scraper',
+                actorFullName: 'compass/Google-Maps-Reviews-Scraper',
                 folder: 'actors/compass_Google-Maps-Reviews-Scraper',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'compass/crawler-google-places',
+                actorFullName: 'compass/crawler-google-places',
                 folder: 'actors/compass_crawler-google-places',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'compass/easy-google-maps',
+                actorFullName: 'compass/easy-google-maps',
                 folder: 'actors/compass_easy-google-maps',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'compass/google-maps-extractor',
+                actorFullName: 'compass/google-maps-extractor',
                 folder: 'actors/compass_google-maps-extractor',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'compass/google-places-api',
+                actorFullName: 'compass/google-places-api',
                 folder: 'actors/compass_google-places-api',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_COMPASS',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'lukaskrivka/google-maps-with-contact-details',
+                actorFullName: 'lukaskrivka/google-maps-with-contact-details',
                 folder: 'actors/lukaskrivka_google-maps-with-contact-details',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'natasha.lekh/gas-prices-scraper',
+                actorFullName: 'natasha.lekh/gas-prices-scraper',
                 folder: 'actors/natasha.lekh_gas-prices-scraper',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_NATASHA_LEKH',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'natasha.lekh/vegan-places-finder',
+                actorFullName: 'natasha.lekh/vegan-places-finder',
                 folder: 'actors/natasha.lekh_vegan-places-finder',
-                isStandalone: false,
+                tokenEnvVar: 'APIFY_TOKEN_NATASHA_LEKH',
+                dockerContextDir: '',
+                contextPaths: [''],
             },
             {
-                actorName: 'lukaskrivka/google-maps-scraper-orchestrator',
+                actorFullName: 'lukaskrivka/google-maps-scraper-orchestrator',
                 folder: 'standalone-actors/lukaskrivka_google-maps-scraper-orchestrator',
-                isStandalone: true,
+                tokenEnvVar: 'APIFY_TOKEN_LUKASKRIVKA',
+                dockerContextDir: 'standalone-actors/lukaskrivka_google-maps-scraper-orchestrator',
+                contextPaths: ['standalone-actors/lukaskrivka_google-maps-scraper-orchestrator'],
             },
         ];
 
@@ -302,6 +359,6 @@ describe('Should build and test parser', () => {
             commits,
         });
 
-        expect(actorsChanged).toEqual(ACTOR_CONFIGS_GOOGLE_MAPS.filter(({ isStandalone }) => !isStandalone));
+        expect(actorsChanged).toEqual(ACTOR_CONFIGS_GOOGLE_MAPS.slice(0, 8));
     });
 });