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

package/eslint.config.mjs

@@ -6,7 +6,7 @@ import tsEslint from 'typescript-eslint';
 
 // eslint-disable-next-line import/no-default-export
 export default [
-    { ignores: ['**/dist', 'eslint.config.mjs'] },
+    { ignores: ['**/dist', 'eslint.config.mjs', '.github'] },
     ...apify,
     prettier,
     {
@@ -25,6 +25,8 @@ export default [
         },
         rules: {
             'no-console': 0,
+            // This was used heavily, I don't have string opinion so turning it off for now, feel free to refactor later
+            'no-use-before-define': 'off',
         },
     },
-];
+];

package/knip.json

@@ -1,3 +1,3 @@
 {
     "$schema": "https://unpkg.com/knip@5/schema.json"
-}
+}

package/lib/extend-expect.ts

@@ -1,8 +1,8 @@
 import type { Assertion, ExpectStatic } from 'vitest';
 
 import { TO_FINISH_WITH_OPTIONS } from './consts.js';
+import type { RunTestResult } from './run-test-result.js';
 import type { Interval, ToFinishWithOptions } from './types.js';
-import { RunTestResult } from './run-test-result.js';
 
 export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
     expect.extend({
@@ -110,7 +110,7 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
         },
         toFinishWith: async <PpeEvent extends string>(
             received: RunTestResult,
-            userOptions: ToFinishWithOptions<PpeEvent>
+            userOptions: ToFinishWithOptions<PpeEvent>,
         ) => {
             const options = {
                 ...TO_FINISH_WITH_OPTIONS,
@@ -146,12 +146,12 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
             const checkInterval = (
                 value: number | undefined,
                 key: ['datasetItemCount', 'duration', 'failedRequests', 'requestsRetries'][number],
-                label: string
+                label: string,
             ) => {
                 const result = isWithinInterval(diffs, value, options, key);
                 if (result === false) {
                     failedAssertions.push(
-                        `Failed ${label} check, expected ${JSON.stringify(options[key])}, got ${value}.`
+                        `Failed ${label} check, expected ${JSON.stringify(options[key])}, got ${value}.`,
                     );
                 }
             };
@@ -161,17 +161,15 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
             checkInterval(stats?.requestsFailed, 'failedRequests', 'failed requests');
             checkInterval(stats?.requestsRetries, 'requestsRetries', 'requests retries');
 
-            {
-                if (options.maxRetriesPerRequest !== null) {
-                    const maxRetriesPerRequestObserved = (stats?.requestRetryHistogram ?? [0]).length - 1;
-                    if (maxRetriesPerRequestObserved > options.maxRetriesPerRequest) {
-                        diffs.pass = false;
-                        diffs.actual.push(`maxRetriesPerRequest=${maxRetriesPerRequestObserved}`);
-                        diffs.expected.push(`maxRetriesPerRequest<=${options.maxRetriesPerRequest}`);
-                        failedAssertions.push(
-                            `Failed max retries observed check, expected <=${options.maxRetriesPerRequest}, got ${maxRetriesPerRequestObserved}.`
-                        );
-                    }
+            if (options.maxRetriesPerRequest !== null) {
+                const maxRetriesPerRequestObserved = (stats?.requestRetryHistogram ?? [0]).length - 1;
+                if (maxRetriesPerRequestObserved > options.maxRetriesPerRequest) {
+                    diffs.pass = false;
+                    diffs.actual.push(`maxRetriesPerRequest=${maxRetriesPerRequestObserved}`);
+                    diffs.expected.push(`maxRetriesPerRequest<=${options.maxRetriesPerRequest}`);
+                    failedAssertions.push(
+                        `Failed max retries observed check, expected <=${options.maxRetriesPerRequest}, got ${maxRetriesPerRequestObserved}.`,
+                    );
                 }
             }
             const ppeDiffs: Diffs = {
@@ -208,8 +206,8 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
                     diffs.expected.push(ppeDiffs.expected.join('\n    '));
                     failedAssertions.push(
                         `Failed PPE event counts check, expected ${JSON.stringify(
-                            options.chargedEventCounts
-                        )}, got ${JSON.stringify(chargedEventCounts)}.`
+                            options.chargedEventCounts,
+                        )}, got ${JSON.stringify(chargedEventCounts)}.`,
                     );
                 }
             }
@@ -228,7 +226,7 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
                     diffs.actual.push(` logs=[${occuredLogs.join(', ')}]`);
                     diffs.expected.push(` logs=[]`);
                     failedAssertions.push(
-                        `Failed forbidden logs check, expected [] but got [${occuredLogs.join(', ')}].`
+                        `Failed forbidden logs check, expected [] but got [${occuredLogs.join(', ')}].`,
                     );
                 }
             }
@@ -280,28 +278,32 @@ const isWithinInterval = <T extends string>(
     diffs: Diffs,
     actual: number | undefined,
     options: Record<T, Interval | null>,
-    intervalOption: T
+    intervalOption: T,
 ) => {
     const expected = options[intervalOption];
     if (expected === null) {
         // check is disabled if expected value is null
-        return;
+        return undefined;
     }
     if (typeof expected === 'number') {
         if (actual !== expected) {
+            // eslint-disable-next-line no-param-reassign --- Don't want to touch this code :)
             diffs.pass = false;
             diffs.actual.push(`${intervalOption}=${actual}`);
             diffs.expected.push(`${intervalOption}=${expected}`);
+            // eslint-disable-next-line consistent-return
             return false;
         }
     } else if (typeof expected === 'object') {
         const { min, max } = expected;
         if (actual === undefined || (min !== undefined && actual < min) || (max !== undefined && actual > max)) {
+            // eslint-disable-next-line no-param-reassign
             diffs.pass = false;
             diffs.actual.push(`${intervalOption}=${actual}`);
             diffs.expected.push(`${intervalOption}=<${min ?? ''},${max ?? ''}>`);
+            // eslint-disable-next-line consistent-return
             return false;
         }
     }
-    return;
+    return undefined;
 };

package/lib/lib.ts

@@ -1,15 +1,11 @@
-import { Actor, ActorRun, ActorRunListItem, ActorStandby, ApifyClient, Task } from 'apify-client';
-import {
-    describe as vitestDescribe,
-    ExpectStatic,
-    TestFunction,
-    test as vitestTest,
-    SuiteFactory,
-    TestContext,
-} from 'vitest';
-import type { ActorBuild, ActorTestOptions, RunOptions } from './types.js';
-import { RunTestResult } from './run-test-result.js';
+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 { extendExpect } from './extend-expect.js';
+import { RunTestResult } from './run-test-result.js';
+import type { ActorBuild, ActorTestOptions, RunOptions } from './types.js';
 import { getActorPrefilledInput, sleep } from './utils.js';
 
 const ACTOR_BUILDS = 'ACTOR_BUILDS';
@@ -56,7 +52,7 @@ export const testActor = <T>(
     actorName: string,
     testName: string,
     fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
-    testOptions?: ActorTestOptions
+    testOptions?: ActorTestOptions,
 ) => {
     const options = {
         ...DEFAULT_TEST_ACTOR_OPTIONS,
@@ -64,7 +60,7 @@ export const testActor = <T>(
     };
     const name = `${actorName}: ${testName}`;
     const shouldRun = !!RUN_ALL_PLATFORM_TESTS || config.has(actorName);
-    vitestTest.runIf(shouldRun)(name, options, async <T extends TestContext>(context: T) => {
+    vitestTest.runIf(shouldRun)(name, options, async <TYPE extends TestContext>(context: TYPE) => {
         const { expect, ...rest } = context;
         await fn({
             expect: extendExpect(expect),
@@ -80,11 +76,12 @@ export const testActor = <T>(
  *
  * Using task is just current shortcoming of standby feature but ideally we would use Actor directly
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const testStandbyActor = <I = any, O = any>(
     actorName: string,
     testName: string,
     fn: TestFunction<{ callStandby: ReturnType<typeof createStartStandbyFn<I, O>> }>,
-    testOptions?: ActorTestOptions
+    testOptions?: ActorTestOptions,
 ) => {
     const options = {
         ...DEFAULT_TEST_ACTOR_OPTIONS,
@@ -105,7 +102,9 @@ export const testStandbyActor = <I = any, O = any>(
                 callStandby: createStartStandbyFn(standbyTask),
                 ...rest,
             });
-        } catch {}
+        } catch {
+            /* */
+        }
 
         const { taskId } = standbyTask;
         const runs = (await apifyClient.task(taskId).runs().list()).items;
@@ -122,13 +121,14 @@ export const testStandbyActor = <I = any, O = any>(
 
 export const testTestActor = <T>(
     testName: string,
-    fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>
+    fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
 ) => {
     vitestTest(testName, async (context) => {
         const { expect, ...rest } = context;
         await fn({
             expect: extendExpect(expect),
             // @ts-expect-error: this just to test custom matchers
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
             run: () => {},
             ...rest,
         });
@@ -191,7 +191,7 @@ const createStandbyTask = async (actorNameOrId: string, buildNumber?: string): P
         throw new Error(`Actor "${actorNameOrId} doesn't contain actorStandby options`);
     }
     const { isEnabled, ...defaultActorStandby } = actorInfo.actorStandby;
-    delete defaultActorStandby.disableStandbyFieldsOverride
+    delete defaultActorStandby.disableStandbyFieldsOverride;
 
     const build = buildNumber ?? defaultActorStandby.build;
 

package/lib/run-test-result.ts

@@ -1,4 +1,5 @@
-import { ActorRun, ApifyClient, KeyValueStoreClient } from 'apify-client';
+import type { ActorRun, ApifyClient, KeyValueStoreClient } from 'apify-client';
+
 import type { Dataset, SdkCrawlerStatistics } from './types.js';
 
 export class RunTestResult {
@@ -9,7 +10,10 @@ export class RunTestResult {
     private runInfo: ActorRun | undefined;
     private input: unknown | undefined;
 
-    constructor(private readonly apifyClient: ApifyClient, private readonly run: ActorRun) {
+    constructor(
+        private readonly apifyClient: ApifyClient,
+        private readonly run: ActorRun,
+    ) {
         /**/
     }
 

package/lib/types.ts

@@ -1,5 +1,5 @@
-import { ActorCallOptions } from 'apify-client';
-import { Assertion, TestOptions } from 'vitest';
+import type { ActorCallOptions } from 'apify-client';
+import type { Assertion, TestOptions } from 'vitest';
 
 export type ActorBuild = {
     buildId: string;
@@ -50,10 +50,6 @@ export type ToFinishWithOptionsWithDefaults = {
     forbiddenLogs: string[];
     maxRetriesPerRequest: number | null;
 };
-export type IntervalOption<PpeEvent extends string> = keyof Pick<
-    ToFinishWithOptions<PpeEvent>,
-    'datasetItemCount' | 'requestsRetries' | 'failedRequests' | 'duration'
->;
 
 export type ToFinishWithOptions<PpeEvent extends string> = Partial<ToFinishWithOptionsWithDefaults> & {
     datasetItemCount: Interval;
@@ -144,9 +140,10 @@ export type ActorTestOptions = Omit<TestOptions, 'retry'> & {
 };
 
 declare module 'vitest' {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
     interface Assertion<T = any> extends ActorMatchers<T> {}
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type
     interface Matchers<T = any> extends ActorMatchers<T> {}
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
     interface AsymmetricMatchersContaining extends ActorMatchers {}
 }

package/lib/utils.ts

@@ -1,5 +1,4 @@
-import { ActorRun, ApifyClient } from 'apify-client';
-import { TestContext } from 'vitest';
+import type { ApifyClient } from 'apify-client';
 
 /**
  * Gets prefilled values for a provided build or, if not provided, uses actor's
@@ -16,26 +15,29 @@ export const getActorPrefilledInput = async (
         const defaultBuildTag = actorInfo?.defaultRunOptions.build;
 
         const taggedBuild = actorInfo?.taggedBuilds?.[defaultBuildTag || ''];
+        // eslint-disable-next-line no-param-reassign --- I think here it is cleaner than creating dummy variable
         buildId = taggedBuild?.buildId;
 
         if (!buildId) {
             console.error(`Coudn't find default build for actor ${actorNameOrId}. Prefilled values will not be used.`);
-            return {}
+            return {};
         }
     }
 
     const buildInfo = await apifyClient.build(buildId).get();
 
-    const inputSchema = buildInfo?.actorDefinition?.input as {
-        properties: Record<string, { prefill?: unknown }>
-    } | undefined
+    const inputSchema = buildInfo?.actorDefinition?.input as
+        | {
+              properties: Record<string, { prefill?: unknown }>;
+          }
+        | undefined;
 
     if (!inputSchema) {
         console.error(
             `Coudn't find input schema definition for actor ${actorNameOrId}, build ${buildId}.`,
             'Prefilled values will not be used',
         );
-        return {}
+        return {};
     }
 
     const prefill: Record<string, unknown> = {};
@@ -50,5 +52,7 @@ export const getActorPrefilledInput = async (
 };
 
 export const sleep = async (ms: number) => {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-test-tools",
-  "version": "0.5.7-beta.3",
+  "version": "0.5.7-beta.5",
   "type": "module",
   "description": "TBD",
   "repository": {
@@ -34,7 +34,9 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.34.1",
     "vitest": "^3.2.4",
-    "knip": "^5.65.0"
+    "knip": "^5.65.0",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2"
   },
   "peerDependencies": {
     "vitest": ">=3.2.4"
@@ -49,7 +51,12 @@
     "format:check": "prettier --check .",
     "type-check": "tsc --noEmit",
     "test": "vitest run",
-    "check-unused": "npx knip"
+    "check-unused": "npx knip",
+    "prepare": "husky .husky || true"
+  },
+  "lint-staged": {
+    "*.js": "eslint",
+    "*.ts": "eslint"
   },
   "author": "oklinov",
   "license": "ISC"

package/test/tsconfig.json

@@ -7,9 +7,7 @@
         "noUnusedLocals": false,
         "noEmit": true,
         "lib": ["DOM", "es2021"],
-        "skipLibCheck": true,
+        "skipLibCheck": true
     },
-    "include": [
-        "./**/*",
-    ]
+    "include": ["./**/*"]
 }

package/test/unit/bin/diff-changes.test.ts

@@ -5,18 +5,28 @@ import * as DiffJsonSchema from '../../../bin/diff-json-schema.js';
 import type { ActorConfig } from '../../../bin/types.js';
 
 const miniActor: ActorConfig = { actorName: 'foo/bar', folder: 'actors/foo_bar', isStandalone: false };
-const standaloneActor: ActorConfig = { actorName: 'standalone', folder: 'standalone-actors/standalone', isStandalone: true };
+const standaloneActor: ActorConfig = {
+    actorName: 'standalone',
+    folder: 'standalone-actors/standalone',
+    isStandalone: true,
+};
 const actorConfigs = [miniActor, standaloneActor];
 
 const commits = [{ sha: 'Commit1', author: '', date: '', message: '' }];
 
 describe('maybeParseActorFolder', () => {
     it('returns actorName for actors/ path', () => {
-        expect(maybeParseActorFolder('actors/foo_bar/actor.json')).toEqual({ isActorFolder: true, actorName: 'foo/bar' });
+        expect(maybeParseActorFolder('actors/foo_bar/actor.json')).toEqual({
+            isActorFolder: true,
+            actorName: 'foo/bar',
+        });
     });
 
     it('returns actorName for standalone-actors/ path', () => {
-        expect(maybeParseActorFolder('standalone-actors/my_actor/main.ts')).toEqual({ isActorFolder: true, actorName: 'my/actor' });
+        expect(maybeParseActorFolder('standalone-actors/my_actor/main.ts')).toEqual({
+            isActorFolder: true,
+            actorName: 'my/actor',
+        });
     });
 
     it('returns false for top-level file', () => {
@@ -153,10 +163,7 @@ describe('getChangedActors', () => {
 
     it('handles mixed changes: returns both mini and standalone actors', () => {
         const result = getChangedActors({
-            filepathsChanged: [
-                'actors/foo_bar/src/main.ts',
-                'standalone-actors/standalone/Dockerfile',
-            ],
+            filepathsChanged: ['actors/foo_bar/src/main.ts', 'standalone-actors/standalone/Dockerfile'],
             actorConfigs,
             commits,
         });

package/test/unit/bin/diff.test.ts

@@ -17,9 +17,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
     });
 
     const mockGitCalls = (oldJson: string, newJson: string) => {
-        gitCommandSpy
-            .mockReturnValueOnce(oldJson)
-            .mockReturnValueOnce(newJson);
+        gitCommandSpy.mockReturnValueOnce(oldJson).mockReturnValueOnce(newJson);
     };
 
     test('returns true when nothing changed', () => {
@@ -69,10 +67,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
     });
 
     test('returns true when only sectionDescription changes', () => {
-        mockGitCalls(
-            JSON.stringify({ sectionDescription: 'Old' }),
-            JSON.stringify({ sectionDescription: 'New' }),
-        );
+        mockGitCalls(JSON.stringify({ sectionDescription: 'Old' }), JSON.stringify({ sectionDescription: 'New' }));
         expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
     });
 
@@ -85,18 +80,12 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
     });
 
     test('returns false when a functional field is added', () => {
-        mockGitCalls(
-            JSON.stringify({ title: 'My field' }),
-            JSON.stringify({ title: 'My field', type: 'string' }),
-        );
+        mockGitCalls(JSON.stringify({ title: 'My field' }), JSON.stringify({ title: 'My field', type: 'string' }));
         expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
     });
 
     test('returns false when a functional field is removed', () => {
-        mockGitCalls(
-            JSON.stringify({ type: 'string', title: 'My field' }),
-            JSON.stringify({ title: 'My field' }),
-        );
+        mockGitCalls(JSON.stringify({ type: 'string', title: 'My field' }), JSON.stringify({ title: 'My field' }));
         expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
     });
 
@@ -159,10 +148,7 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
     });
 
     test('returns false when array content changes (not under a non-functional key)', () => {
-        mockGitCalls(
-            JSON.stringify({ enum: [1, 2, 3] }),
-            JSON.stringify({ enum: [1, 2, 4] }),
-        );
+        mockGitCalls(JSON.stringify({ enum: [1, 2, 3] }), JSON.stringify({ enum: [1, 2, 4] }));
         expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(false);
     });
 
@@ -176,8 +162,20 @@ describe('isCosmeticOnlyJsonSchemaChange', () => {
 
     test('returns true for a realistic actor.json with only title/description change', () => {
         mockGitCalls(
-            JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'Old Title', description: 'Old description', version: '1.0' }),
-            JSON.stringify({ actorSpecification: 1, name: 'my-actor', title: 'New Title', description: 'New description', version: '1.0' }),
+            JSON.stringify({
+                actorSpecification: 1,
+                name: 'my-actor',
+                title: 'Old Title',
+                description: 'Old description',
+                version: '1.0',
+            }),
+            JSON.stringify({
+                actorSpecification: 1,
+                name: 'my-actor',
+                title: 'New Title',
+                description: 'New description',
+                version: '1.0',
+            }),
         );
         expect(isCosmeticOnlyJsonSchemaChange(commits, 'actors/foo/actor.json')).toBe(true);
     });

package/test/unit/bin/git.test.ts

@@ -1,4 +1,6 @@
-import { beforeEach, describe, expect, it, MockInstance, vi } from 'vitest';
+import type { MockInstance } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
 import { getChangedFiles, getCommits } from '../../../bin/git.js';
 import * as Utils from '../../../bin/utils.js';
 

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

@@ -1,7 +1,8 @@
-import process from 'process';
-import { describe } from 'vitest';
+import process from 'node:process';
 
 import { ApifyClient } from 'apify-client';
+import { describe } from 'vitest';
+
 import { testStandbyActor, testTestActor } from '../../lib/lib.js';
 import { RunTestResult } from '../../lib/run-test-result.js';
 
@@ -11,13 +12,13 @@ enum PpeEventEnum {
     SEARCH_PAGE_SCRAPED = 'search-page-scraped',
     ADS_SCRAPED = 'ads-scraped',
 }
-const PPE_EVENT_CONST = {
-    ACTOR_START: 'actor-start',
-    ITEM_PUSHED: 'search-page-scraped',
-    ADS_SCRAPED: 'ads-scraped',
-} as const;
+type PPE_EVENT_CONST = {
+    ACTOR_START: 'actor-start';
+    ITEM_PUSHED: 'search-page-scraped';
+    ADS_SCRAPED: 'ads-scraped';
+};
 
-// TODO: Remake these tests. k5MNKmaDGHlABDn2I run doesn't exist and we probably don't want to depend on fixed run 
+// TODO: Remake these tests. k5MNKmaDGHlABDn2I run doesn't exist and we probably don't want to depend on fixed run
 describe.skip('custom-matchers', { timeout: 100_000 }, () => {
     testTestActor('basic', async ({ expect }) => {
         const apifyClient = new ApifyClient({ token: process.env.TESTER_APIFY_TOKEN });
@@ -43,7 +44,7 @@ describe.skip('custom-matchers', { timeout: 100_000 }, () => {
             },
         });
 
-        await expect(runResult).toFinishWith<(typeof PPE_EVENT_CONST)[keyof typeof PPE_EVENT_CONST]>({
+        await expect(runResult).toFinishWith<PPE_EVENT_CONST[keyof PPE_EVENT_CONST]>({
             datasetItemCount: { min: 1, max: 20 },
             chargedEventCounts: {
                 'actor-start': 1,