@nestia/e2e 0.1.1 → 0.1.3

package/src/TestValidator.ts

@@ -1,145 +1,208 @@
-import { is_sorted } from "tstl/ranges";
-
-/**
- * Test validator.
- *
- * `TestValidator` is a collection gathering E2E validation functions.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace TestValidator {
-    /**
-     * Test whether error occurs.
-     *
-     * If error occurs, nothing would be happened.
-     *
-     * However, no error exists, then exception would be thrown.
-     *
-     * @param title Title of exception because of no error exists
-     */
-    export const error =
-        (title: string) =>
-        async (task: () => any | Promise<any>): Promise<void> => {
-            try {
-                await task();
-            } catch {
-                return;
-            }
-            throw new Error(`Bug on ${title}: exception must be thrown.`);
-        };
-
-    /**
-     * Validate index API.
-     *
-     * Test whether two indexed values are equal.
-     *
-     * If two values are different, then exception would be thrown.
-     *
-     * @param title Title of error message when different
-     * @return Currying function
-     *
-     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_search.ts
-     */
-    export const index =
-        (title: string) =>
-        <Solution extends IEntity<any>>(expected: Solution[]) =>
-        <Summary extends IEntity<any>>(
-            gotten: Summary[],
-            trace: boolean = true,
-        ): void => {
-            const length: number = Math.min(expected.length, gotten.length);
-            expected = expected.slice(0, length);
-            gotten = gotten.slice(0, length);
-
-            const xIds: string[] = get_ids(expected).slice(0, length);
-            const yIds: string[] = get_ids(gotten)
-                .filter((id) => id >= xIds[0])
-                .slice(0, length);
-
-            const equals: boolean = xIds.every((x, i) => x === yIds[i]);
-            if (equals === true) return;
-            else if (trace === true)
-                console.log({
-                    expected: xIds,
-                    gotten: yIds,
-                });
-            throw new Error(
-                `Bug on ${title}: result of the index is different with manual aggregation.`,
-            );
-        };
-
-    /**
-     * Validate sorting options.
-     *
-     * Test a pagination API supporting sorting options.
-     *
-     * You can validate detailed sorting options both asceding and descending orders
-     * with multiple fields. However, as it forms a complicate currying function,
-     * I recomend you to see below example code before using.
-     *
-     * @param title Title of error messaeg when sorting is invalid
-     *
-     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_sort.ts
-     */
-    export const sort =
-        (title: string) =>
-        /**
-         * @param getter A pagination API function to be called
-         */
-        <
-            T extends object,
-            Fields extends string,
-            Sortable extends Array<`-${Fields}` | `+${Fields}`>,
-        >(
-            getter: (sortable: Sortable) => Promise<T[]>,
-        ) =>
-        /**
-         * @param fields List of fields to be sorted
-         */
-        (...fields: Fields[]) =>
-        /**
-         * @param comp Comparator function for validation
-         * @param filter Filter function for data if required
-         */
-        (comp: (x: T, y: T) => number, filter?: (elem: T) => boolean) =>
-        /**
-         * @param direction "+" means ascending order, and "-" means descending order
-         */
-        async (direction: "+" | "-", trace: boolean = true) => {
-            let data: T[] = await getter(
-                fields.map(
-                    (field) => `${direction}${field}` as const,
-                ) as Sortable,
-            );
-            if (filter) data = data.filter(filter);
-
-            const reversed: typeof comp =
-                direction === "+" ? comp : (x, y) => comp(y, x);
-            if (is_sorted(data, (x, y) => reversed(x, y) < 0) === false) {
-                if (
-                    fields.length === 1 &&
-                    data.length &&
-                    (data as any)[0][fields[0]] !== undefined &&
-                    trace
-                )
-                    console.log(data.map((elem) => (elem as any)[fields[0]]));
-                throw new Error(
-                    `Bug on ${title}: wrong sorting on ${direction}(${fields.join(
-                        ", ",
-                    )}).`,
-                );
-            }
-        };
-
-    export type Sortable<Literal extends string> = Array<
-        `-${Literal}` | `+${Literal}`
-    >;
-}
-
-interface IEntity<Type extends string | number | bigint> {
-    id: Type;
-}
-
-function get_ids<Entity extends IEntity<any>>(entities: Entity[]): string[] {
-    return entities.map((entity) => entity.id).sort((x, y) => (x < y ? -1 : 1));
-}
+import { is_sorted } from "tstl/ranges";
+
+import { RandomGenerator } from "./RandomGenerator";
+
+/**
+ * Test validator.
+ *
+ * `TestValidator` is a collection gathering E2E validation functions.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace TestValidator {
+    /**
+     * Test whether error occurs.
+     *
+     * If error occurs, nothing would be happened.
+     *
+     * However, no error exists, then exception would be thrown.
+     *
+     * @param title Title of exception because of no error exists
+     */
+    export const error =
+        (title: string) =>
+        async (task: () => any | Promise<any>): Promise<void> => {
+            try {
+                await task();
+            } catch {
+                return;
+            }
+            throw new Error(`Bug on ${title}: exception must be thrown.`);
+        };
+
+    /**
+     * Validate index API.
+     *
+     * Test whether two indexed values are equal.
+     *
+     * If two values are different, then exception would be thrown.
+     *
+     * @param title Title of error message when different
+     * @return Currying function
+     *
+     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_search.ts
+     */
+    export const index =
+        (title: string) =>
+        <Solution extends IEntity<any>>(expected: Solution[]) =>
+        <Summary extends IEntity<any>>(
+            gotten: Summary[],
+            trace: boolean = true,
+        ): void => {
+            const length: number = Math.min(expected.length, gotten.length);
+            expected = expected.slice(0, length);
+            gotten = gotten.slice(0, length);
+
+            const xIds: string[] = get_ids(expected).slice(0, length);
+            const yIds: string[] = get_ids(gotten)
+                .filter((id) => id >= xIds[0])
+                .slice(0, length);
+
+            const equals: boolean = xIds.every((x, i) => x === yIds[i]);
+            if (equals === true) return;
+            else if (trace === true)
+                console.log({
+                    expected: xIds,
+                    gotten: yIds,
+                });
+            throw new Error(
+                `Bug on ${title}: result of the index is different with manual aggregation.`,
+            );
+        };
+
+    /**
+     * Valiate search options.
+     *
+     * Test a pagination API supporting search options.
+     *
+     * @param title Title of error message when searching is invalid
+     * @returns Currying function
+     *
+     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_search.ts
+     */
+    export const search =
+        (title: string) =>
+        /**
+         * @param getter A pagination API function to be called
+         * @param validator Validator function if required
+         */
+        <Entity extends IEntity<any>, Input>(
+            getter: (input: Input) => Promise<Entity[]>,
+            validator?: (data: Entity[]) => any,
+        ) =>
+        /**
+         * @param total Total entity records for comparison
+         * @param sampleCount Sampling count. Default is 1
+         */
+        (total: Entity[], sampleCount: number = 1) =>
+        /**
+         * @param props Search properties
+         */
+        async <Values extends any[]>(
+            props: ISearchProps<Entity, Values, Input>,
+        ) => {
+            const samples: Entity[] = RandomGenerator.sample(
+                total,
+                sampleCount,
+            );
+            for (const s of samples) {
+                const values: Values = props.values(s);
+                const filtered: Entity[] = total.filter((entity) =>
+                    props.filter(entity, values),
+                );
+                const gotten: Entity[] = await getter(props.search(values));
+                if (validator) validator(gotten);
+
+                TestValidator.index(`${title} (${props.fields.join(", ")})`)(
+                    filtered,
+                )(gotten);
+            }
+        };
+
+    export interface ISearchProps<
+        Entity extends IEntity<any>,
+        Values extends any[],
+        Input,
+    > {
+        fields: string[];
+        values(entity: Entity): Values;
+        filter(entity: Entity, values: Values): boolean;
+        search(values: Values): Input;
+    }
+
+    /**
+     * Validate sorting options.
+     *
+     * Test a pagination API supporting sorting options.
+     *
+     * You can validate detailed sorting options both asceding and descending orders
+     * with multiple fields. However, as it forms a complicate currying function,
+     * I recomend you to see below example code before using.
+     *
+     * @param title Title of error message when sorting is invalid
+     * @example https://github.com/samchon/nestia-template/blob/master/src/test/features/api/bbs/test_api_bbs_article_index_sort.ts
+     */
+    export const sort =
+        (title: string) =>
+        /**
+         * @param getter A pagination API function to be called
+         */
+        <
+            T extends object,
+            Fields extends string,
+            Sortable extends Array<`-${Fields}` | `+${Fields}`>,
+        >(
+            getter: (sortable: Sortable) => Promise<T[]>,
+            validator?: (data: T[]) => any,
+        ) =>
+        /**
+         * @param fields List of fields to be sorted
+         */
+        (...fields: Fields[]) =>
+        /**
+         * @param comp Comparator function for validation
+         * @param filter Filter function for data if required
+         */
+        (comp: (x: T, y: T) => number, filter?: (elem: T) => boolean) =>
+        /**
+         * @param direction "+" means ascending order, and "-" means descending order
+         */
+        async (direction: "+" | "-", trace: boolean = true) => {
+            let data: T[] = await getter(
+                fields.map(
+                    (field) => `${direction}${field}` as const,
+                ) as Sortable,
+            );
+            if (validator) validator(data);
+            if (filter) data = data.filter(filter);
+
+            const reversed: typeof comp =
+                direction === "+" ? comp : (x, y) => comp(y, x);
+            if (is_sorted(data, (x, y) => reversed(x, y) < 0) === false) {
+                if (
+                    fields.length === 1 &&
+                    data.length &&
+                    (data as any)[0][fields[0]] !== undefined &&
+                    trace
+                )
+                    console.log(data.map((elem) => (elem as any)[fields[0]]));
+                throw new Error(
+                    `Bug on ${title}: wrong sorting on ${direction}(${fields.join(
+                        ", ",
+                    )}).`,
+                );
+            }
+        };
+
+    export type Sortable<Literal extends string> = Array<
+        `-${Literal}` | `+${Literal}`
+    >;
+}
+
+interface IEntity<Type extends string | number | bigint> {
+    id: Type;
+}
+
+function get_ids<Entity extends IEntity<any>>(entities: Entity[]): string[] {
+    return entities.map((entity) => entity.id).sort((x, y) => (x < y ? -1 : 1));
+}

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as e2e from "./module";
-
-export default e2e;
-export * from "./module";
+import * as e2e from "./module";
+
+export default e2e;
+export * from "./module";

package/src/module.ts

@@ -1,6 +1,6 @@
-export * from "./ArrayUtil";
-export * from "./DynamicExecutor";
-export * from "./GaffComparator";
-export * from "./RandomGenerator";
-export * from "./StopWatch";
-export * from "./TestValidator";
+export * from "./ArrayUtil";
+export * from "./DynamicExecutor";
+export * from "./GaffComparator";
+export * from "./RandomGenerator";
+export * from "./StopWatch";
+export * from "./TestValidator";