test_helper.js

// Copyright Titanium I.T. LLC.
import * as ensure from "util/ensure.js";
import http from "node:http";
import childProcess from "node:child_process";

/**
 * Perform an HTTP request in a way that's convenient for tests. Deletes certain headers tests don't care about.
 * @param port localhost port
 * @param url path
 * @param method GET, POST, etc.
 * @param headers optional; headers to send
 * @param body optional; body to send
 * @returns { status, headers, body } status, headers, and body returned by server
 */
export async function requestAsync({ port, url, method, headers, body = [] } = {}) {
	return await new Promise((resolve, reject) => {
		ensure.signature(arguments, [[ undefined, {
			port: [ Number, String ],
			url: [ undefined, String ],
			method: [ undefined, String ],
			headers: [ undefined, Object ],
			body: [ undefined, Array ],
		}]]);
		if (method === undefined && body.length !== 0) method = "POST";

		const request = http.request({ port, path: url, method, headers });
		body.forEach((chunk) => request.write(chunk));
		request.end();

		request.on("response", (response) => {
			let body = "";
			response.on("data", (chunk) => {
				body += chunk;
			});
			response.on("error", (err) => reject(err));
			response.on("end", () => {
				const headers = response.headers;
				delete headers.connection;
				delete headers["content-length"];
				delete headers.date;

				resolve({
					status: response.statusCode,
					headers: response.headers,
					body,
				});
			});
		});
	});
}

/**
 * Run specified module in a separate process.
 * @param absolutePath path to module (relative to working directory)
 * @param args optional; process arguments (default none)
 * @param failOnStderr optional; if true, throws an error if anything is written to stderr (default true)
 * @returns { stdout, stderr } data written to stdout and stderr
 */
export function runModuleAsync(absolutePath, { args = [], failOnStderr = true } = {}) {
	return new Promise((resolve, reject) => {
		ensure.signature(arguments, [ String, [ undefined, {
			args: [ undefined, Array ],
			failOnStderr: [ undefined, Boolean ],
		}]], [ "absolutePath", "options" ]);

		const child = forkModule(absolutePath, { args });

		let stdout = "";
		let stderr = "";
		child.stdout.on("data", (data) => {
			stdout += data;
		});
		child.stderr.on("data", (data) => {
			stderr += data;
		});

		child.on("exit", (code) => {
			if (code !== 0 || (failOnStderr && stderr !== "")) {
				return reject(new Error(`Runner failed.\nstdout: ${stdout}\nstderr: ${stderr}`));
			}
			else {
				return resolve({ stdout, stderr });
			}
		});
	});
}

/**
 * Runs a Node.js module in a separate process.
 * @param absolutePath path to module
 * @param args optional; process arguments (default none)
 * @returns { stdout, stderr } data written to stdout and stderr
 */
export function forkModule(absolutePath, {
	args = []
} = {}) {
	ensure.signature(arguments, [ String, [ undefined, {
		args: [ undefined, Array ],
	}]], [ "absolutePath", "options" ]);

	const options = {
		stdio: "pipe",
	};
	return childProcess.fork(absolutePath, args, options);
}

/**
 * Resolves a promise and ignores any errors it throws.
 * @param promise the promise to ignore
 */
export async function ignorePromiseErrorAsync(promise) {
	try {
		await promise;
	}
	catch (err) {
	}
}