@nestia/e2e 0.4.2 → 0.5.0-dev.20240617

package/lib/structures/IBenchmarkServant.d.ts

@@ -0,0 +1,7 @@
+import { IBenchmarkEvent } from "./IBenchmarkEvent";
+export interface IBenchmarkServant {
+    execute(props: {
+        count: number;
+        simultaneous: number;
+    }): Promise<IBenchmarkEvent[]>;
+}

package/lib/structures/IBenchmarkServant.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IBenchmarkServant.js.map

package/lib/structures/IBenchmarkServant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IBenchmarkServant.js","sourceRoot":"","sources":["../../src/structures/IBenchmarkServant.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/e2e",
-  "version": "0.4.2",
+  "version": "0.5.0-dev.20240617",
   "description": "E2E test utilify functions",
   "main": "lib/index.js",
   "scripts": {
@@ -38,12 +38,14 @@
     "ts-node": "^10.9.1",
     "ts-patch": "^3.1.0",
     "typescript": "^5.4.2",
-    "typia": "^5.5.3"
+    "typia": "^6.1.0"
   },
   "dependencies": {
+    "@nestia/fetcher": "^3.2.2",
     "chalk": "^4.1.2",
     "cli": "^1.0.1",
-    "tstl": "^2.5.13"
+    "tgrid": "^1.0.1",
+    "tstl": "^3.0.0"
   },
   "files": [
     "lib",

package/src/ArrayUtil.ts

@@ -1,98 +1,98 @@
-/**
- * Utility functions for arrays.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace ArrayUtil {
-  export const asyncFilter =
-    <Input>(elements: readonly Input[]) =>
-    async (
-      pred: (
-        elem: Input,
-        index: number,
-        array: readonly Input[],
-      ) => Promise<boolean>,
-    ): Promise<Input[]> => {
-      const ret: Input[] = [];
-      await asyncForEach(elements)(async (elem, index, array) => {
-        const flag: boolean = await pred(elem, index, array);
-        if (flag === true) ret.push(elem);
-      });
-      return ret;
-    };
-
-  export const asyncForEach =
-    <Input>(elements: readonly Input[]) =>
-    async (
-      closure: (
-        elem: Input,
-        index: number,
-        array: readonly Input[],
-      ) => Promise<any>,
-    ): Promise<void> => {
-      await asyncRepeat(elements.length)((index) =>
-        closure(elements[index], index, elements),
-      );
-    };
-
-  export const asyncMap =
-    <Input>(elements: readonly Input[]) =>
-    async <Output>(
-      closure: (
-        elem: Input,
-        index: number,
-        array: readonly Input[],
-      ) => Promise<Output>,
-    ): Promise<Output[]> => {
-      const ret: Output[] = [];
-      await asyncForEach(elements)(async (elem, index, array) => {
-        const output: Output = await closure(elem, index, array);
-        ret.push(output);
-      });
-      return ret;
-    };
-
-  export const asyncRepeat =
-    (count: number) =>
-    async <T>(closure: (index: number) => Promise<T>): Promise<T[]> => {
-      const indexes: number[] = new Array(count)
-        .fill(1)
-        .map((_, index) => index);
-
-      const output: T[] = [];
-      for (const index of indexes) output.push(await closure(index));
-
-      return output;
-    };
-
-  export const has =
-    <T>(elements: readonly T[]) =>
-    (pred: (elem: T) => boolean): boolean =>
-      elements.find(pred) !== undefined;
-
-  export const repeat =
-    (count: number) =>
-    <T>(closure: (index: number) => T): T[] =>
-      new Array(count).fill("").map((_, index) => closure(index));
-
-  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
-
-  export const subsets = <T>(array: T[]): T[][] => {
-    const check: boolean[] = new Array(array.length).fill(false);
-    const output: T[][] = [];
-
-    const dfs = (depth: number): void => {
-      if (depth === check.length)
-        output.push(array.filter((_v, idx) => check[idx]));
-      else {
-        check[depth] = true;
-        dfs(depth + 1);
-
-        check[depth] = false;
-        dfs(depth + 1);
-      }
-    };
-    dfs(0);
-    return output;
-  };
-}
+/**
+ * Utility functions for arrays.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace ArrayUtil {
+  export const asyncFilter =
+    <Input>(elements: readonly Input[]) =>
+    async (
+      pred: (
+        elem: Input,
+        index: number,
+        array: readonly Input[],
+      ) => Promise<boolean>,
+    ): Promise<Input[]> => {
+      const ret: Input[] = [];
+      await asyncForEach(elements)(async (elem, index, array) => {
+        const flag: boolean = await pred(elem, index, array);
+        if (flag === true) ret.push(elem);
+      });
+      return ret;
+    };
+
+  export const asyncForEach =
+    <Input>(elements: readonly Input[]) =>
+    async (
+      closure: (
+        elem: Input,
+        index: number,
+        array: readonly Input[],
+      ) => Promise<any>,
+    ): Promise<void> => {
+      await asyncRepeat(elements.length)((index) =>
+        closure(elements[index], index, elements),
+      );
+    };
+
+  export const asyncMap =
+    <Input>(elements: readonly Input[]) =>
+    async <Output>(
+      closure: (
+        elem: Input,
+        index: number,
+        array: readonly Input[],
+      ) => Promise<Output>,
+    ): Promise<Output[]> => {
+      const ret: Output[] = [];
+      await asyncForEach(elements)(async (elem, index, array) => {
+        const output: Output = await closure(elem, index, array);
+        ret.push(output);
+      });
+      return ret;
+    };
+
+  export const asyncRepeat =
+    (count: number) =>
+    async <T>(closure: (index: number) => Promise<T>): Promise<T[]> => {
+      const indexes: number[] = new Array(count)
+        .fill(1)
+        .map((_, index) => index);
+
+      const output: T[] = [];
+      for (const index of indexes) output.push(await closure(index));
+
+      return output;
+    };
+
+  export const has =
+    <T>(elements: readonly T[]) =>
+    (pred: (elem: T) => boolean): boolean =>
+      elements.find(pred) !== undefined;
+
+  export const repeat =
+    (count: number) =>
+    <T>(closure: (index: number) => T): T[] =>
+      new Array(count).fill("").map((_, index) => closure(index));
+
+  export const flat = <T>(matrix: T[][]): T[] => ([] as T[]).concat(...matrix);
+
+  export const subsets = <T>(array: T[]): T[][] => {
+    const check: boolean[] = new Array(array.length).fill(false);
+    const output: T[][] = [];
+
+    const dfs = (depth: number): void => {
+      if (depth === check.length)
+        output.push(array.filter((_v, idx) => check[idx]));
+      else {
+        check[depth] = true;
+        dfs(depth + 1);
+
+        check[depth] = false;
+        dfs(depth + 1);
+      }
+    };
+    dfs(0);
+    return output;
+  };
+}

package/src/DynamicBenchmarker.ts

@@ -0,0 +1,246 @@
+import { IConnection } from "@nestia/fetcher";
+import fs from "fs";
+import { Driver, WorkerConnector, WorkerServer } from "tgrid";
+import { HashMap, hash } from "tstl";
+
+import { IBenchmarkEvent } from "./structures/IBenchmarkEvent";
+import { IBenchmarkMaster } from "./structures/IBenchmarkMaster";
+import { IBenchmarkServant } from "./structures/IBenchmarkServant";
+
+export namespace DynamicBenchmarker {
+  export interface IMasterProps {
+    count: number;
+    threads: number;
+    simultaneous: number;
+    servant: string;
+    filter?: (name: string) => boolean;
+    progress?: (complete: number) => void;
+    stdio?: undefined | "overlapped" | "pipe" | "ignore" | "inherit";
+  }
+  export interface IServantProps<Parameters extends any[]> {
+    connection: IConnection;
+    location: string;
+    prefix: string;
+    parameters: (name: string, connection: IConnection) => Parameters;
+  }
+  export interface IReport {
+    time: number;
+    statistics: IReport.IStatistics;
+    endpoints: Array<IReport.IEndpoint & IReport.IStatistics>;
+  }
+  export namespace IReport {
+    export interface IEndpoint {
+      method: string;
+      path: string;
+    }
+    export interface IStatistics {
+      count: number;
+      success: number;
+      mean: number | null;
+      stdev: number | null;
+      minimum: number | null;
+      maximum: number | null;
+    }
+  }
+
+  export const master = async (props: IMasterProps): Promise<IReport> => {
+    const completes: number[] = new Array(props.threads).fill(0);
+    const servants: WorkerConnector<
+      null,
+      IBenchmarkMaster,
+      IBenchmarkServant
+    >[] = await Promise.all(
+      new Array(props.threads).fill(null).map(async (i) => {
+        const connector: WorkerConnector<
+          null,
+          IBenchmarkMaster,
+          IBenchmarkServant
+        > = new WorkerConnector(
+          null,
+          {
+            filter: props.filter ?? (() => true),
+            progress: (current) => {
+              completes[i] = current;
+              if (props.progress)
+                props.progress(completes.reduce((a, b) => a + b, 0));
+            },
+          },
+          "process",
+        );
+        await connector.connect(props.servant, { stdio: props.stdio });
+        return connector;
+      }),
+    );
+    const started_at: Date = new Date();
+    const events: IBenchmarkEvent[] = (
+      await Promise.all(
+        servants.map((connector) =>
+          connector.getDriver().execute({
+            count: Math.ceil(props.count / props.threads),
+            simultaneous: Math.ceil(props.simultaneous / props.threads),
+          }),
+        ),
+      )
+    ).flat();
+    const time: number = Date.now() - started_at.getTime();
+    await Promise.all(servants.map((connector) => connector.close()));
+    if (props.progress) props.progress(props.count);
+
+    const endpoints: HashMap<IReport.IEndpoint, IBenchmarkEvent[]> =
+      new HashMap(
+        (key) => hash(key.method, key.path),
+        (x, y) => x.method === y.method && x.path === y.path,
+      );
+    for (const e of events)
+      endpoints
+        .take(
+          {
+            method: e.metadata.method,
+            path: e.metadata.template ?? e.metadata.path,
+          },
+          () => [],
+        )
+        .push(e);
+    return {
+      time,
+      statistics: statistics(events),
+      endpoints: [...endpoints].map((it) => ({
+        ...statistics(it.second),
+        ...it.first,
+      })),
+    };
+  };
+
+  export const servant = async <Parameters extends any[]>(
+    props: IServantProps<Parameters>,
+  ): Promise<WorkerServer<null, IBenchmarkServant, IBenchmarkMaster>> => {
+    const server: WorkerServer<null, IBenchmarkServant, IBenchmarkMaster> =
+      new WorkerServer();
+    await server.open({
+      execute: execute({
+        driver: server.getDriver(),
+        props,
+      }),
+    });
+    return server;
+  };
+
+  const execute =
+    <Parameters extends any[]>(ctx: {
+      driver: Driver<IBenchmarkMaster>;
+      props: IServantProps<Parameters>;
+    }) =>
+    async (mass: {
+      count: number;
+      simultaneous: number;
+    }): Promise<IBenchmarkEvent[]> => {
+      const functions: IFunction<Parameters>[] = [];
+      await iterate({
+        collection: functions,
+        driver: ctx.driver,
+        props: ctx.props,
+      })(ctx.props.location);
+      const events: IBenchmarkEvent[] = [];
+
+      ctx.props.connection.logger = async (e): Promise<void> => {
+        events.push({
+          metadata: e.route,
+          status: e.status,
+          started_at: e.started_at.toISOString(),
+          repond_at: e.respond_at?.toISOString() ?? null,
+          completed_at: e.completed_at.toISOString(),
+        });
+      };
+
+      await Promise.all(
+        new Array(mass.simultaneous).fill(null).map(async () => {
+          while (events.length < mass.count) {
+            const prev: number = events.length;
+            const func: IFunction<Parameters> =
+              functions[Math.floor(Math.random() * functions.length)];
+            try {
+              await func.value(
+                ...ctx.props.parameters(func.key, ctx.props.connection),
+              );
+              const current: number = events.length;
+              if (current !== prev)
+                ctx.driver.progress(current).catch(() => {});
+            } catch {}
+          }
+        }),
+      );
+      await ctx.driver.progress(events.length);
+      return events;
+    };
+
+  const statistics = (events: IBenchmarkEvent[]): IReport.IStatistics => {
+    const successes: IBenchmarkEvent[] = events.filter(
+      (event) => event.status === 200 || event.status === 201,
+    );
+    return {
+      count: events.length,
+      success: successes.length,
+      ...average(events),
+    };
+  };
+
+  const average = (
+    events: IBenchmarkEvent[],
+  ): Pick<IReport.IStatistics, "mean" | "stdev" | "minimum" | "maximum"> => {
+    if (events.length === 0)
+      return {
+        mean: null,
+        stdev: null,
+        minimum: null,
+        maximum: null,
+      };
+    let mean: number = 0;
+    let stdev: number = 0;
+    let minimum: number = Number.MAX_SAFE_INTEGER;
+    let maximum: number = Number.MIN_SAFE_INTEGER;
+    for (const event of events) {
+      const elapsed: number =
+        new Date(event.completed_at).getTime() -
+        new Date(event.started_at).getTime();
+      mean += elapsed;
+      stdev += elapsed * elapsed;
+      minimum = Math.min(minimum, elapsed);
+      maximum = Math.max(maximum, elapsed);
+    }
+    mean /= events.length;
+    stdev = Math.sqrt(stdev / events.length - mean * mean);
+    return { mean, stdev, minimum, maximum };
+  };
+}
+
+interface IFunction<Parameters extends any[]> {
+  key: string;
+  value: (...args: Parameters) => Promise<void>;
+}
+
+const iterate =
+  <Parameters extends any[]>(ctx: {
+    collection: IFunction<Parameters>[];
+    driver: Driver<IBenchmarkMaster>;
+    props: DynamicBenchmarker.IServantProps<Parameters>;
+  }) =>
+  async (path: string): Promise<void> => {
+    const directory: string[] = await fs.promises.readdir(path);
+    for (const file of directory) {
+      const location: string = `${path}/${file}`;
+      const stat: fs.Stats = await fs.promises.stat(location);
+      if (stat.isDirectory() === true) await iterate(ctx)(location);
+      else if (file.endsWith(".js") === true) {
+        const modulo = await import(location);
+        for (const [key, value] of Object.entries(modulo)) {
+          if (typeof value !== "function") continue;
+          else if (key.startsWith(ctx.props.prefix) === false) continue;
+          else if ((await ctx.driver.filter(key)) === false) continue;
+          ctx.collection.push({
+            key,
+            value: value as (...args: Parameters) => Promise<any>,
+          });
+        }
+      }
+    }
+  };

package/src/GaffComparator.ts

@@ -1,69 +1,69 @@
-/**
- * Gaff comparator.
- *
- * `GaffComparator` is a set of comparator functions for `Array.sort()` function,
- * which can be used with {@link TestValidator.sort} function. If you want to see
- * how to use them, see the below example link.
- *
- * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_sort.ts
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace GaffComparator {
-  /**
-   * String(s) comparator.
-   *
-   * @param getter Getter of string(s) from input
-   * @returns Comparator function
-   */
-  export const strings =
-    <T>(getter: (input: T) => string | string[]) =>
-    (x: T, y: T) => {
-      const a: string[] = wrap(getter(x));
-      const b: string[] = wrap(getter(y));
-
-      const idx: number = a.findIndex((v, i) => v !== b[i]);
-      return idx !== -1 ? compare(a[idx], b[idx]) : 0;
-    };
-
-  /**
-   * Date(s) comparator.
-   *
-   * @param getter Getter of date(s) from input
-   * @returns Comparator function
-   */
-  export const dates =
-    <T>(getter: (input: T) => string | string[]) =>
-    (x: T, y: T) => {
-      const take = (v: T) =>
-        wrap(getter(v)).map((str) => new Date(str).getTime());
-      const a: number[] = take(x);
-      const b: number[] = take(y);
-
-      const idx: number = a.findIndex((v, i) => v !== b[i]);
-      return idx !== -1 ? a[idx] - b[idx] : 0;
-    };
-
-  /**
-   * Number(s) comparator.
-   *
-   * @param closure Getter of number(s) from input
-   * @returns Comparator function
-   */
-  export const numbers =
-    <T>(closure: (input: T) => number | number[]) =>
-    (x: T, y: T) => {
-      const a: number[] = wrap(closure(x));
-      const b: number[] = wrap(closure(y));
-
-      const idx: number = a.findIndex((v, i) => v !== b[i]);
-      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];
-  }
-}
+/**
+ * Gaff comparator.
+ *
+ * `GaffComparator` is a set of comparator functions for `Array.sort()` function,
+ * which can be used with {@link TestValidator.sort} function. If you want to see
+ * how to use them, see the below example link.
+ *
+ * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_sort.ts
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace GaffComparator {
+  /**
+   * String(s) comparator.
+   *
+   * @param getter Getter of string(s) from input
+   * @returns Comparator function
+   */
+  export const strings =
+    <T>(getter: (input: T) => string | string[]) =>
+    (x: T, y: T) => {
+      const a: string[] = wrap(getter(x));
+      const b: string[] = wrap(getter(y));
+
+      const idx: number = a.findIndex((v, i) => v !== b[i]);
+      return idx !== -1 ? compare(a[idx], b[idx]) : 0;
+    };
+
+  /**
+   * Date(s) comparator.
+   *
+   * @param getter Getter of date(s) from input
+   * @returns Comparator function
+   */
+  export const dates =
+    <T>(getter: (input: T) => string | string[]) =>
+    (x: T, y: T) => {
+      const take = (v: T) =>
+        wrap(getter(v)).map((str) => new Date(str).getTime());
+      const a: number[] = take(x);
+      const b: number[] = take(y);
+
+      const idx: number = a.findIndex((v, i) => v !== b[i]);
+      return idx !== -1 ? a[idx] - b[idx] : 0;
+    };
+
+  /**
+   * Number(s) comparator.
+   *
+   * @param closure Getter of number(s) from input
+   * @returns Comparator function
+   */
+  export const numbers =
+    <T>(closure: (input: T) => number | number[]) =>
+    (x: T, y: T) => {
+      const a: number[] = wrap(closure(x));
+      const b: number[] = wrap(closure(y));
+
+      const idx: number = a.findIndex((v, i) => v !== b[i]);
+      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];
+  }
+}