@nestia/e2e 0.1.0 → 0.1.1

package/src/DynamicExecutor.ts

@@ -1,270 +1,270 @@
-import chalk from "chalk";
-import cli from "cli";
-import fs from "fs";
-import NodePath from "path";
-
-import { StopWatch } from "./StopWatch";
-
-/**
- * Dynamic Executor running prefixed functions.
- *
- * `DynamicExecutor` runs every prefixed functions in a specific directory.
- * However, if you want to run only specific functions, you can use
- * `--include` or `--exclude` option in the CLI (Command Line Interface) level.
- *
- * When you want to see example utilization cases, see the below example links.
- *
- * @example https://github.com/samchon/backend/blob/master/src/test/index.ts
- * @example https://github.com/samchon/nestia-template/blob/master/src/test/index.ts
- * @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> {
-        /**
-         * 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;
-
-        /**
-         * 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>;
-
-        /**
-         * Whether to show elapsed time on `console` or not.
-         *
-         * @default true
-         */
-        showElapsedTime?: boolean;
-    }
-
-    /**
-     * Report, result of dynamic execution.
-     */
-    export interface IReport {
-        /**
-         * Location path of dynamic functions.
-         */
-        location: string;
-
-        /**
-         * 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;
-
-            /**
-             * Location path of the function.
-             */
-            location: string;
-
-            /**
-             * Error when occured.
-             */
-            error: Error | null;
-
-            /**
-             * 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>) =>
-        /**
-         * Run dynamic executor.
-         *
-         * @param path Location of prefixed functions
-         */
-        (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>) =>
-        /**
-         * Run dynamic executor.
-         *
-         * @param path Location of prefix functions
-         * @returns List of errors
-         */
-        (path: string): Promise<IReport> =>
-            main(options)(false)(path);
-
-    const main =
-        <Arguments extends any[]>(options: IOptions<Arguments>) =>
-        (assert: boolean) =>
-        async (path: string) => {
-            const command: ICommand = cli.parse();
-            const report: IReport = {
-                location: path,
-                time: Date.now(),
-                executions: [],
-            };
-
-            const executor = execute(options)(command)(report)(assert);
-            const iterator = iterate(executor);
-            await iterator(path);
-
-            report.time = Date.now() - report.time;
-            return report;
-        };
-
-    const iterate = <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;
-
-                const modulo: Module<Arguments> = await import(location);
-                await executor(location, modulo);
-            }
-        };
-        return visitor;
-    };
-
-    const execute =
-        <Arguments extends any[]>(options: IOptions<Arguments>) =>
-        (command: ICommand) =>
-        (report: IReport) =>
-        (assert: boolean) =>
-        async (location: string, modulo: Module<Arguments>): Promise<void> => {
-            for (const key in modulo) {
-                if (command.exclude && key.indexOf(command.exclude) !== -1)
-                    continue;
-                else if (command.include && key.indexOf(command.include) === -1)
-                    continue;
-                else if (
-                    key.substring(0, options.prefix.length) !== options.prefix
-                )
-                    continue;
-                else if (!(modulo[key] instanceof Function)) continue;
-
-                const closure: Closure<Arguments> = modulo[key];
-                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 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);
-                        console.log(
-                            `  - ${label}: ${chalk.yellowBright(
-                                result.time.toLocaleString(),
-                            )} ms`,
-                        );
-                    }
-                } catch (exp) {
-                    if (!(exp instanceof Error)) return;
-
-                    result.time = Date.now() - result.time;
-                    result.error = exp;
-
-                    console.log(`  - ${label} -> ${chalk.redBright(exp.name)}`);
-                    if (assert === true) throw exp;
-                }
-            }
-        };
-
-    interface ICommand {
-        include?: string;
-        exclude?: string;
-    }
-    interface Module<Arguments extends any[]> {
-        [key: string]: Closure<Arguments>;
-    }
-    const EXTENSION: string = __filename.substring(__filename.length - 2);
-}
+import chalk from "chalk";
+import cli from "cli";
+import fs from "fs";
+import NodePath from "path";
+
+import { StopWatch } from "./StopWatch";
+
+/**
+ * Dynamic Executor running prefixed functions.
+ *
+ * `DynamicExecutor` runs every prefixed functions in a specific directory.
+ * However, if you want to run only specific functions, you can use
+ * `--include` or `--exclude` option in the CLI (Command Line Interface) level.
+ *
+ * When you want to see example utilization cases, see the below example links.
+ *
+ * @example https://github.com/samchon/nestia-template/blob/master/src/test/index.ts
+ * @example https://github.com/samchon/backend/blob/master/src/test/index.ts
+ * @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> {
+        /**
+         * 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;
+
+        /**
+         * 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>;
+
+        /**
+         * Whether to show elapsed time on `console` or not.
+         *
+         * @default true
+         */
+        showElapsedTime?: boolean;
+    }
+
+    /**
+     * Report, result of dynamic execution.
+     */
+    export interface IReport {
+        /**
+         * Location path of dynamic functions.
+         */
+        location: string;
+
+        /**
+         * 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;
+
+            /**
+             * Location path of the function.
+             */
+            location: string;
+
+            /**
+             * Error when occured.
+             */
+            error: Error | null;
+
+            /**
+             * 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>) =>
+        /**
+         * Run dynamic executor.
+         *
+         * @param path Location of prefixed functions
+         */
+        (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>) =>
+        /**
+         * Run dynamic executor.
+         *
+         * @param path Location of prefix functions
+         * @returns List of errors
+         */
+        (path: string): Promise<IReport> =>
+            main(options)(false)(path);
+
+    const main =
+        <Arguments extends any[]>(options: IOptions<Arguments>) =>
+        (assert: boolean) =>
+        async (path: string) => {
+            const command: ICommand = cli.parse();
+            const report: IReport = {
+                location: path,
+                time: Date.now(),
+                executions: [],
+            };
+
+            const executor = execute(options)(command)(report)(assert);
+            const iterator = iterate(executor);
+            await iterator(path);
+
+            report.time = Date.now() - report.time;
+            return report;
+        };
+
+    const iterate = <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;
+
+                const modulo: Module<Arguments> = await import(location);
+                await executor(location, modulo);
+            }
+        };
+        return visitor;
+    };
+
+    const execute =
+        <Arguments extends any[]>(options: IOptions<Arguments>) =>
+        (command: ICommand) =>
+        (report: IReport) =>
+        (assert: boolean) =>
+        async (location: string, modulo: Module<Arguments>): Promise<void> => {
+            for (const key in modulo) {
+                if (command.exclude && key.indexOf(command.exclude) !== -1)
+                    continue;
+                else if (command.include && key.indexOf(command.include) === -1)
+                    continue;
+                else if (
+                    key.substring(0, options.prefix.length) !== options.prefix
+                )
+                    continue;
+                else if (!(modulo[key] instanceof Function)) continue;
+
+                const closure: Closure<Arguments> = modulo[key];
+                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 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);
+                        console.log(
+                            `  - ${label}: ${chalk.yellowBright(
+                                result.time.toLocaleString(),
+                            )} ms`,
+                        );
+                    }
+                } catch (exp) {
+                    if (!(exp instanceof Error)) return;
+
+                    result.time = Date.now() - result.time;
+                    result.error = exp;
+
+                    console.log(`  - ${label} -> ${chalk.redBright(exp.name)}`);
+                    if (assert === true) throw exp;
+                }
+            }
+        };
+
+    interface ICommand {
+        include?: string;
+        exclude?: string;
+    }
+    interface Module<Arguments extends any[]> {
+        [key: string]: Closure<Arguments>;
+    }
+    const EXTENSION: string = __filename.substring(__filename.length - 2);
+}