apify-test-tools 0.6.0 → 0.6.1

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,15 +278,16 @@ 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}`);
@@ -297,11 +296,12 @@ const isWithinInterval = <T extends string>(
     } 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 ?? ''}>`);
             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.6.0",
+    "version": "0.6.1",
     "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

@@ -0,0 +1,182 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getChangedActors, maybeParseActorFolder } from '../../../bin/diff-changes.js';
+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 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',
+        });
+    });
+
+    it('returns actorName for standalone-actors/ path', () => {
+        expect(maybeParseActorFolder('standalone-actors/my_actor/main.ts')).toEqual({
+            isActorFolder: true,
+            actorName: 'my/actor',
+        });
+    });
+
+    it('returns false for top-level file', () => {
+        expect(maybeParseActorFolder('package.json')).toEqual({ isActorFolder: false });
+    });
+
+    it('returns false for path with no file inside actor folder', () => {
+        expect(maybeParseActorFolder('actors/foo_bar')).toEqual({ isActorFolder: false });
+    });
+
+    it('returns false for unrelated folder', () => {
+        expect(maybeParseActorFolder('src/utils.ts')).toEqual({ isActorFolder: false });
+    });
+});
+
+describe('getChangedActors', () => {
+    beforeEach(() => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(false);
+    });
+
+    it('returns empty array when no files changed', () => {
+        expect(getChangedActors({ filepathsChanged: [], actorConfigs, commits })).toEqual([]);
+    });
+
+    it('returns empty array when only ignored top-level files changed', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['.gitignore', 'README.md', '.husky/pre-commit', '.vscode/settings.json'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('returns the actor when a functional file in its folder changes', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/src/main.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('returns actor when isLatest and README in actor folder changed (cosmetic)', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/README.md'],
+            actorConfigs,
+            commits,
+            isLatest: true,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('does not return actor when not isLatest and only README changed (cosmetic)', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/README.md'],
+            actorConfigs,
+            commits,
+            isLatest: false,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('returns actor when isLatest and JSON file has only cosmetic changes', () => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(true);
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/actor.json'],
+            actorConfigs,
+            commits,
+            isLatest: true,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('does not return actor when not isLatest and JSON file has only cosmetic changes', () => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(true);
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/actor.json'],
+            actorConfigs,
+            commits,
+            isLatest: false,
+        });
+        expect(result).toEqual([]);
+    });
+
+    it('returns actor when JSON file has functional changes', () => {
+        vi.spyOn(DiffJsonSchema, 'isCosmeticOnlyJsonSchemaChange').mockReturnValue(false);
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/actor.json'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+
+    it('returns all non-standalone actors when a non-actor-folder functional file changes', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['shared/utils.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toContainEqual(miniActor);
+        expect(result).not.toContainEqual(standaloneActor);
+    });
+
+    it('does not include standalone actor in all-actors expansion from changelog', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['CHANGELOG.md'],
+            actorConfigs,
+            commits,
+            isLatest: true,
+        });
+        expect(result).toContainEqual(miniActor);
+        expect(result).not.toContainEqual(standaloneActor);
+    });
+
+    it('includes standalone actor when its own folder changes', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['standalone-actors/standalone/src/main.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toContainEqual(standaloneActor);
+    });
+
+    it('deduplicates actors when multiple files in same actor folder change', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/src/main.ts', 'actors/foo_bar/package.json'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toHaveLength(1);
+        expect(result).toContainEqual(miniActor);
+    });
+
+    it('handles mixed changes: returns both mini and standalone actors', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['actors/foo_bar/src/main.ts', 'standalone-actors/standalone/Dockerfile'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toContainEqual(miniActor);
+        expect(result).toContainEqual(standaloneActor);
+    });
+
+    it('file paths are matched case-insensitively', () => {
+        const result = getChangedActors({
+            filepathsChanged: ['Actors/FOO_BAR/Main.ts'],
+            actorConfigs,
+            commits,
+        });
+        expect(result).toEqual([miniActor]);
+    });
+});