1.6.1

.gitea/workflows/default_tags.yaml

@@ -119,6 +119,6 @@ jobs:
         run: |
           npmci node install stable
           npmci npm install
-          pnpm install -g @gitzone/tsdoc
+          pnpm install -g @git.zone/tsdoc
           npmci command tsdoc
         continue-on-error: true

changelog.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2025-03-04 - 1.6.1 - fix(build)
+Corrected package.json and workflow dependencies and resolved formatting issues in tests.
+
+- Fixed incorrect global npm package reference for tsdoc installation in workflow file.
+- Updated dependencies in package.json for consistency in package naming.
+- Resolved inconsistent formatting and spacing in test files.
+
+## 2025-03-04 - 1.6.0 - feat(assertion)
+Enhanced the assertion error messaging and added new test cases.
+
+- Improved error messages by incorporating path and value/placeholders in assertions.
+- Added detailed testing of new assertion functionalities.
+- Additional test cases for comprehensive coverage of new features.
+
+## 2025-03-04 - 1.5.0 - feat(Assertion)
+Add toBeTypeOf assertion method
+
+- Introduced a new assertion method `toBeTypeOf` allowing checks for expected data types.
+- Updated devDependencies and dependencies to their latest versions.
+
+## 2024-12-30 - 1.4.0 - feat(Assertion)
+Add log method to Assertion class
+
+- Introduced a log method in the Assertion class to output assertion context.
+
+## 2024-12-30 - 1.3.0 - feat(Assertion)
+Refactor Assertion class for better error handling and code clarity
+
+- Improved method runCheck to better handle async and sync execution
+- Enhanced getObjectToTestReference to handle undefined or null values gracefully
+- Refactored error message logic for clarity and added more descriptive fail messages
+- Added arrayItem method for better handling of array index access
+- Improved structure by integrating consistent error handling in assertion methods
+
 ## 2024-08-24 - 1.2.1 - fix(Assertion)
 Refactor methods for setting failure and success messages
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartexpect",
-  "version": "1.2.1",
+  "version": "1.6.1",
   "private": false,
   "description": "A testing library to manage expectations in code, offering both synchronous and asynchronous assertion methods.",
   "main": "dist_ts/index.js",
@@ -10,20 +10,20 @@
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/ --web)",
-    "build": "(tsbuild --web)",
+    "build": "(tsbuild tsfolders)",
     "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.66",
-    "@gitzone/tsbundle": "^2.0.8",
-    "@gitzone/tsrun": "^1.2.44",
-    "@gitzone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^22.4.0"
+    "@git.zone/tsbuild": "^2.2.1",
+    "@git.zone/tsbundle": "^2.2.5",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^1.0.96",
+    "@push.rocks/tapbundle": "^5.5.6",
+    "@types/node": "^22.13.9"
   },
   "dependencies": {
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartpromise": "^4.0.4",
+    "@push.rocks/smartpromise": "^4.2.3",
     "fast-deep-equal": "^3.1.3"
   },
   "browserslist": [
@@ -57,5 +57,10 @@
   "repository": {
     "type": "git",
     "url": "https://code.foss.global/push.rocks/smartexpect.git"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "mongodb-memory-server"
+    ]
   }
 }

readme.md

@@ -1,5 +1,5 @@
 # @push.rocks/smartexpect
-manage expectations in code
+Manage expectations in code with precise, readable assertions
 
 ## Install
 
@@ -30,14 +30,16 @@ You can employ `expect` to create synchronous assertions:
 ```typescript
 import { expect } from '@push.rocks/smartexpect';
 
-// String type assertion
+// Type assertions
 expect('hello').toBeTypeofString();
-
-// Negated String type assertion
-expect(1).not.toBeTypeofString();
-
-// Boolean type assertion
+expect(42).toBeTypeofNumber();
 expect(true).toBeTypeofBoolean();
+expect(() => {}).toBeTypeOf('function');
+expect({}).toBeTypeOf('object');
+
+// Negated assertions
+expect(1).not.toBeTypeofString();
+expect('string').not.toBeTypeofNumber();
 
 // Equality assertion
 expect('hithere').toEqual('hithere');
@@ -61,16 +63,47 @@ const asyncStringFetcher = async (): Promise<string> => {
 };
 
 const asyncTest = async () => {
-  await expectAsync(asyncStringFetcher()).toBeTypeofString();
+  // Add a timeout to prevent hanging tests
+  await expectAsync(asyncStringFetcher()).timeout(5000).toBeTypeofString();
   await expectAsync(asyncStringFetcher()).toEqual('async string');
 };
 
 asyncTest();
 ```
 
-### Advanced Usage
+### Navigating Complex Objects
 
-- **Properties and Deep Properties:** Assert the existence of properties and their values.
+You can navigate complex objects using the `property()` and `arrayItem()` methods:
+
+```typescript
+const complexObject = {
+  users: [
+    { id: 1, name: 'Alice', permissions: { admin: true } },
+    { id: 2, name: 'Bob', permissions: { admin: false } }
+  ]
+};
+
+// Navigate to a nested property
+expect(complexObject)
+  .property('users')
+  .arrayItem(0)
+  .property('name')
+  .toEqual('Alice');
+
+// Check nested permission
+expect(complexObject)
+  .property('users')
+  .arrayItem(0)
+  .property('permissions')
+  .property('admin')
+  .toBeTrue();
+```
+
+### Advanced Assertions
+
+#### Properties and Deep Properties
+
+Assert the existence of properties and their values:
 
 ```typescript
 const testObject = { level1: { level2: 'value' } };
@@ -78,51 +111,136 @@ asyncTest();
 // Property existence
 expect(testObject).toHaveProperty('level1');
 
+// Property with specific value
+expect(testObject).toHaveProperty('level1.level2', 'value');
+
 // Deep Property existence
 expect(testObject).toHaveDeepProperty(['level1', 'level2']);
 ```
 
-- **Conditions and Comparisons:** Allow more intricate assertions like greater than, less than, or matching specific conditions.
+#### Conditions and Comparisons
+
+Perform more intricate assertions:
 
 ```typescript
-  // Greater Than
+// Numeric comparisons
 expect(5).toBeGreaterThan(3);
-
-  // Less Than
 expect(3).toBeLessThan(5);
+expect(5).toBeGreaterThanOrEqual(5);
+expect(5).toBeLessThanOrEqual(5);
+expect(0.1 + 0.2).toBeCloseTo(0.3, 10); // Floating point comparison with precision
+
+// Truthiness checks
+expect(true).toBeTrue();
+expect(false).toBeFalse();
+expect('non-empty').toBeTruthy();
+expect(0).toBeFalsy();
+
+// Null/Undefined checks
+expect(null).toBeNull();
+expect(undefined).toBeUndefined();
+expect(null).toBeNullOrUndefined();
 
 // Custom conditions
-  expect(7).customAssertion(value => value > 5, 'Value is not greater than 5');
+expect(7).customAssertion(value => value % 2 === 1, 'Value is not odd');
 ```
 
-- **Arrays and Objects:** Work seamlessly with arrays and objects, checking for containment, length, or specific values.
+#### Arrays and Collections
+
+Work seamlessly with arrays and collections:
 
 ```typescript
 const testArray = [1, 2, 3];
 
-  // Containment
-  expect(testArray).toContain(2);
-
-  // Array length
+// Array checks
+expect(testArray).toBeArray();
 expect(testArray).toHaveLength(3);
+expect(testArray).toContain(2);
+expect(testArray).toContainAll([1, 3]);
+expect(testArray).toExclude(4);
+expect([]).toBeEmptyArray();
+expect(testArray).toHaveLengthGreaterThan(2);
+expect(testArray).toHaveLengthLessThan(4);
 
-  // Object matching
-  expect({ name: 'Test', value: 123 }).toMatchObject({ name: 'Test' });
+// Deep equality in arrays
+expect([{ id: 1 }, { id: 2 }]).toContainEqual({ id: 1 });
 ```
 
-### Handling Promises and Async Operations
+#### Strings
 
-`@push.rocks/smartexpect` gracefully integrates with asynchronous operations, providing a `expectAsync` function that handles promise-based assertions. This keeps your tests clean and readable, irrespective of the nature of the code being tested.
+String-specific checks:
 
-### Best Practices
+```typescript
+expect('hello world').toStartWith('hello');
+expect('hello world').toEndWith('world');
+expect('hello world').toInclude('lo wo');
+expect('options').toBeOneOf(['choices', 'options', 'alternatives']);
+```
 
-- **Readability:** Favor clarity and readability by explicitly stating your expectations. `@push.rocks/smartexpect`'s API is designed to be fluent and expressive, making your tests easy to write and, more importantly, easy to read.
+#### Functions and Exceptions
 
-- **Comprehensive Coverage:** Utilize the full spectrum of assertions provided to cover a broad set of use cases, ensuring your code behaves as expected not just in ideal conditions but across various edge cases.
+Test function behavior and exceptions:
 
-- **Maintainability:** Group related assertions together to improve test maintainability. This makes it easier to update tests as your codebase evolves.
+```typescript
+const throwingFn = () => { throw new Error('test error'); };
+expect(throwingFn).toThrow();
+expect(throwingFn).toThrow(Error);
 
-Through judicious use of `@push.rocks/smartexpect`, you can enhance the reliability and maintainability of your test suite, making your codebase more robust and your development workflow more efficient.
+const safeFn = () => 'result';
+expect(safeFn).not.toThrow();
+```
+
+#### Date Assertions
+
+Work with dates:
+
+```typescript
+const now = new Date();
+const past = new Date(Date.now() - 10000);
+const future = new Date(Date.now() + 10000);
+
+expect(now).toBeDate();
+expect(now).toBeAfterDate(past);
+expect(now).toBeBeforeDate(future);
+```
+
+### Debugging Assertions
+
+The `log()` method is useful for debugging complex assertions:
+
+```typescript
+expect(complexObject)
+  .property('users')
+  .log() // Logs the current value in the assertion chain
+  .arrayItem(0)
+  .log() // Logs the first user
+  .property('permissions')
+  .log() // Logs the permissions object
+  .property('admin')
+  .toBeTrue();
+```
+
+### Customizing Error Messages
+
+You can provide custom error messages for more meaningful test failures:
+
+```typescript
+expect(user.age)
+  .setFailMessage('User age must be at least 18 for adult content')
+  .toBeGreaterThanOrEqual(18);
+```
+
+## Best Practices
+
+- **Human-readable assertions**: The fluent API is designed to create tests that read like natural language sentences.
+
+- **Precise error messages**: When tests fail, the error messages provide detailed information about what went wrong, including expected vs. actual values.
+
+- **Property path navigation**: Use the property path methods to navigate complex objects without creating temporary variables.
+
+- **Comprehensive testing**: Take advantage of the wide range of assertion methods to test various aspects of your code.
+
+- **Debugging with log()**: Use the `log()` method to see intermediate values in the assertion chain during test development.
 
 ## License and Legal Information
 

test/test.both.ts

@@ -0,0 +1,218 @@
+import { tap } from '@push.rocks/tapbundle';
+import * as smartexpect from '../ts/index.js';
+
+tap.test('basic type assertions', async () => {
+  // String type checks
+  smartexpect.expect('hello').toBeTypeofString();
+  smartexpect.expect(1).not.toBeTypeofString();
+
+  // Boolean type checks
+  smartexpect.expect(true).toBeTypeofBoolean();
+  smartexpect.expect(false).toBeTypeofBoolean();
+  smartexpect.expect(1).not.toBeTypeofBoolean();
+
+  // Number type checks
+  smartexpect.expect(42).toBeTypeofNumber();
+  smartexpect.expect(true).not.toBeTypeofNumber();
+
+  // Generic type checks with new method
+  smartexpect.expect(() => {}).toBeTypeOf('function');
+  smartexpect.expect(class Test {}).toBeTypeOf('function');
+  smartexpect.expect({}).toBeTypeOf('object');
+  smartexpect.expect(Symbol('test')).toBeTypeOf('symbol');
+});
+
+tap.test('async tests', async (toolsArg) => {
+  const deferred = toolsArg.defer();
+  toolsArg.delayFor(1000).then(() => {
+    deferred.resolve('hello');
+  });
+  await smartexpect.expectAsync(deferred.promise).timeout(2000).toBeTypeofString();
+  await smartexpect.expectAsync(deferred.promise).not.toBeTypeofBoolean();
+
+  // Test async timeout handling
+  const longOperation = toolsArg.defer();
+  toolsArg.delayFor(3000).then(() => {
+    longOperation.resolve('completed');
+  });
+  try {
+    await smartexpect.expectAsync(longOperation.promise).timeout(1000).toBeDefined();
+    throw new Error('Should have timed out');
+  } catch (err) {
+    // Expected timeout error
+    console.log('Successfully caught timeout:', err.message);
+  }
+});
+
+tap.test('equality and matching assertions', async () => {
+  // Basic equality
+  smartexpect.expect('hithere').toEqual('hithere');
+  smartexpect.expect('hithere').not.toEqual('hithere2');
+
+  // Object equality
+  const obj1 = { a: 1, b: { c: true } };
+  const obj2 = { a: 1, b: { c: true } };
+  const obj3 = { a: 1, b: { c: false } };
+  smartexpect.expect(obj1).toEqual(obj2);
+  smartexpect.expect(obj1).not.toEqual(obj3);
+
+  // RegExp matching
+  smartexpect.expect('hithere').toMatch(/hi/);
+  smartexpect.expect('hithere').toMatch(/^hithere$/);
+  smartexpect.expect('hithere').not.toMatch(/ho/);
+
+  // String inclusion
+  smartexpect.expect('hithere').toInclude('hit');
+  smartexpect.expect('hithere').not.toInclude('missing');
+
+  // String start/end
+  smartexpect.expect('hithere').toStartWith('hi');
+  smartexpect.expect('hithere').toEndWith('ere');
+});
+
+tap.test('object property assertions', async () => {
+  const testObject = {
+    topLevel: 'hello',
+    nested: {
+      prop: 42,
+      deeplyNested: {
+        array: [1, 2, 3],
+      },
+    },
+  };
+
+  // Basic property checks
+  smartexpect.expect(testObject).toHaveProperty('topLevel');
+  smartexpect.expect(testObject).toHaveProperty('topLevel', 'hello');
+  smartexpect.expect(testObject).not.toHaveProperty('missing');
+
+  // Drill-down property navigation
+  smartexpect.expect(testObject).property('nested').toHaveProperty('prop', 42);
+  smartexpect
+    .expect(testObject)
+    .property('nested')
+    .property('deeplyNested')
+    .property('array')
+    .toBeArray();
+
+  // Deep property checks
+  smartexpect.expect(testObject).toHaveDeepProperty(['nested', 'deeplyNested', 'array']);
+
+  // Array item navigation
+  smartexpect
+    .expect(testObject)
+    .property('nested')
+    .property('deeplyNested')
+    .property('array')
+    .arrayItem(0)
+    .toEqual(1);
+});
+
+tap.test('numeric comparison assertions', async () => {
+  // Greater/less than
+  smartexpect.expect(4).toBeGreaterThan(3);
+  smartexpect.expect(4).toBeLessThan(5);
+  smartexpect.expect(4).toBeGreaterThanOrEqual(4);
+  smartexpect.expect(4).toBeLessThanOrEqual(4);
+
+  // Approximate equality
+  smartexpect.expect(0.1 + 0.2).toBeCloseTo(0.3, 10);
+});
+
+tap.test('array assertions', async () => {
+  const obj1 = { id: 1 };
+  const obj2 = { id: 2 };
+  const testArray = [1, 'two', obj1, true];
+
+  // Basic array checks
+  smartexpect.expect(testArray).toBeArray();
+  smartexpect.expect(testArray).toHaveLength(4);
+
+  // Content checks
+  smartexpect.expect(testArray).toContain('two');
+  smartexpect.expect(testArray).toContain(obj1);
+  smartexpect.expect(testArray).not.toContain(obj2);
+
+  // Array with equal items (not same reference)
+  smartexpect.expect([{ a: 1 }, { b: 2 }]).toContainEqual({ a: 1 });
+
+  // Multiple values
+  smartexpect.expect(testArray).toContainAll([1, 'two']);
+  smartexpect.expect(testArray).toExclude('missing');
+
+  // Empty array
+  smartexpect.expect([]).toBeEmptyArray();
+
+  // Length comparisons
+  smartexpect.expect(testArray).toHaveLengthGreaterThan(3);
+  smartexpect.expect(testArray).toHaveLengthLessThan(5);
+});
+
+tap.test('boolean assertions', async () => {
+  // True/False
+  smartexpect.expect(true).toBeTrue();
+  smartexpect.expect(false).toBeFalse();
+
+  // Truthy/Falsy
+  smartexpect.expect('something').toBeTruthy();
+  smartexpect.expect(0).toBeFalsy();
+
+  // Null/Undefined
+  smartexpect.expect(null).toBeNull();
+  smartexpect.expect(undefined).toBeUndefined();
+  smartexpect.expect(null).toBeNullOrUndefined();
+  smartexpect.expect(undefined).toBeNullOrUndefined();
+});
+
+tap.test('function assertions', async () => {
+  // Function that throws
+  const throwingFn = () => {
+    throw new Error('test error');
+  };
+  smartexpect.expect(throwingFn).toThrow();
+  smartexpect.expect(throwingFn).toThrow(Error);
+
+  // Function that doesn't throw
+  const nonThrowingFn = () => 'safe';
+  smartexpect.expect(nonThrowingFn).not.toThrow();
+});
+
+tap.test('date assertions', async () => {
+  const now = new Date();
+  const past = new Date(Date.now() - 10000);
+  const future = new Date(Date.now() + 10000);
+
+  smartexpect.expect(now).toBeDate();
+  smartexpect.expect(now).toBeAfterDate(past);
+  smartexpect.expect(now).toBeBeforeDate(future);
+});
+
+tap.test('custom assertions', async () => {
+  // Custom validation logic
+  smartexpect.expect(42).customAssertion((value) => value % 2 === 0, 'Expected number to be even');
+
+  // With fail message
+  smartexpect.expect('test').setFailMessage('Custom fail message for assertion').toHaveLength(4);
+});
+
+tap.test('logging and debugging', async () => {
+  // Using log() for debugging
+  const complexObject = {
+    level1: {
+      level2: {
+        value: 'nested value',
+      },
+    },
+  };
+
+  // This logs the current value in the chain for debugging
+  smartexpect
+    .expect(complexObject)
+    .property('level1')
+    .property('level2')
+    .log()
+    .property('value')
+    .toEqual('nested value');
+});
+
+export default tap.start();

test/test.ts

@@ -1,52 +0,0 @@
-import { tap } from '@push.rocks/tapbundle';
-import * as smartexpect from '../ts/index.js';
-
-tap.test('sync tests', async () => {
-  smartexpect.expect('hello').toBeTypeofString();
-  smartexpect.expect(1).not.toBeTypeofString();
-  smartexpect.expect(true).toBeTypeofBoolean();
-  smartexpect.expect(true).not.toBeTypeofNumber();
-});
-
-tap.test('async tests', async (toolsArg) => {
-  const deferred = toolsArg.defer();
-  toolsArg.delayFor(4000).then(() => {
-    deferred.resolve('hello');
-  });
-  await smartexpect.expectAsync(deferred.promise).timeout(5000).toBeTypeofString();
-  await smartexpect.expectAsync(deferred.promise).not.toBeTypeofBoolean();
-});
-
-tap.test('should check equality', async () => {
-  smartexpect.expect('hithere').toEqual('hithere');
-  smartexpect.expect('hithere').not.toEqual('hithere2');
-});
-
-tap.test('should check for regexp matching', async () => {
-  smartexpect.expect('hithere').toMatch(/hi/);
-  smartexpect.expect('hithere').not.toMatch(/ho/);
-});
-
-tap.test('should correctly state property presence', async () => {
-  const testObject = {
-    aprop: 'hello',
-  };
-
-  smartexpect.expect(testObject).toHaveProperty('aprop');
-  smartexpect.expect(testObject).not.toHaveProperty('aprop2');
-});
-
-tap.test('should be greater than', async () => {
-  smartexpect.expect(4).toBeGreaterThan(3);
-  smartexpect.expect(4).toBeLessThan(5);
-});
-
-tap.test('should correctly determine toContain', async () => {
-  const hello = {
-    socool: 'yes',
-  };
-  const testArray = [hello];
-  smartexpect.expect(testArray).toContain(hello);
-});
-
-tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartexpect',
-  version: '1.2.1',
+  version: '1.6.1',
   description: 'A testing library to manage expectations in code, offering both synchronous and asynchronous assertion methods.'
 }

ts/smartexpect.classes.assertion.ts

@@ -5,9 +5,13 @@ export type TExecutionType = 'sync' | 'async';
 export class Assertion {
   executionMode: TExecutionType;
   baseReference: any;
-  propertyDrillDown: string[] = [];
+  propertyDrillDown: Array<string | number> = [];
+
   private notSetting = false;
   private timeoutSetting = 0;
+  private failMessage: string;
+  private successMessage: string;
+
   constructor(baseReferenceArg: any, executionModeArg: TExecutionType) {
     this.baseReference = baseReferenceArg;
     this.executionMode = executionModeArg;
@@ -16,11 +20,70 @@ export class Assertion {
   private getObjectToTestReference() {
     let returnObjectToTestReference = this.baseReference;
     for (const property of this.propertyDrillDown) {
+      if (returnObjectToTestReference == null) {
+        // if it's null or undefined, stop
+        break;
+      }
+
+      // We just directly access with bracket notation.
+      // If property is a string, it's like obj["someProp"];
+      // If property is a number, it's like obj[0].
       returnObjectToTestReference = returnObjectToTestReference[property];
     }
     return returnObjectToTestReference;
   }
 
+  private formatDrillDown(): string {
+    if (!this.propertyDrillDown || this.propertyDrillDown.length === 0) {
+      return '';
+    }
+    
+    const path = this.propertyDrillDown.map(prop => {
+      if (typeof prop === 'number') {
+        return `[${prop}]`;
+      } else {
+        return `.${prop}`;
+      }
+    }).join('');
+    
+    return path;
+  }
+  
+  private formatValue(value: any): string {
+    if (value === null) {
+      return 'null';
+    } else if (value === undefined) {
+      return 'undefined';
+    } else if (typeof value === 'object') {
+      try {
+        return JSON.stringify(value);
+      } catch (e) {
+        return `[Object ${value.constructor.name}]`;
+      }
+    } else if (typeof value === 'function') {
+      return `[Function${value.name ? ': ' + value.name : ''}]`;
+    } else if (typeof value === 'string') {
+      return `"${value}"`;
+    } else {
+      return String(value);
+    }
+  }
+
+  private createErrorMessage(message: string): string {
+    if (this.failMessage) {
+      return this.failMessage;
+    }
+    
+    const testValue = this.getObjectToTestReference();
+    const formattedValue = this.formatValue(testValue);
+    const drillDown = this.formatDrillDown();
+    
+    // Replace placeholders in the message
+    return message
+      .replace('{value}', formattedValue)
+      .replace('{path}', drillDown || '');
+  }
+
   public get not() {
     this.notSetting = true;
     return this;
@@ -31,13 +94,11 @@ export class Assertion {
     return this;
   }
 
-  private failMessage: string;
   public setFailMessage(failMessageArg: string) {
     this.failMessage = failMessageArg;
     return this;
   }
 
-  private successMessage: string;
   public setSuccessMessage(successMessageArg: string) {
     this.successMessage = successMessageArg;
     return this;
@@ -55,7 +116,7 @@ export class Assertion {
           isOk = true;
         }
         if (!isOk) {
-          throw new Error(this.failMessage || 'Negated assertion is not ok!');
+          throw new Error(this.failMessage || 'Negated assertion failed');
         }
       }
     };
@@ -63,16 +124,16 @@ export class Assertion {
     if (this.executionMode === 'async') {
       const done = plugins.smartpromise.defer();
       if (!(this.baseReference instanceof Promise)) {
-        done.reject(new Error(`${this.baseReference} is not of type promise.`));
+        done.reject(new Error(`Expected a Promise but received: ${this.formatValue(this.baseReference)}`));
       } else {
         if (this.timeoutSetting) {
           plugins.smartdelay.delayFor(this.timeoutSetting).then(() => {
             if (done.status === 'pending') {
-              done.reject(new Error(`${this.baseReference} timed out at ${this.timeoutSetting}!`));
+              done.reject(new Error(`Promise timed out after ${this.timeoutSetting}ms`));
             }
           });
         }
-        this.baseReference.then((promiseResultArg) => {
+        this.baseReference.then((promiseResultArg: any) => {
           this.baseReference = promiseResultArg;
           done.resolve(runDirectOrNegated(checkFunction));
         });
@@ -83,29 +144,22 @@ export class Assertion {
     }
   }
 
-  /**
-   * checks if the given object is defined
-   */
   public toBeDefined() {
     return this.runCheck(() => {
       if (this.getObjectToTestReference() === undefined) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not defined`
+          this.createErrorMessage('Expected value{path} to be defined, but got undefined')
         );
       }
     });
   }
 
-  /**
-   * checks if the given object is not defined
-   */
   public toBeTypeofString() {
     return this.runCheck(() => {
-      if (typeof this.getObjectToTestReference() !== 'string') {
+      const value = this.getObjectToTestReference();
+      if (typeof value !== 'string') {
         throw new Error(
-          this.failMessage || `Assertion failed: ${this.baseReference} with drill down ${
-            this.propertyDrillDown
-          } is not of type string, but typeof ${typeof this.baseReference}`
+          this.createErrorMessage(`Expected value{path} to be of type string, but got ${typeof value}`)
         );
       }
     });
@@ -113,11 +167,10 @@ export class Assertion {
 
   public toBeTypeofNumber() {
     return this.runCheck(() => {
-      if (typeof this.getObjectToTestReference() !== 'number') {
+      const value = this.getObjectToTestReference();
+      if (typeof value !== 'number') {
         throw new Error(
-          this.failMessage || `Assertion failed: ${this.baseReference} with drill down ${
-            this.propertyDrillDown
-          } is not of type string, but typeof ${typeof this.baseReference}`
+          this.createErrorMessage(`Expected value{path} to be of type number, but got ${typeof value}`)
         );
       }
     });
@@ -125,11 +178,22 @@ export class Assertion {
 
   public toBeTypeofBoolean() {
     return this.runCheck(() => {
-      if (typeof this.getObjectToTestReference() !== 'boolean') {
+      const value = this.getObjectToTestReference();
+      if (typeof value !== 'boolean') {
         throw new Error(
-          this.failMessage || `Assertion failed: ${this.baseReference} with drill down ${
-            this.propertyDrillDown
-          } is not of type string, but typeof ${typeof this.baseReference}`
+          this.createErrorMessage(`Expected value{path} to be of type boolean, but got ${typeof value}`)
+        );
+      }
+    });
+  }
+
+  public toBeTypeOf(expectedType: string) {
+    return this.runCheck(() => {
+      const value = this.getObjectToTestReference();
+      const actualType = typeof value;
+      if (actualType !== expectedType) {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to be of type ${expectedType}, but got ${actualType}`)
         );
       }
     });
@@ -137,10 +201,11 @@ export class Assertion {
 
   public toEqual(comparisonObject: any) {
     return this.runCheck(() => {
-      const result = plugins.fastDeepEqual(this.getObjectToTestReference(), comparisonObject);
+      const value = this.getObjectToTestReference();
+      const result = plugins.fastDeepEqual(value, comparisonObject);
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not equal ${comparisonObject}`
+          this.createErrorMessage(`Expected value{path} to equal ${this.formatValue(comparisonObject)}`)
         );
       }
     });
@@ -148,10 +213,11 @@ export class Assertion {
 
   public toMatch(comparisonObject: RegExp) {
     return this.runCheck(() => {
-      const result = comparisonObject.test(this.getObjectToTestReference());
+      const value = this.getObjectToTestReference();
+      const result = comparisonObject.test(value);
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not equal ${comparisonObject}`
+          this.createErrorMessage(`Expected value{path} to match regex ${comparisonObject}`)
         );
       }
     });
@@ -159,12 +225,11 @@ export class Assertion {
 
   public toBeTrue() {
     return this.runCheck(() => {
-      const result =
-        typeof this.getObjectToTestReference() === 'boolean' &&
-        this.getObjectToTestReference() === true;
+      const value = this.getObjectToTestReference();
+      const result = typeof value === 'boolean' && value === true;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not true or not of type boolean`
+          this.createErrorMessage(`Expected value{path} to be true, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -172,12 +237,11 @@ export class Assertion {
 
   public toBeFalse() {
     return this.runCheck(() => {
-      const result =
-        typeof this.getObjectToTestReference() === 'boolean' &&
-        this.getObjectToTestReference() === false;
+      const value = this.getObjectToTestReference();
+      const result = typeof value === 'boolean' && value === false;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not false or not of type boolean`
+          this.createErrorMessage(`Expected value{path} to be false, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -185,10 +249,11 @@ export class Assertion {
 
   public toBeInstanceOf(classArg: any) {
     return this.runCheck(() => {
-      const result = this.getObjectToTestReference() instanceof classArg;
+      const value = this.getObjectToTestReference();
+      const result = value instanceof classArg;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not an instance of ${classArg}`
+          this.createErrorMessage(`Expected value{path} to be an instance of ${classArg.name || 'provided class'}`)
         );
       }
     });
@@ -196,16 +261,18 @@ export class Assertion {
 
   public toHaveProperty(propertyArg: string, equalsArg?: any) {
     return this.runCheck(() => {
-      const result = !!this.getObjectToTestReference()[propertyArg];
-      if (!result) {
+      const obj = this.getObjectToTestReference();
+      if (!obj || !(propertyArg in obj)) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not have property ${propertyArg}`
+          this.createErrorMessage(`Expected value{path} to have property '${propertyArg}'`)
         );
       }
-      if (equalsArg) {
-        if (result !== equalsArg) {
+      if (equalsArg !== undefined) {
+        if (obj[propertyArg] !== equalsArg) {
           throw new Error(
-            this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does have property ${propertyArg}, but it does not equal ${equalsArg}`
+            this.createErrorMessage(
+              `Expected property '${propertyArg}' of value{path} to equal ${this.formatValue(equalsArg)}, but got ${this.formatValue(obj[propertyArg])}`
+            )
           );
         }
       }
@@ -225,7 +292,9 @@ export class Assertion {
         }
 
         if (!obj || !(property in obj)) {
-          throw new Error(this.failMessage || `Missing property at path "${currentPath}" in ${this.baseReference}`);
+          throw new Error(
+            this.createErrorMessage(`Expected value{path} to have property at path '${currentPath}'`)
+          );
         }
         obj = obj[property];
       }
@@ -234,10 +303,11 @@ export class Assertion {
 
   public toBeGreaterThan(numberArg: number) {
     return this.runCheck(() => {
-      const result = this.getObjectToTestReference() > numberArg;
+      const value = this.getObjectToTestReference();
+      const result = value > numberArg;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not greater than ${numberArg}`
+          this.createErrorMessage(`Expected value{path} to be greater than ${numberArg}, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -245,10 +315,11 @@ export class Assertion {
 
   public toBeLessThan(numberArg: number) {
     return this.runCheck(() => {
-      const result = this.getObjectToTestReference() < numberArg;
+      const value = this.getObjectToTestReference();
+      const result = value < numberArg;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not less than ${numberArg}`
+          this.createErrorMessage(`Expected value{path} to be less than ${numberArg}, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -256,10 +327,11 @@ export class Assertion {
 
   public toBeNull() {
     return this.runCheck(() => {
-      const result = this.getObjectToTestReference() === null;
+      const value = this.getObjectToTestReference();
+      const result = value === null;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not null`
+          this.createErrorMessage(`Expected value{path} to be null, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -267,10 +339,11 @@ export class Assertion {
 
   public toBeUndefined() {
     return this.runCheck(() => {
-      const result = this.getObjectToTestReference() === undefined;
+      const value = this.getObjectToTestReference();
+      const result = value === undefined;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not undefined`
+          this.createErrorMessage(`Expected value{path} to be undefined, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -278,26 +351,25 @@ export class Assertion {
 
   public toBeNullOrUndefined() {
     return this.runCheck(() => {
-      const result =
-        this.getObjectToTestReference() === null || this.getObjectToTestReference() === undefined;
+      const value = this.getObjectToTestReference();
+      const result = value === null || value === undefined;
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not null or undefined`
+          this.createErrorMessage(`Expected value{path} to be null or undefined, but got ${this.formatValue(value)}`)
         );
       }
     });
   }
 
-  // Array
+  // Array checks
 
   public toContain(itemArg: any) {
     return this.runCheck(() => {
-      const result =
-        this.getObjectToTestReference() instanceof Array &&
-        this.getObjectToTestReference().includes(itemArg);
+      const value = this.getObjectToTestReference();
+      const result = Array.isArray(value) && value.includes(itemArg);
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not contain ${itemArg}`
+          this.createErrorMessage(`Expected array{path} to contain ${this.formatValue(itemArg)}`)
         );
       }
     });
@@ -305,40 +377,49 @@ export class Assertion {
 
   public toBeEmptyArray() {
     return this.runCheck(() => {
-      const arrayRef = this.getObjectToTestReference();
-      if (!Array.isArray(arrayRef) || arrayRef.length !== 0) {
-        throw new Error(this.failMessage || `Expected ${this.baseReference} to be an empty array, but it was not.`);
+      const value = this.getObjectToTestReference();
+      if (!Array.isArray(value)) {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof value}`)
+        );
+      }
+      if (value.length !== 0) {
+        throw new Error(
+          this.createErrorMessage(`Expected array{path} to be empty, but it has ${value.length} elements`)
+        );
       }
     });
   }
 
   public toContainAll(values: any[]) {
     return this.runCheck(() => {
-      const arrayRef = this.getObjectToTestReference();
-      if (!Array.isArray(arrayRef)) {
-        throw new Error(this.failMessage || `Expected ${this.baseReference} to be an array.`);
-      }
-
-      for (const value of values) {
-        if (!arrayRef.includes(value)) {
+      const arr = this.getObjectToTestReference();
+      if (!Array.isArray(arr)) {
         throw new Error(
-            this.failMessage || `Expected ${this.baseReference} to include value "${value}", but it did not.`
+          this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof arr}`)
         );
       }
+      
+      const missing = values.filter(v => !arr.includes(v));
+      if (missing.length > 0) {
+        throw new Error(
+          this.createErrorMessage(`Expected array{path} to contain all values ${this.formatValue(values)}, but missing: ${this.formatValue(missing)}`)
+        );
       }
     });
   }
 
   public toExclude(value: any) {
     return this.runCheck(() => {
-      const arrayRef = this.getObjectToTestReference();
-      if (!Array.isArray(arrayRef)) {
-        throw new Error(this.failMessage || `Expected ${this.baseReference} to be an array.`);
-      }
-
-      if (arrayRef.includes(value)) {
+      const arr = this.getObjectToTestReference();
+      if (!Array.isArray(arr)) {
         throw new Error(
-          this.failMessage || `Expected ${this.baseReference} to exclude value "${value}", but it included it.`
+          this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof arr}`)
+        );
+      }
+      if (arr.includes(value)) {
+        throw new Error(
+          this.createErrorMessage(`Expected array{path} to exclude ${this.formatValue(value)}, but it was found`)
         );
       }
     });
@@ -346,11 +427,11 @@ export class Assertion {
 
   public toStartWith(itemArg: any) {
     return this.runCheck(() => {
-      const testObject = this.getObjectToTestReference();
-      const result = typeof testObject === 'string' && testObject.startsWith(itemArg);
+      const value = this.getObjectToTestReference();
+      const result = typeof value === 'string' && value.startsWith(itemArg);
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not contain ${itemArg}`
+          this.createErrorMessage(`Expected string{path} to start with "${itemArg}", but got "${value}"`)
         );
       }
     });
@@ -358,24 +439,23 @@ export class Assertion {
 
   public toEndWith(itemArg: any) {
     return this.runCheck(() => {
-      const testObject = this.getObjectToTestReference();
-      const result = typeof testObject === 'string' && testObject.endsWith(itemArg);
+      const value = this.getObjectToTestReference();
+      const result = typeof value === 'string' && value.endsWith(itemArg);
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not contain ${itemArg}`
+          this.createErrorMessage(`Expected string{path} to end with "${itemArg}", but got "${value}"`)
         );
       }
     });
   }
 
-  // ... previous code ...
-
   public toBeOneOf(values: any[]) {
     return this.runCheck(() => {
-      const result = values.includes(this.getObjectToTestReference());
+      const value = this.getObjectToTestReference();
+      const result = values.includes(value);
       if (!result) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not one of ${values}`
+          this.createErrorMessage(`Expected value{path} to be one of ${this.formatValue(values)}, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -384,9 +464,14 @@ export class Assertion {
   public toHaveLength(length: number) {
     return this.runCheck(() => {
       const obj = this.getObjectToTestReference();
-      if (typeof obj.length !== 'number' || obj.length !== length) {
+      if (typeof obj.length !== 'number') {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not have a length of ${length}`
+          this.createErrorMessage(`Expected value{path} to have a length property, but it doesn't`)
+        );
+      }
+      if (obj.length !== length) {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to have length ${length}, but got length ${obj.length}`)
         );
       }
     });
@@ -394,10 +479,12 @@ export class Assertion {
 
   public toBeCloseTo(value: number, precision = 2) {
     return this.runCheck(() => {
-      const difference = Math.abs(this.getObjectToTestReference() - value);
-      if (difference > Math.pow(10, -precision) / 2) {
+      const actual = this.getObjectToTestReference();
+      const difference = Math.abs(actual - value);
+      const epsilon = Math.pow(10, -precision) / 2;
+      if (difference > epsilon) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not close to ${value} up to ${precision} decimal places`
+          this.createErrorMessage(`Expected value{path} to be close to ${value} (within ${epsilon}), but the difference was ${difference}`)
         );
       }
     });
@@ -405,28 +492,42 @@ export class Assertion {
 
   public toThrow(expectedError?: any) {
     return this.runCheck(() => {
+      const fn = this.getObjectToTestReference();
+      if (typeof fn !== 'function') {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to be a function, but got ${typeof fn}`)
+        );
+      }
+      
       let thrown = false;
+      let error: any;
+      
       try {
-        this.getObjectToTestReference()();
+        fn();
       } catch (e) {
         thrown = true;
+        error = e;
         if (expectedError && !(e instanceof expectedError)) {
           throw new Error(
-            this.failMessage || `Expected function to throw ${expectedError.name}, but it threw ${e.name}`
+            this.createErrorMessage(`Expected function{path} to throw ${expectedError.name}, but it threw ${e.constructor.name}`)
           );
         }
       }
+      
       if (!thrown) {
-        throw new Error(`Expected function to throw, but it didn't.`);
+        throw new Error(
+          this.createErrorMessage(`Expected function{path} to throw, but it didn't throw any error`)
+        );
       }
     });
   }
 
   public toBeTruthy() {
     return this.runCheck(() => {
-      if (!this.getObjectToTestReference()) {
+      const value = this.getObjectToTestReference();
+      if (!value) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not truthy`
+          this.createErrorMessage(`Expected value{path} to be truthy, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -434,9 +535,10 @@ export class Assertion {
 
   public toBeFalsy() {
     return this.runCheck(() => {
-      if (this.getObjectToTestReference()) {
+      const value = this.getObjectToTestReference();
+      if (value) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not falsy`
+          this.createErrorMessage(`Expected value{path} to be falsy, but got ${this.formatValue(value)}`)
         );
       }
     });
@@ -444,9 +546,10 @@ export class Assertion {
 
   public toBeGreaterThanOrEqual(numberArg: number) {
     return this.runCheck(() => {
-      if (this.getObjectToTestReference() <= numberArg) {
+      const value = this.getObjectToTestReference();
+      if (value < numberArg) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not greater than or equal to ${numberArg}`
+          this.createErrorMessage(`Expected value{path} to be greater than or equal to ${numberArg}, but got ${value}`)
         );
       }
     });
@@ -454,9 +557,10 @@ export class Assertion {
 
   public toBeLessThanOrEqual(numberArg: number) {
     return this.runCheck(() => {
-      if (this.getObjectToTestReference() >= numberArg) {
+      const value = this.getObjectToTestReference();
+      if (value > numberArg) {
         throw new Error(
-          `${this.baseReference} with drill down ${this.propertyDrillDown} is not less than or equal to ${numberArg}`
+          this.createErrorMessage(`Expected value{path} to be less than or equal to ${numberArg}, but got ${value}`)
         );
       }
     });
@@ -464,10 +568,11 @@ export class Assertion {
 
   public toMatchObject(objectArg: object) {
     return this.runCheck(() => {
-      const partialMatch = plugins.fastDeepEqual(this.getObjectToTestReference(), objectArg); // Note: Implement a deep comparison function or use one from a library
-      if (!partialMatch) {
+      const value = this.getObjectToTestReference();
+      const matchResult = plugins.fastDeepEqual(value, objectArg);
+      if (!matchResult) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not match the object ${objectArg}`
+          this.createErrorMessage(`Expected value{path} to match ${this.formatValue(objectArg)}`)
         );
       }
     });
@@ -476,10 +581,16 @@ export class Assertion {
   public toContainEqual(value: any) {
     return this.runCheck(() => {
       const arr = this.getObjectToTestReference();
-      const found = arr.some((item: any) => plugins.fastDeepEqual(item, value)); // Assuming fastDeepEqual checks deep equality
+      if (!Array.isArray(arr)) {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof arr}`)
+        );
+      }
+      
+      const found = arr.some((item: any) => plugins.fastDeepEqual(item, value));
       if (!found) {
         throw new Error(
-          `${this.baseReference} with drill down ${this.propertyDrillDown} does not contain the value ${value}`
+          this.createErrorMessage(`Expected array{path} to contain an item equal to ${this.formatValue(value)}`)
         );
       }
     });
@@ -487,9 +598,10 @@ export class Assertion {
 
   public toBeArray() {
     return this.runCheck(() => {
-      if (!Array.isArray(this.getObjectToTestReference())) {
+      const value = this.getObjectToTestReference();
+      if (!Array.isArray(value)) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not an array`
+          this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof value}`)
         );
       }
     });
@@ -497,9 +609,15 @@ export class Assertion {
 
   public toInclude(substring: string) {
     return this.runCheck(() => {
-      if (!this.getObjectToTestReference().includes(substring)) {
+      const value = this.getObjectToTestReference();
+      if (typeof value !== 'string') {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not include the substring ${substring}`
+          this.createErrorMessage(`Expected value{path} to be a string, but got ${typeof value}`)
+        );
+      }
+      if (!value.includes(substring)) {
+        throw new Error(
+          this.createErrorMessage(`Expected string{path} to include "${substring}", but it doesn't`)
         );
       }
     });
@@ -508,9 +626,14 @@ export class Assertion {
   public toHaveLengthGreaterThan(length: number) {
     return this.runCheck(() => {
       const obj = this.getObjectToTestReference();
-      if (typeof obj.length !== 'number' || obj.length <= length) {
+      if (typeof obj.length !== 'number') {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not have a length greater than ${length}`
+          this.createErrorMessage(`Expected value{path} to have a length property, but it doesn't`)
+        );
+      }
+      if (obj.length <= length) {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to have length greater than ${length}, but got length ${obj.length}`)
         );
       }
     });
@@ -519,9 +642,14 @@ export class Assertion {
   public toHaveLengthLessThan(length: number) {
     return this.runCheck(() => {
       const obj = this.getObjectToTestReference();
-      if (typeof obj.length !== 'number' || obj.length >= length) {
+      if (typeof obj.length !== 'number') {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} does not have a length less than ${length}`
+          this.createErrorMessage(`Expected value{path} to have a length property, but it doesn't`)
+        );
+      }
+      if (obj.length >= length) {
+        throw new Error(
+          this.createErrorMessage(`Expected value{path} to have length less than ${length}, but got length ${obj.length}`)
         );
       }
     });
@@ -529,9 +657,10 @@ export class Assertion {
 
   public toBeDate() {
     return this.runCheck(() => {
-      if (!(this.getObjectToTestReference() instanceof Date)) {
+      const value = this.getObjectToTestReference();
+      if (!(value instanceof Date)) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not a date`
+          this.createErrorMessage(`Expected value{path} to be a Date, but got ${value.constructor ? value.constructor.name : typeof value}`)
         );
       }
     });
@@ -539,9 +668,15 @@ export class Assertion {
 
   public toBeBeforeDate(date: Date) {
     return this.runCheck(() => {
-      if (!(this.getObjectToTestReference() < date)) {
+      const value = this.getObjectToTestReference();
+      if (!(value instanceof Date)) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not before ${date}`
+          this.createErrorMessage(`Expected value{path} to be a Date, but got ${value.constructor ? value.constructor.name : typeof value}`)
+        );
+      }
+      if (value >= date) {
+        throw new Error(
+          this.createErrorMessage(`Expected date{path} to be before ${date.toISOString()}, but got ${value.toISOString()}`)
         );
       }
     });
@@ -549,24 +684,53 @@ export class Assertion {
 
   public toBeAfterDate(date: Date) {
     return this.runCheck(() => {
-      if (!(this.getObjectToTestReference() > date)) {
+      const value = this.getObjectToTestReference();
+      if (!(value instanceof Date)) {
         throw new Error(
-          this.failMessage || `${this.baseReference} with drill down ${this.propertyDrillDown} is not after ${date}`
+          this.createErrorMessage(`Expected value{path} to be a Date, but got ${value.constructor ? value.constructor.name : typeof value}`)
+        );
+      }
+      if (value <= date) {
+        throw new Error(
+          this.createErrorMessage(`Expected date{path} to be after ${date.toISOString()}, but got ${value.toISOString()}`)
         );
       }
     });
   }
 
-  public customAssertion(assertionFunction: (value: any) => boolean, errorMessage: string) {
+  public customAssertion(
+    assertionFunction: (value: any) => boolean,
+    errorMessage: string
+  ) {
     return this.runCheck(() => {
-      if (!assertionFunction(this.getObjectToTestReference())) {
+      const value = this.getObjectToTestReference();
+      if (!assertionFunction(value)) {
         throw new Error(this.failMessage || errorMessage);
       }
     });
   }
 
+  /**
+   * Drill into a property
+   */
   public property(propertyNameArg: string) {
     this.propertyDrillDown.push(propertyNameArg);
     return this;
   }
+
+  /**
+   * Drill into an array index
+   */
+  public arrayItem(indexArg: number) {
+    // Save the number (instead of "[index]")
+    this.propertyDrillDown.push(indexArg);
+    return this;
+  }
+
+  public log() {
+    console.log(`Current value:`);
+    console.log(JSON.stringify(this.getObjectToTestReference(), null, 2));
+    console.log(`Path: ${this.formatDrillDown() || '(root)'}`);
+    return this;
+  }
 }

tsconfig.json

@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
     "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "useDefineForClassFields": false,
     "target": "ES2022",
     "module": "NodeNext",