@api-client/core 0.3.5 → 0.3.6

package/src/runtime/reporters/ProjectRunCliReporter.ts

@@ -0,0 +1,79 @@
+import { Table } from 'console-table-printer';
+import chalk from 'chalk';
+import { ErrorResponse, IErrorResponse } from '../../models/ErrorResponse.js';
+import { IArcResponse } from '../../models/ArcResponse.js';
+import { ISerializedError } from '../../models/SerializableError.js';
+import { Reporter } from './Reporter.js';
+
+/**
+ * HTTP project execution reporter for a terminal output.
+ */
+export class ProjectRunCliReporter extends Reporter {
+  async generate(): Promise<void> {
+    const { info } = this;
+
+    const table = new Table({
+      title: 'Project execution summary',
+      columns: [
+        { name: 'position', title: ' ', alignment: 'left',  },
+        { name: 'succeeded', title: 'Succeeded', alignment: 'right', },
+        { name: 'failed', title: 'Failed', alignment: 'right', },
+        { name: 'total', title: 'Total', alignment: 'right', },
+      ],
+    });
+
+    table.addRow({
+      position: 'Iterations',
+      succeeded: info.iterations.length,
+      failed: 0,
+      total: info.iterations.length,
+    });
+
+    const failed = this.computeFailed();
+    const succeeded = this.computeSucceeded();
+    table.addRow({
+      position: 'Requests',
+      succeeded,
+      failed: failed > 0 ? chalk.redBright(failed) : failed,
+      total: failed + succeeded,
+    });
+    table.printTable();
+    process.stdout.write('\n');
+
+    info.iterations.forEach((run, index) => {
+      const itNumber = index + 1;
+      if (run.error) {
+        process.stdout.write(`Iteration ${itNumber} failed: ${run.error}\n\n`);
+        return;
+      }
+      const failed = run.executed.filter(log => this.isFailedLog(log));
+      if (!failed.length) {
+        return;
+      }
+      process.stdout.write(`Iteration ${itNumber} Errors\n`);
+      failed.forEach((log) => {
+        let url = 'Unknown request URL.';
+        if (log.request) {
+          url = log.request.url;
+        }
+        const prefix = chalk.dim(`[${url}] `);
+        if (log.response && ErrorResponse.isErrorResponse(log.response)) {
+          const response = log.response as IErrorResponse;
+          let message = (response.error as ISerializedError).message ? (response.error as Error).message : response.error;
+          if (typeof message !== 'string') {
+            message = 'Unknown error.';
+          }
+          process.stdout.write(`${prefix}${message}\n`);
+          return;
+        }
+        if (!log.request) {
+          process.stdout.write('Request not executed.\n');
+          return;
+        }
+        const response = log.response as IArcResponse;
+        process.stdout.write(`${prefix} Status code is: ${response.status}\n`);
+      });
+      process.stdout.write('\n\n');
+    });
+  }
+}

package/src/runtime/reporters/Reporter.ts

@@ -0,0 +1,142 @@
+import { IRequestLog } from '../../models/RequestLog.js';
+import { IArcResponse } from '../../models/ArcResponse.js';
+import { ErrorResponse } from '../../models/ErrorResponse.js';
+
+export interface IProjectExecutionIteration {
+  /**
+   * The index of the iteration.
+   */
+  index: number;
+  /**
+   * The list of requests executed in the iteration.
+   */
+  executed: IRequestLog[];
+  /**
+   * Optional general error message.
+   */
+  error?: string;
+}
+
+export interface IProjectExecutionLog {
+  /**
+   * The timestamp when the execution started
+   */
+  started: number;
+  /**
+   * The timestamp when the execution ended
+   */
+  ended: number;
+  /**
+   * The execution logs for each iteration.
+   */
+  iterations: IProjectExecutionIteration[];
+}
+
+/**
+ * Base class for project execution reporters.
+ */
+export abstract class Reporter {
+  info: IProjectExecutionLog;
+
+  constructor(info: IProjectExecutionLog) {
+    this.info = info;
+  }
+
+  /**
+   * Generates the report for the current execution log.
+   */
+  abstract generate(): Promise<void>;
+
+  /**
+   * Checks whether the execution log should be considered a failure.
+   * @param log The execution log.
+   * @returns `true` when the request was a failure.
+   */
+  protected isFailedLog(log: IRequestLog): boolean {
+    if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
+      return true;
+    }
+    const response = log.response as IArcResponse;
+    if (response.status >= 400) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Computes the number of requests that failed.
+   */
+  computeFailed(): number {
+    let result = 0;
+    const { info } = this;
+    const { iterations } = info;
+    iterations.forEach((iteration) => {
+      iteration.executed.forEach((log) => {
+        if (this.isFailedLog(log)) {
+          result++;
+        }
+      });
+    });
+
+    return result;
+  }
+
+  /**
+   * Computes the number of requests that ended with the status code 399 at the most.
+   */
+  computeSucceeded(): number {
+    let result = 0;
+    const { info } = this;
+    const { iterations } = info;
+    iterations.forEach((iteration) => {
+      iteration.executed.forEach((log) => {
+        if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
+          return;
+        }
+        const response = log.response as IArcResponse;
+        if (response.status < 400) {
+          result++;
+        }
+      });
+    });
+    return result;
+  }
+
+  /**
+   * Computes the total time of sending each request.
+   */
+  computeTotalTime(): number {
+    let result = 0;
+    const { info } = this;
+    const { iterations } = info;
+    iterations.forEach((iteration) => {
+      iteration.executed.forEach((log) => {
+        if (!log.response || ErrorResponse.isErrorResponse(log.response)) {
+          return;
+        }
+        const response = log.response as IArcResponse;
+        if (response.loadingTime && response.loadingTime > 0) {
+          result += response.loadingTime;
+        }
+      });
+    });
+    return result;
+  }
+
+  /**
+   * Computes the total size of received data.
+   */
+  computeTotalSize(): number {
+    let result = 0;
+    const { info } = this;
+    const { iterations } = info;
+    iterations.forEach((iteration) => {
+      iteration.executed.forEach((log) => {
+        if (log.size && log.size.response) {
+          result += log.size.response;
+        }
+      });
+    });
+    return result;
+  }
+}

package/src/testing/TestCliHelper.ts

@@ -0,0 +1,76 @@
+export interface ITestRunCommandOptions {
+  includeError?: boolean;
+  noCleaning?: boolean;
+}
+
+export class TestCliHelper {
+  static cleanTerminalOutput(s: string): string {
+    let result = s.trim();
+    result = result.replace(/[^\x20-\x7E\n]/gm, '');
+    // result = result.replace(/\[\d+m/gm, '');
+    result = result.replace(/\[\d+[a-zA-Z]/gm, '');
+    result = result.split('\n').filter(i => !!i.trim()).join('\n');
+    return result;
+  }
+
+  static splitLines(table: string): string[] {
+    const result: string[] = [];
+    table.split('\n').forEach((line) => {
+      const value = line.trim();
+      if (!value) {
+        return;
+      }
+      result.push(value);
+    });
+    return result;
+  }
+
+  /**
+   * Executes a passed asynchronous function and captures stdout.
+   * When the function fails, it cleans up output listeners and throws the error.
+   * 
+   * ```javascript
+   * const out = grabOutput(async () => {
+   *  // ...
+   * });
+   * console.log(out); // combined stdout and stderr.
+   * ```
+   * 
+   * @param fn The function to execute.
+   * @returns The terminal output.
+   */
+  static async grabOutput(fn: () => Promise<void>): Promise<string> {
+    const messages: string[] = [];
+    function noop(): void {
+      //
+    }
+    const origOut = process.stdout.write;
+    const origErr = process.stderr.write;
+    const origClear = console.clear;
+    function messageHandler(buffer: string | Buffer): boolean {
+      if (typeof buffer === 'string') {
+        messages.push(buffer);
+      } else {
+        messages.push(buffer.toString('utf8'));
+      }
+      return true;
+    }
+    function stop(): void {
+      process.stdout.write = origOut;
+      process.stderr.write = origErr;
+      console.clear = origClear;
+    }
+    process.stdout.write = messageHandler;
+    process.stderr.write = messageHandler;
+    console.clear = noop;
+
+    try {
+      await fn();
+      stop();
+    } catch (e) {
+      stop();
+      throw e;
+    }
+    return messages.join('');
+  }
+}

package/src/testing/getPort.ts

@@ -0,0 +1,212 @@
+import net from 'net';
+import os from 'os';
+
+/* global NodeJS */
+
+export interface IGetPortOptions extends Omit<net.ListenOptions, 'port'> {
+	/**
+	A preferred port or an iterable of preferred ports to use.
+	*/
+	readonly port?: number | Iterable<number>;
+
+	/**
+	The host on which port resolution should be performed. Can be either an IPv4 or IPv6 address.
+
+	By default, it checks availability on all local addresses defined in [OS network interfaces](https://nodejs.org/api/os.html#os_os_networkinterfaces). If this option is set, it will only check the given host.
+	*/
+	readonly host?: string;
+}
+
+class Locked extends Error {
+	constructor(port = 0) {
+		super(`${port} is locked`);
+	}
+}
+
+const lockedPorts = {
+	old: new Set(),
+	young: new Set(),
+};
+
+// On this interval, the old locked ports are discarded,
+// the young locked ports are moved to old locked ports,
+// and a new young set for locked ports are created.
+const releaseOldLockedPortsIntervalMs = 1000 * 15;
+
+// Lazily create interval on first use
+let interval:NodeJS.Timer;
+
+const getLocalHosts = (): Set<string | undefined> => {
+	const interfaces = os.networkInterfaces();
+
+	// Add undefined value for createServer function to use default host,
+	// and default IPv4 host in case createServer defaults to IPv6.
+	const results = new Set([undefined, '0.0.0.0']);
+
+	for (const _interface of Object.values(interfaces)) {
+    if (_interface) {
+      for (const config of _interface) {
+        results.add(config.address);
+      }
+    }
+	}
+
+	return results;
+};
+
+const checkAvailablePort = (options: net.ListenOptions): Promise<number> =>
+	new Promise((resolve, reject) => {
+		const server = net.createServer();
+		server.unref();
+		server.on('error', reject);
+
+		server.listen(options, () => {
+			const {port} = server.address() as net.AddressInfo;
+			server.close(() => {
+				resolve(port);
+			});
+		});
+	});
+
+const getAvailablePort = async (options: net.ListenOptions, hosts: Set<string | undefined>): Promise<number | undefined> => {
+	if (options.host || options.port === 0) {
+		return checkAvailablePort(options);
+	}
+
+	for (const host of hosts) {
+		try {
+			await checkAvailablePort({port: options.port, host}); // eslint-disable-line no-await-in-loop
+		} catch (error) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const typed = error as any;
+			if (!['EADDRNOTAVAIL', 'EINVAL'].includes(typed.code)) {
+				throw typed;
+			}
+		}
+	}
+
+	return options.port;
+};
+
+const portCheckSequence = function * (ports?: number[] | Iterable<number>): IterableIterator<number|undefined> {
+	if (ports) {
+		yield * ports;
+	}
+
+	yield 0; // Fall back to 0 if anything else failed
+};
+
+/**
+Get an available TCP port number.
+
+@returns Port number.
+
+@example
+```
+import getPort from 'get-port';
+
+console.log(await getPort());
+//=> 51402
+
+// Pass in a preferred port
+console.log(await getPort({port: 3000}));
+// Will use 3000 if available, otherwise fall back to a random port
+
+// Pass in an array of preferred ports
+console.log(await getPort({port: [3000, 3001, 3002]}));
+// Will use any element in the preferred ports array if available, otherwise fall back to a random port
+```
+*/
+export async function getPort(options?: IGetPortOptions): Promise<number> {
+	let ports: number[] | Iterable<number> = [];
+
+	if (options) {
+    if (typeof options.port === 'number') {
+      ports = [options.port];
+    } else if (options.port) {
+      ports = options.port;
+    }
+	}
+
+	if (interval === undefined) {
+		interval = setInterval(() => {
+			lockedPorts.old = lockedPorts.young;
+			lockedPorts.young = new Set();
+		}, releaseOldLockedPortsIntervalMs);
+
+		// Does not exist in some environments (Electron, Jest jsdom env, browser, etc).
+		if (interval.unref) {
+			interval.unref();
+		}
+	}
+
+	const hosts = getLocalHosts();
+
+	for (const port of portCheckSequence(ports)) {
+		try {
+			let availablePort = await getAvailablePort({...options, port}, hosts); // eslint-disable-line no-await-in-loop
+			while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+				if (port !== 0) {
+					throw new Locked(port);
+				}
+
+				availablePort = await getAvailablePort({...options, port}, hosts); // eslint-disable-line no-await-in-loop
+			}
+
+			lockedPorts.young.add(availablePort);
+      if (!availablePort) {
+        throw new Error('No available ports found');
+      }
+			return availablePort;
+		} catch (error) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const typed = error as any;
+			if (!['EADDRINUSE', 'EACCES'].includes(typed.code) && !(typed instanceof Locked)) {
+				throw error;
+			}
+		}
+	}
+
+	throw new Error('No available ports found');
+}
+
+/**
+Generate port numbers in the given range `from`...`to`.
+
+@param from - The first port of the range. Must be in the range `1024`...`65535`.
+@param to - The last port of the range. Must be in the range `1024`...`65535` and must be greater than `from`.
+@returns The port numbers in the range.
+
+@example
+```
+import getPort, {portNumbers} from 'get-port';
+
+console.log(await getPort({port: portNumbers(3000, 3100)}));
+// Will use any port from 3000 to 3100, otherwise fall back to a random port
+```
+*/
+export function portNumbers(from: number, to: number): Iterable<number> {
+	if (!Number.isInteger(from) || !Number.isInteger(to)) {
+		throw new TypeError('`from` and `to` must be integer numbers');
+	}
+
+	if (from < 1024 || from > 65_535) {
+		throw new RangeError('`from` must be between 1024 and 65535');
+	}
+
+	if (to < 1024 || to > 65_536) {
+		throw new RangeError('`to` must be between 1024 and 65536');
+	}
+
+	if (to < from) {
+		throw new RangeError('`to` must be greater than or equal to `from`');
+	}
+
+	const generator = function * (from: number, to: number): IterableIterator<number> {
+		for (let port = from; port <= to; port++) {
+			yield port;
+		}
+	};
+
+	return generator(from, to);
+}