revert refactoring

Author: metalwarrior665

lib/lib.ts

@@ -1,14 +1,23 @@
 import { fileURLToPath } from 'node:url';
 
+import type { Actor, ActorRun, ActorRunListItem, ActorStandby, Task } from 'apify-client';
 import { ApifyClient } from 'apify-client';
 import type { SuiteFactory, TestContext, TestFunction } from 'vitest';
 import { describe as vitestDescribe, ExpectStatic, test as vitestTest } from 'vitest';
 
 import { DEFAULT_DESCRIBE_OPTIONS, DEFAULT_TEST_ACTOR_OPTIONS, DEFAULT_TRIGGERS } from './consts.js';
 import { extendExpect } from './extend-expect.js';
+import { RunTestResult } from './run-test-result.js';
 import { shouldRunForTrigger } from './trigger.js';
-import type { ActorBuild, ActorTestOptions, DescribeConfig, TestActorConfig, TriggerConfig } from './types.js';
-import { createStandbyTask, createStartRunFn, createStartStandbyFn, generateRunLink } from './utils.js';
+import type {
+    ActorBuild,
+    ActorTestOptions,
+    DescribeConfig,
+    RunOptions,
+    TestActorConfig,
+    TriggerConfig,
+} from './types.js';
+import { getActorPrefilledInput, sleep } from './utils.js';
 
 export { getCurrentTrigger, TRIGGER_ENV_VAR } from './trigger.js';
 export { ExpectStatic };
@@ -30,7 +39,7 @@ try {
     throw new Error(`Failed to parse actor builds: ${err}`);
 }
 
-const actorConfig = actorBuilds.reduce<Map<string, ActorBuild>>((map, cfg) => {
+const config = actorBuilds.reduce<Map<string, ActorBuild>>((map, cfg) => {
     map.set(cfg.actorName, cfg);
     map.set(cfg.actorId, cfg);
     return map;
@@ -166,7 +175,7 @@ function resolveActorTestConfig(
         ...(triggers !== undefined ? [triggers] : []),
     ]);
     const shouldRun =
-        (!!RUN_ALL_PLATFORM_TESTS || actorConfig.has(actorName)) && shouldRunForTrigger(effectiveTriggers.runWhen);
+        (!!RUN_ALL_PLATFORM_TESTS || config.has(actorName)) && shouldRunForTrigger(effectiveTriggers.runWhen);
 
     return { fullName: `${actorName}: ${name}`, effectiveTriggers, vitestOptions: options ?? {}, shouldRun };
 }
@@ -209,7 +218,7 @@ export const testActor = <T>(
         const { expect, ...rest } = context;
         await fn({
             expect: extendExpect(expect),
-            run: createStartRunFn(apifyClient, actorConfig, actorName, context),
+            run: createStartRunFn(actorName, context),
             ...rest,
         });
     });
@@ -246,15 +255,15 @@ export const testStandbyActor = <I = any, O = any>(
         // @ts-expect-error: `TaskMeta` cannot be retyped
         context.task.meta = { ...context.task.meta, alerts: effectiveTriggers.alerts };
 
-        const standbyTask = await createStandbyTask(apifyClient, actorName, actorConfig.get(actorName)?.buildNumber);
+        const standbyTask = await createStandbyTask(actorName, config.get(actorName)?.buildNumber);
         const { annotate } = context;
         const { expect, ...rest } = context;
 
         // NOTE: wrap `fn` in try-catch so the task is always cleaned up afterwards
         try {
             await fn({
                 expect: extendExpect(expect),
-                callStandby: createStartStandbyFn(apifyClient, standbyTask),
+                callStandby: createStartStandbyFn(standbyTask),
                 ...rest,
             });
         } catch {

lib/utils.ts

@@ -1,8 +1,4 @@
-import type { Actor, ActorRun, ActorRunListItem, ActorStandby, ApifyClient, Task } from 'apify-client';
-import type { TestContext } from 'vitest';
-
-import { RunTestResult } from './run-test-result.js';
-import type { ActorBuild, RunOptions } from './types.js';
+import type { ApifyClient } from 'apify-client';
 
 /**
  * Gets prefilled values for a provided build or, if not provided, uses actor's
@@ -60,128 +56,3 @@ export const sleep = async (ms: number) => {
         setTimeout(resolve, ms);
     });
 };
-
-export const generateRunLink = (run: ActorRun | ActorRunListItem): string =>
-    `https://console.apify.com/view/runs/${run.id}`;
-
-export const createStartRunFn = <T>(
-    apifyClient: ApifyClient,
-    config: Map<string, ActorBuild>,
-    actorNameOrId: string,
-    testContext: TestContext,
-) => {
-    const { annotate, task } = testContext;
-    const actorConfig = config.get(actorNameOrId);
-    const build = actorConfig?.buildNumber;
-    const buildId = actorConfig?.buildId;
-
-    return async (runOptions: RunOptions<T>) => {
-        const { input, options, prefilledInput, runId } = runOptions;
-
-        if (runId) {
-            const run = await apifyClient.run(runId).get();
-            if (!run) {
-                throw new Error(`Run with id "${runId}" doesn't exist`);
-            }
-            return new RunTestResult(apifyClient, run);
-        }
-
-        const actor = apifyClient.actor(actorNameOrId);
-
-        const actorInput = {
-            ...(prefilledInput && (await getActorPrefilledInput(apifyClient, actorNameOrId, buildId))),
-            ...input,
-        };
-        const run = await actor.call(actorInput, { build, log: null, ...options });
-
-        const runLink = generateRunLink(run);
-        await annotate(`${task.name} - ${runLink}`, 'run_link');
-        // @ts-expect-error: `TaskMeta` cannot be retyped
-        task.meta = {
-            runId: run.id,
-            runLink,
-            actorName: actorNameOrId,
-        };
-
-        // waiting for datasetItemCount and chargedEventCounts to sync
-        await sleep(10_000);
-
-        return new RunTestResult(apifyClient, run);
-    };
-};
-
-export interface StandbyTask {
-    standbyUrl: string;
-    taskId: string;
-}
-
-/**
- * Creates a function that accepts input for a standby actor and sends a request
- * containing that input to the task's standby URL.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const createStartStandbyFn = <I = any, O = any>(apifyClient: ApifyClient, standbyTask: StandbyTask) => {
-    const { standbyUrl } = standbyTask;
-    return async ({ input }: Pick<RunOptions<I>, 'input'>) => {
-        const response = await fetch(standbyUrl, {
-            headers: { Authorization: `Bearer ${apifyClient.token}` },
-            method: 'POST',
-            body: JSON.stringify(input),
-        });
-
-        const data = (await response.json()) as O;
-        return { data, status: response.status, headers: response.headers };
-    };
-};
-
-/**
- * Creates a task with a specific `build` — either `buildNumber` or the actor default.
- *
- * @throws if the actor doesn't exist or doesn't support standby mode.
- */
-export const createStandbyTask = async (
-    apifyClient: ApifyClient,
-    actorNameOrId: string,
-    buildNumber?: string,
-): Promise<StandbyTask> => {
-    const actor = apifyClient.actor(actorNameOrId);
-
-    const actorInfo = (await actor.get()) as Actor & { standbyUrl?: string };
-    if (!actorInfo) throw new Error(`Actor "${actorNameOrId}" not found`);
-    if (!actorInfo.standbyUrl) throw new Error(`Actor "${actorNameOrId}" doesn't support standby mode`);
-    if (!actorInfo.actorStandby) throw new Error(`Actor "${actorNameOrId}" doesn't contain actorStandby options`);
-
-    const { isEnabled, ...defaultActorStandby } = actorInfo.actorStandby;
-    delete defaultActorStandby.disableStandbyFieldsOverride;
-
-    const actorStandbyOptions: ActorStandby = {
-        ...defaultActorStandby,
-        build: buildNumber ?? defaultActorStandby.build,
-    };
-
-    try {
-        const { build } = actorStandbyOptions;
-        const title = `Test task - ${build}:${actorNameOrId}`.slice(0, 62);
-        // Unique task name: only `a-z0-9-` chars, at most 63 chars long
-        const randomPrefix = Math.floor(Math.random() * 1_000_000);
-        const name = `${randomPrefix}${title
-            .toLowerCase()
-            .replaceAll(/\s+/g, '')
-            .replaceAll(/[^a-z0-9-]+/g, '-')}`.slice(0, 62);
-
-        const newTask = (await apifyClient.tasks().create({
-            actId: actorNameOrId,
-            actorStandby: actorStandbyOptions,
-            description: `Task for testing standby version ${build}`,
-            title,
-            name,
-        })) as Task & { standbyUrl?: string };
-
-        const { id, standbyUrl } = newTask;
-        if (!standbyUrl) throw new Error(`Task "${id}" doesn't contain standbyUrl property`);
-
-        return { standbyUrl, taskId: id };
-    } catch (error) {
-        throw new Error(`Failed to create task: ${error}`);
-    }
-};