biz-a-cli 2.3.73 → 2.3.74

package/tests/hub.test.js

@@ -1,998 +0,0 @@
-import { Server as ioServer } from "socket.io";
-import { createServer } from "node:http";
-import { streamEvent, hubEvent, socketAgent } from "../bin/hubEvent.js";
-import { io as ioClient } from "socket.io-client";
-import { afterAll, expect, jest } from "@jest/globals";
-import axios from "axios";
-import net from "node:net";
-import tls from "node:tls";
-import ss from "socket.io-stream";
-import { Writable, pipeline } from "node:stream";
-import { text } from "node:stream/consumers";
-import { directHubEvent, createSocketServer } from "../bin/directHubEvent.js";
-import os from "node:os";
-import { cliScriptWorkerPool } from "../worker/cliWorkerPool.js";
-import workerpool from "workerpool";
-import { isAsyncFunction } from "node:util/types";
-
-let socketsBySubdomain = {};
-
-const createSockTunnel2CLI = (socket) => {
-	return (subdomain, responseCb) => {
-		const responseCallback = (error) => {
-			if (responseCb) responseCb(error);
-		};
-		let subdomainStr = subdomain.toString();
-
-		socketsBySubdomain[subdomainStr] = socket;
-		socket.subdomain = subdomainStr;
-
-		responseCallback(null);
-	};
-};
-
-const deleteSubdomain = (socket) => () => {
-	if (socket.subdomain) {
-		delete socketsBySubdomain[socket.subdomain];
-		console.log(new Date() + ": " + socket.subdomain + " unregistered");
-	}
-};
-
-const toPromise = (cb) =>
-	new Promise((resolve, reject) => {
-		cb(resolve);
-		setTimeout(() => reject(new Error("timeout")), 1000);
-	});
-
-describe("Hub event tests", () => {
-	let bizAServer_ServerSocket, port;
-	let cliHttpServer;
-
-	const startSocket = function startSocket(server) {
-		let io = new ioServer(server);
-		io.on("connection", (socket) => {
-			socket.on("createTunnel", createSockTunnel2CLI(socket));
-			socket.on("disconnect", deleteSubdomain(socket));
-		});
-		return io;
-	};
-
-	function freeSocketClient(sock) {
-		if (sock) {
-			if (sock.connected) {
-				sock.off();
-				sock.disconnect();
-			}
-			sock.destroy();
-			sock = undefined;
-		}
-	}
-
-	beforeAll((done) => {
-		cliHttpServer = createServer();
-		bizAServer_ServerSocket = startSocket(cliHttpServer);
-
-		cliHttpServer.listen(async () => {
-			port = cliHttpServer.address().port;
-			done();
-		});
-	});
-
-	afterAll(async () => {
-		bizAServer_ServerSocket.close();
-		await cliHttpServer.close();
-	});
-
-	test("request to cli", async () => {
-		const logSpy = jest.spyOn(console, "log").mockImplementation();
-		let mockedRequest = jest
-			.spyOn(axios, "request")
-			.mockReturnValue({ data: "OK" });
-
-		let socket;
-		try {
-			socket = ioClient(`http://localhost:${port}`);
-			await streamEvent(socket, {
-				server: `http://localhost:${port}`,
-				subdomain: "scy",
-				hostname: "localhost",
-				port: 212,
-				serverport: 3002,
-			});
-
-			let result = await toPromise((resolve) =>
-				socketsBySubdomain["scy"].emit(
-					"cli-req",
-					{
-						method: "POST",
-						query: { subdomain: "abc" },
-						body: { data: "xyz" },
-					},
-					(cb) => resolve(cb),
-				),
-			);
-
-			expect(result).toStrictEqual("OK");
-			expect(mockedRequest).toHaveBeenCalledWith({
-				data: { body: { data: "xyz" }, query: { subdomain: "abc" } },
-				method: "POST",
-				url: "http://localhost:3002/cb",
-			});
-
-			result = await toPromise((resolve) =>
-				socketsBySubdomain["scy"].emit(
-					"cli-req",
-					{
-						path: "/a/b",
-						method: "POST",
-						query: { subdomain: "abc" },
-						body: { data: "xyz" },
-					},
-					(cb) => resolve(cb),
-				),
-			);
-
-			expect(result).toStrictEqual("OK");
-			expect(mockedRequest).toHaveBeenCalledWith({
-				data: { body: { data: "xyz" }, query: { subdomain: "abc" } },
-				method: "POST",
-				url: "http://localhost:3002/cb/a/b",
-			});
-
-			socket.disconnect();
-
-			expect(logSpy).toHaveBeenCalledWith("error", "error");
-
-			logSpy.mockRestore();
-		} catch (error) {
-			console.log(error);
-		}
-	});
-
-	test("should used correct socket agent", () => {
-		expect(socketAgent(false)).toBe(net);
-		expect(socketAgent(true)).toBe(tls);
-	});
-
-	test("should access API with scheme of BizA Client <--https--> BizA Server <--socket stream--> BizA CLI <--socket--> API", async () => {
-		const uniqueId = "123456"; // this is used for make sure BizA Server will get correct response from BizA CLI
-		const subdomain = "hub";
-
-		let cliToBizAServerSocket; // mocking of socket client from BizA CLI to BizA Server
-		let mockAPIServer; // mocking of FINA API Datasnap server. We need to used TCP Server to test data flow using socket, so don't used HTTP Server
-		let cliToAPISocket; // mocking of socket client from BizA CLI to FINA API Datasnap Server
-
-		try {
-			cliToBizAServerSocket = ioClient(`http://localhost:${port}`);
-			await streamEvent(cliToBizAServerSocket, {
-				server: `http://localhost:${port}`,
-				subdomain,
-				hostname: "127.0.0.1",
-				port: 212,
-				serverport: 3002,
-				cliAddress: () => {
-					return {
-						ip: "59.60.1.22",
-						port: "3002",
-						address: `59.60.1.22:3002`,
-						publicUrl: "https://some.tunnel.url",
-						hubUrl: "https://some.hub.url",
-					};
-				},
-				hubServer: "https://some.hub.url",
-			});
-
-			mockAPIServer = net.createServer((clientSocket) => {
-				cliToAPISocket = clientSocket;
-				clientSocket.on("data", (data) => {
-					if (
-						data.toString().toUpperCase() ===
-						"POST /SUCCESS HTTP/1.1"
-					) {
-						clientSocket.write(
-							"HTTP/1.1 200 Ok\r\nServer: datasnapHTTPService\r\n\r\n",
-						);
-					} else if (
-						data.toString().toUpperCase() === "POST /FAIL HTTP/1.1"
-					) {
-						clientSocket.write(
-							"HTTP/1.1 403 Forbidden\r\nServer: datasnapHTTPService\r\n\r\n",
-						);
-					}
-				});
-			});
-			await toPromise((resolve) => {
-				mockAPIServer.listen({ port: 212, host: "127.0.0.1" }, () => {
-					resolve();
-				});
-			});
-
-			const getResponse = async (httpRawRequest) => {
-				let tunnelStream; // mocking of socket stream between BizA CLI and BizA Server, also act as mocking of HTTP Request from BizA Client
-				let outputStream; // mocking of HTTP Response received by BizA Client
-				try {
-					let outputContent = [];
-					outputStream = new Writable({
-						write(chunk, encoding, next) {
-							outputContent.push(chunk);
-							cliToAPISocket.end(); // Imitate API Server to finish sending response, it will call end "tunnelStream" and lastly it will close "outputStream"
-							next();
-						},
-					});
-					tunnelStream = await toPromise((resolve) => {
-						ss(socketsBySubdomain[subdomain]).once(
-							uniqueId,
-							(stream) => {
-								pipeline(stream, outputStream, (err) => {
-									if (err) console.error(err);
-								});
-								resolve(stream);
-							},
-						);
-						socketsBySubdomain[subdomain].emit(
-							"incomingClient",
-							uniqueId,
-						);
-					});
-
-					tunnelStream.write(httpRawRequest);
-					await text(tunnelStream); // this will try to read data from "cliToAPISocket" -> "transformStream" -> "tunnelStream" -> "outputStream"
-					return outputContent.toString();
-				} finally {
-					if (tunnelStream) tunnelStream.destroy();
-					if (outputStream) outputStream.destroy();
-					freeSocketClient(cliToAPISocket);
-				}
-			};
-
-			expect(await getResponse("POST /success HTTP/1.1")).toBe(
-				"HTTP/1.1 200 Ok\r\n" +
-					"Server: datasnapHTTPService\r\n" +
-					"Access-Control-Expose-Headers: biza-cli-address, biza-hub-address\r\n" +
-					"biza-cli-address: https://some.tunnel.url\r\n" +
-					"biza-hub-address: https://some.hub.url\r\n\r\n",
-			);
-
-			expect(await getResponse("POST /fail HTTP/1.1")).toBe(
-				"HTTP/1.1 403 Forbidden\r\n" +
-					"Server: datasnapHTTPService\r\n\r\n",
-			);
-		} finally {
-			freeSocketClient(cliToBizAServerSocket);
-			if (mockAPIServer) mockAPIServer.close();
-		}
-	});
-
-	describe("should access API with scheme of BizA Client <--socket tunnel--> BizA CLI <--http--> API", () => {
-		const apiAddress = "127.0.0.1";
-		const subdomain = "directHub";
-		let cliSocketServer; // mocking of CLI socket server
-		let clientToCliSocket; // mocking of socket client from BizA Client to BizA CLI
-		let mockedRequest;
-
-		beforeEach(() => {
-			mockedRequest = jest.spyOn(axios, "request");
-			mockedRequest.mockClear();
-		});
-
-		beforeAll(() => {
-			cliSocketServer = new ioServer(9999); // mocking of CLI socket server
-			directHubEvent(cliSocketServer, {
-				subdomain,
-				hostname: apiAddress,
-				port,
-				secure: false,
-				dbindex: 2,
-				cliAddress: () => {
-					return {
-						ip: "59.60.1.22",
-						port: "3002",
-						address: `59.60.1.22:3002`,
-						publicUrl: "https://some.tunnel.url",
-						hubUrl: "https://some.hub.url",
-					};
-				},
-			});
-			clientToCliSocket = ioClient("http://localhost:9999", {
-				query: { isClient: true },
-			});
-		});
-
-		afterAll(async () => {
-			freeSocketClient(clientToCliSocket);
-			if (cliSocketServer) {
-				await cliSocketServer
-					.of("")
-					.sockets.forEach((sock) => sock.removeAllListeners());
-				await cliSocketServer.close();
-			}
-		});
-
-		describe("apiRequest listener", () => {
-			test("should return success response", async () => {
-				mockedRequest.mockResolvedValueOnce({
-					status: 200,
-					statusText: "Success",
-					headers: { "res-header": "aa" },
-					data: "body of response",
-					config: { baseURL: "localhost", url: "/test" },
-				});
-
-				const [error, response] = await toPromise((resolve) => {
-					clientToCliSocket.emit(
-						"apiRequest",
-						{
-							subDomain: subdomain,
-							method: "POST",
-							path: "/test",
-							headers: { "req-header": "aa" },
-							body: "body of request",
-							responseType: "json",
-						},
-						(err, res) => {
-							resolve([err, res]);
-						},
-					);
-				});
-
-				expect(response).toStrictEqual({
-					status: 200,
-					statusText: "Success",
-					headers: {
-						"res-header": "aa",
-						"biza-cli-address": "https://some.tunnel.url",
-						"biza-hub-address": "https://some.hub.url",
-					},
-					body: "body of response",
-					url: `http://${apiAddress}:${port}/test`,
-				});
-
-				expect(error).toBe(null);
-
-				expect(mockedRequest).toHaveBeenCalledWith({
-					timeout: 30 * 1000,
-					baseURL: `http://127.0.0.1:${port}`,
-					url: "/test",
-					method: "POST",
-					headers: { "req-header": "aa" },
-					data: "body of request",
-					// decompress: false,
-					responseType: "json",
-					maxContentLength: Infinity,
-				});
-			});
-
-			test("should return fail response", async () => {
-				const mockErrorResponse = {
-					response: {
-						status: 400,
-						statusText: "Failed",
-						headers: { "res-header": "aa" },
-						data: "body of response",
-						config: { baseURL: "localhost", url: "/test" },
-					},
-				};
-				mockedRequest.mockRejectedValueOnce(mockErrorResponse);
-
-				const [error, response] = await toPromise((resolve) => {
-					clientToCliSocket.emit(
-						"apiRequest",
-						{
-							subDomain: subdomain,
-							method: "POST",
-							path: "/test",
-							headers: { "req-header": "aa" },
-							body: "body of request",
-							responseType: "arraybuffer",
-						},
-						(err, res) => {
-							resolve([err, res]);
-						},
-					);
-				});
-
-				expect(response).toBe(null);
-
-				expect(error).toStrictEqual(mockErrorResponse);
-
-				expect(mockedRequest).toHaveBeenCalledWith({
-					timeout: 30 * 1000,
-					baseURL: `http://127.0.0.1:${port}`,
-					url: "/test",
-					method: "POST",
-					headers: { "req-header": "aa" },
-					data: "body of request",
-					// decompress: false,
-					responseType: "arraybuffer",
-					maxContentLength: Infinity,
-				});
-			});
-
-			test("should return bad subdomain response", async () => {
-				const [error, response] = await toPromise((resolve) => {
-					clientToCliSocket.emit(
-						"apiRequest",
-						{
-							subDomain: "wrong subdomain",
-							method: "POST",
-							path: "/test",
-							headers: { "req-header": "aa" },
-							body: "body of request",
-						},
-						(err, res) => {
-							resolve([err, res]);
-						},
-					);
-				});
-
-				expect(response).toBe(null);
-
-				expect(error).toStrictEqual({
-					status: 401,
-					statusText: "bad subdomain",
-					url: `http://${apiAddress}:${port}/test`,
-				});
-
-				expect(mockedRequest).not.toHaveBeenCalledWith();
-			});
-		});
-
-		describe("cliCommand listener", () => {
-			test("status", async () => {
-				const runCommand = async (command) => {
-					return await toPromise((resolve) => {
-						clientToCliSocket.emit(
-							"cliCommand",
-							{ command },
-							(err, res) => {
-								resolve([err, res]);
-							},
-						);
-					});
-				};
-
-				let [error, response] = await runCommand("StAtus ");
-				const cpuArchitecture = os.arch();
-				const osArchitecture = [
-					"x64",
-					"arm64",
-					"ppc64",
-					"s390x",
-				].includes(cpuArchitecture)
-					? "64-bit"
-					: ["ia32", "arm", "mips", "mipsel", "s390"].includes(cpuArchitecture)
-						? "32-bit"
-						: `Unknown CPU architecture: ${cpuArchitecture}`;
-				expect(response).toMatchObject({
-					cli: {
-						hubUrl: "https://some.hub.url",
-						publicUrl: "https://some.tunnel.url",
-						address: "59.60.1.22:3002",
-						version: expect.any(String),
-						mode: "test",
-						memoryUsage: expect.any(String),
-						nodeVersion: process.version,
-						uptime: expect.objectContaining({
-							days: expect.any(Number),
-							hours: expect.any(Number),
-							minutes: expect.any(Number),
-							seconds: expect.any(Number),
-						}),
-						workers: {
-							cliScript: cliScriptWorkerPool.stats(),
-						},
-					},
-					api: {
-						address: `${apiAddress}:${port}`,
-						dbIndex: 2,
-					},
-					os: {
-						name: os.type(),
-						architecture: osArchitecture,
-						platform: os.platform(),
-						cpuCount: os.cpus().length,
-						memory: {
-							total:
-								(os.totalmem / (1024 * 1024 * 1024)).toFixed(
-									2,
-								) + " GB",
-							free: expect.any(String),
-							used: expect.any(String),
-						},
-					},
-				});
-				expect(error).toBe(null);
-
-				[error, response] = await runCommand(" invalid command");
-				expect(response).toBe(null);
-				expect(error).toBe("Unknown CLI command 'invalid command'");
-			});
-
-			describe("runCLIScript", () => {
-				const runCommand = () =>
-					toPromise((resolve) => {
-						clientToCliSocket.emit(
-							"cliCommand",
-							{
-								command: "runCliScript",
-								scriptName: "sumScript",
-								scriptData: { x: 1, y: 2 },
-							},
-							(err, res) => {
-								resolve([err, res]);
-							},
-						);
-					});
-
-				test("shall used worker pool", async () => {
-					expect(cliScriptWorkerPool.workerType).toBe("thread"); // used node.js worker thread
-					expect(cliScriptWorkerPool.workerThreadOpts).toStrictEqual({
-						env: { NODE_ENV: process.env.NODE_ENV },
-					});
-
-					const execSpy = jest.spyOn(cliScriptWorkerPool, "exec");
-
-					execSpy.mockResolvedValueOnce("success");
-					await expect(runCommand()).resolves.toStrictEqual([
-						null,
-						"success",
-					]);
-					expect(execSpy.mock.calls.length).toBe(1);
-					expect(execSpy).toHaveBeenCalledWith("run", [
-						{
-							dbindex: 2,
-							subdomain,
-							url: `http://${apiAddress}:${port}`,
-						},
-						"sumScript",
-						{ x: 1, y: 2 },
-					]);
-					execSpy.mockReset();
-
-					execSpy.mockRejectedValueOnce("fail");
-					await expect(runCommand()).resolves.toStrictEqual([
-						"fail",
-						null,
-					]);
-					expect(execSpy.mock.calls.length).toBe(1);
-					expect(execSpy).toHaveBeenCalledWith("run", [
-						{
-							dbindex: 2,
-							subdomain,
-							url: `http://${apiAddress}:${port}`,
-						},
-						"sumScript",
-						{ x: 1, y: 2 },
-					]);
-					execSpy.mockReset();
-
-					// process beforeexit can not be reliably triggered or handled as expected within Jest's test environment, especially in worker thread scenario
-					// so we trigger the function directly
-					const workerpoolBeforeExit = process
-						.listeners("beforeexit")
-						.find(
-							(listener) =>
-								listener
-									.toString()
-									.toLowerCase()
-									.indexOf("cliscriptworkerpool") !== -1,
-						);
-					expect(isAsyncFunction(workerpoolBeforeExit)).toBeTruthy();
-					const terminateSpy = jest.spyOn(
-						cliScriptWorkerPool,
-						"terminate",
-					);
-					terminateSpy.mockReset();
-					workerpoolBeforeExit();
-					expect(terminateSpy.mock.calls.length).toBe(1);
-				});
-
-				test("shall used worker thread", async () => {
-					let mockAPIServer;
-					let scriptWorkerPool;
-					try {
-						// cannot used jest mocking because worker thread is running in different context.
-						// We must create http mock server, then direct worker request to the mock server
-						mockAPIServer = createServer((req, res) => {
-							res.writeHead(200, {
-								"Content-Type": "application/json",
-							});
-							res.end(
-								JSON.stringify([
-									{
-										"SYS$CLI_SCRIPT.SCRIPT": `get = function (lib) {
-                                        return {
-                                            functions: {
-                                                onInit: function (data) {
-                                                    return (data.x + data.y);
-                                                }
-                                            }
-                                        }
-                                    }`,
-									},
-								]),
-							);
-						});
-						await toPromise((resolve) => {
-							mockAPIServer.listen(
-								{ host: "127.0.0.1", port: 0 },
-								() => {
-									resolve();
-								},
-							);
-						});
-						scriptWorkerPool = workerpool.pool(
-							"./worker/cliScriptWorker.js",
-							{
-								workerType: "thread",
-								workerThreadOpts: {
-									env: { NODE_ENV: "production" },
-								},
-							},
-						); // set worker NODE_ENV, so logger will not print to console
-						const sumResult = await scriptWorkerPool
-							.exec("run", [
-								{
-									dbindex: 2,
-									subdomain,
-									url: `http://127.0.0.1:${mockAPIServer.address().port}`,
-								},
-								"sumScript",
-								{ x: 1, y: 2 },
-							])
-							.then(async (result) => {
-								await scriptWorkerPool.terminate();
-								return result;
-							})
-							.catch((err) => {
-								return err.message || err;
-							});
-						expect(sumResult).toBe(3);
-					} finally {
-						if (mockAPIServer) {
-							mockAPIServer.close();
-						}
-					}
-				});
-			});
-		});
-	});
-
-	describe("should access API with scheme of BizA Client <--socket--> BizA Hub <--socket--> BizA CLI <--http--> API", () => {
-		const apiAddress = "127.0.0.1";
-		const subdomain = "roomA";
-		let cliToHubSocket;
-		let hubToCLISocket;
-		let hubServer;
-
-		beforeAll(async () => {
-			hubServer = new ioServer(9998);
-			hubServer.on("connection", (sock) => (hubToCLISocket = sock));
-			cliToHubSocket = ioClient("http://localhost:9998");
-			hubEvent(
-				cliToHubSocket,
-				{
-					server: `http://localhost:${port}`,
-					subdomain,
-					hostname: apiAddress,
-					dbindex: 2,
-					port,
-					serverport: 3002,
-					cliAddress: () => {
-						return {
-							ip: "59.60.1.22",
-							port: "3002",
-							address: `59.60.1.22:3002`,
-							publicUrl: "https://some.tunnel.url",
-							hubUrl: "https://some.hub.url",
-						};
-					},
-					hubServer: "https://some.hub.url",
-				},
-				(hubUrl) => {
-					expect(hubUrl).toBe("https://some.hub.url");
-				},
-			);
-			await toPromise((resolve) =>
-				cliToHubSocket.once("connect", () => resolve()),
-			);
-		});
-
-		afterAll(async () => {
-			freeSocketClient(cliToHubSocket);
-			if (hubServer) {
-				hubServer.close();
-			}
-		});
-
-		test("apiRequest listener", async () => {
-			const emitApiRequest = async (reqData) => {
-				const [error, response] = await toPromise((resolve) => {
-					hubToCLISocket.emit(
-						"apiRequest",
-						{
-							subDomain: subdomain,
-							method: "POST",
-							path: "/test",
-							headers: { "req-header": "aa" },
-							body: reqData,
-							responseType: "json",
-						},
-						(err, res) => {
-							resolve([err, res]);
-						},
-					);
-				});
-				return { error, response };
-			};
-
-			mockedRequest = jest.spyOn(axios, "request");
-			mockedRequest.mockResolvedValue({
-				status: 200,
-				statusText: "Success",
-				headers: { "res-header": "aa" },
-				data: "body of response",
-				config: { baseURL: "localhost", url: "/test" },
-			});
-
-			// without parameterize apiAddress
-			mockedRequest.mockClear();
-			let result = await emitApiRequest("body of request");
-			expect(result.response).toStrictEqual({
-				status: 200,
-				statusText: "Success",
-				headers: {
-					"res-header": "aa",
-					"biza-cli-address": "https://some.tunnel.url",
-					"biza-hub-address": "https://some.hub.url",
-				},
-				body: "body of response",
-				url: `http://127.0.0.1:${port}/test`,
-			});
-			expect(result.error).toBe(null);
-			expect(mockedRequest).toHaveBeenCalledWith({
-				timeout: 30 * 1000,
-				baseURL: `http://127.0.0.1:${port}`,
-				url: "/test",
-				method: "POST",
-				headers: { "req-header": "aa" },
-				data: "body of request",
-				responseType: "json",
-				maxContentLength: Infinity,
-			});
-
-			// parameterize API address as String
-			mockedRequest.mockClear();
-			result = await emitApiRequest(
-				JSON.stringify({
-					other: "data",
-					apiAddress: "http://apiHost:apiPort",
-				}),
-			);
-			expect(result.response).toStrictEqual({
-				status: 200,
-				statusText: "Success",
-				headers: {
-					"res-header": "aa",
-					"biza-cli-address": "https://some.tunnel.url",
-					"biza-hub-address": "https://some.hub.url",
-				},
-				body: "body of response",
-				url: "http://apiHost:apiPort/test",
-			});
-			expect(result.error).toBe(null);
-			expect(mockedRequest).toHaveBeenCalledWith({
-				timeout: 30 * 1000,
-				baseURL: "http://apiHost:apiPort",
-				url: "/test",
-				method: "POST",
-				headers: { "req-header": "aa" },
-				data: JSON.stringify({ other: "data" }),
-				responseType: "json",
-				maxContentLength: Infinity,
-			});
-
-			// parameterize API address as Object
-			mockedRequest.mockClear();
-			result = await emitApiRequest({
-				other: "data",
-				apiAddress: "http://apiHost:apiPort",
-			});
-			expect(result.response).toStrictEqual({
-				status: 200,
-				statusText: "Success",
-				headers: {
-					"res-header": "aa",
-					"biza-cli-address": "https://some.tunnel.url",
-					"biza-hub-address": "https://some.hub.url",
-				},
-				body: "body of response",
-				url: "http://apiHost:apiPort/test",
-			});
-			expect(result.error).toBe(null);
-			expect(mockedRequest).toHaveBeenCalledWith({
-				timeout: 30 * 1000,
-				baseURL: "http://apiHost:apiPort",
-				url: "/test",
-				method: "POST",
-				headers: { "req-header": "aa" },
-				data: { other: "data" },
-				responseType: "json",
-				maxContentLength: Infinity,
-			});
-		});
-
-		describe("cliCommand listener", () => {
-			test("status", async () => {
-				const runCommand = async (command) => {
-					return await toPromise((resolve) => {
-						hubToCLISocket.emit(
-							"cliCommand",
-							{ command },
-							(err, res) => {
-								resolve([err, res]);
-							},
-						);
-					});
-				};
-
-				let [error, response] = await runCommand("StAtus ");
-				const cpuArchitecture = os.arch();
-				const osArchitecture = [
-					"x64",
-					"arm64",
-					"ppc64",
-					"s390x",
-				].includes(cpuArchitecture)
-					? "64-bit"
-					: ["ia32", "arm", "mips", "mipsel", "s390"].includes(
-								cpuArchitecture,
-						  )
-						? "32-bit"
-						: `Unknown CPU architecture: ${cpuArchitecture}`;
-				expect(response).toMatchObject({
-					cli: {
-						hubUrl: "https://some.hub.url",
-						publicUrl: "https://some.tunnel.url",
-						address: "59.60.1.22:3002",
-						version: expect.any(String),
-						mode: "test",
-						memoryUsage: expect.any(String),
-						nodeVersion: process.version,
-						uptime: expect.objectContaining({
-							days: expect.any(Number),
-							hours: expect.any(Number),
-							minutes: expect.any(Number),
-							seconds: expect.any(Number),
-						}),
-						workers: {
-							cliScript: cliScriptWorkerPool.stats(),
-						},
-					},
-					api: {
-						address: `${apiAddress}:${port}`,
-						dbIndex: 2,
-					},
-					os: {
-						name: os.type(),
-						architecture: osArchitecture,
-						platform: os.platform(),
-						cpuCount: os.cpus().length,
-						memory: {
-							total:
-								(os.totalmem / (1024 * 1024 * 1024)).toFixed(
-									2,
-								) + " GB",
-							free: expect.any(String),
-							used: expect.any(String),
-						},
-					},
-				});
-				expect(error).toBe(null);
-
-				[error, response] = await runCommand(" invalid command");
-				expect(response).toBe(null);
-				expect(error).toBe("Unknown CLI command 'invalid command'");
-			});
-
-			describe("runCLIScript", () => {
-				test("shall used worker pool", async () => {
-					expect(cliScriptWorkerPool.workerType).toBe("thread"); // used node.js worker thread
-
-					const execSpy = jest.spyOn(cliScriptWorkerPool, "exec");
-					const runCommand = () =>
-						toPromise((resolve) => {
-							hubToCLISocket.emit(
-								"cliCommand",
-								{
-									command: "runCliScript",
-									scriptName: "sumScript",
-									scriptData: { x: 1, y: 2 },
-								},
-								(err, res) => {
-									resolve([err, res]);
-								},
-							);
-						});
-
-					execSpy.mockResolvedValueOnce("success");
-					await expect(runCommand()).resolves.toStrictEqual([
-						null,
-						"success",
-					]);
-					expect(execSpy.mock.calls.length).toBe(1);
-					expect(execSpy).toHaveBeenCalledWith("run", [
-						{
-							dbindex: 2,
-							subdomain,
-							url: `http://${apiAddress}:${port}`,
-						},
-						"sumScript",
-						{ x: 1, y: 2 },
-					]);
-					execSpy.mockReset();
-
-					execSpy.mockRejectedValueOnce("fail");
-					await expect(runCommand()).resolves.toStrictEqual([
-						"fail",
-						null,
-					]);
-					expect(execSpy.mock.calls.length).toBe(1);
-					expect(execSpy).toHaveBeenCalledWith("run", [
-						{
-							dbindex: 2,
-							subdomain,
-							url: `http://${apiAddress}:${port}`,
-						},
-						"sumScript",
-						{ x: 1, y: 2 },
-					]);
-					execSpy.mockReset();
-
-					// process beforeexit can not be reliably triggered or handled as expected within Jest's test environment, especially in worker thread scenario
-					// so we trigger the function directly
-					const terminateSpy = jest.spyOn(
-						cliScriptWorkerPool,
-						"terminate",
-					);
-					const workerpoolBeforeExit = process
-						.listeners("beforeexit")
-						.find(
-							(listener) =>
-								listener
-									.toString()
-									.toLowerCase()
-									.indexOf("cliscriptworkerpool") !== -1,
-						);
-					expect(isAsyncFunction(workerpoolBeforeExit)).toBeTruthy();
-					terminateSpy.mockReset();
-					workerpoolBeforeExit();
-					expect(terminateSpy.mock.calls.length).toBe(1);
-				});
-			});
-		});
-	});
-
-	test("shall create socket server with correct options", () => {
-		const sockHttpServer = createServer();
-		const sockServer = createSocketServer(sockHttpServer, "1.2.3.4");
-		try {
-			const opts = sockServer.opts;
-			expect(opts.cors.origin).toStrictEqual([
-				"https://biz-a.id",
-				"https://test.biz-a.id",
-				/\.biz-a\.id$/,
-				"vscode-file://vscode-app",
-				/\.vscode-cdn\.net$/,
-				"http://1.2.3.4:4200",
-				"http://localhost:4200",
-			]);
-			expect(opts.maxHttpBufferSize).toBe(1e8);
-			expect(opts.pingInterval).toBe(35000);
-			expect(opts.pingTimeout).toBe(30000);
-		} finally {
-			sockServer.close();
-			sockHttpServer.close();
-		}
-	});
-});