@nestia/e2e 0.6.0-dev.20240620-4 → 0.7.0-dev.20240709

package/package.json

@@ -1,59 +1,52 @@
-{
-  "name": "@nestia/e2e",
-  "version": "0.6.0-dev.20240620-4",
-  "description": "E2E test utilify functions",
-  "main": "lib/index.js",
-  "scripts": {
-    "build": "rimraf lib && tsc",
-    "dev": "npm run build -- --watch",
-    "eslint": "eslint src",
-    "prepare": "ts-patch install && typia patch",
-    "test": "node lib/test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/samchon/nestia"
-  },
-  "keywords": [
-    "e2e",
-    "nestia",
-    "nestjs",
-    "test",
-    "tdd",
-    "utility"
-  ],
-  "author": "Jeongho Nam",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/samchon/nestia/issues"
-  },
-  "homepage": "https://nestia.io",
-  "devDependencies": {
-    "@trivago/prettier-plugin-sort-imports": "^4.0.0",
-    "@types/cli": "^0.11.21",
-    "@types/node": "^18.11.18",
-    "@typescript-eslint/eslint-plugin": "^5.57.0",
-    "@typescript-eslint/parser": "^5.57.0",
-    "rimraf": "^4.1.2",
-    "ts-node": "^10.9.1",
-    "ts-patch": "^3.1.0",
-    "typescript": "^5.4.2",
-    "typia": "^6.1.1"
-  },
-  "dependencies": {
-    "@nestia/fetcher": "^3.2.2",
-    "chalk": "^4.1.2",
-    "cli": "^1.0.1",
-    "tgrid": "^1.0.1",
-    "tstl": "^3.0.0"
-  },
-  "files": [
-    "lib",
-    "src",
-    "!lib/test",
-    "!src/test",
-    "README.md",
-    "LICENSE",
-    "package.json"
-  ]
-}
+{
+  "name": "@nestia/e2e",
+  "version": "0.7.0-dev.20240709",
+  "description": "E2E test utilify functions",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "npm run build:main && npm run build:test",
+    "build:main": "rimraf lib && tsc",
+    "build:test": "rimraf bin && tsc -p test/tsconfig.json",
+    "dev": "npm run build:test -- --watch",
+    "eslint": "eslint src && eslint test",
+    "prepare": "ts-patch install && typia patch",
+    "test": "node bin/test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samchon/nestia"
+  },
+  "keywords": [
+    "e2e",
+    "nestia",
+    "nestjs",
+    "test",
+    "tdd",
+    "utility"
+  ],
+  "author": "Jeongho Nam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/samchon/nestia/issues"
+  },
+  "homepage": "https://nestia.io",
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^4.0.0",
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "rimraf": "^4.1.2",
+    "ts-node": "^10.9.1",
+    "ts-patch": "^3.2.1",
+    "typescript": "^5.5.3",
+    "typescript-transform-paths": "^3.4.7",
+    "typia": "^6.4.3"
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ]
+}

package/src/DynamicExecutor.ts

@@ -1,9 +1,6 @@
-import chalk from "chalk";
 import fs from "fs";
 import NodePath from "path";
 
-import { StopWatch } from "./StopWatch";
-
 /**
  * Dynamic Executor running prefixed functions.
  *
@@ -36,7 +33,7 @@ export namespace DynamicExecutor {
   /**
    * Options for dynamic executor.
    */
-  export interface IOptions<Parameters extends any[], Ret = any> {
+  export interface IProps<Parameters extends any[], Ret = any> {
     /**
      * Prefix of function name.
      *
@@ -46,6 +43,11 @@ export namespace DynamicExecutor {
      */
     prefix: string;
 
+    /**
+     * Location of the test functions.
+     */
+    location: string;
+
     /**
      * Get parameters of a function.
      *
@@ -54,6 +56,15 @@ export namespace DynamicExecutor {
      */
     parameters: (name: string) => Parameters;
 
+    /**
+     * On complete function.
+     *
+     * Listener of completion of a test function.
+     *
+     * @param exec Execution result of a test function
+     */
+    onComplete?: (exec: IExecution) => void;
+
     /**
      * Filter function whether to run or not.
      *
@@ -80,13 +91,6 @@ export namespace DynamicExecutor {
       paramters: Parameters,
     ) => Promise<any>;
 
-    /**
-     * Whether to show elapsed time on `console` or not.
-     *
-     * @default true
-     */
-    showElapsedTime?: boolean;
-
     /**
      * Extension of dynamic functions.
      *
@@ -107,38 +111,42 @@ export namespace DynamicExecutor {
     /**
      * Execution results of dynamic functions.
      */
-    executions: IReport.IExecution[];
+    executions: IExecution[];
 
     /**
      * Total elapsed time.
      */
     time: number;
   }
-  export namespace IReport {
+
+  /**
+   * Execution of a test function.
+   */
+  export interface IExecution {
     /**
-     * Execution result of a dynamic function.
+     * Name of function.
      */
-    export interface IExecution {
-      /**
-       * Name of function.
-       */
-      name: string;
+    name: string;
 
-      /**
-       * Location path of the function.
-       */
-      location: string;
+    /**
+     * Location path of the function.
+     */
+    location: string;
 
-      /**
-       * Error when occured.
-       */
-      error: Error | null;
+    /**
+     * Error when occured.
+     */
+    error: Error | null;
 
-      /**
-       * Elapsed time.
-       */
-      time: number;
-    }
+    /**
+     * Elapsed time.
+     */
+    started_at: string;
+
+    /**
+     * Completion time.
+     */
+    completed_at: string;
   }
 
   /**
@@ -148,18 +156,12 @@ export namespace DynamicExecutor {
    * Otherwise, {@link validate} mode does not terminate when error occurs, but
    * just archive the error log.
    *
-   * @param options Options of dynamic executor
-   * @returns Runner of dynamic functions with specific location
+   * @param props Properties of dynamic execution
+   * @returns Report of dynamic test functions execution
    */
-  export const assert =
-    <Arguments extends any[]>(options: IOptions<Arguments>) =>
-    /**
-     * Run dynamic executor.
-     *
-     * @param path Location of prefixed functions
-     */
-    (path: string): Promise<IReport> =>
-      main(options)(true)(path);
+  export const assert = <Arguments extends any[]>(
+    props: IProps<Arguments>,
+  ): Promise<IReport> => main(true)(props);
 
   /**
    * Prepare dynamic executor in loose mode.
@@ -168,33 +170,27 @@ export namespace DynamicExecutor {
    * Instead, the error would be archived and returns as a list. Otherwise,
    * {@link assert} mode terminates the program directly when error occurs.
    *
-   * @param options Options of dynamic executor
-   * @returns Runner of dynamic functions with specific location
+   * @param props Properties of dynamic executor
+   * @returns Report of dynamic test functions execution
    */
-  export const validate =
-    <Arguments extends any[]>(options: IOptions<Arguments>) =>
-    /**
-     * Run dynamic executor.
-     *
-     * @param path Location of prefix functions
-     * @returns List of errors
-     */
-    (path: string): Promise<IReport> =>
-      main(options)(false)(path);
+  export const validate = <Arguments extends any[]>(
+    props: IProps<Arguments>,
+  ): Promise<IReport> => main(false)(props);
 
   const main =
-    <Arguments extends any[]>(options: IOptions<Arguments>) =>
     (assert: boolean) =>
-    async (path: string) => {
+    async <Arguments extends any[]>(
+      props: IProps<Arguments>,
+    ): Promise<IReport> => {
       const report: IReport = {
-        location: path,
+        location: props.location,
         time: Date.now(),
         executions: [],
       };
 
-      const executor = execute(options)(report)(assert);
-      const iterator = iterate(options.extension ?? "js")(executor);
-      await iterator(path);
+      const executor = execute(props)(report)(assert);
+      const iterator = iterate(props.extension ?? "js")(executor);
+      await iterator(props.location);
 
       report.time = Date.now() - report.time;
       return report;
@@ -224,54 +220,42 @@ export namespace DynamicExecutor {
     };
 
   const execute =
-    <Arguments extends any[]>(options: IOptions<Arguments>) =>
+    <Arguments extends any[]>(props: IProps<Arguments>) =>
     (report: IReport) =>
     (assert: boolean) =>
     async (location: string, modulo: Module<Arguments>): Promise<void> => {
       for (const [key, closure] of Object.entries(modulo)) {
         if (
-          key.substring(0, options.prefix.length) !== options.prefix ||
+          key.substring(0, props.prefix.length) !== props.prefix ||
           typeof closure !== "function" ||
-          (options.filter && options.filter(key) === false)
+          (props.filter && props.filter(key) === false)
         )
           continue;
 
         const func = async () => {
-          if (options.wrapper !== undefined)
-            await options.wrapper(key, closure, options.parameters(key));
-          else await closure(...options.parameters(key));
+          if (props.wrapper !== undefined)
+            await props.wrapper(key, closure, props.parameters(key));
+          else await closure(...props.parameters(key));
         };
-        const label: string = chalk.greenBright(key);
 
-        const result: IReport.IExecution = {
+        const result: IExecution = {
           name: key,
           location,
           error: null,
-          time: Date.now(),
+          started_at: new Date().toISOString(),
+          completed_at: new Date().toISOString(),
         };
         report.executions.push(result);
 
         try {
-          if (options.showElapsedTime === false) {
-            await func();
-            result.time = Date.now() - result.time;
-            console.log(`  - ${label}`);
-          } else {
-            result.time = (await StopWatch.measure(func))[1];
-            console.log(
-              `  - ${label}: ${chalk.yellowBright(
-                result.time.toLocaleString(),
-              )} ms`,
-            );
-          }
+          await func();
+          result.completed_at = new Date().toISOString();
         } catch (exp) {
-          result.time = Date.now() - result.time;
           result.error = exp as Error;
-
-          console.log(
-            `  - ${label} -> ${chalk.redBright((exp as Error)?.name)}`,
-          );
           if (assert === true) throw exp;
+        } finally {
+          result.completed_at = new Date().toISOString();
+          if (props.onComplete) props.onComplete(result);
         }
       }
     };

package/src/GaffComparator.ts

@@ -17,7 +17,7 @@ export namespace GaffComparator {
    */
   export const strings =
     <T>(getter: (input: T) => string | string[]) =>
-    (x: T, y: T) => {
+    (x: T, y: T): number => {
       const a: string[] = wrap(getter(x));
       const b: string[] = wrap(getter(y));
 
@@ -33,7 +33,7 @@ export namespace GaffComparator {
    */
   export const dates =
     <T>(getter: (input: T) => string | string[]) =>
-    (x: T, y: T) => {
+    (x: T, y: T): number => {
       const take = (v: T) =>
         wrap(getter(v)).map((str) => new Date(str).getTime());
       const a: number[] = take(x);
@@ -51,7 +51,7 @@ export namespace GaffComparator {
    */
   export const numbers =
     <T>(closure: (input: T) => number | number[]) =>
-    (x: T, y: T) => {
+    (x: T, y: T): number => {
       const a: number[] = wrap(closure(x));
       const b: number[] = wrap(closure(y));
 
@@ -59,11 +59,6 @@ export namespace GaffComparator {
       return idx !== -1 ? a[idx] - b[idx] : 0;
     };
 
-  function compare(x: string, y: string) {
-    return x.localeCompare(y);
-  }
-
-  function wrap<T>(elem: T | T[]): T[] {
-    return Array.isArray(elem) ? elem : [elem];
-  }
+  const compare = (x: string, y: string) => x.localeCompare(y);
+  const wrap = <T>(elem: T | T[]): T[] => (Array.isArray(elem) ? elem : [elem]);
 }

package/src/RandomGenerator.ts

@@ -1,6 +1,3 @@
-import { back_inserter, randint } from "tstl";
-import { ranges } from "tstl";
-
 /**
  * Random data generator.
  *
@@ -146,9 +143,10 @@ export namespace RandomGenerator {
   export const sample =
     <T>(array: T[]) =>
     (count: number): T[] => {
-      const ret: T[] = [];
-      ranges.sample(array, back_inserter(ret), count);
-      return ret;
+      count = Math.min(count, array.length);
+      const indexes: Set<number> = new Set();
+      while (indexes.size < count) indexes.add(randint(0, array.length - 1));
+      return Array.from(indexes).map((index) => array[index]);
     };
 
   /**
@@ -159,3 +157,6 @@ export namespace RandomGenerator {
    */
   export const pick = <T>(array: T[]): T => array[randint(0, array.length - 1)];
 }
+
+const randint = (min: number, max: number): number =>
+  Math.floor(Math.random() * (max - min + 1)) + min;

package/src/TestValidator.ts

@@ -1,5 +1,3 @@
-import { ranges } from "tstl";
-
 import { RandomGenerator } from "./RandomGenerator";
 import { json_equal_to } from "./internal/json_equal_to";
 
@@ -304,7 +302,7 @@ export namespace TestValidator {
 
       const reversed: typeof comp =
         direction === "+" ? comp : (x, y) => comp(y, x);
-      if (ranges.is_sorted(data, (x, y) => reversed(x, y) < 0) === false) {
+      if (is_sorted(data, reversed) === false) {
         if (
           fields.length === 1 &&
           data.length &&
@@ -341,3 +339,9 @@ function is_promise(input: any): input is Promise<any> {
     typeof (input as any).catch === "function"
   );
 }
+
+function is_sorted<T>(data: T[], comp: (x: T, y: T) => number): boolean {
+  for (let i: number = 1; i < data.length; ++i)
+    if (comp(data[i - 1], data[i]) > 0) return false;
+  return true;
+}

package/src/module.ts

@@ -1,7 +1,5 @@
 export * from "./ArrayUtil";
-export * from "./DynamicBenchmarker";
 export * from "./DynamicExecutor";
 export * from "./GaffComparator";
 export * from "./RandomGenerator";
-export * from "./StopWatch";
 export * from "./TestValidator";

package/lib/DynamicBenchmarker.d.ts

@@ -1,176 +0,0 @@
-import { IConnection } from "@nestia/fetcher";
-import { WorkerServer } from "tgrid";
-import { IBenchmarkMaster } from "./structures/IBenchmarkMaster";
-import { IBenchmarkServant } from "./structures/IBenchmarkServant";
-/**
- * Dynamic benchmark executor running prefixed functions.
- *
- * `DynamicBenchmarker` is composed with two programs,
- * {@link DynamicBenchmarker.master} and
- * {@link DynamicBenchmarker.servant servants}. The master program creates
- * multiple servant programs, and the servant programs execute the prefixed
- * functions in parallel. When the pre-congirued count of requests are all
- * completed, the master program collects the results and returns them.
- *
- * Therefore, when you want to benchmark the performance of a backend server,
- * you have to make two programs; one for calling the
- * {@link DynamicBenchmarker.master} function, and the other for calling the
- * {@link DynamicBenchmarker.servant} function. Also, never forget to write
- * the path of the servant program to the
- * {@link DynamicBenchmarker.IMasterProps.servant} property.
- *
- * Also, you when you complete the benchmark execution through the
- * {@link DynamicBenchmarker.master} and {@link DynamicBenchmarker.servant}
- * functions, you can convert the result to markdown content by using the
- * {@link DynamicBenchmarker.markdown} function.
- *
- * Additionally, if you hope to see some utilization cases,
- * see the below example tagged links.
- *
- * @example https://github.com/samchon/nestia-start/blob/master/test/benchmaark/index.ts
- * @example https://github.com/samchon/backend/blob/master/test/benchmark/index.ts
- * @author Jeongho Nam - https://github.com/samchon
- */
-export declare namespace DynamicBenchmarker {
-    /**
-     * Properties of the master program.
-     */
-    interface IMasterProps {
-        /**
-         * Total count of the requests.
-         */
-        count: number;
-        /**
-         * Number of threads.
-         *
-         * The number of threads to be executed as parallel servant.
-         */
-        threads: number;
-        /**
-         * Number of simultaneous requests.
-         *
-         * The number of requests to be executed simultaneously.
-         *
-         * This property value would be divided by the {@link threads} in the servants.
-         */
-        simultaneous: number;
-        /**
-         * Path of the servant program.
-         *
-         * The path of the servant program executing the
-         * {@link DynamicBenchmarker.servant} function.
-         */
-        servant: string;
-        /**
-         * Filter function.
-         *
-         * The filter function to determine whether to execute the function in
-         * the servant or not.
-         *
-         * @param name Function name
-         * @returns Whether to execute the function or not.
-         */
-        filter?: (name: string) => boolean;
-        /**
-         * Progress callback function.
-         *
-         * @param complete The number of completed requests.
-         */
-        progress?: (complete: number) => void;
-        /**
-         * Standard I/O option.
-         *
-         * The standard I/O option for the servant programs.
-         */
-        stdio?: undefined | "overlapped" | "pipe" | "ignore" | "inherit";
-    }
-    /**
-     * Properties of the servant progrma.
-     */
-    interface IServantProps<Parameters extends any[]> {
-        /**
-         * Default connection.
-         *
-         * Default connection to be used in the servant.
-         */
-        connection: IConnection;
-        /**
-         * Location of the benchmark functions.
-         */
-        location: string;
-        /**
-         * Prefix of the benchmark functions.
-         *
-         * Every prefixed function will be executed in the servant.
-         *
-         * In other words, if a function name doesn't start with the prefix,
-         * then it would never be executed.
-         */
-        prefix: string;
-        /**
-         * Get parameters of a function.
-         *
-         * When composing the parameters, never forget to copy the
-         * {@link IConnection.logger} property of default connection to the
-         * returning parameters.
-         *
-         * @param connection Default connection instance
-         * @param name Function name
-         */
-        parameters: (connection: IConnection, name: string) => Parameters;
-    }
-    /**
-     * Benchmark report.
-     */
-    interface IReport {
-        count: number;
-        threads: number;
-        simultaneous: number;
-        started_at: string;
-        completed_at: string;
-        statistics: IReport.IStatistics;
-        endpoints: Array<IReport.IEndpoint & IReport.IStatistics>;
-    }
-    namespace IReport {
-        interface IEndpoint {
-            method: string;
-            path: string;
-        }
-        interface IStatistics {
-            count: number;
-            success: number;
-            mean: number | null;
-            stdev: number | null;
-            minimum: number | null;
-            maximum: number | null;
-        }
-    }
-    /**
-     * Master program.
-     *
-     * Creates a master program that executing the servant programs in parallel.
-     *
-     * Note that, {@link IMasterProps.servant} property must be the path of
-     * the servant program executing the {@link servant} function.
-     *
-     * @param props Properties of the master program
-     * @returns Benchmark report
-     */
-    const master: (props: IMasterProps) => Promise<IReport>;
-    /**
-     * Create a servant program.
-     *
-     * Creates a servant program executing the prefixed functions in parallel.
-     *
-     * @param props Properties of the servant program
-     * @returns Servant program as a worker server
-     */
-    const servant: <Parameters extends any[]>(props: IServantProps<Parameters>) => Promise<WorkerServer<null, IBenchmarkServant, IBenchmarkMaster>>;
-    /**
-     * Convert the benchmark report to markdown content.
-     *
-     * @param report Benchmark report
-     * @returns Markdown content
-     */
-    const markdown: (report: DynamicBenchmarker.IReport) => string;
-}