kizu 3.7.7 → 3.9.0

package/README.md

@@ -22,6 +22,7 @@ Designed to help you write simple, readable, and maintainable tests.
 
 ### **😀 Easy to Use**
 - Very simple functional [assertion API](docs/api.md). No need to learn a DSL or framework.
+- **One assertion method does it all**: `assert.equal()` handles primitives, objects, arrays, Maps, Sets, and even RegExp pattern matching!
 - Built-in [powerful diff visualization tool](/docs/visualDiff.md)
 - Clean, organized output.
 - Failed tests are easy to find, grouped at the end of the output.
@@ -38,6 +39,20 @@ Designed to help you write simple, readable, and maintainable tests.
 - Works great with [c8](https://github.com/bcoe/c8) for code coverage.
 - Handles compilation errors gracefully.
 
+### **✨ Powerful `assert.equal()` - One Assertion to Rule Them All**
+The `assert.equal()` method is incredibly versatile and handles most of your testing needs:
+
+- **Primitive comparison**: Numbers, strings, booleans, null, undefined
+- **Deep object equality**: Compares nested objects, arrays, Maps, and Sets
+- **RegExp pattern matching**: Test string values against RegExp patterns in the expected value
+- **Mixed comparisons**: Combine exact values and RegExp patterns in the same object
+- **Visual diffs**: Beautiful, detailed output when assertions fail
+- **Type safety**: Full TypeScript support with proper type checking
+
+Note: `assert.equal()` compares values by value (deep equality), not by reference.
+
+This single assertion method eliminates the need for multiple specialized assertion methods or complex mocking while providing powerful, flexible testing capabilities.
+
 ## Quick Examples
 
 For more examples, see the [examples](examples) and [src](src) folders.
@@ -55,7 +70,6 @@ npx kizu 'src/example.test.ts'
 import {test} from 'kizu';
 
 // Basic test
-
 function greet(name: string): string {
   return `hello, ${name}`;
 }
@@ -64,8 +78,73 @@ test('greet', (assert) => {
   assert.equal(greet('world'), 'hello, world');
 });
 
-// Error handling
+// Deep object comparison
+test('user object', (assert) => {
+  const actual = {
+    name: 'John',
+    age: 30,
+    email: 'john@example.com',
+    preferences: {
+      theme: 'dark',
+      notifications: true
+    }
+  };
+  
+  const expected = {
+    name: 'John',
+    age: 30,
+    email: 'john@example.com',
+    preferences: {
+      theme: 'dark',
+      notifications: true
+    }
+  };
+  
+  assert.equal(actual, expected); // Deep equality comparison
+});
+
+// RegExp pattern matching ✨ NEW!
+test('email validation', (assert) => {
+  const email = 'user@example.com';
+  
+  // Match email pattern
+  assert.equal(email, /^[^@]+@[^@]+\.[^@]+$/);
+  
+  // Match domain
+  assert.equal(email, /@example\.com$/);
+  
+  // Match username
+  assert.equal(email, /^user@/);
+});
+
+// Complex data structures
+test('complex data', (assert) => {
+  const actual = {
+    users: [
+      { name: 'Alice', email: 'alice@company.com' },
+      { name: 'Bob', email: 'bob@company.com' }
+    ],
+    metadata: {
+      count: 2,
+      lastUpdated: '2024-01-15'
+    }
+  };
+  
+  const expected = {
+    users: [
+      { name: 'Alice', email: /@company\.com$/ }, // RegExp in nested objects!
+      { name: 'Bob', email: /@company\.com$/ }
+    ],
+    metadata: {
+      count: 2,
+      lastUpdated: /^\d{4}-\d{2}-\d{2}$/ // Date pattern
+    }
+  };
+  
+  assert.equal(actual, expected);
+});
 
+// Error handling
 function throwError(): never {
   throw new Error('oops');
 }
@@ -75,7 +154,6 @@ test('throwError', (assert) => {
 });
 
 // Async test
-
 async function fetchData(): Promise<string> {
   return Promise.resolve('data');
 }
@@ -105,6 +183,24 @@ test('fetchData', async (assert) => {
 To install and get started with `kizu`, see our [Getting Started](docs/gettingStarted.md) guide.
 See the [examples](examples) and [src](src) folders for more examples.
 
+## Why `assert.equal()` is Amazing
+
+With just one assertion method, you can test:
+
+✅ **Simple values**: `assert.equal(42, 42)`
+✅ **Complex objects**: Deep comparison of nested structures
+✅ **Pattern matching**: `assert.equal('user@example.com', /@example\.com$/)`
+✅ **Mixed data**: Combine exact values and RegExp patterns
+✅ **Collections**: Arrays, Maps, and Sets with full deep equality
+✅ **Beautiful failures**: Visual diffs show exactly what's different
+
+No need to learn multiple assertion methods or complex APIs. `assert.equal()` handles it all with elegance and power!
+
+```typescript
+// One assertion method to rule them all! ✨
+assert.equal(actual, expected);
+```
+
 ## Support, feedback, and contributions
 
 - Star this repo if you like it!

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/lib/deepStrictEqual.d.ts

@@ -1 +1 @@
-export declare function deepStrictEqual(obj1: any, obj2: any): boolean;
+export declare function deepStrictEqual(actual: any, expected: any): boolean;

package/dist/lib/deepStrictEqual.js

@@ -2,34 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deepStrictEqual = deepStrictEqual;
 /* eslint-disable max-lines-per-function */
-function deepStrictEqual(obj1, obj2) {
-    if (obj1 === obj2)
+function deepStrictEqual(actual, expected) {
+    if (actual === expected)
         return true;
-    if (isPrimitive(obj1) && isPrimitive(obj2))
-        return obj1 === obj2;
-    if (Array.isArray(obj1) !== Array.isArray(obj2))
+    // Handle RegExp comparison - expected can be RegExp, actual should be string
+    if (expected instanceof RegExp) {
+        if (typeof actual !== 'string')
+            return false;
+        return expected.test(actual);
+    }
+    // Handle case where actual is RegExp but expected is not RegExp
+    if (actual instanceof RegExp && !(expected instanceof RegExp)) {
+        return false;
+    }
+    if (isPrimitive(actual) && isPrimitive(expected))
+        return actual === expected;
+    if (Array.isArray(actual) !== Array.isArray(expected))
         return false;
-    if (typeof obj1 !== typeof obj2)
+    if (typeof actual !== typeof expected)
         return false;
-    if (obj1 === null || obj2 === null)
+    if (actual === null || expected === null)
         return false;
     // Handle Map objects
-    if (obj1 instanceof Map && obj2 instanceof Map) {
-        if (obj1.size !== obj2.size)
+    if (actual instanceof Map && expected instanceof Map) {
+        if (actual.size !== expected.size)
             return false;
-        for (const [key, value] of obj1) {
-            if (!obj2.has(key) || !deepStrictEqual(value, obj2.get(key)))
+        for (const [key, value] of actual) {
+            if (!expected.has(key) || !deepStrictEqual(value, expected.get(key)))
                 return false;
         }
         return true;
     }
     // Handle Set objects
-    if (obj1 instanceof Set && obj2 instanceof Set) {
-        if (obj1.size !== obj2.size)
+    if (actual instanceof Set && expected instanceof Set) {
+        if (actual.size !== expected.size)
             return false;
-        for (const item of obj1) {
+        for (const item of actual) {
             let matchFound = false;
-            for (const item2 of obj2) {
+            for (const item2 of expected) {
                 if (deepStrictEqual(item, item2)) {
                     matchFound = true;
                     break;
@@ -41,14 +51,14 @@ function deepStrictEqual(obj1, obj2) {
         return true;
     }
     // Handle object comparison
-    const keys1 = Object.keys(obj1);
-    const keys2 = Object.keys(obj2);
+    const keys1 = Object.keys(actual);
+    const keys2 = Object.keys(expected);
     if (keys1.length !== keys2.length)
         return false;
     for (const key of keys1) {
-        if (!Object.prototype.hasOwnProperty.call(obj2, key))
+        if (!Object.prototype.hasOwnProperty.call(expected, key))
             return false;
-        if (!deepStrictEqual(obj1[key], obj2[key]))
+        if (!deepStrictEqual(actual[key], expected[key]))
             return false;
     }
     return true;

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.9.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",