@nestia/e2e 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# Nestia E2E Helper
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/nestia/blob/master/LICENSE)
+[![npm version](https://img.shields.io/npm/v/@nestia/e2e.svg)](https://www.npmjs.com/package/@nestia/e2e)
+[![Downloads](https://img.shields.io/npm/dm/@nestia/e2e.svg)](https://www.npmjs.com/package/@nestia/e2e)
+[![Build Status](https://github.com/samchon/typia/workflows/build/badge.svg)](https://github.com/samchon/nestia/actions?query=workflow%3Abuild)
+[![Guide Documents](https://img.shields.io/badge/wiki-documentation-forestgreen)](https://github.com/samchon/nestia/wiki)
+
+Helper library for E2E testing in NestJS.
+
+With `@nestia/e2e`, you can easily validate your NestJS server through E2E testing.
+
+```typescript
+import typia from "typia";
+import { 
+    ArrayUtil, 
+    GaffComparator, 
+    RandomGenerator, 
+    TestValidator 
+} from "@nestia/e2e";
+
+import api from "@samchon/bbs-api/lib/index";
+import { IBbsArticle } from "@samchon/bbs-api/lib/structures/bbs/IBbsArticle";
+
+export async function test_api_bbs_article_index_sort(
+    connection: api.IConnection,
+): Promise<void> {
+    // GENERATE 100 ARTICLES
+    const section: string = "general";
+    const articles: IBbsArticle[] = await ArrayUtil.asyncRepeat(100, () =>
+        api.functional.bbs.articles.store(connection, section, {
+            writer: RandomGenerator.name(),
+            title: RandomGenerator.paragraph(),
+            body: RandomGenerator.content(),
+            format: "txt",
+            files: [],
+            password: RandomGenerator.alphabets(8),
+        }),
+    );
+    typia.assertEquals(articles);
+
+    // PREPARE VALIDATOR
+    const validator = validate_index_sort("BbsArticleProvider.idex()")(
+        (input: IBbsArticle.IRequest) =>
+            api.functional.bbs.articles.index(connection, section, input),
+    );
+
+    // DO VALIDATE
+    const components = [
+        validator("created_at")(GaffComparator.dates((x) => x.created_at)),
+        validator("updated_at")(GaffComparator.dates((x) => x.updated_at)),
+        validator("title")(GaffComparator.strings((x) => x.title)),
+        validator("writer")(GaffComparator.strings((x) => x.writer)),
+        validator(
+            "writer",
+            "title",
+        )(GaffComparator.strings((x) => [x.writer, x.title])),
+    ];
+    for (const comp of components) {
+        await comp("+");
+        await comp("-");
+    }
+}
+```
+
+
+
+
+## Setup
+```bash
+npm install --save-dev @nestia/e2e
+```
+
+Just setup with npm command, that's all.
+
+For referece, due to test program would not be published, I rcommend to install as `dev` mode.
+
+
+
+
+## Features
+About supported features, read descriptive comments of below:
+
+  - [`ArrayUtil`](https://github.com/samchon/nestia/tree/master/packages/e2e/src/ArrayUtil.ts)
+  - [`GaffComparator`](https://github.com/samchon/nestia/tree/master/packages/e2e/src/GaffComparator.ts)
+  - [`RandomGenerator`](https://github.com/samchon/nestia/tree/master/packages/e2e/src/RandomGenerator.ts)
+  - [`StopWatch`](https://github.com/samchon/nestia/tree/master/packages/e2e/src/StopWatch.ts)
+  - [`TestValidator`](https://github.com/samchon/nestia/tree/master/packages/e2e/src/TestValidator.ts)

package/lib/ArrayUtil.d.ts

@@ -0,0 +1,11 @@
+export declare namespace ArrayUtil {
+    function at<T>(array: T[], index: number): T;
+    function asyncFilter<Input>(elements: readonly Input[], pred: (elem: Input, index: number, array: readonly Input[]) => Promise<boolean>): Promise<Input[]>;
+    function asyncForEach<Input>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<any>): Promise<void>;
+    function asyncMap<Input, Output>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<Output>): Promise<Output[]>;
+    function asyncRepeat<T>(count: number, closure: (index: number) => Promise<T>): Promise<T[]>;
+    function has<T>(elements: readonly T[], pred: (elem: T) => boolean): boolean;
+    function repeat<T>(count: number, closure: (index: number) => T): T[];
+    function last<T>(array: T[]): T;
+    function flat<T>(matrix: T[][]): T[];
+}

package/lib/ArrayUtil.js

@@ -0,0 +1,216 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayUtil = void 0;
+var ArrayUtil;
+(function (ArrayUtil) {
+    function at(array, index) {
+        return array[index < 0 ? array.length + index : index];
+    }
+    ArrayUtil.at = at;
+    function asyncFilter(elements, pred) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ret;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ret = [];
+                        return [4 /*yield*/, asyncForEach(elements, function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
+                                var flag;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, pred(elem, index, array)];
+                                        case 1:
+                                            flag = _a.sent();
+                                            if (flag === true)
+                                                ret.push(elem);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    }
+    ArrayUtil.asyncFilter = asyncFilter;
+    function asyncForEach(elements, closure) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, asyncRepeat(elements.length, function (index) {
+                            return closure(elements[index], index, elements);
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    ArrayUtil.asyncForEach = asyncForEach;
+    function asyncMap(elements, closure) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ret;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ret = [];
+                        return [4 /*yield*/, asyncForEach(elements, function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
+                                var output;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, closure(elem, index, array)];
+                                        case 1:
+                                            output = _a.sent();
+                                            ret.push(output);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    }
+    ArrayUtil.asyncMap = asyncMap;
+    function asyncRepeat(count, closure) {
+        return __awaiter(this, void 0, void 0, function () {
+            var indexes, output, indexes_1, indexes_1_1, index, _a, _b, e_1_1;
+            var e_1, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        indexes = new Array(count)
+                            .fill(1)
+                            .map(function (_, index) { return index; });
+                        output = [];
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!indexes_1_1.done) return [3 /*break*/, 5];
+                        index = indexes_1_1.value;
+                        _b = (_a = output).push;
+                        return [4 /*yield*/, closure(index)];
+                    case 3:
+                        _b.apply(_a, [_d.sent()]);
+                        _d.label = 4;
+                    case 4:
+                        indexes_1_1 = indexes_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (indexes_1_1 && !indexes_1_1.done && (_c = indexes_1.return)) _c.call(indexes_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/, output];
+                }
+            });
+        });
+    }
+    ArrayUtil.asyncRepeat = asyncRepeat;
+    function has(elements, pred) {
+        return elements.find(pred) !== undefined;
+    }
+    ArrayUtil.has = has;
+    function repeat(count, closure) {
+        return new Array(count).fill("").map(function (_, index) { return closure(index); });
+    }
+    ArrayUtil.repeat = repeat;
+    function last(array) {
+        return array[array.length - 1];
+    }
+    ArrayUtil.last = last;
+    function flat(matrix) {
+        var _a;
+        return (_a = []).concat.apply(_a, __spreadArray([], __read(matrix), false));
+    }
+    ArrayUtil.flat = flat;
+})(ArrayUtil = exports.ArrayUtil || (exports.ArrayUtil = {}));
+//# sourceMappingURL=ArrayUtil.js.map

package/lib/ArrayUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayUtil.js","sourceRoot":"","sources":["../src/ArrayUtil.ts"],"names":[],"mappings":"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"}

package/lib/DynamicExecutor.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 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 declare namespace DynamicExecutor {
+    /**
+     * Function type of a prefixed.
+     *
+     * @template Arguments Type of parameters
+     * @template Ret Type of return value
+     */
+    interface Closure<Arguments extends any[], Ret = any> {
+        (...args: Arguments): Promise<Ret>;
+    }
+    /**
+     * Options for dynamic executor.
+     */
+    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.
+     */
+    interface IReport {
+        /**
+         * Location path of dynamic functions.
+         */
+        location: string;
+        /**
+         * Execution results of dynamic functions.
+         */
+        executions: IReport.IExecution[];
+        /**
+         * Total elapsed time.
+         */
+        time: number;
+    }
+    namespace IReport {
+        /**
+         * Execution result of a dynamic function.
+         */
+        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
+     */
+    const assert: <Arguments extends any[]>(options: IOptions<Arguments, any>) => (path: string) => Promise<IReport>;
+    /**
+     * 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
+     */
+    const validate: <Arguments extends any[]>(options: IOptions<Arguments, any>) => (path: string) => Promise<IReport>;
+}