apify-test-tools 0.9.1-beta.2 → 0.9.1-beta.4

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';
@@ -31,7 +31,7 @@ const config = actorBuilds.reduce<Map<string, ActorBuild>>((map, cfg) => {
 
 export { ExpectStatic };
 
-const { TESTER_APIFY_TOKEN, RUN_PLATFORM_TESTS, RUN_ALL_PLATFORM_TESTS } = process.env;
+const { TESTER_APIFY_TOKEN, RUN_ALL_PLATFORM_TESTS } = process.env;
 const apifyClient = new ApifyClient({ token: TESTER_APIFY_TOKEN });
 
 const DEFAULT_TEST_OPTIONS: ActorTestOptions = {
@@ -39,16 +39,17 @@ const DEFAULT_TEST_OPTIONS: ActorTestOptions = {
     concurrent: true,
     // test should finish within 1 hour
     timeout: DEFAULT_TEST_RUN_DURATION_MS,
+    retry: 1,
 };
 
+/**
+ * Platform tests need `TESTER_APIFY_TOKEN` to talk to the platform, so without it we skip them altogether.
+ *
+ * `RUN_ALL_PLATFORM_TESTS` enables them too because locally we can test against a hardcoded `runId`,
+ * which doesn't need the tester token.
+ */
 export const describe = (name: string, fn?: SuiteFactory<object>, options: ActorTestOptions = DEFAULT_TEST_OPTIONS) => {
-    vitestDescribe.runIf(!!RUN_PLATFORM_TESTS || !!RUN_ALL_PLATFORM_TESTS)(name, options, fn);
-};
-
-const DEFAULT_TEST_ACTOR_OPTIONS: ActorTestOptions = {
-    retry: 1,
-    // prevent orphaned runs
-    timeout: DEFAULT_TEST_RUN_DURATION_MS,
+    vitestDescribe.runIf(!!TESTER_APIFY_TOKEN || !!RUN_ALL_PLATFORM_TESTS)(name, options, fn);
 };
 
 /**
@@ -60,11 +61,11 @@ 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.
     const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorId);
     vitestTest.runIf(shouldRun)(name, options, async <TYPE extends TestContext>(context: TYPE) => {
         const { expect, ...rest } = context;
@@ -92,11 +93,11 @@ 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.
     const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorId);
 
     vitestTest.runIf(shouldRun)(name, options, async <T extends TestContext>(context: T) => {
@@ -269,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');
@@ -296,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.2",
+  "version": "0.9.1-beta.4",
   "type": "module",
   "description": "TBD",
   "repository": {

package/test/unit/lib.test.ts

@@ -0,0 +1,53 @@
+import type { Actor, ActorClient, ActorRun } from 'apify-client';
+import { ApifyClient } from 'apify-client';
+import type { TestContext } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DEFAULT_TEST_ACTOR_TIMEOUT_SECS } from '../../lib/consts.js';
+import { _private } from '../../lib/lib.js';
+import * as UtilsModule from '../../lib/utils.js';
+
+const { createStartRunFn } = _private;
+
+describe('createStartRunFn()', () => {
+    const actorCallMock = vi.fn(async () => Promise.resolve({ id: 'fake-run-id' } as ActorRun));
+    const testContext = { task: {}, annotate: vi.fn() as TestContext['annotate'] } as TestContext;
+
+    vi.spyOn(UtilsModule, 'sleep').mockResolvedValue(undefined);
+
+    beforeEach(vi.clearAllMocks);
+
+    it('should apply default timeout to actor runs', async () => {
+        // Arrange
+
+        vi.spyOn(ApifyClient.prototype, 'actor').mockReturnValue({
+            call: actorCallMock as ActorClient['call'],
+            get: vi.fn(async () => ({ defaultRunOptions: {} }) as Actor) as ActorClient['get'],
+        } as ActorClient);
+
+        // Act
+        await createStartRunFn('123', testContext)({ input: {} });
+
+        // Assert
+        expect(actorCallMock).toHaveBeenCalledTimes(1);
+        expect(actorCallMock).toHaveBeenCalledWith(
+            {},
+            { build: undefined, log: null, timeout: DEFAULT_TEST_ACTOR_TIMEOUT_SECS },
+        );
+    });
+
+    it('should respect the default actor run timeout if less', async () => {
+        // Arrange
+        vi.spyOn(ApifyClient.prototype, 'actor').mockReturnValue({
+            call: actorCallMock as ActorClient['call'],
+            get: vi.fn(async () => ({ defaultRunOptions: { timeoutSecs: 60 } }) as Actor) as ActorClient['get'],
+        } as ActorClient);
+
+        // Act
+        await createStartRunFn('123', testContext)({ input: {} });
+
+        // Assert
+        expect(actorCallMock).toHaveBeenCalledTimes(1);
+        expect(actorCallMock).toHaveBeenCalledWith({}, { build: undefined, log: null, timeout: 60 });
+    });
+});