@nestia/e2e 7.3.3 → 8.0.0-dev.20250829

package/lib/TestValidator.js

@@ -84,21 +84,21 @@ var json_equal_to_1 = require("./internal/json_equal_to");
  * HTTP error validation, pagination testing, search functionality validation,
  * and sorting validation.
  *
- * All functions follow a currying pattern to enable reusable test
- * configurations and provide detailed error messages for debugging failed
- * assertions.
+ * Most functions use direct parameter passing for simplicity, while some
+ * maintain currying patterns for advanced composition. All provide detailed
+ * error messages for debugging failed assertions.
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @example
  *   ```typescript
  *   // Basic condition testing
- *   TestValidator.predicate("user should be authenticated")(user.isAuthenticated);
+ *   TestValidator.predicate("user should be authenticated", user.isAuthenticated);
  *
  *   // Equality validation
- *   TestValidator.equals("API response should match expected")(expected)(actual);
+ *   TestValidator.equals("API response should match expected", x, y);
  *
  *   // Error validation
- *   TestValidator.error("should throw on invalid input")(() => validateInput(""));
+ *   TestValidator.error("should throw on invalid input", () => assertInput(""));
  *   ```;
  */
 var TestValidator;
@@ -114,53 +114,54 @@ var TestValidator;
      * @example
      *   ```typescript
      *   // Synchronous boolean
-     *   TestValidator.predicate("user should exist")(user !== null);
+     *   TestValidator.predicate("user should exist", user !== null);
      *
      *   // Synchronous function
-     *   TestValidator.predicate("array should be empty")(() => arr.length === 0);
+     *   TestValidator.predicate("array should be empty", () => arr.length === 0);
      *
      *   // Asynchronous function
-     *   await TestValidator.predicate("database should be connected")(
+     *   await TestValidator.predicate("database should be connected",
      *     async () => await db.ping()
      *   );
      *   ```;
      *
      * @param title - Descriptive title used in error messages when validation
      *   fails
-     * @returns A currying function that accepts the condition to validate
+     * @param condition - The condition to validate (boolean, function, or async
+     *   function)
+     * @returns Void or Promise<void> based on the input type
      * @throws Error with descriptive message when condition is not satisfied
      */
-    TestValidator.predicate = function (title) {
-        return function (condition) {
-            var message = function () {
-                return "Bug on ".concat(title, ": expected condition is not satisfied.");
-            };
-            // SCALAR
-            if (typeof condition === "boolean") {
-                if (condition !== true)
-                    throw new Error(message());
-                return undefined;
-            }
-            // CLOSURE
-            var output = condition();
-            if (typeof output === "boolean") {
-                if (output !== true)
-                    throw new Error(message());
-                return undefined;
-            }
-            // ASYNCHRONOUS
-            return new Promise(function (resolve, reject) {
-                output
-                    .then(function (flag) {
-                    if (flag === true)
-                        resolve();
-                    else
-                        reject(message());
-                })
-                    .catch(reject);
-            });
+    function predicate(title, condition) {
+        var message = function () {
+            return "Bug on ".concat(title, ": expected condition is not satisfied.");
         };
-    };
+        // SCALAR
+        if (typeof condition === "boolean") {
+            if (condition !== true)
+                throw new Error(message());
+            return undefined;
+        }
+        // CLOSURE
+        var output = condition();
+        if (typeof output === "boolean") {
+            if (output !== true)
+                throw new Error(message());
+            return undefined;
+        }
+        // ASYNCHRONOUS
+        return new Promise(function (resolve, reject) {
+            output
+                .then(function (flag) {
+                if (flag === true)
+                    resolve();
+                else
+                    reject(message());
+            })
+                .catch(reject);
+        });
+    }
+    TestValidator.predicate = predicate;
     /**
      * Validates deep equality between two values using JSON comparison.
      *
@@ -168,61 +169,44 @@ var TestValidator;
      * exception filter to ignore specific keys during comparison. Useful for
      * validating API responses, data transformations, and object state changes.
      *
-     * **Type Safety Notes:**
-     *
-     * - The generic type T is inferred from the `actual` parameter (first in the
-     *   currying chain)
-     * - The `expected` parameter must be assignable to `T | null | undefined`
-     * - For objects, `expected` must have the same or subset of properties as
-     *   `actual`
-     * - For union types like `string | null`, ensure proper type compatibility:
-     *
-     *   ```typescript
-     *   const x: string | null;
-     *   TestValidator.equals("works")(x)(null);        // ✅ Works: null is assignable to string | null
-     *   TestValidator.equals("error")(null)(x);        // ❌ Error: x might be string, but expected is null
-     * ```
-     *
      * @example
      *   ```typescript
      *   // Basic equality
-     *   TestValidator.equals("response should match expected")(expectedUser)(actualUser);
+     *   TestValidator.equals("response should match expected", expectedUser, actualUser);
      *
      *   // Ignore timestamps in comparison
-     *   TestValidator.equals("user data should match", (key) => key === "updatedAt")(
-     *     expectedUser
-     *   )(actualUser);
+     *   TestValidator.equals("user data should match", expectedUser, actualUser,
+     *     (key) => key === "updatedAt"
+     *   );
      *
      *   // Validate API response structure
-     *   const validateResponse = TestValidator.equals("API response structure");
-     *   validateResponse({ id: 1, name: "John" })({ id: 1, name: "John" });
+     *   TestValidator.equals("API response structure",
+     *     { id: 1, name: "John" },
+     *     { id: 1, name: "John" }
+     *   );
      *
      *   // Type-safe nullable comparisons
      *   const nullableData: { name: string } | null = getData();
-     *   TestValidator.equals("nullable check")(nullableData)(null); // ✅ Safe
+     *   TestValidator.equals("nullable check", nullableData, null);
      *   ```;
      *
      * @param title - Descriptive title used in error messages when values differ
+     * @param x - The first value to compare
+     * @param y - The second value to compare (can be null or undefined)
      * @param exception - Optional filter function to exclude specific keys from
      *   comparison
-     * @returns A currying function chain: first accepts expected value, then
-     *   actual value
      * @throws Error with detailed diff information when values are not equal
      */
-    TestValidator.equals = function (title, exception) {
-        if (exception === void 0) { exception = function () { return false; }; }
-        return function (actual) {
-            return function (expected) {
-                var diff = (0, json_equal_to_1.json_equal_to)(exception)(actual)(expected);
-                if (diff.length)
-                    throw new Error([
-                        "Bug on ".concat(title, ": found different values - [").concat(diff.join(", "), "]:"),
-                        "\n",
-                        JSON.stringify({ actual: actual, expected: expected }, null, 2),
-                    ].join("\n"));
-            };
-        };
-    };
+    function equals(title, x, y, exception) {
+        var diff = (0, json_equal_to_1.json_equal_to)(exception !== null && exception !== void 0 ? exception : (function () { return false; }))(x)(y);
+        if (diff.length)
+            throw new Error([
+                "Bug on ".concat(title, ": found different values - [").concat(diff.join(", "), "]:"),
+                "\n",
+                JSON.stringify({ x: x, y: y }, null, 2),
+            ].join("\n"));
+    }
+    TestValidator.equals = equals;
     /**
      * Validates deep inequality between two values using JSON comparison.
      *
@@ -231,62 +215,42 @@ var TestValidator;
      * comparison. Useful for validating that data has changed, objects are
      * different, or mutations have occurred.
      *
-     * **Type Safety Notes:**
-     *
-     * - The generic type T is inferred from the `actual` parameter (first in the
-     *   currying chain)
-     * - The `expected` parameter must be assignable to `T | null | undefined`
-     * - For objects, `expected` must have the same or subset of properties as
-     *   `actual`
-     * - For union types like `string | null`, ensure proper type compatibility:
-     *
-     *   ```typescript
-     *   const x: string | null;
-     *   TestValidator.notEquals("works")(x)(null);     // ✅ Works: null is assignable to string | null
-     *   TestValidator.notEquals("error")(null)(x);     // ❌ Error: x might be string, but expected is null
-     * ```
-     *
      * @example
      *   ```typescript
      *   // Basic inequality
-     *   TestValidator.notEquals("user should be different after update")(originalUser)(updatedUser);
+     *   TestValidator.notEquals("user should be different after update", originalUser, updatedUser);
      *
      *   // Ignore timestamps in comparison
-     *   TestValidator.notEquals("user data should differ", (key) => key === "updatedAt")(
-     *     originalUser
-     *   )(modifiedUser);
+     *   TestValidator.notEquals("user data should differ", originalUser, modifiedUser,
+     *     (key) => key === "updatedAt"
+     *   );
      *
      *   // Validate state changes
-     *   const validateStateChange = TestValidator.notEquals("state should have changed");
-     *   validateStateChange(initialState)(currentState);
+     *   TestValidator.notEquals("state should have changed", initialState, currentState);
      *
      *   // Type-safe nullable comparisons
      *   const mutableData: { count: number } | null = getMutableData();
-     *   TestValidator.notEquals("should have changed")(mutableData)(null); // ✅ Safe
+     *   TestValidator.notEquals("should have changed", mutableData, null);
      *   ```;
      *
      * @param title - Descriptive title used in error messages when values are
      *   equal
+     * @param x - The first value to compare
+     * @param y - The second value to compare (can be null or undefined)
      * @param exception - Optional filter function to exclude specific keys from
      *   comparison
-     * @returns A currying function chain: first accepts expected value, then
-     *   actual value
      * @throws Error when values are equal (indicating validation failure)
      */
-    TestValidator.notEquals = function (title, exception) {
-        if (exception === void 0) { exception = function () { return false; }; }
-        return function (actual) {
-            return function (expected) {
-                var diff = (0, json_equal_to_1.json_equal_to)(exception)(actual)(expected);
-                if (diff.length === 0)
-                    throw new Error([
-                        "Bug on ".concat(title, ": values should be different but are equal:"),
-                        "\n",
-                        JSON.stringify({ actual: actual, expected: expected }, null, 2),
-                    ].join("\n"));
-            };
-        };
-    };
+    function notEquals(title, x, y, exception) {
+        var diff = (0, json_equal_to_1.json_equal_to)(exception !== null && exception !== void 0 ? exception : (function () { return false; }))(x)(y);
+        if (diff.length === 0)
+            throw new Error([
+                "Bug on ".concat(title, ": values should be different but are equal:"),
+                "\n",
+                JSON.stringify({ x: x, y: y }, null, 2),
+            ].join("\n"));
+    }
+    TestValidator.notEquals = notEquals;
     /**
      * Validates that a function throws an error or rejects when executed.
      *
@@ -297,43 +261,43 @@ var TestValidator;
      * @example
      *   ```typescript
      *   // Synchronous error validation
-     *   TestValidator.error("should reject invalid email")(
+     *   TestValidator.error("should reject invalid email",
      *     () => validateEmail("invalid-email")
      *   );
      *
      *   // Asynchronous error validation
-     *   await TestValidator.error("should reject unauthorized access")(
+     *   await TestValidator.error("should reject unauthorized access",
      *     async () => await api.functional.getSecretData()
      *   );
      *
      *   // Validate input validation
-     *   TestValidator.error("should throw on empty string")(
+     *   TestValidator.error("should throw on empty string",
      *     () => processRequiredInput("")
      *   );
      *   ```;
      *
      * @param title - Descriptive title used in error messages when no error
      *   occurs
-     * @returns A currying function that accepts the task function to validate
+     * @param task - The function that should throw an error or reject
+     * @returns Void or Promise<void> based on the input type
      * @throws Error when the task function does not throw an error or reject
      */
-    TestValidator.error = function (title) {
-        return function (task) {
-            var message = function () { return "Bug on ".concat(title, ": exception must be thrown."); };
-            try {
-                var output_1 = task();
-                if (is_promise(output_1))
-                    return new Promise(function (resolve, reject) {
-                        return output_1.catch(function () { return resolve(); }).then(function () { return reject(message()); });
-                    });
-                else
-                    throw new Error(message());
-            }
-            catch (_a) {
-                return undefined;
-            }
-        };
-    };
+    function error(title, task) {
+        var message = function () { return "Bug on ".concat(title, ": exception must be thrown."); };
+        try {
+            var output_1 = task();
+            if (is_promise(output_1))
+                return new Promise(function (resolve, reject) {
+                    return output_1.catch(function () { return resolve(); }).then(function () { return reject(message()); });
+                });
+            else
+                throw new Error(message());
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    TestValidator.error = error;
     /**
      * Validates that a function throws an HTTP error with specific status codes.
      *
@@ -344,90 +308,70 @@ var TestValidator;
      * @example
      *   ```typescript
      *   // Validate 401 Unauthorized
-     *   await TestValidator.httpError("should return 401 for invalid token")(401)(
+     *   await TestValidator.httpError("should return 401 for invalid token", 401,
      *     async () => await api.functional.getProtectedResource("invalid-token")
      *   );
      *
      *   // Validate multiple possible error codes
-     *   await TestValidator.httpError("should return client error")(400, 404, 422)(
+     *   await TestValidator.httpError("should return client error", [400, 404, 422],
      *     async () => await api.functional.updateNonexistentResource(data)
      *   );
      *
      *   // Validate server errors
-     *   TestValidator.httpError("should handle server errors")(500, 502, 503)(
+     *   TestValidator.httpError("should handle server errors", [500, 502, 503],
      *     () => callFaultyEndpoint()
      *   );
      *   ```;
      *
      * @param title - Descriptive title used in error messages
-     * @returns A currying function that accepts status codes, then the task
-     *   function
+     * @param status - Expected status code(s), can be a single number or array
+     * @param task - The function that should throw an HttpError
+     * @returns Void or Promise<void> based on the input type
      * @throws Error when function doesn't throw HttpError or status code doesn't
      *   match
      */
-    TestValidator.httpError = function (title) {
-        return function () {
-            var statuses = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                statuses[_i] = arguments[_i];
-            }
-            return function (task) {
-                var message = function (actual) {
-                    return typeof actual === "number"
-                        ? "Bug on ".concat(title, ": status code must be ").concat(statuses.join(" or "), ", but ").concat(actual, ".")
-                        : "Bug on ".concat(title, ": status code must be ").concat(statuses.join(" or "), ", but succeeded.");
-                };
-                var predicate = function (exp) {
-                    return typeof exp === "object" &&
-                        exp.constructor.name === "HttpError" &&
-                        statuses.some(function (val) { return val === exp.status; })
-                        ? null
-                        : new Error(message(typeof exp === "object" && exp.constructor.name === "HttpError"
-                            ? exp.status
-                            : undefined));
-                };
-                try {
-                    var output_2 = task();
-                    if (is_promise(output_2))
-                        return new Promise(function (resolve, reject) {
-                            return output_2
-                                .catch(function (exp) {
-                                var res = predicate(exp);
-                                if (res)
-                                    reject(res);
-                                else
-                                    resolve();
-                            })
-                                .then(function () { return reject(new Error(message())); });
-                        });
-                    else
-                        throw new Error(message());
-                }
-                catch (exp) {
-                    var res = predicate(exp);
-                    if (res)
-                        throw res;
-                    return undefined;
-                }
-            };
+    function httpError(title, status, task) {
+        if (typeof status === "number")
+            status = [status];
+        var message = function (actual) {
+            return typeof actual === "number"
+                ? "Bug on ".concat(title, ": status code must be ").concat(status.join(" or "), ", but ").concat(actual, ".")
+                : "Bug on ".concat(title, ": status code must be ").concat(status.join(" or "), ", but succeeded.");
+        };
+        var predicate = function (exp) {
+            return typeof exp === "object" &&
+                exp.constructor.name === "HttpError" &&
+                status.some(function (val) { return val === exp.status; })
+                ? null
+                : new Error(message(typeof exp === "object" && exp.constructor.name === "HttpError"
+                    ? exp.status
+                    : undefined));
         };
-    };
-    function proceed(task) {
         try {
-            var output_3 = task();
-            if (is_promise(output_3))
-                return new Promise(function (resolve) {
-                    return output_3
-                        .catch(function (exp) { return resolve(exp); })
-                        .then(function () { return resolve(null); });
+            var output_2 = task();
+            if (is_promise(output_2))
+                return new Promise(function (resolve, reject) {
+                    return output_2
+                        .catch(function (exp) {
+                        var res = predicate(exp);
+                        if (res)
+                            reject(res);
+                        else
+                            resolve();
+                    })
+                        .then(function () { return reject(new Error(message())); });
                 });
+            else
+                throw new Error(message());
         }
         catch (exp) {
-            return exp;
+            var res = predicate(exp);
+            if (res)
+                throw res;
+            return undefined;
         }
-        return null;
     }
-    TestValidator.proceed = proceed;
+    TestValidator.httpError = httpError;
     /**
      * Validates pagination index API results against expected entity order.
      *
@@ -442,8 +386,7 @@ var TestValidator;
      *   const expectedArticles = await db.articles.findAll({ order: 'created_at DESC' });
      *   const actualArticles = await api.functional.getArticles({ page: 1, limit: 10 });
      *
-     *   TestValidator.index("article pagination order")(expectedArticles)(
-     *     actualArticles,
+     *   TestValidator.index("article pagination order", expectedArticles, actualArticles,
      *     true // enable trace logging
      *   );
      *
@@ -451,37 +394,33 @@ var TestValidator;
      *   const manuallyFilteredUsers = allUsers.filter(u => u.name.includes("John"));
      *   const apiSearchResults = await api.functional.searchUsers({ query: "John" });
      *
-     *   TestValidator.index("user search results")(manuallyFilteredUsers)(
-     *     apiSearchResults
-     *   );
+     *   TestValidator.index("user search results", manuallyFilteredUsers, apiSearchResults);
      *   ```;
      *
      * @param title - Descriptive title used in error messages when order differs
-     * @returns A currying function chain: expected entities, then actual entities
+     * @param expected - The expected entities in correct order
+     * @param gotten - The actual entities returned by the API
+     * @param trace - Optional flag to enable debug logging (default: false)
      * @throws Error when entity order differs between expected and actual results
      */
-    TestValidator.index = function (title) {
-        return function (expected) {
-            return function (gotten, trace) {
-                if (trace === void 0) { trace = false; }
-                var length = Math.min(expected.length, gotten.length);
-                expected = expected.slice(0, length);
-                gotten = gotten.slice(0, length);
-                var xIds = get_ids(expected).slice(0, length);
-                var yIds = get_ids(gotten)
-                    .filter(function (id) { return id >= xIds[0]; })
-                    .slice(0, length);
-                var equals = xIds.every(function (x, i) { return x === yIds[i]; });
-                if (equals === true)
-                    return;
-                else if (trace === true)
-                    console.log({
-                        expected: xIds,
-                        gotten: yIds,
-                    });
-                throw new Error("Bug on ".concat(title, ": result of the index is different with manual aggregation."));
-            };
-        };
+    TestValidator.index = function (title, expected, gotten, trace) {
+        if (trace === void 0) { trace = false; }
+        var length = Math.min(expected.length, gotten.length);
+        expected = expected.slice(0, length);
+        gotten = gotten.slice(0, length);
+        var xIds = get_ids(expected).slice(0, length);
+        var yIds = get_ids(gotten)
+            .filter(function (id) { return id >= xIds[0]; })
+            .slice(0, length);
+        var equals = xIds.every(function (x, i) { return x === yIds[i]; });
+        if (equals === true)
+            return;
+        else if (trace === true)
+            console.log({
+                expected: xIds,
+                gotten: yIds,
+            });
+        throw new Error("Bug on ".concat(title, ": result of the index is different with manual aggregation."));
     };
     /**
      * Validates search functionality by testing API results against manual
@@ -494,97 +433,104 @@ var TestValidator;
      *
      * @example
      *   ```typescript
-     *   // Test article search functionality
+     *   // Test article search functionality with exact matching
      *   const allArticles = await db.articles.findAll();
-     *   const searchValidator = TestValidator.search("article search API")(
-     *     (req) => api.searchArticles(req)
-     *   )(allArticles, 5); // test with 5 random samples
+     *   const searchValidator = TestValidator.search(
+     *     "article search API",
+     *     (req) => api.searchArticles(req),
+     *     allArticles,
+     *     5 // test with 5 random samples
+     *   );
+     *
+     *   // Test exact match search
+     *   await searchValidator({
+     *     fields: ["title"],
+     *     values: (article) => [article.title], // full title for exact match
+     *     filter: (article, [title]) => article.title === title, // exact match
+     *     request: ([title]) => ({ search: { title } })
+     *   });
      *
+     *   // Test partial match search with includes
      *   await searchValidator({
-     *     fields: ["title", "content"],
-     *     values: (article) => [article.title.split(" ")[0]], // first word
-     *     filter: (article, [keyword]) =>
-     *       article.title.includes(keyword) || article.content.includes(keyword),
+     *     fields: ["content"],
+     *     values: (article) => [article.content.substring(0, 20)], // partial content
+     *     filter: (article, [keyword]) => article.content.includes(keyword),
      *     request: ([keyword]) => ({ q: keyword })
      *   });
      *
-     *   // Test user search with multiple criteria
-     *   await TestValidator.search("user search with filters")(
-     *     (req) => api.getUsers(req)
-     *   )(allUsers, 3)({
-     *     fields: ["status", "role"],
-     *     values: (user) => [user.status, user.role],
-     *     filter: (user, [status, role]) =>
-     *       user.status === status && user.role === role,
-     *     request: ([status, role]) => ({ status, role })
+     *   // Test multi-field search with exact matching
+     *   await searchValidator({
+     *     fields: ["writer", "title"],
+     *     values: (article) => [article.writer, article.title],
+     *     filter: (article, [writer, title]) =>
+     *       article.writer === writer && article.title === title,
+     *     request: ([writer, title]) => ({ search: { writer, title } })
      *   });
      *   ```;
      *
      * @param title - Descriptive title used in error messages when search fails
-     * @returns A currying function chain: API getter function, then dataset and
-     *   sample count
+     * @param getter - API function that performs the search
+     * @param total - Complete dataset to sample from for testing
+     * @param sampleCount - Number of random samples to test (default: 1)
+     * @returns A function that accepts search configuration properties
      * @throws Error when API search results don't match manual filtering results
      */
-    TestValidator.search = function (title) {
-        return function (getter) {
-            return function (total, sampleCount) {
-                if (sampleCount === void 0) { sampleCount = 1; }
-                return function (props) { return __awaiter(_this, void 0, void 0, function () {
-                    var samples, _loop_1, samples_1, samples_1_1, s, e_1_1;
-                    var e_1, _a;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                samples = RandomGenerator_1.RandomGenerator.sample(total)(sampleCount);
-                                _loop_1 = function (s) {
-                                    var values, filtered, gotten;
-                                    return __generator(this, function (_c) {
-                                        switch (_c.label) {
-                                            case 0:
-                                                values = props.values(s);
-                                                filtered = total.filter(function (entity) {
-                                                    return props.filter(entity, values);
-                                                });
-                                                return [4 /*yield*/, getter(props.request(values))];
-                                            case 1:
-                                                gotten = _c.sent();
-                                                TestValidator.index("".concat(title, " (").concat(props.fields.join(", "), ")"))(filtered)(gotten);
-                                                return [2 /*return*/];
-                                        }
-                                    });
-                                };
-                                _b.label = 1;
-                            case 1:
-                                _b.trys.push([1, 6, 7, 8]);
-                                samples_1 = __values(samples), samples_1_1 = samples_1.next();
-                                _b.label = 2;
-                            case 2:
-                                if (!!samples_1_1.done) return [3 /*break*/, 5];
-                                s = samples_1_1.value;
-                                return [5 /*yield**/, _loop_1(s)];
-                            case 3:
-                                _b.sent();
-                                _b.label = 4;
-                            case 4:
-                                samples_1_1 = samples_1.next();
-                                return [3 /*break*/, 2];
-                            case 5: return [3 /*break*/, 8];
-                            case 6:
-                                e_1_1 = _b.sent();
-                                e_1 = { error: e_1_1 };
-                                return [3 /*break*/, 8];
-                            case 7:
-                                try {
-                                    if (samples_1_1 && !samples_1_1.done && (_a = samples_1.return)) _a.call(samples_1);
+    TestValidator.search = function (title, getter, total, sampleCount) {
+        if (sampleCount === void 0) { sampleCount = 1; }
+        return function (props) { return __awaiter(_this, void 0, void 0, function () {
+            var samples, _loop_1, samples_1, samples_1_1, s, e_1_1;
+            var e_1, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        samples = RandomGenerator_1.RandomGenerator.sample(total, sampleCount);
+                        _loop_1 = function (s) {
+                            var values, filtered, gotten;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        values = props.values(s);
+                                        filtered = total.filter(function (entity) {
+                                            return props.filter(entity, values);
+                                        });
+                                        return [4 /*yield*/, getter(props.request(values))];
+                                    case 1:
+                                        gotten = _c.sent();
+                                        TestValidator.index("".concat(title, " (").concat(props.fields.join(", "), ")"), filtered, gotten);
+                                        return [2 /*return*/];
                                 }
-                                finally { if (e_1) throw e_1.error; }
-                                return [7 /*endfinally*/];
-                            case 8: return [2 /*return*/];
+                            });
+                        };
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        samples_1 = __values(samples), samples_1_1 = samples_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!samples_1_1.done) return [3 /*break*/, 5];
+                        s = samples_1_1.value;
+                        return [5 /*yield**/, _loop_1(s)];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        samples_1_1 = samples_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (samples_1_1 && !samples_1_1.done && (_a = samples_1.return)) _a.call(samples_1);
                         }
-                    });
-                }); };
-            };
-        };
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        }); };
     };
     /**
      * Validates sorting functionality of pagination APIs.
@@ -596,87 +542,98 @@ var TestValidator;
      *
      * @example
      *   ```typescript
-     *   // Test single field sorting
-     *   const sortValidator = TestValidator.sort("article sorting")(
+     *   // Test single field sorting with GaffComparator
+     *   const sortValidator = TestValidator.sort(
+     *     "article sorting",
      *     (sortable) => api.getArticles({ sort: sortable })
      *   )("created_at")(
-     *     (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+     *     GaffComparator.dates((a) => a.created_at)
      *   );
      *
      *   await sortValidator("+"); // ascending
      *   await sortValidator("-"); // descending
      *
-     *   // Test multi-field sorting with filtering
-     *   const userSortValidator = TestValidator.sort("user sorting")(
+     *   // Test multi-field sorting with GaffComparator
+     *   const userSortValidator = TestValidator.sort(
+     *     "user sorting",
      *     (sortable) => api.getUsers({ sort: sortable })
-     *   )("status", "created_at")(
-     *     (a, b) => {
-     *       if (a.status !== b.status) return a.status.localeCompare(b.status);
-     *       return new Date(a.created_at).getTime() - new Date(b.created_at).getTime();
-     *     },
+     *   )("lastName", "firstName")(
+     *     GaffComparator.strings((user) => [user.lastName, user.firstName]),
      *     (user) => user.isActive // only test active users
      *   );
      *
      *   await userSortValidator("+", true); // ascending with trace logging
+     *
+     *   // Custom comparator for complex logic
+     *   const customSortValidator = TestValidator.sort(
+     *     "custom sorting",
+     *     (sortable) => api.getProducts({ sort: sortable })
+     *   )("price", "rating")(
+     *     (a, b) => {
+     *       const priceDiff = a.price - b.price;
+     *       return priceDiff !== 0 ? priceDiff : b.rating - a.rating; // price asc, rating desc
+     *     }
+     *   );
      *   ```;
      *
      * @param title - Descriptive title used in error messages when sorting fails
-     * @returns A currying function chain: API getter, field names, comparator,
-     *   then direction
+     * @param getter - API function that fetches sorted data
+     * @returns A currying function chain: field names, comparator, then direction
      * @throws Error when API results are not properly sorted according to
      *   specification
      */
-    TestValidator.sort = function (title) {
-        return function (getter) {
-            return function () {
-                var fields = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    fields[_i] = arguments[_i];
-                }
-                return function (comp, filter) {
-                    return function (direction_1) {
-                        var args_1 = [];
-                        for (var _i = 1; _i < arguments.length; _i++) {
-                            args_1[_i - 1] = arguments[_i];
-                        }
-                        return __awaiter(_this, __spreadArray([direction_1], __read(args_1), false), void 0, function (direction, trace) {
-                            var data, reversed;
-                            if (trace === void 0) { trace = false; }
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, getter(fields.map(function (field) { return "".concat(direction).concat(field); }))];
-                                    case 1:
-                                        data = _a.sent();
-                                        if (filter)
-                                            data = data.filter(filter);
-                                        reversed = direction === "+" ? comp : function (x, y) { return comp(y, x); };
-                                        if (is_sorted(data, reversed) === false) {
-                                            if (fields.length === 1 &&
-                                                data.length &&
-                                                data[0][fields[0]] !== undefined &&
-                                                trace)
-                                                console.log(data.map(function (elem) { return elem[fields[0]]; }));
-                                            throw new Error("Bug on ".concat(title, ": wrong sorting on ").concat(direction, "(").concat(fields.join(", "), ")."));
-                                        }
-                                        return [2 /*return*/];
-                                }
-                            });
+    TestValidator.sort = function (title, getter) {
+        return function () {
+            var fields = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                fields[_i] = arguments[_i];
+            }
+            return function (comp, filter) {
+                return function (direction_1) {
+                    var args_1 = [];
+                    for (var _i = 1; _i < arguments.length; _i++) {
+                        args_1[_i - 1] = arguments[_i];
+                    }
+                    return __awaiter(_this, __spreadArray([direction_1], __read(args_1), false), void 0, function (direction, trace) {
+                        var data, reversed;
+                        if (trace === void 0) { trace = false; }
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, getter(fields.map(function (field) { return "".concat(direction).concat(field); }))];
+                                case 1:
+                                    data = _a.sent();
+                                    if (filter)
+                                        data = data.filter(filter);
+                                    reversed = direction === "+" ? comp : function (x, y) { return comp(y, x); };
+                                    if (is_sorted(data, reversed) === false) {
+                                        if (fields.length === 1 &&
+                                            data.length &&
+                                            data[0][fields[0]] !== undefined &&
+                                            trace)
+                                            console.log(data.map(function (elem) { return elem[fields[0]]; }));
+                                        throw new Error("Bug on ".concat(title, ": wrong sorting on ").concat(direction, "(").concat(fields.join(", "), ")."));
+                                    }
+                                    return [2 /*return*/];
+                            }
                         });
-                    };
+                    });
                 };
             };
         };
     };
 })(TestValidator || (exports.TestValidator = TestValidator = {}));
+/** @internal */
 function get_ids(entities) {
     return entities.map(function (entity) { return entity.id; }).sort(function (x, y) { return (x < y ? -1 : 1); });
 }
+/** @internal */
 function is_promise(input) {
     return (typeof input === "object" &&
         input !== null &&
         typeof input.then === "function" &&
         typeof input.catch === "function");
 }
+/** @internal */
 function is_sorted(data, comp) {
     for (var i = 1; i < data.length; ++i)
         if (comp(data[i - 1], data[i]) > 0)