kizu 3.7.7 → 3.8.0

package/dist/assertions/index.d.ts

@@ -1,10 +1,12 @@
 import { Assertion } from '../test';
-export declare function createAssertionPredicates(assertions: Assertion[]): {
+export type AssertionAPI = {
     pass: (description?: string) => void;
     fail: (description?: string) => void;
     isTrue: (condition: boolean, description?: string) => void;
     isFalse: (condition: boolean, description?: string) => void;
     equal: (actual: any, expected: any, description?: string) => void;
+    isError: (actual: any, expected: any, description?: string) => void;
     errorsEquivalent: (actual: any, expected: any, description?: string) => void;
-    throws: (experiment: () => any, expectedErr: Error | RegExp, description?: string) => void;
+    throws: (experiment: () => any, expectedErr: Error | RegExp, description?: string) => Promise<void>;
 };
+export declare function createAssertionPredicates(assertions: Assertion[]): AssertionAPI;

package/dist/assertions/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAssertionPredicates = createAssertionPredicates;
-const errorsEquivalent_1 = require("./errorsEquivalent");
+const isError_1 = require("./isError");
 const equal_1 = require("./equal");
 const throws_1 = require("./throws");
 const isTrue_1 = require("./isTrue");
@@ -10,12 +10,13 @@ const fail_1 = require("./fail");
 const pass_1 = require("./pass");
 function createAssertionPredicates(assertions) {
     return {
-        pass: (description) => ((0, pass_1.pass)(assertions, description)),
-        fail: (description) => ((0, fail_1.fail)(assertions, description)),
-        isTrue: (condition, description) => ((0, isTrue_1.isTrue)(assertions, condition, description)),
-        isFalse: (condition, description) => ((0, isFalse_1.isFalse)(assertions, condition, description)),
+        pass: (description) => (0, pass_1.pass)(assertions, description),
+        fail: (description) => (0, fail_1.fail)(assertions, description),
+        isTrue: (condition, description) => (0, isTrue_1.isTrue)(assertions, condition, description),
+        isFalse: (condition, description) => (0, isFalse_1.isFalse)(assertions, condition, description),
         equal: (actual, expected, description) => ((0, equal_1.equal)(assertions, actual, expected, description)),
-        errorsEquivalent: (actual, expected, description) => ((0, errorsEquivalent_1.errorsEquivalent)(assertions, actual, expected, description)),
+        isError: (actual, expected, description) => ((0, isError_1.isError)(assertions, actual, expected, description)),
+        errorsEquivalent: (actual, expected, description) => ((0, isError_1.isError)(assertions, actual, expected, description)), // deprecated
         throws: (experiment, expectedErr, description) => ((0, throws_1.throws)(assertions, experiment, expectedErr, description)),
     };
 }

package/dist/assertions/{errorsEquivalent.d.ts → isError.d.ts}

@@ -1,3 +1,3 @@
 import { Assertion } from '../test';
-export declare function errorsEquivalent(assertions: Assertion[], actualErr: Error, expectedErr: Error | RegExp, description?: string): void;
+export declare function isError(assertions: Assertion[], actualErr: Error, expectedErr: Error | RegExp, description?: string): void;
 export declare function createDiagnosticRegexMismatch(actualErrMsg: string, expectedRegEx: RegExp): string;

package/dist/assertions/{errorsEquivalent.js → isError.js}

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorsEquivalent = errorsEquivalent;
+exports.isError = isError;
 exports.createDiagnosticRegexMismatch = createDiagnosticRegexMismatch;
 const serialize_error_1 = require("serialize-error");
 const equal_1 = require("./equal");
 const pass_1 = require("./pass");
 const AssertionError_1 = require("./AssertionError");
 const kleur_1 = __importDefault(require("kleur"));
-function errorsEquivalent(assertions, actualErr, expectedErr, description) {
+function isError(assertions, actualErr, expectedErr, description) {
     if (!(actualErr instanceof Error))
         throw new Error('actualErr is not an instance of Error');
     if (!(expectedErr instanceof Error) && !(expectedErr instanceof RegExp))
@@ -46,4 +46,4 @@ function createDiagnosticRegexMismatch(actualErrMsg, expectedRegEx) {
     const expected = `\n\n${kleur_1.default.grey().bold('Expected RegEx:')}\n\n${expectedRegEx}`;
     return `${actual}${expected}\n\n`;
 }
-//# sourceMappingURL=errorsEquivalent.js.map
+//# sourceMappingURL=isError.js.map

package/dist/assertions/throws.d.ts

@@ -1,2 +1,2 @@
 import { Assertion } from '../test';
-export declare function throws(assertions: Assertion[], experiment: () => any, expectedErr: Error | RegExp, description?: string): void;
+export declare function throws(assertions: Assertion[], experiment: () => any, expectedErr: Error | RegExp, description?: string): Promise<void>;

package/dist/assertions/throws.js

@@ -1,16 +1,42 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.throws = throws;
-const toResult_1 = require("../lib/toResult");
-const errorsEquivalent_1 = require("./errorsEquivalent");
+const isError_1 = require("./isError");
 function throws(assertions, experiment, expectedErr, description) {
-    if (typeof experiment !== 'function')
-        throw new Error('experiment must be a function');
-    if (!(expectedErr instanceof Error) && !(expectedErr instanceof RegExp))
-        throw new Error('expectedErr is not an instance of Error or a RegExp');
-    const [actualErr] = (0, toResult_1.toResult)(experiment);
-    if (!actualErr)
-        throw new Error('experiment did not throw an error');
-    (0, errorsEquivalent_1.errorsEquivalent)(assertions, actualErr, expectedErr, description || 'throws()');
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof experiment !== 'function')
+            throw new Error('experiment must be a function');
+        if (!(expectedErr instanceof Error) && !(expectedErr instanceof RegExp))
+            throw new Error('expectedErr is not an instance of Error or a RegExp');
+        let actualErr;
+        try {
+            const result = experiment();
+            // Check if the result is a Promise
+            if (result && typeof result.then === 'function') {
+                // Handle async function - wait for the promise to resolve or reject
+                yield result;
+                // If we get here, the promise resolved without throwing
+                throw new Error('experiment did not throw an error');
+            }
+            // If we get here, the sync function completed without throwing
+            throw new Error('experiment did not throw an error');
+        }
+        catch (e) {
+            actualErr = e;
+        }
+        if (!actualErr) {
+            throw new Error('experiment did not throw an error');
+        }
+        (0, isError_1.isError)(assertions, actualErr, expectedErr, description || 'throws()');
+    });
 }
 //# sourceMappingURL=throws.js.map

package/dist/test.d.ts

@@ -1,4 +1,4 @@
-import { createAssertionPredicates } from './assertions';
+import { AssertionAPI } from './assertions';
 import { ErrorObject } from 'serialize-error';
 export type TestResults = {
     description: string;
@@ -11,6 +11,4 @@ export type Assertion = {
     diagnostic?: string;
     stack?: string;
 };
-type AssertionAPI = ReturnType<typeof createAssertionPredicates>;
 export declare function test(description: string, experiment: (assert: AssertionAPI) => void): Promise<void>;
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kizu",
-  "version": "3.7.7",
+  "version": "3.8.0",
   "description": "An easy-to-use, fast, and defensive Typescript/Javascript test runner designed to help you to write simple, readable, and maintainable tests.",
   "license": "MIT",
   "main": "./dist/index.js",