apify-test-tools 0.10.2-beta.1 → 0.10.2-beta.11

package/lib/extend-expect.ts

@@ -1,106 +1,45 @@
+import { inspect } from 'node:util';
+
 import type { Assertion, ExpectStatic } from 'vitest';
 
-import { TO_FINISH_WITH_OPTIONS } from './consts.js';
+import { checkRun } from './run-checks.js';
 import type { RunTestResult } from './run-test-result.js';
-import type { Interval, ToFinishWithOptions } from './types.js';
+import type { ToFinishWithOptions } from './types.js';
+
+/** Matchers that only check the type or shape of a value. */
+const SHAPE_MATCHERS = {
+    toBeArray: ['an array', (actual: unknown) => Array.isArray(actual)],
+    toBeBoolean: ['a boolean', (actual: unknown) => typeof actual === 'boolean'],
+    toBeEmptyArray: ['an empty array', (actual: unknown) => Array.isArray(actual) && actual.length === 0],
+    toBeNonEmptyArray: ['a non-empty array', (actual: unknown) => Array.isArray(actual) && actual.length > 0],
+    toBeNonEmptyString: ['a non-empty string', (actual: unknown) => typeof actual === 'string' && actual.length > 0],
+    toBeNumber: ['a number', (actual: unknown) => typeof actual === 'number'],
+    toBeFalse: ['false', (actual: unknown) => actual === false],
+    toBeTrue: ['true', (actual: unknown) => actual === true],
+    toBeNonEmptyObject: ['a non-empty object', (actual: unknown) => isObject(actual) && Object.keys(actual).length > 0],
+    toBeObject: ['an object', isObject],
+    toBeString: ['a string', (actual: unknown) => typeof actual === 'string'],
+    toBeWholeNumber: ['a whole number', (actual: unknown) => Number.isInteger(actual)],
+} as const satisfies Record<string, readonly [string, (actual: unknown) => boolean]>;
+
+function isObject(actual: unknown): actual is object {
+    return typeof actual === 'object' && !Array.isArray(actual) && actual !== null;
+}
+
+const shapeMatchers = Object.fromEntries(
+    Object.entries(SHAPE_MATCHERS).map(([name, [description, predicate]]) => [
+        name,
+        (actual: unknown) => ({
+            pass: predicate(actual),
+            message: () => `Expected ${inspect(actual)} to be ${description}`,
+            actual,
+        }),
+    ]),
+);
 
 export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
     expect.extend({
-        toBeArray: (actual) => {
-            const pass = Array.isArray(actual);
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be a array`,
-            };
-        },
-        toBeBoolean: (received) => {
-            const actual = typeof received;
-            const expected = 'boolean';
-            return {
-                pass: actual === expected,
-                message: () => `Expected "${actual}" to be a boolean`,
-                expected: 'boolean',
-            };
-        },
-        toBeEmptyArray: (actual) => {
-            const pass = Array.isArray(actual) && actual.length === 0;
-            return {
-                pass,
-                message: () => `Expected ${actual} to be an empty array`,
-                actual,
-                expected: [],
-            };
-        },
-        toBeNonEmptyArray: (actual) => {
-            const pass = Array.isArray(actual) && actual.length > 0;
-            return {
-                pass,
-                message: () => `Expected ${actual} to be a non-empty array`,
-            };
-        },
-        toBeNonEmptyString: (actual) => {
-            const pass = typeof actual === 'string' && actual.length > 0;
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be a non-empty string`,
-            };
-        },
-        toBeNumber: (actual) => {
-            const pass = typeof actual === 'number';
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be a number`,
-            };
-        },
-        toBeNonEmptyObject: (actual) => {
-            const isObject = typeof actual === 'object' && !Array.isArray(actual) && actual !== null;
-            const isNonEmpty = Object.entries(actual).length > 0;
-            const pass = isObject && isNonEmpty;
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be a non-emtpy object`,
-            };
-        },
-        toBeObject: (actual) => {
-            const pass = typeof actual === 'object' && !Array.isArray(actual) && actual !== null;
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be an object`,
-            };
-        },
-        toBeString: (received) => {
-            const actual = typeof received;
-            const expected = 'string';
-            return {
-                pass: actual === expected,
-                message: () => `Expected "${actual}" to be a string`,
-                actual,
-                expected,
-            };
-        },
-        toBeTrue: (actual) => {
-            const pass = actual === true;
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be true`,
-                expected: true,
-                actual,
-            };
-        },
-        toBeFalse: (actual) => {
-            const pass = actual === false;
-            return {
-                pass,
-                message: () => `Expected "${actual}" to be false`,
-            };
-        },
-        toBeWholeNumber: (received) => {
-            const pass = Number.isInteger(received);
-            return {
-                pass,
-                message: () => `Expected "${received}" to be a whole number`,
-            };
-        },
+        ...shapeMatchers,
         toBeWithinRange: (received, lower, upper) => {
             const pass = received >= lower && received <= upper;
             return {
@@ -112,130 +51,19 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
             received: RunTestResult,
             userOptions: ToFinishWithOptions<PpeEvent>,
         ) => {
-            const options = {
-                ...TO_FINISH_WITH_OPTIONS,
-                ...userOptions,
-            };
-
-            const failedAssertions: string[] = [];
-
-            const diffs: Diffs = {
-                pass: true,
-                actual: ['Run:'],
-                expected: ['Run:'],
-            };
-            {
-                const expected = options?.status;
-                const actual = received.status;
-                const statusTest = expected === actual;
-                if (statusTest === false) {
-                    diffs.pass = false;
-                    diffs.actual.push(`status=${actual}`);
-                    diffs.expected.push(`status=${expected}`);
-                    failedAssertions.push(`Failed status check, expected "${expected}", got "${actual}".`);
-                }
-            }
-
-            const {
-                chargedEventCounts,
-                stats: { durationMillis },
-            } = await received.getRunInfo();
-            const datasetItemCount = (await received.getDataset()).items.length;
-            const stats = await received.getStatistics();
-
-            const checkInterval = (
-                value: number | undefined,
-                key: ['datasetItemCount', 'duration', 'failedRequests', 'requestsRetries'][number],
-                label: string,
-            ) => {
-                const result = isWithinInterval(diffs, value, options, key);
-                if (result === false) {
-                    failedAssertions.push(
-                        `Failed ${label} check, expected ${JSON.stringify(options[key])}, got ${value}.`,
-                    );
-                }
-            };
-
-            checkInterval(datasetItemCount, 'datasetItemCount', 'dataset item count');
-            checkInterval(durationMillis, 'duration', 'duration');
-            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}.`,
-                    );
-                }
-            }
-            const ppeDiffs: Diffs = {
-                pass: true,
-                actual: ['PPE Events:'],
-                expected: ['PPE Events:'],
-            };
-
-            if (options.chargedEventCounts) {
-                const expected = options.chargedEventCounts;
-                const actual = chargedEventCounts ?? {};
-                const uniquePpeEvents = new Set([
-                    ...Array.from(Object.keys(expected)),
-                    ...Array.from(Object.keys(actual)),
-                ]);
-
-                for (const ppeEvent of uniquePpeEvents) {
-                    if (!(ppeEvent in expected)) {
-                        isWithinInterval(ppeDiffs, actual[ppeEvent], { [ppeEvent]: 0 }, ppeEvent);
-                        continue;
-                    }
-                    if (!(ppeEvent in actual)) {
-                        ppeDiffs.pass = false;
-                        ppeDiffs.actual.push(`${ppeEvent}=X`);
-                        ppeDiffs.expected.push(`${ppeEvent}=${expected[ppeEvent as PpeEvent]}`);
-                        continue;
-                    }
-                    isWithinInterval(ppeDiffs, actual[ppeEvent], expected, ppeEvent as PpeEvent);
-                }
-
-                if (ppeDiffs.pass === false) {
-                    diffs.pass = ppeDiffs.pass;
-                    diffs.actual.push(ppeDiffs.actual.join('\n    '));
-                    diffs.expected.push(ppeDiffs.expected.join('\n    '));
-                    failedAssertions.push(
-                        `Failed PPE event counts check, expected ${JSON.stringify(
-                            options.chargedEventCounts,
-                        )}, got ${JSON.stringify(chargedEventCounts)}.`,
-                    );
-                }
-            }
-
-            {
-                const { forbiddenLogs } = options;
-                const log = await received.getLog();
-                const occuredLogs = [];
-                for (const forbiddenLog of forbiddenLogs) {
-                    if (log.includes(forbiddenLog)) {
-                        occuredLogs.push(forbiddenLog);
-                    }
-                }
-                if (occuredLogs.length > 0) {
-                    diffs.pass = false;
-                    diffs.actual.push(` logs=[${occuredLogs.join(', ')}]`);
-                    diffs.expected.push(` logs=[]`);
-                    failedAssertions.push(
-                        `Failed forbidden logs check, expected [] but got [${occuredLogs.join(', ')}].`,
-                    );
-                }
-            }
-
+            const checks = await checkRun(received, userOptions);
+            const failed = checks.filter(({ pass }) => !pass);
             return {
-                pass: diffs.pass,
-                message: () => `Run did not finish as expected. Failed assertions: ${failedAssertions.join(' ')}`,
-                actual: diffs.actual.join('\n  '),
-                expected: diffs.expected.join('\n  '),
+                pass: failed.length === 0,
+                message: () =>
+                    `Run did not finish as expected. Failed assertions: ${failed
+                        .map(
+                            ({ name, expected, actual }) =>
+                                `Failed ${name} check, expected ${expected}, got ${actual}.`,
+                        )
+                        .join(' ')}`,
+                actual: ['Run:', ...failed.map(({ name, actual }) => `${name}=${actual}`)].join('\n  '),
+                expected: ['Run:', ...failed.map(({ name, expected }) => `${name}=${expected}`)].join('\n  '),
             };
         },
         toStartWith: (received, prefix) => {
@@ -267,41 +95,3 @@ export const extendExpect = (expect: ExpectStatic): ExpectStatic => {
 
     return softExpect as unknown as ExpectStatic;
 };
-
-type Diffs = {
-    pass: boolean;
-    actual: string[];
-    expected: string[];
-};
-
-const isWithinInterval = <T extends string>(
-    diffs: Diffs,
-    actual: number | undefined,
-    options: Record<T, Interval | null>,
-    intervalOption: T,
-) => {
-    const expected = options[intervalOption];
-    if (expected === null) {
-        // check is disabled if expected value is null
-        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}`);
-            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 ?? ''}>`);
-            return false;
-        }
-    }
-    return undefined;
-};

package/lib/lib.ts

@@ -53,27 +53,36 @@ export const describe = (name: string, fn?: SuiteFactory<object>, options: Actor
 };
 
 /**
- * @param actorId - The actor's raw platform ID or its full name (`owner/name`, e.g. `"apify/web-scraper"`).
+ * Registers a vitest test for an Actor, which only runs when that Actor was built (or for the scheduled runs).
+ * `body` gets the test context with the soft `expect` and the full test name.
  */
-export const testActor = <T>(
+const defineActorTest = (
     actorId: string,
     testName: string,
-    fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
-    testOptions?: ActorTestOptions,
+    testOptions: ActorTestOptions | undefined,
+    body: (context: TestContext, name: string) => Promise<void>,
 ) => {
     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;
-        await fn({
-            expect: extendExpect(expect),
-            run: createStartRunFn(actorId, context),
-            ...rest,
-        });
+    vitestTest.runIf(shouldRun)(name, options, async (context) => {
+        await body({ ...context, expect: extendExpect(context.expect) }, name);
+    });
+};
+
+/**
+ * @param actorId - The actor's raw platform ID or its full name (`owner/name`, e.g. `"apify/web-scraper"`).
+ */
+export const testActor = <T>(
+    actorId: string,
+    testName: string,
+    fn: TestFunction<{ run: ReturnType<typeof createStartRunFn<T>> }>,
+    testOptions?: ActorTestOptions,
+) => {
+    defineActorTest(actorId, testName, testOptions, async (context) => {
+        await fn({ ...context, run: createStartRunFn(actorId, context) });
     });
 };
 
@@ -82,8 +91,7 @@ export const testActor = <T>(
  * `callStandby` function, which calls the task's `standbyUrl`.
  *
  * Using task is just current shortcoming of standby feature but ideally we would use Actor directly
- */
-/**
+ *
  * @param actorId - The actor's raw platform ID or its full name (`owner/name`, e.g. `"apify/web-scraper"`).
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -93,24 +101,12 @@ export const testStandbyActor = <I = any, O = any>(
     fn: TestFunction<{ callStandby: ReturnType<typeof createStartStandbyFn<I, O>> }>,
     testOptions?: ActorTestOptions,
 ) => {
-    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) => {
+    defineActorTest(actorId, testName, testOptions, async (context, name) => {
         const standbyTask = await createStandbyTask(actorId, config.get(actorId)?.buildNumber);
-        const { expect, ...rest } = context;
 
         // NOTE: we wrap `fn` in try/finally so cleanup (deleting the task) always runs afterwards
         try {
-            await fn({
-                expect: extendExpect(expect),
-                callStandby: createStartStandbyFn(standbyTask, context, name),
-                ...rest,
-            });
+            await fn({ ...context, callStandby: createStartStandbyFn(standbyTask, context, name) });
         } finally {
             const { taskId } = standbyTask;
             // we want to delete the task at the end of the test

package/lib/run-checks.ts

@@ -0,0 +1,101 @@
+import { TO_FINISH_WITH_OPTIONS } from './consts.js';
+import type { RunTestResult } from './run-test-result.js';
+import type { Interval, ToFinishWithOptions } from './types.js';
+
+type Check = {
+    name: string;
+    pass: boolean;
+    actual: string;
+    expected: string;
+};
+
+const isWithinInterval = (actual: number | undefined, interval: Interval): boolean => {
+    if (typeof interval === 'number') {
+        return actual === interval;
+    }
+    const { min, max } = interval;
+    return actual !== undefined && (min === undefined || actual >= min) && (max === undefined || actual <= max);
+};
+
+const describeInterval = (interval: Interval): string => {
+    return typeof interval === 'number' ? `${interval}` : `<${interval.min ?? ''},${interval.max ?? ''}>`;
+};
+
+const intervalCheck = (name: string, actual: number | undefined, interval: Interval | null | undefined): Check[] => {
+    // `null` disables the check, and so does an explicit `undefined`, e.g. from a caller forwarding an optional setting
+    if (interval == null) {
+        return [];
+    }
+    return [
+        {
+            name,
+            pass: isWithinInterval(actual, interval),
+            actual: `${actual}`,
+            expected: describeInterval(interval),
+        },
+    ];
+};
+
+const ppeChecks = (expected: Record<string, Interval>, actual: Record<string, number> = {}): Check[] => {
+    const events = new Set([...Object.keys(expected), ...Object.keys(actual)]);
+    return [...events].flatMap((event): Check[] => {
+        const name = `chargedEventCounts.${event}`;
+        // charged events the test didn't list are expected to not happen at all
+        if (!(event in expected)) {
+            return intervalCheck(name, actual[event], 0);
+        }
+        // an expected event that was never charged is a failure, even for an interval that includes 0
+        if (!(event in actual)) {
+            return [{ name, pass: false, actual: 'X', expected: describeInterval(expected[event]) }];
+        }
+        return intervalCheck(name, actual[event], expected[event]);
+    });
+};
+
+/**
+ * Evaluates every `toFinishWith` expectation against the run, so a failing assertion reports all of them at once.
+ */
+export const checkRun = async <PpeEvent extends string>(
+    run: RunTestResult,
+    userOptions: ToFinishWithOptions<PpeEvent>,
+): Promise<Check[]> => {
+    const options = { ...TO_FINISH_WITH_OPTIONS, ...userOptions };
+
+    // The dataset's item count lags the run by 10-20 seconds, so counting the downloaded items is the only way to
+    // be in sync. Don't swap it for the count from the dataset info.
+    const [runInfo, { items }, stats, log] = await Promise.all([
+        run.getRunInfo(),
+        run.getDataset(),
+        run.getStatistics(),
+        run.getLog(),
+    ]);
+
+    // the histogram has one bucket per retry count, so its length - 1 is the most retries any request needed
+    const maxRetriesPerRequest = (stats?.requestRetryHistogram ?? [0]).length - 1;
+    const occurredLogs = options.forbiddenLogs.filter((forbidden) => log.includes(forbidden));
+
+    return [
+        { name: 'status', pass: run.status === options.status, actual: run.status, expected: options.status },
+        ...intervalCheck('datasetItemCount', items.length, options.datasetItemCount),
+        ...intervalCheck('duration', runInfo.stats.durationMillis, options.duration),
+        ...intervalCheck('failedRequests', stats?.requestsFailed, options.failedRequests),
+        ...intervalCheck('requestsRetries', stats?.requestsRetries, options.requestsRetries),
+        ...(options.maxRetriesPerRequest == null
+            ? []
+            : [
+                  {
+                      name: 'maxRetriesPerRequest',
+                      pass: maxRetriesPerRequest <= options.maxRetriesPerRequest,
+                      actual: `${maxRetriesPerRequest}`,
+                      expected: `<=${options.maxRetriesPerRequest}`,
+                  },
+              ]),
+        ...(options.chargedEventCounts ? ppeChecks(options.chargedEventCounts, runInfo.chargedEventCounts) : []),
+        {
+            name: 'forbiddenLogs',
+            pass: occurredLogs.length === 0,
+            actual: `[${occurredLogs.join(', ')}]`,
+            expected: '[]',
+        },
+    ];
+};

package/lib/run-test-result.ts

@@ -2,14 +2,25 @@ import type { ActorRun, ApifyClient, KeyValueStoreClient } from 'apify-client';
 
 import type { Dataset, SdkCrawlerStatistics } from './types.js';
 
-export class RunTestResult {
-    private log: string | undefined;
-    private dataset: Dataset<unknown> | undefined;
-    private keyValueStoreClient: KeyValueStoreClient | undefined;
-    private statistics: SdkCrawlerStatistics | undefined;
-    private runInfo: ActorRun | undefined;
-    private input: unknown | undefined;
+/** Items fetched per request, so no single response can exceed Node's string limit on large datasets. */
+const DATASET_PAGE_SIZE = 1000;
+
+/**
+ * Runs `fn` at most once and shares its promise, so repeated and concurrent calls are one request.
+ * A failure is not cached, the next call retries.
+ */
+const once = <T>(fn: () => Promise<T>): (() => Promise<T>) => {
+    let promise: Promise<T> | undefined;
+    return async () => {
+        promise ??= fn().catch((error) => {
+            promise = undefined;
+            throw error;
+        });
+        return promise;
+    };
+};
 
+export class RunTestResult {
     constructor(
         private readonly apifyClient: ApifyClient,
         private readonly run: ActorRun,
@@ -17,62 +28,41 @@ export class RunTestResult {
         /**/
     }
 
-    getStatistics = async (): Promise<SdkCrawlerStatistics | undefined> => {
-        if (this.statistics) {
-            return this.statistics;
-        }
-        const kvs = this.apifyClient.keyValueStore(this.run.defaultKeyValueStoreId);
-        const stats = await kvs.getRecord('SDK_CRAWLER_STATISTICS_0');
-        this.statistics = stats?.value as unknown as SdkCrawlerStatistics;
-        return this.statistics;
-    };
+    getStatistics = once(async (): Promise<SdkCrawlerStatistics | undefined> => {
+        const record = await this.getKeyValueStoreClient().getRecord('SDK_CRAWLER_STATISTICS_0');
+        return record?.value as SdkCrawlerStatistics | undefined;
+    });
 
-    getLog = async (): Promise<string> => {
-        if (this.log) {
-            return this.log;
-        }
-        const runLog = await this.apifyClient.run(this.id).log().get();
-        this.log = runLog;
-        return runLog as string;
-    };
+    getLog = once(async (): Promise<string> => {
+        return (await this.apifyClient.run(this.id).log().get()) as string;
+    });
 
-    getDataset = async <T>(): Promise<Dataset<T>> => {
-        if (this.dataset) {
-            return this.dataset as Dataset<T>;
-        }
+    private readonly datasetItems = once(async (): Promise<unknown[]> => {
         const dataset = this.apifyClient.dataset(this.run.defaultDatasetId);
-        const items = (await dataset.listItems()).items as T[];
-        this.dataset = { items };
-        return this.dataset as Dataset<T>;
-    };
+        const items: unknown[] = [];
+        for (;;) {
+            const page = await dataset.listItems({ offset: items.length, limit: DATASET_PAGE_SIZE });
+            items.push(...page.items);
+            if (page.items.length === 0 || items.length >= page.total) {
+                return items;
+            }
+        }
+    });
+
+    getDataset = async <T>(): Promise<Dataset<T>> => ({ items: (await this.datasetItems()) as T[] });
 
     getKeyValueStoreClient = (): KeyValueStoreClient => {
-        if (this.keyValueStoreClient) {
-            return this.keyValueStoreClient;
-        }
-        const keyValueStoreClient = this.apifyClient.keyValueStore(this.run.defaultKeyValueStoreId);
-        this.keyValueStoreClient = keyValueStoreClient;
-        return keyValueStoreClient;
+        return this.apifyClient.keyValueStore(this.run.defaultKeyValueStoreId);
     };
 
-    getInput = async <T>(): Promise<T> => {
-        if (this.input) {
-            return this.input as T;
-        }
-        const kvs = this.apifyClient.keyValueStore(this.run.defaultKeyValueStoreId);
-        const input = await kvs.getRecord('INPUT');
-        this.input = input?.value;
-        return this.input as T;
-    };
+    private readonly inputRecord = once(async () => (await this.getKeyValueStoreClient().getRecord('INPUT'))?.value);
 
-    getRunInfo = async (): Promise<ActorRun> => {
-        if (this.runInfo) {
-            return this.runInfo;
-        }
-        const run = this.apifyClient.run(this.run.id);
-        this.runInfo = await run.get();
-        return this.runInfo!;
-    };
+    getInput = async <T>(): Promise<T> => (await this.inputRecord()) as T;
+
+    /** Fetches the run again, so unlike `id` and `status` it also reflects what changed after the run finished. */
+    getRunInfo = once(async (): Promise<ActorRun> => {
+        return (await this.apifyClient.run(this.run.id).get())!;
+    });
 
     get id(): string {
         return this.run.id;