apify-test-tools 0.9.1-beta.10 → 0.9.1-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.9.1-beta.10",
+  "version": "0.9.1-beta.11",
   "type": "module",
   "description": "TBD",
   "repository": {

package/test/unit/bin/utils/config/load-config.test.ts

@@ -41,6 +41,7 @@ describe('loadActorConfig', () => {
         folder: 'actors/shopify',
         actorFullName: 'myteam/shopify',
         tokenEnvVar: 'APIFY_TOKEN',
+        overrideActorContext: undefined,
         ...fields,
     });
 

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

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 
 import { _privates, parseConfigFile } from '../../../../../bin/utils/config/parser.js';
 import { CONFIG_FILE_STRATEGY } from '../../../../../bin/utils/config/structures/base.js';
+import { GROUPED_PARSER } from '../../../../../bin/utils/config/structures/grouped.js';
 import { LEGACY_PARSER } from '../../../../../bin/utils/config/structures/legacy.js';
 
 const { selectStrategy, verifyConfiguration } = _privates;
@@ -10,27 +11,31 @@ const actor = (fields: Record<string, unknown> = {}) => ({
     folder: 'actors/shopify',
     actorFullName: 'myteam/shopify',
     tokenEnvVar: 'APIFY_TOKEN',
+    overrideActorContext: undefined,
     ...fields,
 });
 
 describe('selectStrategy', () => {
     it('falls back to the legacy strategy when no mode is declared', () => {
-        expect(selectStrategy(undefined)).toBe(LEGACY_PARSER);
+        expect(selectStrategy({})).toBe(LEGACY_PARSER);
     });
 
-    it('honours an explicit mode', () => {
-        expect(selectStrategy(CONFIG_FILE_STRATEGY.LEGACY)).toBe(LEGACY_PARSER);
+    it.each([
+        [CONFIG_FILE_STRATEGY.LEGACY, LEGACY_PARSER],
+        [CONFIG_FILE_STRATEGY.GROUPED, GROUPED_PARSER],
+    ])('honours an explicit "%s" mode', (mode, expected) => {
+        expect(selectStrategy({ mode })).toBe(expected);
     });
 
     it('throws on a mode no strategy is registered for', () => {
-        expect(() => selectStrategy('some-nonexistent-mode')).toThrow(/Invalid input/);
+        expect(() => selectStrategy('some-nonexistent-mode')).toThrow();
     });
 });
 
 describe('verifyConfiguration', () => {
     it('resolves the repo root to "" and gets rid of trailing slashes', () => {
         const result = verifyConfiguration([
-            { folder: '.', actorFullName: 'myteam/root', tokenEnvVar: 'APIFY_TOKEN' },
+            { folder: '.', actorFullName: 'myteam/root', tokenEnvVar: 'APIFY_TOKEN', overrideActorContext: undefined },
             {
                 folder: 'actors/shopify/',
                 actorFullName: 'myteam/shopify',
@@ -124,6 +129,22 @@ describe('parseConfigFile', () => {
         ]);
     });
 
+    it('parses a grouped config file, which needs mode to be stripped', () => {
+        expect(
+            parseConfigFile({
+                mode: CONFIG_FILE_STRATEGY.GROUPED,
+                groups: {
+                    myteam: {
+                        actors: [{ folder: 'actors/shopify/', actorFullName: 'myteam/shopify' }],
+                        tokenEnvVar: 'APIFY_TOKEN',
+                    },
+                },
+            }),
+        ).toEqual([
+            actor({ folder: 'actors/shopify', actorFullName: 'myteam/shopify', overrideActorContext: undefined }),
+        ]);
+    });
+
     it('surfaces cross-entry violations from verifyConfiguration', () => {
         expect(() =>
             parseConfigFile({

package/test/unit/bin/utils/config/structures/grouped.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+
+import { GROUPED_PARSER } from '../../../../../../bin/utils/config/structures/grouped.js';
+
+const actor = (fields: Record<string, unknown> = {}) => ({
+    folder: 'actors/shopify',
+    actorFullName: 'myteam/shopify',
+    ...fields,
+});
+
+const group = (fields: Record<string, unknown> = {}) => ({
+    actors: [actor()],
+    tokenEnvVar: 'APIFY_TOKEN',
+    ...fields,
+});
+
+describe('GROUPED_PARSER', () => {
+    it('flattens every group into one list, handing each actor its group’s settings', () => {
+        expect(
+            GROUPED_PARSER.parse({
+                groups: {
+                    myteam: {
+                        actors: [actor(), actor({ folder: 'actors/email', actorFullName: 'myteam/email' })],
+                        tokenEnvVar: 'APIFY_TOKEN_MYTEAM',
+                        overrideActorContext: ['packages'],
+                    },
+                    other: { actors: [actor({ folder: 'actors/x', actorFullName: 'other/x' })], tokenEnvVar: 'TOKEN' },
+                },
+            }),
+        ).toEqual([
+            {
+                folder: 'actors/shopify',
+                actorFullName: 'myteam/shopify',
+                tokenEnvVar: 'APIFY_TOKEN_MYTEAM',
+                overrideActorContext: ['packages'],
+            },
+            {
+                folder: 'actors/email',
+                actorFullName: 'myteam/email',
+                tokenEnvVar: 'APIFY_TOKEN_MYTEAM',
+                overrideActorContext: ['packages'],
+            },
+            { folder: 'actors/x', actorFullName: 'other/x', tokenEnvVar: 'TOKEN', overrideActorContext: undefined },
+        ]);
+    });
+
+    it('ignores the group key entirely', () => {
+        expect(GROUPED_PARSER.parse({ groups: { 'not-a-folder-at-all': group() } })).toEqual([
+            { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' },
+        ]);
+    });
+
+    it('allows actors to override some fields', () => {
+        expect(
+            GROUPED_PARSER.parse({ groups: { myteam: group({ actors: [actor({ tokenEnvVar: 'FROM_ACTOR' })] }) } }),
+        ).toEqual([{ folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'FROM_ACTOR' }]);
+    });
+
+    it("returns the entries as written — normalizing is not this layer's job", () => {
+        const raw = actor({ folder: 'actors/shopify/' });
+
+        expect(
+            GROUPED_PARSER.parse({ groups: { myteam: group({ actors: [raw], overrideActorContext: ['packages/'] }) } }),
+        ).toEqual([{ ...raw, tokenEnvVar: 'APIFY_TOKEN', overrideActorContext: ['packages/'] }]);
+    });
+
+    it('rejects a config with no groups (and thus no actors)', () => {
+        expect(() => GROUPED_PARSER.parse({})).toThrow();
+    });
+
+    it('reports problems from every group at once instead of only the first', () => {
+        const message = (() => {
+            try {
+                GROUPED_PARSER.parse({
+                    groups: {
+                        myteam: { actors: [actor({ folder: 123 })], tokenEnvVar: 'APIFY_TOKEN' },
+                        other: { actors: [actor({ actorFullName: 'nope' })] },
+                    },
+                });
+                throw new Error('Function should have thrown');
+            } catch (err) {
+                return (err as Error).message;
+            }
+        })();
+
+        expect(message).toContain('myteam.actors[0].folder');
+        expect(message).toContain('other.actors[0].actorFullName');
+        expect(message).toContain('other.tokenEnvVar');
+    });
+});