multi http api unit tests

Author: Iztok

packages/fasset-bots-core/package.json

@@ -121,10 +121,12 @@
         "@types/chai": "4.3.6",
         "@types/chai-as-promised": "7.1.6",
         "@types/chai-spies": "1.0.4",
+        "@types/express": "^4.17.18",
         "axios-mock-adapter": "1.22.0",
         "chai": "4.5.0",
         "chai-as-promised": "7.1.1",
         "chai-spies": "1.0.0",
+        "express": "4.18.2",
         "hardhat": "2.24.3",
         "rewire": "7.0.0",
         "typechain": "8.3.0",

packages/fasset-bots-core/src/utils/HttpApiClient.ts

@@ -6,9 +6,9 @@ import { logger } from "./logger";
 
 export const DEFAULT_TIMEOUT = 15_000;
 
-export class ApiNetworkError extends ErrorWithCause {}
+export class ApiBaseError extends ErrorWithCause {}
 
-export class ApiServiceError extends ErrorWithCause {
+export class ApiServiceError extends ApiBaseError {
     #response: AxiosResponse<unknown>;
 
     constructor(message: string, response: AxiosResponse<unknown>, cause: AxiosError) {
@@ -19,6 +19,11 @@ export class ApiServiceError extends ErrorWithCause {
     get response() { return this.#response; }
 }
 
+export class ApiNetworkError extends ApiBaseError {}
+export class ApiTimeoutError extends ApiBaseError {}
+export class ApiCanceledError extends ApiBaseError {}
+export class ApiUnexpectedError extends ApiBaseError {}
+
 export class HttpApiClient {
     constructor(
         public serviceName: string,
@@ -37,11 +42,11 @@ export class HttpApiClient {
         return await this.request("GET", url, undefined, methodName, requestId, abortSignal);
     }
 
-    async post<R>(url: string, data: any, methodName: string, requestId: number, abortSignal?: AbortSignal): Promise<R> {
+    async post<R, D = unknown>(url: string, data: D, methodName: string, requestId: number, abortSignal?: AbortSignal): Promise<R> {
         return await this.request("POST", url, data, methodName, requestId, abortSignal);
     }
 
-    async request<R>(httpMethod: Method, url: string, data: any, methodName: string, requestId: number, abortSignal?: AbortSignal): Promise<R> {
+    async request<R, D = unknown>(httpMethod: Method, url: string, data: D, methodName: string, requestId: number, abortSignal?: AbortSignal): Promise<R> {
         const requestInfo = `request[${requestId}] client[${this.serverIndex}] ${this.serviceName}.${methodName}`;
         logger.info(`START ${requestInfo}: ${httpMethod.toUpperCase()} ${this.client.getUri()}${url}`);
         const startTimestamp = Date.now();
@@ -57,25 +62,35 @@ export class HttpApiClient {
             logger.info(`SUCCESS ${requestInfo} (${elapsedSec(startTimestamp)}s): [${response.status} ${response.statusText}]`);
             return response.data;
         } catch (error) {
-            if (isAxiosError(error) && error.response) {
+            if (isAxiosError(error)) {
                 const message = clipText(error.message, 120);
                 if (error.response) {
                     const response = error.response;
                     const responseText = clipText(typeof response.data === "string" ? response.data : tryJsonStringify(response.data), 160);
                     logger.error(`SERVICE ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): [${response.status} ${response.statusText}] ${message}\n    ${responseText}`);
                     throw new ApiServiceError(`${this.serviceName}.${methodName}: ${message}`, response, error);
+                } else if (error.name === "CanceledError") {
+                    if (Date.now() - startTimestamp < this.timeout) {
+                        logger.info(`CANCELED ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
+                        throw new ApiCanceledError(`${this.serviceName}.${methodName}: ${message}`, error);
+                    } else {
+                        logger.error(`TIMEOUT ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
+                        throw new ApiTimeoutError(`${this.serviceName}.${methodName}: ${message}`, error);
+                    }
+                } else if (error.name === "AxiosError") {
+                    if (error.message?.match(/^timeout of \w* exceeded$/)) {
+                        logger.error(`TIMEOUT ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
+                        throw new ApiTimeoutError(`${this.serviceName}.${methodName}: ${message}`, error);
+                    } else {
+                        logger.error(`NETWORK ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
+                        throw new ApiNetworkError(`${this.serviceName}.${methodName}: ${message}`, error);
+                    }
                 }
-                logger.error(`NETWORK ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
-                throw new ApiNetworkError(`${this.serviceName}.${methodName}: ${message}`, error);
+                // other error types treated as unexpected, even if they are axios errors
             }
             const message = clipText(String(error), 120);
-            const elapsedMs = Date.now() - startTimestamp;
-            if (error instanceof Error && error.name === "CanceledError" && elapsedMs < this.timeout) {
-                logger.info(`CANCELED ${requestInfo} (${elapsedSec(startTimestamp)}s): ${error.message}`);
-            } else {
-                logger.error(`UNEXPECTED ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
-            }
-            throw new ApiNetworkError(`${this.serviceName}.${methodName}: UNEXPECTED ${message}`, error);
+            logger.error(`UNEXPECTED ERROR ${requestInfo} (${elapsedSec(startTimestamp)}s): ${message}`);
+            throw new ApiUnexpectedError(`${this.serviceName}.${methodName}: ${message}`, error);
         }
     }
 

packages/fasset-bots-core/src/utils/MultiApiClient.ts

@@ -1,7 +1,7 @@
 import { Method } from "axios";
 import { ErrorWithCause } from "./ErrorWithCause";
 import { abortableSleep } from "./helpers";
-import { ApiNetworkError, ApiServiceError, DEFAULT_TIMEOUT, HttpApiClient } from "./HttpApiClient";
+import { ApiServiceError, ApiTimeoutError, DEFAULT_TIMEOUT, HttpApiClient } from "./HttpApiClient";
 import { logger } from "./logger";
 
 const PARALLEL = true;
@@ -48,7 +48,7 @@ export abstract class MultiApiClient {
         tryNextAfter: number = DEFAULT_TRY_NEXT_AFTER,   // start request with next client in parallel after this time
         timeout: number = DEFAULT_TIMEOUT,               // axios http request timeout
         killAfter: number = DEFAULT_KILL_AFTER,          // stop waiting after this many seconds, even if there is no timeout from axios
-    ) {
+    ): MultiApiClient {
         if (parallel) {
             return new MultiApiClientParallel(serviceName, tryNextAfter, timeout, killAfter);
         } else {
@@ -65,15 +65,15 @@ export abstract class MultiApiClient {
         return await this.request("GET", url, undefined, methodName);
     }
 
-    async post<R>(url: string, data: any, methodName: string): Promise<R> {
+    async post<R, D = unknown>(url: string, data: D, methodName: string): Promise<R> {
         return await this.request("POST", url, data, methodName);
     }
 
-    abstract request<R>(httpMethod: Method, url: string, data: any, methodName: string): Promise<R>;
+    abstract request<R, D = unknown>(httpMethod: Method, url: string, data: D, methodName: string): Promise<R>;
 }
 
 class MultiApiClientSerial extends MultiApiClient {
-    override async request<R>(httpMethod: Method, url: string, data: any, methodName: string): Promise<R> {
+    override async request<R, D = unknown>(httpMethod: Method, url: string, data: D, methodName: string): Promise<R> {
         const requestId = HttpApiClient.newRequestId();
         const clients = Array.from(this.clients);
         if (clients.length === 0) {
@@ -94,7 +94,7 @@ class MultiApiClientSerial extends MultiApiClient {
 }
 
 class MultiApiClientParallel extends MultiApiClient {
-    override async request<R>(httpMethod: Method, url: string, data: any, methodName: string): Promise<R> {
+    override async request<R, D = unknown>(httpMethod: Method, url: string, data: D, methodName: string): Promise<R> {
         const requestId = HttpApiClient.newRequestId();
         const clients = Array.from(this.clients);
         if (clients.length === 0) {
@@ -103,19 +103,23 @@ class MultiApiClientParallel extends MultiApiClient {
         const abortController = new AbortController();
         const abortSignal = abortController.signal;
         const results = await Promise.allSettled(clients.map(async (client, index) => {
-            try {
-                await abortableSleep(index * this.tryNextAfter, abortSignal);
-                return await Promise.race([
-                    client.request<R>(httpMethod, url, data, methodName, requestId, abortSignal),
-                    abortableSleep(this.killAfter, abortSignal)
-                        .then(() => { throw new ApiNetworkError(`Timeout of ${this.killAfter}ms reached`, null); }),
-                ]);
-            } finally {
-                if (!abortSignal.aborted) {
-                    abortController.abort(new Error("Request aborted because it finished first on another client"));
-                }
+            await abortableSleep(index * this.tryNextAfter, abortSignal);
+            const result = await Promise.race([
+                client.request<R>(httpMethod, url, data, methodName, requestId, abortSignal),
+                abortableSleep(this.killAfter, abortSignal)
+                    .then(() => { throw new ApiTimeoutError(`${this.serviceName}.${methodName}: Timeout of ${this.killAfter}ms reached`, null); }),
+            ]);
+            // on success, cancel attempts on other clients
+            if (!abortSignal.aborted) {
+                abortController.abort(new Error("Request aborted because it finished first on another client"));
             }
+            return result;
         }));
+        // cancel requests that are hanging after timeouts expired
+        if (!abortSignal.aborted) {
+            abortController.abort(new Error("Request aborted because it finished first on another client"));
+        }
+        // find successful response, if any exists
         const successfulResult = results.find(res => res.status === "fulfilled");
         if (successfulResult) {
             return successfulResult.value;

packages/fasset-bots-core/test/test-utils/test-api-server.ts

@@ -0,0 +1,78 @@
+import express from "express";
+import type { Server } from "node:http";
+import { elapsedSec, sleep } from "../../src/utils/helpers";
+
+type AppData = { index: number };
+
+function createApp(data?: AppData) {
+    const app = express();
+    app.use(express.json());
+
+    app.get("/wait/:seconds", (req, res) => runAsyncBody(res, async () => {
+        const start = Date.now();
+        const delayMs = Number(req.params.seconds) * 1000;
+        await sleep(delayMs);
+        return { elapsed: elapsedSec(start) };
+    }));
+
+    app.post("/error", (req, res) => runAsyncBody(res, async () => {
+        const body = req.body;
+        throw new Error(`text=${body?.text}`);
+    }));
+
+    app.post("/multiwait", (req, res) => runAsyncBody(res, async () => {
+        const start = Date.now();
+        const delaysMs = (req.body as number[]).map(s => s * 1000);
+        await sleep(delaysMs[data?.index ?? 0]);
+        return { elapsed: elapsedSec(start), index: data?.index };
+    }));
+
+    app.post("/multierror", (req, res) => runAsyncBody(res, async () => {
+        const doError = (req.body as number[]).includes(data?.index ?? -1);
+        if (doError) {
+            throw new Error(`index=${data?.index}`);
+        } else {
+            return { status: "OK", index: data?.index };
+        }
+    }));
+
+    return app;
+}
+
+function runAsyncBody(res: express.Response, handler: () => Promise<unknown>) {
+    handler()
+        .then(v => {
+            res.json(v);
+        })
+        .catch(e => {
+            res.status(400);
+            res.json({ error: String(e) });
+        })
+}
+
+export function startHttpListening(host: string, port: number, data?: AppData) {
+    return new Promise<Server>((resolve) => {
+        const app = createApp(data);
+        const server = app.listen(port, host, () => {
+            console.log(`Http server listening on http://${host}:${port}`);
+            resolve(server);
+        });
+    });
+}
+
+export function stopHttpListening(server: Server | undefined) {
+    return new Promise<void>((resolve) => {
+        if (server) {
+            server.close(() => {
+                console.log("Http server stopped");
+                resolve();
+            });
+        } else {
+            resolve();
+        }
+    });
+}
+
+if (typeof require !== "undefined" && require.main === module) {
+    void startHttpListening("127.0.0.1", 8080);
+}

packages/fasset-bots-core/test/unit/utils/http-api-client.ts

@@ -0,0 +1,67 @@
+import { assert, expect, use } from "chai";
+import chaiAsPromised from "chai-as-promised";
+import { Server } from "node:http";
+import { ApiCanceledError, ApiNetworkError, ApiServiceError, ApiTimeoutError, ApiUnexpectedError, HttpApiClient } from "../../../src/utils/HttpApiClient";
+import { startHttpListening, stopHttpListening } from "../../test-utils/test-api-server";
+use(chaiAsPromised);
+
+describe("Test http server timeouts and errors", () => {
+    const testHost = "127.0.0.1";
+    const testPort = 8080;
+    const serverName = "TestService";
+    const testUrl = `http://${testHost}:${testPort}`;
+    let server: Server;
+
+    before(async () => {
+        server = await startHttpListening(testHost, testPort);
+    });
+
+    after(async () => {
+        await stopHttpListening(server);
+    });
+
+    it("test http server successful wait", async () => {
+        const server = HttpApiClient.create(serverName, 0, testUrl, undefined, 2000);
+        const a = await server.get<{ elapsed: number }>("/wait/1", "wait", 1);
+        assert.typeOf(a.elapsed, "number");
+        assert.isAtLeast(a.elapsed, 1);
+    });
+
+    it("test http server default timeout/abort (don't know which)", async () => {
+        const server = HttpApiClient.create(serverName, 0, testUrl, undefined, 1000);
+        await expect(server.get<{ elapsed: number }>("/wait/3", "wait", 2))
+            .eventually.rejectedWith(ApiTimeoutError, /canceled|timeout/);
+    });
+
+    it("test http server timeout", async () => {
+        const server = HttpApiClient.create(serverName, 0, testUrl, undefined, 1000);
+        const abortSignal = AbortSignal.timeout(5000);
+        await expect(server.get<{ elapsed: number }>("/wait/3", "wait", 3, abortSignal))
+            .eventually.rejectedWith(ApiTimeoutError, /TestService.wait: timeout of 1000ms exceeded/);
+    });
+
+    it("test http server default cancelation (abort before timeout expires)", async () => {
+        const server = HttpApiClient.create(serverName, 0, testUrl, undefined, 5000);
+        const abortSignal = AbortSignal.timeout(1000);
+        await expect(server.get<{ elapsed: number }>("/wait/3", "wait", 4, abortSignal))
+            .eventually.rejectedWith(ApiCanceledError, /TestService.wait: canceled/);
+    });
+
+    it("test http server service error", async () => {
+        const server = HttpApiClient.create(serverName, 0, testUrl, undefined, 5000);
+        await expect(server.post("/error", { text: "ABCD" }, "error", 5))
+            .eventually.rejectedWith(ApiServiceError, /TestService.error: Request failed with status code 400/);
+    });
+
+    it("test http server 404 error", async () => {
+        const server = HttpApiClient.create(serverName, 0, testUrl, undefined, 5000);
+        await expect(server.get("/wrong_path", "wrong_path", 5))
+            .eventually.rejectedWith(ApiServiceError, /TestService.wrong_path: Request failed with status code 404/);
+    });
+
+    it("test http invalid url (no 'http://' prefix) - should throw unexpected error", async () => {
+        const server = HttpApiClient.create(serverName, 0, `127.0.0.1:${testPort}`, undefined, 2000);
+        await expect(server.get<{ elapsed: number }>("/wait/1", "wait", 6))
+            .eventually.rejectedWith(ApiUnexpectedError, /TestService.wait/);
+    });
+});