@nestia/e2e 0.1.0

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@nestia/e2e",
+  "version": "0.1.0",
+  "description": "E2E test utilify functions",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "rimraf lib && tsc",
+    "dev": "npm run build -- --watch",
+    "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://github.com/samchon/nestia#readme",
+  "devDependencies": {
+    "@types/cli": "^0.11.21",
+    "@types/node": "^18.11.18",
+    "rimraf": "^4.1.2",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli": "^1.0.1",
+    "tstl": "^2.5.13"
+  },
+  "files": [
+    "lib",
+    "src",
+    "!lib/test",
+    "!src/test",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ]
+}

package/src/ArrayUtil.ts

@@ -0,0 +1,86 @@
+export namespace ArrayUtil {
+    export function at<T>(array: T[], index: number): T {
+        return array[index < 0 ? array.length + index : index];
+    }
+
+    export async function asyncFilter<Input>(
+        elements: readonly Input[],
+        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 async function asyncForEach<Input>(
+        elements: readonly Input[],
+        closure: (
+            elem: Input,
+            index: number,
+            array: readonly Input[],
+        ) => Promise<any>,
+    ): Promise<void> {
+        await asyncRepeat(elements.length, (index) =>
+            closure(elements[index], index, elements),
+        );
+    }
+
+    export async function asyncMap<Input, Output>(
+        elements: readonly Input[],
+        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 async function asyncRepeat<T>(
+        count: number,
+        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 function has<T>(
+        elements: readonly T[],
+        pred: (elem: T) => boolean,
+    ): boolean {
+        return elements.find(pred) !== undefined;
+    }
+
+    export function repeat<T>(
+        count: number,
+        closure: (index: number) => T,
+    ): T[] {
+        return new Array(count).fill("").map((_, index) => closure(index));
+    }
+
+    export function last<T>(array: T[]): T {
+        return array[array.length - 1];
+    }
+
+    export function flat<T>(matrix: T[][]): T[] {
+        return ([] as T[]).concat(...matrix);
+    }
+}

package/src/DynamicExecutor.ts

@@ -0,0 +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);
+}

package/src/GaffComparator.ts

@@ -0,0 +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[0].localeCompare(y[0]);
+    }
+
+    function wrap<T>(elem: T | T[]): T[] {
+        return Array.isArray(elem) ? elem : [elem];
+    }
+}

package/src/RandomGenerator.ts

@@ -0,0 +1,178 @@
+import { back_inserter, randint } from "tstl";
+import { sample as _Sample } from "tstl/ranges";
+
+/**
+ * Random data generator.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace RandomGenerator {
+    /* ----------------------------------------------------------------
+        IDENTIFICATIONS
+    ---------------------------------------------------------------- */
+    const CHARACTERS = "abcdefghijklmnopqrstuvwxyz";
+    const LETTERS: string = "0123456789" + CHARACTERS;
+
+    /**
+     * Generate random alphabets
+     *
+     * @param length Length of alphabets
+     * @returns Generated alphabets
+     */
+    export function alphabets(length: number): string {
+        return new Array(length)
+            .fill("")
+            .map(() => CHARACTERS[randint(0, CHARACTERS.length - 1)])
+            .join("");
+    }
+
+    /**
+     * Generate random alpha-numeric characters.
+     *
+     * Generate random string constructed with only alphabets and numbers.
+     *
+     * @param length Length of characters
+     * @returns Generated string
+     */
+    export function alphaNumeric(length: number): string {
+        return new Array(length)
+            .fill("")
+            .map(() => LETTERS[randint(0, LETTERS.length - 1)])
+            .join("");
+    }
+
+    /**
+     * Generate random name.
+     *
+     * @param length Length of paragraph, default is 2 or 3
+     * @returns Generated name
+     */
+    export function name(length: number = randint(2, 3)): string {
+        return paragraph(length)();
+    }
+
+    /**
+     * Generate random paragraph.
+     *
+     * @param sentences Number of sentences
+     * @returns Paragraph generator
+     */
+    export const paragraph =
+        (sentences: number) =>
+        /**
+         * @param wordMin Minimum number of characters in a sentence
+         * @param wordMax Maximum number of characters in a sentence
+         * @returns Generated paragraph
+         */
+        (wordMin: number = 3, wordMax: number = 7): string =>
+            new Array(sentences)
+                .fill("")
+                .map(() => alphabets(randint(wordMin, wordMax)))
+                .join(" ");
+
+    /**
+     * Generate random content.
+     *
+     * @param paragraphes Number of paragraphes
+     * @returns Currying function
+     */
+    export const content =
+        (paragraphes: number) =>
+        /**
+         * @param sentenceMin Minimum number of sentences in a paragraph
+         * @param sentenceMax Maximum number of sentences in a paragraph
+         * @returns Currying function
+         */
+        (sentenceMin: number = 10, sentenceMax: number = 40) =>
+        /**
+         * @param wordMin Minimum number of characters in a sentence
+         * @param wordMax Maximum number of characters in a sentence
+         * @returns Content generator
+         */
+        (wordMin: number = 1, wordMax: number = 7): string =>
+            new Array(paragraphes)
+                .fill("")
+                .map(() =>
+                    paragraph(randint(sentenceMin, sentenceMax))(
+                        wordMin,
+                        wordMax,
+                    ),
+                )
+                .join("\n\n");
+
+    /**
+     * Generate random substring.
+     *
+     * @param content Target content
+     * @returns Random substring
+     */
+    export function substring(content: string): string {
+        const first: number = randint(0, content.length - 1);
+        const last: number = randint(first + 1, content.length);
+
+        return content.substring(first, last).trim();
+    }
+
+    /**
+     * Generate random mobile number.
+     *
+     * @param prefix Prefix string, default is "010"
+     * @returns Random mobile number
+     */
+    export function mobile(prefix: string = "010"): string {
+        return `${prefix}${digit(3, 4)}${digit(4, 4)}`;
+    }
+
+    /**
+     * Generate random digit.
+     *
+     * Generate random digit that filling front with zero characters
+     * when value is less than maximum cipher.
+     *
+     * @param minC Minimum cipher
+     * @param maxC Maximum cipher
+     * @returns
+     */
+    export function digit(minC: number, maxC: number): string {
+        const val: number = randint(0, Math.pow(10.0, maxC) - 1);
+        const log10: number = val ? Math.floor(Math.log10(val)) + 1 : 0;
+        const prefix: string = "0".repeat(Math.max(0, minC - log10));
+
+        return prefix + val.toString();
+    }
+
+    /**
+     * Generate random date.
+     *
+     * @param from Start date
+     * @param range Range of random milliseconds
+     * @returns Random date
+     */
+    export function date(from: Date, range: number): Date {
+        const time: number = from.getTime() + randint(0, range);
+        return new Date(time);
+    }
+
+    /**
+     * Pick random elements from an array.
+     *
+     * @param array Target array
+     * @param count Number of count to pick
+     * @returns Sampled array
+     */
+    export function sample<T>(array: T[], count: number): T[] {
+        const ret: T[] = [];
+        _Sample(array, back_inserter(ret), count);
+        return ret;
+    }
+
+    /**
+     * Pick random element from an array.
+     *
+     * @param array Target array
+     * @returns picked element
+     */
+    export function pick<T>(array: T[]): T {
+        return array[randint(0, array.length - 1)];
+    }
+}

package/src/StopWatch.ts

@@ -0,0 +1,36 @@
+/**
+ * Elapsed time measurement utility.
+ *
+ * @author Sachon
+ */
+export namespace StopWatch {
+    /**
+     * Type of task.
+     */
+    export type Task = () => Promise<void>;
+
+    /**
+     *
+     * @param task
+     * @returns
+     */
+    export async function measure(task: Task): Promise<number> {
+        const time: number = Date.now();
+        await task();
+        return Date.now() - time;
+    }
+
+    /**
+     *
+     * @param title
+     * @param task
+     * @returns
+     */
+    export async function trace(title: string, task: Task): Promise<number> {
+        process.stdout.write(`  - ${title}: `);
+        const time: number = await measure(task);
+
+        console.log(`${time.toLocaleString()} ms`);
+        return time;
+    }
+}