@nestia/e2e 0.4.0 → 0.4.2

package/src/DynamicExecutor.ts

@@ -18,266 +18,260 @@ import { StopWatch } from "./StopWatch";
  * @author Jeongho Nam - https://github.com/samchon
  */
 export namespace DynamicExecutor {
+  /**
+   * Function type of a prefixed.
+   *
+   * @template Arguments Type of parameters
+   * @template Ret Type of return value
+   */
+  export interface Closure<Arguments extends any[], Ret = any> {
+    (...args: Arguments): Promise<Ret>;
+  }
+
+  /**
+   * Options for dynamic executor.
+   */
+  export interface IOptions<Parameters extends any[], Ret = any> {
     /**
-     * Function type of a prefixed.
+     * Prefix of function name.
+     *
+     * Every prefixed function will be executed.
      *
-     * @template Arguments Type of parameters
-     * @template Ret Type of return value
+     * In other words, if a function name doesn't start with the prefix, then it would never be executed.
      */
-    export interface Closure<Arguments extends any[], Ret = any> {
-        (...args: Arguments): Promise<Ret>;
-    }
+    prefix: string;
 
     /**
-     * Options for dynamic executor.
+     * Get parameters of a function.
+     *
+     * @param name Function name
+     * @returns Parameters
      */
-    export interface IOptions<Parameters extends any[], Ret = any> {
-        /**
-         * Prefix of function name.
-         *
-         * Every prefixed function will be executed.
-         *
-         * 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.
-         *
-         * @param name Function name
-         * @returns Parameters
-         */
-        parameters: (name: string) => Parameters;
+    parameters: (name: string) => Parameters;
 
-        /**
-         * Filter function whether to run or not.
-         *
-         * @param name Function name
-         * @returns Whether to run or not
-         */
-        filter?: (name: string) => boolean;
+    /**
+     * Filter function whether to run or not.
+     *
+     * @param name Function name
+     * @returns Whether to run or not
+     */
+    filter?: (name: string) => boolean;
 
-        /**
-         * Wrapper of test function.
-         *
-         * If you specify this `wrapper` property,  every dynamic functions
-         * loaded and called by this `DynamicExecutor` would be wrapped by
-         * the `wrapper` function.
-         *
-         * @param name Function name
-         * @param closure Function to be executed
-         * @returns Wrapper function
-         */
-        wrapper?: (
-            name: string,
-            closure: Closure<Parameters, Ret>,
-        ) => Promise<any>;
+    /**
+     * Wrapper of test function.
+     *
+     * If you specify this `wrapper` property,  every dynamic functions
+     * loaded and called by this `DynamicExecutor` would be wrapped by
+     * the `wrapper` function.
+     *
+     * @param name Function name
+     * @param closure Function to be executed
+     * @param parameters Parameters, result of options.parameters function.
+     * @returns Wrapper function
+     */
+    wrapper?: (
+      name: string,
+      closure: Closure<Parameters, Ret>,
+      paramters: Parameters,
+    ) => Promise<any>;
 
-        /**
-         * Whether to show elapsed time on `console` or not.
-         *
-         * @default true
-         */
-        showElapsedTime?: boolean;
+    /**
+     * Whether to show elapsed time on `console` or not.
+     *
+     * @default true
+     */
+    showElapsedTime?: boolean;
 
-        /**
-         * Extension of dynamic functions.
-         *
-         * @default js
-         */
-        extension?: string;
-    }
+    /**
+     * Extension of dynamic functions.
+     *
+     * @default js
+     */
+    extension?: string;
+  }
 
+  /**
+   * Report, result of dynamic execution.
+   */
+  export interface IReport {
     /**
-     * Report, result of dynamic execution.
+     * Location path of dynamic functions.
      */
-    export interface IReport {
-        /**
-         * Location path of dynamic functions.
-         */
-        location: string;
+    location: string;
 
-        /**
-         * Execution results of dynamic functions.
-         */
-        executions: IReport.IExecution[];
+    /**
+     * Execution results of dynamic functions.
+     */
+    executions: IReport.IExecution[];
 
-        /**
-         * Total elapsed time.
-         */
-        time: number;
-    }
-    export namespace IReport {
-        /**
-         * Execution result of a dynamic function.
-         */
-        export interface IExecution {
-            /**
-             * Name of function.
-             */
-            name: string;
+    /**
+     * Total elapsed time.
+     */
+    time: number;
+  }
+  export namespace IReport {
+    /**
+     * Execution result of a dynamic function.
+     */
+    export interface IExecution {
+      /**
+       * Name of function.
+       */
+      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.
+       */
+      time: number;
     }
+  }
 
+  /**
+   * Prepare dynamic executor in strict mode.
+   *
+   * In strict mode, if any error occurs, the program will be terminated directly.
+   * 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
+   */
+  export const assert =
+    <Arguments extends any[]>(options: IOptions<Arguments>) =>
     /**
-     * Prepare dynamic executor in strict mode.
-     *
-     * In strict mode, if any error occurs, the program will be terminated directly.
-     * Otherwise, {@link validate} mode does not terminate when error occurs, but
-     * just archive the error log.
+     * Run dynamic executor.
      *
-     * @param options Options of dynamic executor
-     * @returns Runner of dynamic functions with specific location
+     * @param path Location of prefixed functions
      */
-    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);
+    (path: string): Promise<IReport> =>
+      main(options)(true)(path);
 
+  /**
+   * Prepare dynamic executor in loose mode.
+   *
+   * In loose mode, the program would not be terminated even when error occurs.
+   * 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
+   */
+  export const validate =
+    <Arguments extends any[]>(options: IOptions<Arguments>) =>
     /**
-     * Prepare dynamic executor in loose mode.
+     * Run dynamic executor.
      *
-     * In loose mode, the program would not be terminated even when error occurs.
-     * 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 path Location of prefix functions
+     * @returns List of errors
      */
-    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);
+    (path: string): Promise<IReport> =>
+      main(options)(false)(path);
 
-    const main =
-        <Arguments extends any[]>(options: IOptions<Arguments>) =>
-        (assert: boolean) =>
-        async (path: string) => {
-            const report: IReport = {
-                location: path,
-                time: Date.now(),
-                executions: [],
-            };
+  const main =
+    <Arguments extends any[]>(options: IOptions<Arguments>) =>
+    (assert: boolean) =>
+    async (path: string) => {
+      const report: IReport = {
+        location: path,
+        time: Date.now(),
+        executions: [],
+      };
 
-            const executor = execute(options)(report)(assert);
-            const iterator = iterate(options.extension ?? "js")(executor);
-            await iterator(path);
+      const executor = execute(options)(report)(assert);
+      const iterator = iterate(options.extension ?? "js")(executor);
+      await iterator(path);
 
-            report.time = Date.now() - report.time;
-            return report;
-        };
+      report.time = Date.now() - report.time;
+      return report;
+    };
 
-    const iterate =
-        (extension: string) =>
-        <Arguments extends any[]>(
-            executor: (
-                path: string,
-                modulo: Module<Arguments>,
-            ) => Promise<void>,
-        ) => {
-            const visitor = async (path: string): Promise<void> => {
-                const directory: string[] = await fs.promises.readdir(path);
-                for (const file of directory) {
-                    const location: string = NodePath.resolve(
-                        `${path}/${file}`,
-                    );
-                    const stats: fs.Stats = await fs.promises.lstat(location);
+  const iterate =
+    (extension: string) =>
+    <Arguments extends any[]>(
+      executor: (path: string, modulo: Module<Arguments>) => Promise<void>,
+    ) => {
+      const visitor = async (path: string): Promise<void> => {
+        const directory: string[] = await fs.promises.readdir(path);
+        for (const file of directory) {
+          const location: string = NodePath.resolve(`${path}/${file}`);
+          const stats: fs.Stats = await fs.promises.lstat(location);
 
-                    if (stats.isDirectory() === true) {
-                        await visitor(location);
-                        continue;
-                    } else if (file.substr(-3) !== `.${extension}`) continue;
+          if (stats.isDirectory() === true) {
+            await visitor(location);
+            continue;
+          } else if (file.substr(-3) !== `.${extension}`) continue;
 
-                    const modulo: Module<Arguments> = await import(location);
-                    await executor(location, modulo);
-                }
-            };
-            return visitor;
-        };
+          const modulo: Module<Arguments> = await import(location);
+          await executor(location, modulo);
+        }
+      };
+      return visitor;
+    };
 
-    const execute =
-        <Arguments extends any[]>(options: IOptions<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 ||
-                    typeof closure !== "function" ||
-                    (options.filter && options.filter(key) === false)
-                )
-                    continue;
+  const execute =
+    <Arguments extends any[]>(options: IOptions<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 ||
+          typeof closure !== "function" ||
+          (options.filter && options.filter(key) === false)
+        )
+          continue;
 
-                const func = async () => {
-                    if (options.wrapper !== undefined)
-                        await options.wrapper(key, closure);
-                    else await closure(...options.parameters(key));
-                };
-                const label: string = chalk.greenBright(key);
+        const func = async () => {
+          if (options.wrapper !== undefined)
+            await options.wrapper(key, closure, options.parameters(key));
+          else await closure(...options.parameters(key));
+        };
+        const label: string = chalk.greenBright(key);
 
-                const result: IReport.IExecution = {
-                    name: key,
-                    location,
-                    error: null,
-                    time: Date.now(),
-                };
-                report.executions.push(result);
+        const result: IReport.IExecution = {
+          name: key,
+          location,
+          error: null,
+          time: Date.now(),
+        };
+        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`,
-                        );
-                    }
-                } catch (exp) {
-                    result.time = Date.now() - result.time;
-                    result.error = exp as Error;
+        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`,
+            );
+          }
+        } 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;
-                }
-            }
-        };
+          console.log(
+            `  - ${label} -> ${chalk.redBright((exp as Error)?.name)}`,
+          );
+          if (assert === true) throw exp;
+        }
+      }
+    };
 
-    interface Module<Arguments extends any[]> {
-        [key: string]: Closure<Arguments>;
-    }
+  interface Module<Arguments extends any[]> {
+    [key: string]: Closure<Arguments>;
+  }
 }

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];
+  }
+}