apify-test-tools 0.1.0 → 0.2.1

package/index.ts

@@ -1,2 +1,2 @@
-export { describe, testActor, ExpectStatic } from './lib/lib.js';
+export { describe, testActor, testStandbyActor, ExpectStatic } from './lib/lib.js';
 export { RunTestResult } from './lib/run-test-result.js';

package/lib/lib.ts

@@ -1,4 +1,4 @@
-import { ApifyClient } from 'apify-client';
+import { Actor, ActorRun, ActorRunListItem, ActorStandby, ApifyClient, Task } from 'apify-client';
 import {
     describe as vitestDescribe,
     ExpectStatic,
@@ -11,7 +11,7 @@ import {
 import type { ActorBuild, RunOptions } from './types';
 import { RunTestResult } from './run-test-result.js';
 import { extendExpect } from './extend-expect.js';
-import { getActorPrefilledInput } from './utils.js';
+import { getActorPrefilledInput, sleep } from './utils.js';
 
 const ACTOR_BUILDS = 'ACTOR_BUILDS';
 let actorBuilds: ActorBuild[] = [];
@@ -80,6 +80,53 @@ export const testActor = <T>(
     });
 };
 
+/**
+ * This wrapper creates a new task with specific `build` of the standby actor and provides
+ * `callStandby` function, which calls the task's `standbyUrl`.
+ *
+ * Using task is just current shortcoming of standby feature but ideally we would use Actor directly
+ */
+export const testStandbyActor = <I = any, O = any>(
+    actorName: string,
+    testName: string,
+    fn: TestFunction<{ callStandby: ReturnType<typeof createStartStandbyFn<I, O>> }>,
+    testOptions?: TestOptions,
+) => {
+    const options = {
+        ...DEFAULT_TEST_ACTOR_OPTIONS,
+        ...testOptions,
+    };
+    const name = `${actorName}: ${testName}`;
+    const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorName);
+
+    vitestTest.runIf(shouldRun)(name, options, async (context) => {
+        const standbyTask = await createStandbyTask(actorName, config.get(actorName)?.buildNumber);
+        const { annotate } = context;
+        const { expect, ...rest } = context;
+
+        // NOTE: we need to wrap `fn` in try-catch so that we can always clean up (delete the task) afterwards
+        try {
+            await fn({
+                expect: extendExpect(expect),
+                callStandby: createStartStandbyFn(standbyTask),
+                ...rest,
+            });
+        } catch {}
+
+        const { taskId } = standbyTask;
+        const runs = (await apifyClient.task(taskId).runs().list()).items
+        for (const run of runs) {
+            const runLink = generateRunLink(run);
+            await annotate(runLink, 'run_link');
+        }
+
+        if (taskId) {
+            await apifyClient.task(taskId).delete()
+        }
+
+    });
+};
+
 export const testTestActor = <T>(
     testName: string,
     fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
@@ -97,7 +144,88 @@ export const testTestActor = <T>(
 
 export const it = testActor;
 
-const createStartRunFn = <T>(actorNameOrId: string, { annotate, task }: TestContext) => {
+/**
+ * Creates a function the accepts input for a standby actor and sends request containing input
+ * to the task's standby url.
+ */
+const createStartStandbyFn = <I, O>(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,
+        };
+    };
+}
+
+interface StandbyTask {
+    standbyUrl: string;
+    taskId: string;
+}
+
+/**
+ * Creates a task with specific `build` - either `buildNumber` or default.
+ *
+ * @throws if actor doesn't exist or it doesn't support standby mode.
+ */
+const createStandbyTask = async (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;
+    const build = buildNumber ?? defaultActorStandby.build;
+
+    const actorStandbyOptions: ActorStandby = {
+        ...defaultActorStandby,
+        build,
+    }
+
+    try {
+        const newTask = await apifyClient.tasks().create({
+            actId: actorNameOrId,
+            actorStandby: actorStandbyOptions,
+            description: `Task for testing standby version ${build}`,
+            title: `Test task - ${build}`,
+        }) 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}`);
+    }
+}
+
+const createStartRunFn = <T>(actorNameOrId: string, testContext: TestContext) => {
+    const { annotate, task } = testContext;
     const actorConfig = config.get(actorNameOrId);
     const build = actorConfig?.buildNumber;
     const buildId = actorConfig?.buildId;
@@ -118,7 +246,7 @@ const createStartRunFn = <T>(actorNameOrId: string, { annotate, task }: TestCont
             { build, ...options, },
         );
 
-        const runLink = `https://console.apify.com/view/runs/${run.id}`;
+        const runLink = generateRunLink(run);
         await annotate(runLink, 'run_link');
         // @ts-expect-error: `TaskMeta` cannot be retyped
         task.meta = {
@@ -127,8 +255,12 @@ const createStartRunFn = <T>(actorNameOrId: string, { annotate, task }: TestCont
         };
 
         // waiting for datasetItemCount and chargedEventCounts to sync
-        await new Promise((resolve) => setTimeout(resolve, 10_000));
+        await sleep(10_000);
 
         return new RunTestResult(apifyClient, run);
     };
 };
+
+const generateRunLink = (run: ActorRun | ActorRunListItem): string => {
+    return `https://console.apify.com/view/runs/${run.id}`;
+}

package/lib/run-test-result.ts

@@ -48,7 +48,8 @@ export class RunTestResult {
         }
         const kvs = this.apifyClient.keyValueStore(this.run.defaultKeyValueStoreId);
         const input = await kvs.getRecord('INPUT');
-        return input as T;
+        this.input = input?.value;
+        return this.input as T;
     }
 
     getRunInfo = async (): Promise<ActorRun> => {

package/lib/utils.ts

@@ -1,4 +1,5 @@
-import { ApifyClient } from 'apify-client';
+import { ActorRun, ApifyClient } from 'apify-client';
+import { TestContext } from 'vitest';
 
 /**
  * Gets prefilled values for a provided build or, if not provided, uses actor's
@@ -47,3 +48,7 @@ export const getActorPrefilledInput = async (
 
     return prefill;
 };
+
+export const sleep = async (ms: number) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "apify-test-tools",
-    "version": "0.1.0",
+    "version": "0.2.1",
     "type": "module",
     "description": "TBD",
     "engines": {

package/test/unit/custom-matchers.test.ts

@@ -2,7 +2,7 @@ import process from 'process';
 import { describe } from 'vitest';
 
 import { ApifyClient } from 'apify-client';
-import { testTestActor } from '../../lib/lib';
+import { testStandbyActor, testTestActor } from '../../lib/lib';
 import { RunTestResult } from '../../lib/run-test-result';
 
 type PpeEventType =
@@ -58,4 +58,28 @@ describe('custom-matchers', { timeout: 100_000 }, () => {
         expect.hard(5).toEqual(5);
         expect(10).toEqual(10);
     });
+
+    testStandbyActor('ondrejklinovsky/contact-info', 'CDS standby', async ({ expect, callStandby }) => {
+        {
+            const { data, status } = await callStandby({
+                input: {
+                    startUrls: [{ url: 'https://apify.com' }],
+                    maxRequests: 3,
+                    aggregateContacts: true,
+                },
+            })
+            expect(status).toBe(200);
+            expect(data[0].domain).toEqual('apify.com');
+        }
+
+        const { data, status } = await callStandby({
+            input: {
+                startUrls: [{ url: 'https://apify.com' }],
+                maxRequests: 3,
+                aggregateContacts: true,
+            },
+        })
+        expect(status).toBe(200);
+        expect(data[0].domain).toEqual('apify.com');
+    });
 });

package/test/unit/parse-commit.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { GIT_FORMAT_SEPARATOR, parseCommit } from '../../bin/git';
+
+describe('parseCommit', () => {
+
+    describe('valid commit strings', () => {
+        it('should parse a basic commit string correctly', () => {
+            const commitString = `abc123${GIT_FORMAT_SEPARATOR}John Doe<john@example.com>${GIT_FORMAT_SEPARATOR}Mon, 25 Dec 2023 10:30:00 +0100${GIT_FORMAT_SEPARATOR}Add new feature`;
+
+            const result = parseCommit(commitString);
+
+            expect(result).toEqual({
+                sha: 'abc123',
+                author: 'John Doe<john@example.com>',
+                date: 'Mon, 25 Dec 2023 10:30:00 +0100',
+                message: 'Add new feature'
+            });
+        });
+
+        it('should parse commit with double quotes in message', () => {
+            const commitString = `def456${GIT_FORMAT_SEPARATOR}Jane Smith<jane@example.com>${GIT_FORMAT_SEPARATOR}Tue, 26 Dec 2023 14:15:00 +0100${GIT_FORMAT_SEPARATOR}test: commit with double quotes: "`;
+
+            const result = parseCommit(commitString);
+
+            expect(result).toEqual({
+                sha: 'def456',
+                author: 'Jane Smith<jane@example.com>',
+                date: 'Tue, 26 Dec 2023 14:15:00 +0100',
+                message: 'test: commit with double quotes: \"'
+            });
+        });
+
+        it('should parse commit with special characters and Unicode', () => {
+            const commitString = `jkl012${GIT_FORMAT_SEPARATOR}María García<maria@example.com>${GIT_FORMAT_SEPARATOR}Thu, 28 Dec 2023 16:20:00 +0100${GIT_FORMAT_SEPARATOR}Add émojis 🚀 and "special" chars`;
+
+            const result = parseCommit(commitString);
+
+            expect(result).toEqual({
+                sha: 'jkl012',
+                author: 'María García<maria@example.com>',
+                date: 'Thu, 28 Dec 2023 16:20:00 +0100',
+                message: 'Add émojis 🚀 and "special" chars'
+            });
+        });
+
+        it('should parse commit with empty message', () => {
+            const commitString = `mno345${GIT_FORMAT_SEPARATOR}Test User<test@example.com>${GIT_FORMAT_SEPARATOR}Fri, 29 Dec 2023 11:00:00 +0100${GIT_FORMAT_SEPARATOR}`;
+
+            const result = parseCommit(commitString);
+
+            expect(result).toEqual({
+                sha: 'mno345',
+                author: 'Test User<test@example.com>',
+                date: 'Fri, 29 Dec 2023 11:00:00 +0100',
+                message: ''
+            });
+        });
+    });
+
+    describe('invalid commit strings', () => {
+        it('should throw error for commit string with too few parts', () => {
+            const commitString = `abc123${GIT_FORMAT_SEPARATOR}John Doe<john@example.com>${GIT_FORMAT_SEPARATOR}Mon, 25 Dec 2023 10:30:00 +0100`;
+
+            expect(() => parseCommit(commitString)).toThrow(`Failed to parse commit string: ${commitString}`);
+        });
+
+        it('should throw error for commit string with too many parts', () => {
+            const commitString = `abc123${GIT_FORMAT_SEPARATOR}John Doe<john@example.com>${GIT_FORMAT_SEPARATOR}Mon, 25 Dec 2023 10:30:00 +0100${GIT_FORMAT_SEPARATOR}Add feature${GIT_FORMAT_SEPARATOR}extra part`;
+
+            expect(() => parseCommit(commitString)).toThrow(`Failed to parse commit string: ${commitString}`);
+        });
+    });
+});