push.rocks/smartexpect
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat(assertion): Enhanced the assertion error messaging and added new test cases.

Browse Source
This commit is contained in:
Philipp Kunz 2025-03-04 12:20:06 +00:00
parent 5f5628f647
commit f0ab180902
8 changed files with 1627 additions and 1524 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
changelog.md
View File

@ -1,5 +1,12 @@
# Changelog
## 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

2163
pnpm-lock.yaml generated
View File

File diff suppressed because it is too large Load Diff

210
readme.md
View File

@ -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,68 +63,184 @@ 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.
```typescript
const testObject = { level1: { level2: 'value' } };
You can navigate complex objects using the `property()` and `arrayItem()` methods:
// Property existence
expect(testObject).toHaveProperty('level1');
// Deep Property existence
expect(testObject).toHaveDeepProperty(['level1', 'level2']);
```
```typescript
const complexObject = {
users: [
{ id: 1, name: 'Alice', permissions: { admin: true } },
{ id: 2, name: 'Bob', permissions: { admin: false } }
]
};
- **Conditions and Comparisons:** Allow more intricate assertions like greater than, less than, or matching specific conditions.
// Navigate to a nested property
expect(complexObject)
.property('users')
.arrayItem(0)
.property('name')
.toEqual('Alice');
```typescript
// Greater Than
expect(5).toBeGreaterThan(3);
// Check nested permission
expect(complexObject)
.property('users')
.arrayItem(0)
.property('permissions')
.property('admin')
.toBeTrue();
```
// Less Than
expect(3).toBeLessThan(5);
### Advanced Assertions
// Custom conditions
expect(7).customAssertion(value => value > 5, 'Value is not greater than 5');
```
#### Properties and Deep Properties
- **Arrays and Objects:** Work seamlessly with arrays and objects, checking for containment, length, or specific values.
Assert the existence of properties and their values:
```typescript
const testArray = [1, 2, 3];
```typescript
const testObject = { level1: { level2: 'value' } };
// Containment
expect(testArray).toContain(2);
// Property existence
expect(testObject).toHaveProperty('level1');
// Array length
expect(testArray).toHaveLength(3);
// Property with specific value
expect(testObject).toHaveProperty('level1.level2', 'value');
// Object matching
expect({ name: 'Test', value: 123 }).toMatchObject({ name: 'Test' });
```
// Deep Property existence
expect(testObject).toHaveDeepProperty(['level1', 'level2']);
```
### Handling Promises and Async Operations
#### Conditions and Comparisons
`@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.
Perform more intricate assertions:
### Best Practices
```typescript
// Numeric comparisons
expect(5).toBeGreaterThan(3);
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
- **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.
// Truthiness checks
expect(true).toBeTrue();
expect(false).toBeFalse();
expect('non-empty').toBeTruthy();
expect(0).toBeFalsy();
- **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.
// Null/Undefined checks
expect(null).toBeNull();
expect(undefined).toBeUndefined();
expect(null).toBeNullOrUndefined();
- **Maintainability:** Group related assertions together to improve test maintainability. This makes it easier to update tests as your codebase evolves.
// Custom conditions
expect(7).customAssertion(value => value % 2 === 1, 'Value is not odd');
```
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.
#### Arrays and Collections
Work seamlessly with arrays and collections:
```typescript
const testArray = [1, 2, 3];
// 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);
// Deep equality in arrays
expect([{ id: 1 }, { id: 2 }]).toContainEqual({ id: 1 });
```
#### Strings
String-specific checks:
```typescript
expect('hello world').toStartWith('hello');
expect('hello world').toEndWith('world');
expect('hello world').toInclude('lo wo');
expect('options').toBeOneOf(['choices', 'options', 'alternatives']);
```
#### Functions and Exceptions
Test function behavior and exceptions:
```typescript
const throwingFn = () => { throw new Error('test error'); };
expect(throwingFn).toThrow();
expect(throwingFn).toThrow(Error);
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
@ -141,4 +259,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

204
test/test.both.ts Normal file
View File

@ -0,0 +1,204 @@
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();

52
test/test.ts
View File

@ -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();

2
ts/00_commitinfo_data.ts
View File

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

512
ts/smartexpect.classes.assertion.ts
View File

@ -33,6 +33,57 @@ export class Assertion {
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;
@ -65,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');
}
}
};
@ -73,12 +124,12 @@ 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`));
}
});
}
@ -97,8 +148,7 @@ export class Assertion {
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')
);
}
});
@ -106,12 +156,10 @@ export class Assertion {
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}`)
);
}
});
@ -119,12 +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}`)
);
}
});
@ -132,78 +178,10 @@ 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}`
);
}
});
}
public toEqual(comparisonObject: any) {
return this.runCheck(() => {
const result = plugins.fastDeepEqual(this.getObjectToTestReference(), comparisonObject);
if (!result) {
throw new Error(
this.failMessage ||
`${this.baseReference} with drill down ${this.propertyDrillDown} does not equal ${comparisonObject}`
);
}
});
}
public toMatch(comparisonObject: RegExp) {
return this.runCheck(() => {
const result = comparisonObject.test(this.getObjectToTestReference());
if (!result) {
throw new Error(
this.failMessage ||
`${this.baseReference} with drill down ${
this.propertyDrillDown
} does not match regex ${comparisonObject}`
);
}
});
}
public toBeTrue() {
return this.runCheck(() => {
const result =
typeof this.getObjectToTestReference() === 'boolean' &&
this.getObjectToTestReference() === true;
if (!result) {
throw new Error(
this.failMessage ||
`${this.baseReference} with drill down ${this.propertyDrillDown} is not true or not of type boolean`
);
}
});
}
public toBeFalse() {
return this.runCheck(() => {
const result =
typeof this.getObjectToTestReference() === 'boolean' &&
this.getObjectToTestReference() === false;
if (!result) {
throw new Error(
this.failMessage ||
`${this.baseReference} with drill down ${this.propertyDrillDown} is not false or not of type boolean`
);
}
});
}
public toBeInstanceOf(classArg: any) {
return this.runCheck(() => {
const result = this.getObjectToTestReference() 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 of type boolean, but got ${typeof value}`)
);
}
});
@ -211,13 +189,71 @@ export class Assertion {
public toBeTypeOf(expectedType: string) {
return this.runCheck(() => {
const actualType = typeof this.getObjectToTestReference();
const value = this.getObjectToTestReference();
const actualType = typeof value;
if (actualType !== expectedType) {
throw new Error(
this.failMessage ||
`Assertion failed: ${this.baseReference} with drill down ${
this.propertyDrillDown
} is not of type ${expectedType}, but typeof ${actualType}`
this.createErrorMessage(`Expected value{path} to be of type ${expectedType}, but got ${actualType}`)
);
}
});
}
public toEqual(comparisonObject: any) {
return this.runCheck(() => {
const value = this.getObjectToTestReference();
const result = plugins.fastDeepEqual(value, comparisonObject);
if (!result) {
throw new Error(
this.createErrorMessage(`Expected value{path} to equal ${this.formatValue(comparisonObject)}`)
);
}
});
}
public toMatch(comparisonObject: RegExp) {
return this.runCheck(() => {
const value = this.getObjectToTestReference();
const result = comparisonObject.test(value);
if (!result) {
throw new Error(
this.createErrorMessage(`Expected value{path} to match regex ${comparisonObject}`)
);
}
});
}
public toBeTrue() {
return this.runCheck(() => {
const value = this.getObjectToTestReference();
const result = typeof value === 'boolean' && value === true;
if (!result) {
throw new Error(
this.createErrorMessage(`Expected value{path} to be true, but got ${this.formatValue(value)}`)
);
}
});
}
public toBeFalse() {
return this.runCheck(() => {
const value = this.getObjectToTestReference();
const result = typeof value === 'boolean' && value === false;
if (!result) {
throw new Error(
this.createErrorMessage(`Expected value{path} to be false, but got ${this.formatValue(value)}`)
);
}
});
}
public toBeInstanceOf(classArg: any) {
return this.runCheck(() => {
const value = this.getObjectToTestReference();
const result = value instanceof classArg;
if (!result) {
throw new Error(
this.createErrorMessage(`Expected value{path} to be an instance of ${classArg.name || 'provided class'}`)
);
}
});
@ -228,19 +264,15 @@ export class Assertion {
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 !== 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])}`
)
);
}
}
@ -261,8 +293,7 @@ export class Assertion {
if (!obj || !(property in obj)) {
throw new Error(
this.failMessage ||
`Missing property at path "${currentPath}" in ${this.baseReference}`
this.createErrorMessage(`Expected value{path} to have property at path '${currentPath}'`)
);
}
obj = obj[property];
@ -272,11 +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)}`)
);
}
});
@ -284,11 +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)}`)
);
}
});
@ -296,11 +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)}`)
);
}
});
@ -308,11 +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)}`)
);
}
});
@ -320,12 +351,11 @@ export class Assertion {
public toBeNullOrUndefined() {
return this.runCheck(() => {
const testRef = this.getObjectToTestReference();
const result = testRef === null || testRef === 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)}`)
);
}
});
@ -335,12 +365,11 @@ export class Assertion {
public toContain(itemArg: any) {
return this.runCheck(() => {
const testRef = this.getObjectToTestReference();
const result = Array.isArray(testRef) && testRef.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} does not contain ${itemArg}`
this.createErrorMessage(`Expected array{path} to contain ${this.formatValue(itemArg)}`)
);
}
});
@ -348,11 +377,15 @@ export class Assertion {
public toBeEmptyArray() {
return this.runCheck(() => {
const arrayRef = this.getObjectToTestReference();
if (!Array.isArray(arrayRef) || arrayRef.length !== 0) {
const value = this.getObjectToTestReference();
if (!Array.isArray(value)) {
throw new Error(
this.failMessage ||
`Expected ${this.baseReference} to be an empty array, but it was not.`
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`)
);
}
});
@ -360,41 +393,33 @@ export class Assertion {
public toContainAll(values: any[]) {
return this.runCheck(() => {
const arrayRef = this.getObjectToTestReference();
if (!Array.isArray(arrayRef)) {
const arr = this.getObjectToTestReference();
if (!Array.isArray(arr)) {
throw new Error(
this.failMessage ||
`Expected ${this.baseReference} with drill down ${
this.propertyDrillDown
} to be an array.`
this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof arr}`)
);
}
for (const value of values) {
if (!arrayRef.includes(value)) {
throw new Error(
this.failMessage ||
`Expected ${this.baseReference} to include value "${value}", but it did not.`
);
}
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)) {
const arr = this.getObjectToTestReference();
if (!Array.isArray(arr)) {
throw new Error(
this.failMessage ||
`Expected ${this.baseReference} with drill down ${
this.propertyDrillDown
} to be an array.`
this.createErrorMessage(`Expected value{path} to be an array, but got ${typeof arr}`)
);
}
if (arrayRef.includes(value)) {
if (arr.includes(value)) {
throw new Error(
this.failMessage ||
`Expected ${this.baseReference} to exclude value "${value}", but it included it.`
this.createErrorMessage(`Expected array{path} to exclude ${this.formatValue(value)}, but it was found`)
);
}
});
@ -402,14 +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
} does not start with ${itemArg}`
this.createErrorMessage(`Expected string{path} to start with "${itemArg}", but got "${value}"`)
);
}
});
@ -417,14 +439,11 @@ 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
} does not end with ${itemArg}`
this.createErrorMessage(`Expected string{path} to end with "${itemArg}", but got "${value}"`)
);
}
});
@ -432,11 +451,11 @@ export class Assertion {
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)}`)
);
}
});
@ -445,12 +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}`)
);
}
});
@ -458,13 +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}`)
);
}
});
@ -472,30 +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)}`)
);
}
});
@ -503,10 +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)}`)
);
}
});
@ -514,12 +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}`)
);
}
});
@ -527,12 +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.failMessage ||
`${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}`)
);
}
});
@ -540,14 +568,11 @@ export class Assertion {
public toMatchObject(objectArg: object) {
return this.runCheck(() => {
// Implement a partial object match if needed.
const matchResult = plugins.fastDeepEqual(this.getObjectToTestReference(), objectArg);
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 ${JSON.stringify(objectArg)}`
this.createErrorMessage(`Expected value{path} to match ${this.formatValue(objectArg)}`)
);
}
});
@ -558,16 +583,14 @@ export class Assertion {
const arr = this.getObjectToTestReference();
if (!Array.isArray(arr)) {
throw new Error(
this.failMessage || `Expected ${this.baseReference} to be an array but it is not.`
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.failMessage ||
`${this.baseReference} with drill down ${
this.propertyDrillDown
} does not contain the value ${JSON.stringify(value)}`
this.createErrorMessage(`Expected array{path} to contain an item equal to ${this.formatValue(value)}`)
);
}
});
@ -575,10 +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}`)
);
}
});
@ -586,13 +609,15 @@ export class Assertion {
public toInclude(substring: string) {
return this.runCheck(() => {
const testRef = this.getObjectToTestReference();
if (typeof testRef !== 'string' || !testRef.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`)
);
}
});
@ -601,12 +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}`)
);
}
});
@ -615,12 +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}`)
);
}
});
@ -628,11 +657,10 @@ export class Assertion {
public toBeDate() {
return this.runCheck(() => {
const testRef = this.getObjectToTestReference();
if (!(testRef 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}`)
);
}
});
@ -640,11 +668,15 @@ export class Assertion {
public toBeBeforeDate(date: Date) {
return this.runCheck(() => {
const testRef = this.getObjectToTestReference();
if (!(testRef instanceof Date) || testRef >= 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()}`)
);
}
});
@ -652,11 +684,15 @@ export class Assertion {
public toBeAfterDate(date: Date) {
return this.runCheck(() => {
const testRef = this.getObjectToTestReference();
if (!(testRef instanceof Date) || testRef <= 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()}`)
);
}
});
@ -667,7 +703,8 @@ export class Assertion {
errorMessage: string
) {
return this.runCheck(() => {
if (!assertionFunction(this.getObjectToTestReference())) {
const value = this.getObjectToTestReference();
if (!assertionFunction(value)) {
throw new Error(this.failMessage || errorMessage);
}
});
@ -691,8 +728,9 @@ export class Assertion {
}
public log() {
console.log(`this is the object to test:`);
console.log(`Current value:`);
console.log(JSON.stringify(this.getObjectToTestReference(), null, 2));
console.log(`Path: ${this.formatDrillDown() || '(root)'}`);
return this;
}
}

1
tsconfig.json
View File

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