apify-test-tools 0.9.1-beta.3 → 0.9.1-beta.5

package/lib/consts.ts

@@ -17,6 +17,10 @@ export const TO_FINISH_WITH_OPTIONS: ToFinishWithOptionsWithDefaults = {
  */
 export const DEFAULT_TEST_RUN_DURATION_MS = 60 * 60 * 1000; // 1 hour
 
+// Prevent orphaned runs - timeout the Actor 1 minute before the test does so everything is logged correctly.
+//      - Otherwise the run link URL can get lost.
+export const DEFAULT_TEST_ACTOR_TIMEOUT_SECS = DEFAULT_TEST_RUN_DURATION_MS / 1000 - 60;
+
 /**
  * Delay before checking the dataset and statistics after a run finishes to resolve eventual consistency.
  * - This value should ensure that the dataset and statistics are fully updated before any assertions are made.

package/lib/lib.ts

@@ -3,7 +3,7 @@ import { ApifyClient } from 'apify-client';
 import type { SuiteFactory, TestContext, TestFunction } from 'vitest';
 import { describe as vitestDescribe, ExpectStatic, test as vitestTest } from 'vitest';
 
-import { DATASET_SYNC_DELAY_MS, DEFAULT_TEST_RUN_DURATION_MS } from './consts.js';
+import { DATASET_SYNC_DELAY_MS, DEFAULT_TEST_ACTOR_TIMEOUT_SECS, DEFAULT_TEST_RUN_DURATION_MS } from './consts.js';
 import { extendExpect } from './extend-expect.js';
 import { RunTestResult } from './run-test-result.js';
 import type { ActorBuild, ActorTestOptions, RunOptions } from './types.js';
@@ -39,6 +39,7 @@ const DEFAULT_TEST_OPTIONS: ActorTestOptions = {
     concurrent: true,
     // test should finish within 1 hour
     timeout: DEFAULT_TEST_RUN_DURATION_MS,
+    retry: 1,
 };
 
 /**
@@ -51,12 +52,6 @@ export const describe = (name: string, fn?: SuiteFactory<object>, options: Actor
     vitestDescribe.runIf(!!TESTER_APIFY_TOKEN || !!RUN_ALL_PLATFORM_TESTS)(name, options, fn);
 };
 
-const DEFAULT_TEST_ACTOR_OPTIONS: ActorTestOptions = {
-    retry: 1,
-    // prevent orphaned runs
-    timeout: DEFAULT_TEST_RUN_DURATION_MS,
-};
-
 /**
  * @param actorId - The actor's raw platform ID or its full name (`owner/name`, e.g. `"apify/web-scraper"`).
  */
@@ -66,10 +61,8 @@ export const testActor = <T>(
     fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
     testOptions?: ActorTestOptions,
 ) => {
-    const options = {
-        ...DEFAULT_TEST_ACTOR_OPTIONS,
-        ...testOptions,
-    };
+    const options = { ...DEFAULT_TEST_OPTIONS, ...testOptions };
+
     const name = `${actorId}: ${testName}`;
     // `RUN_ALL_PLATFORM_TESTS` is needed for the scheduled tests, which have no `ACTOR_BUILDS` to match the
     // tests against - without it, every test would be filtered out as an actor we didn't build.
@@ -100,10 +93,8 @@ export const testStandbyActor = <I = any, O = any>(
     fn: TestFunction<{ callStandby: ReturnType<typeof createStartStandbyFn<I, O>> }>,
     testOptions?: ActorTestOptions,
 ) => {
-    const options = {
-        ...DEFAULT_TEST_ACTOR_OPTIONS,
-        ...testOptions,
-    };
+    const options = { ...DEFAULT_TEST_OPTIONS, ...testOptions };
+
     const name = `${actorId}: ${testName}`;
     // `RUN_ALL_PLATFORM_TESTS` is needed for the scheduled tests, which have no `ACTOR_BUILDS` to match the
     // tests against - without it, every test would be filtered out as an actor we didn't build.
@@ -279,13 +270,20 @@ const createStartRunFn = <T>(actorId: string, testContext: TestContext) => {
             return new RunTestResult(apifyClient, run);
         }
 
-        const actor = apifyClient.actor(actorId);
-
         const actorInput = {
             ...(prefilledInput && (await getActorPrefilledInput(apifyClient, actorId, buildId))),
             ...input,
         };
-        const run = await actor.call(actorInput, { build, log: null, ...options });
+
+        const actor = apifyClient.actor(actorId);
+        const actorInfo = await actor.get();
+        const timeout = Math.min(
+            actorInfo?.defaultRunOptions?.timeoutSecs ?? DEFAULT_TEST_ACTOR_TIMEOUT_SECS,
+            DEFAULT_TEST_ACTOR_TIMEOUT_SECS,
+        );
+
+        const actorOptions = { timeout, build, log: null, ...options };
+        const run = await actor.call(actorInput, actorOptions);
 
         const runLink = generateRunLink(run);
         await annotate(`${task.name} - ${runLink}`, 'run_link');
@@ -306,3 +304,7 @@ const createStartRunFn = <T>(actorId: string, testContext: TestContext) => {
 const generateRunLink = (run: ActorRun | ActorRunListItem): string => {
     return `https://console.apify.com/view/runs/${run.id}`;
 };
+
+/** Used for unit testing */
+// eslint-disable-next-line no-underscore-dangle
+export const _private = { createStartRunFn } as const;

package/lib/types.ts

@@ -10,7 +10,15 @@ export type ActorBuild = {
 
 export type RunOptions<T> = {
     input: Omit<T, 'actorName'>;
-    options?: ActorCallOptions;
+    options?: Omit<ActorCallOptions, 'timeout'> & {
+        /**
+         * Timeout for the actor run in seconds. Zero value means there is no timeout.
+         * - If `undefined`, the run uses timeout of the default Actor run configuration.
+         *
+         * @default 3540 // 59 minutes (finish the run before the test)
+         */
+        timeout?: number;
+    };
     prefilledInput?: boolean;
     /**
      * If you specify `runId`, all the other options will be ignored and this run's data will
@@ -138,8 +146,8 @@ export type ActorTestOptions = Omit<TestOptions, 'retry' | 'timeout'> & {
     // we are just extending the docs here to replace the default value, otherwise it's the exact same
     retry?: TestOptions['retry'];
     /**
-     * Timeout for the actor run in milliseconds. Zero value means there is no timeout.
-     * - If `undefined`, the run uses timeout of the default Actor run configuration.
+     * Timeout for the test in milliseconds. Zero value means there is no timeout.
+     * - If `undefined`, the run uses timeout of the default test configuration.
      *
      * @default 60 * 60 * 1000 // 1 hour
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.9.1-beta.3",
+  "version": "0.9.1-beta.5",
   "type": "module",
   "description": "TBD",
   "repository": {
@@ -20,7 +20,8 @@
     "@slack/web-api": "^7.9.2",
     "apify-client": "^2.22.2",
     "ignore": "^7.0.5",
-    "yargs": "^18.0.0"
+    "yargs": "^18.0.0",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@apify/eslint-config": "^1.0.0",

package/test/fixtures/bin/utils/files/array.json

@@ -0,0 +1 @@
+[{ "a": 1 }]

package/test/fixtures/bin/utils/files/comments.jsonc

@@ -0,0 +1,4 @@
+{
+    // this is a comment
+    "a": 3,
+}

package/test/fixtures/bin/utils/files/empty-object.json

@@ -0,0 +1 @@
+{}

package/test/fixtures/bin/utils/files/malformed.json

@@ -0,0 +1 @@
+{ "a": 1

package/test/fixtures/bin/utils/files/nested.json

@@ -0,0 +1,6 @@
+{
+    "storages": { "datasets": { "default": { "title": "Default" } } },
+    "overrideActorContext": ["../shared", "."],
+    "changelog": null,
+    "nested": [{ "deep": [1, 2, { "deeper": true }] }]
+}

package/test/fixtures/bin/utils/files/no-json-extension.actorrc

@@ -0,0 +1 @@
+{ "a": 1 }

package/test/fixtures/bin/utils/files/null.json

@@ -0,0 +1 @@
+null

package/test/fixtures/bin/utils/files/number.json

@@ -0,0 +1 @@
+42

package/test/fixtures/bin/utils/files/unreadable.json

@@ -0,0 +1 @@
+{ "a": 1 }

package/test/tsconfig.json

@@ -1,13 +1,15 @@
 {
     "extends": "@apify/tsconfig",
     "compilerOptions": {
-        "module": "ES2022",
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
         "target": "ES2022",
         "outDir": "dist",
         "noUnusedLocals": false,
         "noEmit": true,
+        "rootDir": "..",
         "lib": ["DOM", "es2021"],
         "skipLibCheck": true
     },
-    "include": ["./**/*"]
+    "include": ["./**/*", "../bin/**/*", "../lib/**/*"]
 }

package/test/unit/bin/{utils.test.ts → utils/actor-config.test.ts}

@@ -1,36 +1,102 @@
-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 }));
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+    CONFIG_FILE_NAME,
+    loadActorConfig,
+    parseConfigFile,
+    readConfigFile,
+    resolveRawConfig,
+} from '../../../../bin/utils/config/load-config.js';
+
+// `readConfigFile` resolves every path against the process's working directory, so these tests give it
+// a real one: a throwaway repo in a temp dir. Reading actual files rather than a mocked
+// `node:fs/promises` is what makes the path handling (the ".actor/" hop, a dockerContextDir escaping
+// the repo root) worth asserting on — against a mock those assertions only describe the mock.
+let repoDir: string;
+let originalCwd: string;
+
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    // `realpath` because macOS hands out a symlinked temp dir, while `process.cwd()` reports the target.
+    repoDir = await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), 'apify-test-tools-config-')));
+    process.chdir(repoDir);
+});
 
-afterEach(() => vi.restoreAllMocks());
+afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.rm(repoDir, { recursive: true, force: true });
+});
 
 const emptyActorSelection = { actors: [], ignore: [] };
 
 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 writeFiles = async (files: Record<string, string>) =>
+    Promise.all(
+        Object.entries(files).map(async ([filePath, contents]) => {
+            const absPath = path.join(repoDir, filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, contents);
+        }),
+    );
+
+// Stages 2-4 are callable on their own, which is the point: a differently shaped config file only
+// has to reach `resolveRawConfig`'s output to work with everything downstream.
+describe('the parse/resolve/load seam', () => {
+    it('parseConfigFile validates the file shape without touching the filesystem', () => {
+        const entry = { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' };
+
+        expect(parseConfigFile({ actors: [entry] })).toEqual({ actors: [entry] });
+        expect(() => parseConfigFile({ actors: [{ ...entry, folder: 123 }] })).toThrow(/Invalid "folder"/);
+    });
 
-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}`));
+    it('resolveRawConfig is where the repo root becomes "" and trailing slashes go', () => {
+        const result = resolveRawConfig({
+            actors: [
+                { folder: '.', actorFullName: 'myteam/root', tokenEnvVar: 'APIFY_TOKEN' },
+                {
+                    folder: 'actors/shopify/',
+                    actorFullName: 'myteam/shopify',
+                    tokenEnvVar: 'APIFY_TOKEN',
+                    overrideActorContext: ['packages/'],
+                },
+            ],
+        });
+
+        expect(result).toEqual([
+            { folder: '', actorFullName: 'myteam/root', tokenEnvVar: 'APIFY_TOKEN', overrideActorContext: undefined },
+            {
+                folder: 'actors/shopify',
+                actorFullName: 'myteam/shopify',
+                tokenEnvVar: 'APIFY_TOKEN',
+                overrideActorContext: ['packages'],
+            },
+        ]);
     });
-};
+
+    it('loadActorConfig resolves data coming from actor.json', async () => {
+        await writeFiles({ 'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '..' }) });
+
+        expect(
+            loadActorConfig({ folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' }),
+        ).toEqual({
+            actorFullName: 'myteam/shopify',
+            folder: 'actors/shopify',
+            tokenEnvVar: 'APIFY_TOKEN',
+            dockerContextDir: 'actors/shopify',
+            contextPaths: ['actors/shopify'],
+        });
+    });
+});
 
 describe('readConfigFile', () => {
     it('returns correct ActorConfig[] for a valid config', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -42,7 +108,6 @@ describe('readConfigFile', () => {
         });
 
         const result = await readConfigFile(emptyActorSelection);
-        expectFileRead('actors/shopify/.actor/actor.json');
         expect(result).toEqual([
             {
                 actorFullName: 'myteam/shopify-scraper',
@@ -55,7 +120,7 @@ describe('readConfigFile', () => {
     });
 
     it('normalizes folder "." to ""', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: '.', actorFullName: 'apify/my-actor', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -64,11 +129,10 @@ describe('readConfigFile', () => {
 
         const result = await readConfigFile(emptyActorSelection);
         expect(result[0].folder).toBe('');
-        expectFileRead('.actor/actor.json');
     });
 
     it('defaults dockerContextDir to actor folder when absent from actor.json', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/web-scraper', actorFullName: 'apify/web-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -81,7 +145,7 @@ describe('readConfigFile', () => {
     });
 
     it('resolves dockerContextDir relative to .actor/ folder', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' },
             ]),
@@ -92,8 +156,19 @@ describe('readConfigFile', () => {
         expect(result[0].dockerContextDir).toBe('');
     });
 
+    it('throws when dockerContextDir resolves outside the repository root', async () => {
+        await writeFiles({
+            [CONFIG_FILE_NAME]: validConfig([
+                { folder: 'actors/shopify', actorFullName: 'myteam/shopify', tokenEnvVar: 'APIFY_TOKEN' },
+            ]),
+            'actors/shopify/.actor/actor.json': actorJson({ dockerContextDir: '../../../..' }),
+        });
+
+        await expect(readConfigFile(emptyActorSelection)).rejects.toThrow(/resolves outside the repository root/);
+    });
+
     it('resolves contextPaths from overrideActorContext', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -110,7 +185,7 @@ describe('readConfigFile', () => {
     });
 
     it('handles multiple actors', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/web-scraper', actorFullName: 'apify/web-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
                 {
@@ -130,22 +205,26 @@ describe('readConfigFile', () => {
     });
 
     it('throws when config file is missing', async () => {
-        fsMock.readFile.mockRejectedValue(new Error('ENOENT'));
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('not found');
     });
 
     it('throws when config file contains invalid JSON', async () => {
-        fsMock.readFile.mockResolvedValue('{bad json');
+        await writeFiles({ [CONFIG_FILE_NAME]: '{bad json' });
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('invalid JSON');
     });
 
     it('throws when actors array is missing', async () => {
-        fsMock.readFile.mockResolvedValue(JSON.stringify({ notActors: [] }));
+        await writeFiles({ [CONFIG_FILE_NAME]: JSON.stringify({ notActors: [] }) });
+        await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('"actors" array');
+    });
+
+    it('throws when the config file is not a JSON object', async () => {
+        await writeFiles({ [CONFIG_FILE_NAME]: JSON.stringify([{ folder: 'actors/shopify' }]) });
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('"actors" array');
     });
 
     it('throws on duplicate folders', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
                 { folder: 'actors/shopify', actorFullName: 'other/shopify', tokenEnvVar: 'APIFY_TOKEN_OTHER' },
@@ -157,7 +236,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws on duplicate folders after normalization ("." and "")', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: '.', actorFullName: 'apify/actor-a', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
                 { folder: '', actorFullName: 'other/actor-b', tokenEnvVar: 'APIFY_TOKEN_OTHER' },
@@ -169,7 +248,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actor.json is missing', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -179,7 +258,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when folder is missing', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([{ actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' }]),
         });
 
@@ -187,7 +266,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when folder is not a string', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 123, actorFullName: 'apify/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -197,7 +276,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actorFullName is missing', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([{ folder: 'actors/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' }]),
             'actors/shopify/.actor/actor.json': actorJson({}),
         });
@@ -206,7 +285,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actorFullName has no slash', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: 'shopify-scraper', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -217,7 +296,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when actorFullName has empty parts', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 { folder: 'actors/shopify', actorFullName: '/shopify', tokenEnvVar: 'APIFY_TOKEN_APIFY' },
             ]),
@@ -227,8 +306,29 @@ describe('readConfigFile', () => {
         await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('Invalid "actorFullName"');
     });
 
+    it('throws when tokenEnvVar is missing', async () => {
+        await writeFiles({
+            [CONFIG_FILE_NAME]: validConfig([{ folder: 'actors/shopify', actorFullName: 'apify/shopify' }]),
+            'actors/shopify/.actor/actor.json': actorJson({}),
+        });
+
+        await expect(readConfigFile(emptyActorSelection)).rejects.toThrow('Invalid "tokenEnvVar"');
+    });
+
+    it('reports every invalid field at once instead of only the first', async () => {
+        await writeFiles({
+            [CONFIG_FILE_NAME]: validConfig([{ folder: 123, actorFullName: 'shopify', overrideActorContext: 'nope' }]),
+        });
+
+        const promise = readConfigFile(emptyActorSelection);
+        await expect(promise).rejects.toThrow(/Invalid "folder"/);
+        await expect(promise).rejects.toThrow(/Invalid "actorFullName"/);
+        await expect(promise).rejects.toThrow(/Invalid "tokenEnvVar"/);
+        await expect(promise).rejects.toThrow(/Invalid "overrideActorContext"/);
+    });
+
     it('throws when overrideActorContext is not an array', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -244,7 +344,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when overrideActorContext contains non-strings', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -260,7 +360,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when overrideActorContext entries overlap (one is a prefix of another)', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -276,7 +376,7 @@ describe('readConfigFile', () => {
     });
 
     it('throws when overrideActorContext contains the repo root alongside another entry', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -292,7 +392,7 @@ describe('readConfigFile', () => {
     });
 
     it('adds the actor own folder automatically when overrideActorContext does not cover it', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -309,7 +409,7 @@ describe('readConfigFile', () => {
     });
 
     it('strips trailing slashes from folder and overrideActorContext entries', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify/',
@@ -327,7 +427,7 @@ describe('readConfigFile', () => {
     });
 
     it('allows overrideActorContext with disjoint sibling paths that all reach the actor folder via one entry', async () => {
-        mockFiles({
+        await writeFiles({
             [CONFIG_FILE_NAME]: validConfig([
                 {
                     folder: 'actors/shopify',
@@ -344,8 +444,8 @@ describe('readConfigFile', () => {
     });
 
     describe('actor selection', () => {
-        const twoActors = () =>
-            mockFiles({
+        const twoActors = async () =>
+            writeFiles({
                 [CONFIG_FILE_NAME]: validConfig([
                     { folder: 'actors/a', actorFullName: 'team/a', tokenEnvVar: 'TOKEN' },
                     { folder: 'actors/b', actorFullName: 'team/b', tokenEnvVar: 'TOKEN' },
@@ -357,22 +457,22 @@ describe('readConfigFile', () => {
         const fullNames = (result: { actorFullName: string }[]) => result.map((c) => c.actorFullName);
 
         it('returns all actors when the selection is empty', async () => {
-            twoActors();
+            await twoActors();
             expect(fullNames(await readConfigFile(emptyActorSelection))).toEqual(['team/a', 'team/b']);
         });
 
         it('keeps only the selected actors', async () => {
-            twoActors();
+            await twoActors();
             expect(fullNames(await readConfigFile({ actors: ['team/a'], ignore: [] }))).toEqual(['team/a']);
         });
 
         it('drops ignored actors', async () => {
-            twoActors();
+            await twoActors();
             expect(fullNames(await readConfigFile({ actors: [], ignore: ['team/a'] }))).toEqual(['team/b']);
         });
 
         it('throws on an unknown actor name', async () => {
-            twoActors();
+            await twoActors();
             await expect(readConfigFile({ actors: ['team/nope'], ignore: [] })).rejects.toThrow(
                 'do not exist: team/nope',
             );