chore: improve TS typing in tests

Author: barjin

package-lock.json

@@ -87,6 +87,7 @@
         "@rsbuild/plugin-node-polyfill": "^1.3.0",
         "@stylistic/eslint-plugin-ts": "^4.2.0",
         "@types/async-retry": "^1.4.5",
+        "@types/compression": "^1.8.1",
         "@types/content-type": "^1.1.5",
         "@types/express": "^5.0.0",
         "@types/fs-extra": "^11.0.1",

package.json

@@ -2,16 +2,23 @@ import { launchPuppeteer, puppeteerUtils } from '@crawlee/puppeteer';
 import { expect } from 'vitest';
 
 import { mockServer } from './mock_server/server';
+import { Dictionary } from 'apify-client';
+import { Browser as PuppeteerBrowser } from 'puppeteer';
+import { Request } from 'express';
 
 export class Browser {
+    private browser: PuppeteerBrowser | undefined;
+
     async start() {
         this.browser = await launchPuppeteer({
             launchOptions: { headless: true, args: ['--disable-web-security', '--no-sandbox'] },
         });
         return this.browser;
     }
 
-    async getInjectedPage(baseUrl, DEFAULT_OPTIONS, gotoUrl = null) {
+    async getInjectedPage(baseUrl?: string, DEFAULT_OPTIONS?: Dictionary<any>, gotoUrl?: string) {
+        if (!this.browser) throw new Error('Browser is not started. Call start() first.');
+
         const page = await this.browser.newPage();
         if (gotoUrl) await page.goto(gotoUrl);
 
@@ -20,7 +27,7 @@ export class Browser {
         page.on('console', (msg) => console.log(msg.text()));
         await page.evaluate(
             (url, defaultQuery) => {
-                window.client = new window.Apify.ApifyClient({
+                (window as any).client = new (window as any).Apify.ApifyClient({
                     baseUrl: url,
                     maxRetries: 0,
                     ...defaultQuery,
@@ -34,7 +41,7 @@ export class Browser {
     }
 
     async cleanUpBrowser() {
-        return this.browser.close.call(this.browser);
+        return this.browser?.close.call(this.browser);
     }
 }
 
@@ -49,9 +56,9 @@ const getExpectedQuery = (callQuery = {}) => {
     };
 };
 
-function optsToQuery(params) {
+function optsToQuery(params: Dictionary<any>) {
     return Object.entries(params)
-        .filter(([k, v]) => v !== false)
+        .filter(([_, v]) => v !== false)
         .map(([k, v]) => {
             if (v === true) v = '1';
             else if (Array.isArray(v)) v = v.join(',');
@@ -61,24 +68,46 @@ function optsToQuery(params) {
         .reduce((newObj, [k, v]) => {
             newObj[k] = v;
             return newObj;
-        }, {});
+        }, {} as Dictionary<string>);
 }
 
-export const validateRequest = (query = {}, params = {}, body = {}, additionalHeaders = {}) => {
+export const validateRequest = ({
+    query = {},
+    params = {},
+    body = {},
+    additionalHeaders = {},
+    path,
+}: {
+    query?: Request['query'];
+    params?: Request['params'];
+    body?: Request['body'];
+    additionalHeaders?: Request['headers'];
+    path?: Request['path'];
+} = {}) => {
     const headers = {
         authorization: `Bearer ${DEFAULT_OPTIONS.token}`,
         ...additionalHeaders,
     };
     const request = mockServer.getLastRequest();
+    if (path) {
+        expect(request?.path).toEqual(path);
+    }
+
     const expectedQuery = getExpectedQuery(query);
-    if (query !== false) expect(request.query).toEqual(expectedQuery);
-    if (params !== false) expect(request.params).toEqual(params);
-    if (body !== false) expect(request.body).toEqual(body);
+    if (query) expect(request?.query).toEqual(expectedQuery);
+    if (params) expect(request?.params).toEqual(params);
+    if (body) expect(request?.body).toEqual(body);
     Object.entries(headers).forEach(([key, value]) => {
         // Browsers tend to send headers "a bit differently".
-        expect(request.headers).toHaveProperty(key);
-        const expectedHeaderValue = value.toLowerCase().replace(/\s/g, '');
-        const actualHeaderValue = request.headers[key].toLowerCase().replace(/\s/g, '');
+        expect(request?.headers).toHaveProperty(key);
+        const expectedHeaderValue = Array.isArray(value)
+            ? value.join('').toLowerCase().replace(/\s/g, '')
+            : value.toLowerCase().replace(/\s/g, '');
+
+        const actualHeaderValue = Array.isArray(request?.headers[key])
+            ? request?.headers[key].join('').toLowerCase().replace(/\s/g, '')
+            : request?.headers[key]?.toLowerCase().replace(/\s/g, '');
+
         expect(actualHeaderValue).toBe(expectedHeaderValue);
     });
 };

test/_helper.ts

@@ -3,6 +3,8 @@ import { setTimeout } from 'node:timers/promises';
 import c from 'ansi-colors';
 import { ActorListSortBy, ApifyClient, LoggerActorRedirect } from 'apify-client';
 import express from 'express';
+import type { Page } from 'puppeteer';
+import type { AddressInfo } from 'net';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect,test, vi } from 'vitest';
 
 import { LEVELS,Log } from '@apify/log';
@@ -11,23 +13,24 @@ import { stringifyWebhooksToBase64 } from '../src/utils';
 import { Browser, DEFAULT_OPTIONS,validateRequest } from './_helper';
 import { createDefaultApp,mockServer } from './mock_server/server';
 import { MOCKED_ACTOR_LOGS_PROCESSED, StatusGenerator } from './mock_server/test_utils';
+import { WEBHOOK_EVENT_TYPES } from '@apify/consts';
 
 describe('Actor methods', () => {
-    let baseUrl;
+    let baseUrl: string;
     const browser = new Browser();
 
     beforeAll(async () => {
-        const server = await mockServer.start();
+        const server = await mockServer.start() as import('http').Server;
         await browser.start();
-        baseUrl = `http://localhost:${server.address().port}`;
+        baseUrl = `http://localhost:${(server.address() as AddressInfo).port}`;
     });
 
     afterAll(async () => {
         await Promise.all([mockServer.close(), browser.cleanUpBrowser()]);
     });
 
-    let client;
-    let page;
+    let client: ApifyClient;
+    let page: Page;
     beforeEach(async () => {
         page = await browser.getInjectedPage(baseUrl, DEFAULT_OPTIONS);
         client = new ApifyClient({
@@ -37,7 +40,8 @@ describe('Actor methods', () => {
         });
     });
     afterEach(async () => {
-        client = null;
+        // purge the client instance to avoid sharing state between tests
+        client = null as any;
         page.close().catch(() => {});
     });
 
@@ -90,7 +94,7 @@ describe('Actor methods', () => {
             const actorId = 'some-id';
 
             const res = await client.actor(actorId).get();
-            expect(res.id).toEqual('get-actor');
+            expect(res?.id).toEqual('get-actor');
             validateRequest({}, { actorId });
 
             const browserRes = await page.evaluate((id) => client.actor(id).get(), actorId);
@@ -115,7 +119,7 @@ describe('Actor methods', () => {
 
             const defaultBuildClient = await client.actor(actorId).defaultBuild();
             const res = await defaultBuildClient.get();
-            expect(res.id).toEqual('get-build');
+            expect(res?.id).toEqual('get-build');
             validateRequest({}, { buildId: 'default-build-get' });
 
             const browserRes = await page.evaluate(async (id) => {
@@ -179,7 +183,7 @@ describe('Actor methods', () => {
             const actorId = 'some-id';
             const input = {
                 foo: 'bar',
-                fn: async (a, b) => a + b,
+                fn: async (a: number, b: number) => a + b,
             };
 
             const expectedRequestProps = [
@@ -196,7 +200,7 @@ describe('Actor methods', () => {
             const browserRes = await page.evaluate((id) => {
                 return client.actor(id).start({
                     foo: 'bar',
-                    fn: async (a, b) => a + b,
+                    fn: async (a: number, b: number) => a + b,
                 });
             }, actorId);
             expect(browserRes).toEqual(res);
@@ -207,11 +211,11 @@ describe('Actor methods', () => {
             const actorId = 'some-id';
             const webhooks = [
                 {
-                    eventTypes: ['ACTOR.RUN.CREATED'],
+                    eventTypes: [WEBHOOK_EVENT_TYPES.ACTOR_RUN_CREATED],
                     requestUrl: 'https://example.com/run-created',
                 },
                 {
-                    eventTypes: ['ACTOR.RUN.SUCCEEDED'],
+                    eventTypes: [WEBHOOK_EVENT_TYPES.ACTOR_RUN_SUCCEEDED],
                     requestUrl: 'https://example.com/run-succeeded',
                 },
             ];
@@ -357,7 +361,7 @@ describe('Actor methods', () => {
         });
 
         describe('lastRun()', () => {
-            test.each(['get', 'dataset', 'keyValueStore', 'requestQueue', 'log'])('%s() works', async (method) => {
+            test.each(['get', 'dataset', 'keyValueStore', 'requestQueue', 'log'] as const)('%s() works', async (method) => {
                 const actorId = 'some-actor-id';
                 const requestedStatus = 'SUCCEEDED';
 
@@ -367,7 +371,7 @@ describe('Actor methods', () => {
                 if (method === 'log') {
                     expect(res).toEqual('last-run-log');
                 } else {
-                    expect(res.id).toEqual(`last-run-${method}`);
+                    expect(res?.id).toEqual(`last-run-${method}`);
                 }
                 validateRequest({ status: requestedStatus }, { actorId });
 
@@ -581,7 +585,7 @@ describe('Actor methods', () => {
                 const envVarName = 'TEST_ENV_VAR';
 
                 const res = await client.actor(actorId).version(versionNumber).envVar(envVarName).get();
-                expect(res.id).toEqual('get-actor-env-var');
+                expect(res?.id).toEqual('get-actor-env-var');
                 validateRequest({}, { actorId, versionNumber, envVarName });
 
                 const browserRes = await page.evaluate(
@@ -681,8 +685,8 @@ describe('Actor methods', () => {
 });
 
 describe('Run actor with redirected logs', () => {
-    let baseUrl;
-    let client;
+    let baseUrl: string;
+    let client: ApifyClient;
     const statusGenerator = new StatusGenerator();
 
     beforeAll(async () => {
@@ -698,7 +702,7 @@ describe('Run actor with redirected logs', () => {
         });
         const app = createDefaultApp(router);
         const server = await mockServer.start(undefined, app);
-        baseUrl = `http://localhost:${server.address().port}`;
+        baseUrl = `http://localhost:${(server.address() as AddressInfo).port}`;
     });
 
     afterAll(async () => {
@@ -715,7 +719,7 @@ describe('Run actor with redirected logs', () => {
     afterEach(async () => {
         // Reset the generator to so that the next test starts fresh
         statusGenerator.reset();
-        client = null;
+        client = null as unknown as ApifyClient;
     });
 
     const testCases = [
@@ -727,7 +731,7 @@ describe('Run actor with redirected logs', () => {
                 log: new Log({ level: LEVELS.DEBUG, prefix: 'custom prefix...', logger: new LoggerActorRedirect() }),
             },
         },
-    ];
+    ] as const;
 
     describe('actor.call - redirected logs', () => {
         test.each(testCases)('logOptions:$logOptions', async ({ expectedPrefix, logOptions }) => {

test/actors.test.ts

@@ -1,17 +1,18 @@
-import { ApifyClient } from 'apify-client';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect,test, vi } from 'vitest';
+import { ApifyApiError, ApifyClient, Dictionary } from 'apify-client';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 
 import { Browser, DEFAULT_OPTIONS } from './_helper';
 import { mockServer } from './mock_server/server';
+import { AddressInfo } from 'node:net';
 
 describe('ApifyApiError', () => {
-    let baseUrl;
+    let baseUrl: string;
     const browser = new Browser();
 
     beforeAll(async () => {
         await browser.start();
         const server = await mockServer.start();
-        baseUrl = `http://localhost:${server.address().port}`;
+        baseUrl = `http://localhost:${(server.address() as AddressInfo).port}`;
     });
 
     afterAll(async () => {
@@ -25,7 +26,9 @@ describe('ApifyApiError', () => {
         try {
             await actorCollectionClient[method]();
             throw new Error('wrong error');
-        } catch (err) {
+        } catch (err: any) {
+            if (!(err instanceof ApifyApiError)) throw err;
+
             expect(err.name).toEqual('ApifyApiError');
             // This does not work in v10 and lower, but we want to be able to run tests for v10,
             // because some people might still use it. They will just see clientMethod: undefined.
@@ -45,20 +48,22 @@ describe('ApifyApiError', () => {
         const page = await browser.getInjectedPage();
         const method = 'list';
         const error = await page.evaluate(async (m) => {
-            const client = new window.Apify.ApifyClient();
+            const client = new (window as any).Apify.ApifyClient();
             const actorCollectionClient = client.actors();
             try {
                 await actorCollectionClient[m]();
                 throw new Error('wrong error');
-            } catch (err) {
-                const serializableErr = {};
+            } catch (err: any) {
+                const serializableErr: Dictionary<any> = {};
                 Object.getOwnPropertyNames(err).forEach((prop) => {
                     serializableErr[prop] = err[prop];
                 });
                 serializableErr.resourcePath = actorCollectionClient.resourcePath;
-                return serializableErr;
+                return serializableErr as Dictionary<any>;
             }
         }, method);
+
+
         expect(error.name).toEqual('ApifyApiError');
         expect(error.clientMethod).toBe(`ActorCollectionClient.${method}`);
         expect(error.type).toEqual('token-not-provided');
@@ -84,6 +89,8 @@ describe('ApifyApiError', () => {
             await client.dataset(datasetId).pushItems(data);
             throw new Error('wrong error');
         } catch (err) {
+            if (!(err instanceof ApifyApiError)) throw err;
+
             expect(err.name).toEqual('ApifyApiError');
             expect(err.type).toEqual('schema-validation-error');
             expect(err.data).toEqual({
@@ -97,13 +104,13 @@ describe('ApifyApiError', () => {
         const page = await browser.getInjectedPage();
         const error = await page.evaluate(
             async (cConfig, dId, d) => {
-                const client = new window.Apify.ApifyClient(cConfig);
+                const client = new (window as any).Apify.ApifyClient(cConfig);
                 const datasetClient = client.dataset(dId);
                 try {
                     await datasetClient.pushItems(d);
                     throw new Error('wrong error');
-                } catch (err) {
-                    const serializableErr = {};
+                } catch (err: any) {
+                    const serializableErr: Dictionary<any> = {};
                     Object.getOwnPropertyNames(err).forEach((prop) => {
                         serializableErr[prop] = err[prop];
                     });