assert-enhanced
✨ An enhanced Node.js assert module.
This librairy provide an enhanced Node.js assert module.
IMPORTANT: This module is an improvement from joyent/node-assert-plus module with added assertions registration methods.
Installation:
npm install assert-enhanced
Example:
const assert = require('assert-enhanced');
function example (stdout, chunk, next) {
assert.writable(stdout, 'stdout');
assert.object(chunk, 'chunk');
assert.string(chunk.id, 'chunk.id');
assert.buffer(chunk.buffer, 'chunk.buffer');
assert.function(next, 'next');
stdout.write(chunk);
}
Or to add a new assertion set
const assert = require('assert-enhanced');
const definition = {
custom: {
check: (arg) => (arg instanceof Custom),
operator: 'instanceof',
actual: (arg) => Object.prototype.toString.call(arg).slice(8, -1)
}
};
assert._utils.register(null, definitions, { arrayOf: false, optionalArrayOf: false });
API:
The added assertions methods take two arguments, the value tested first and then the name of the checked parameter.
assert.bool(myBoolArg, 'myBoolArg');
assert.optionalBool(myBoolArg, 'myBoolArg');
assert.arrayOfbool(myBoolArg, 'myBoolArg');
assert.optionalArrayOfBool(myBoolArg, 'myBoolArg');
On bad assertion it will throw an EnhancedAssertionError:
AssertionError [ERR_ASSERTION]: myBoolArg (bool) is required.
at Object.<anonymous> (/home/user/projects/test-assert-enhanced/test.js:3:8)
at Module._compile (internal/modules/cjs/loader.js:1147:30)
at Object.Module._extensions..js (internal/modules/cjs/loader.js:1167:10)
at Module.load (internal/modules/cjs/loader.js:996:32)
at Function.Module._load (internal/modules/cjs/loader.js:896:14)
at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)
at internal/main/run_main_module.js:17:47
Enhanced:
- assert.EnhancedAssertionError
- assert.bool
- assert.number
- assert.string
- assert.symbol
- assert.object
- assert.function
- assert.array
- assert.asyncFunction
- assert.promise
- assert.date
- assert.regexp
- assert.buffer
- assert.stream
- assert.readable
- assert.writable
- assert.duplex
- assert.optionalBool
- assert.optionalNumber
- assert.optionalString
- assert.optionalSymbol
- assert.optionalObject
- assert.optionalFunction
- assert.optionalArray
- assert.optionalAsyncFunction
- assert.optionalPromise
- assert.optionalDate
- assert.optionalRegexp
- assert.optionalBuffer
- assert.optionalStream
- assert.optionalReadable
- assert.optionalWritable
- assert.optionalDuplex
- assert.arrayOfBool
- assert.arrayOfNumber
- assert.arrayOfString
- assert.arrayOfSymbol
- assert.arrayOfObject
- assert.arrayOfFunction
- assert.arrayOfArray
- assert.arrayOfAsyncFunction
- assert.arrayOfPromise
- assert.arrayOfDate
- assert.arrayOfRegexp
- assert.arrayOfBuffer
- assert.arrayOfStream
- assert.arrayOfReadable
- assert.arrayOfWritable
- assert.arrayOfDuplex
- assert.optionalArrayOfBool
- assert.optionalArrayOfNumber
- assert.optionalArrayOfString
- assert.optionalArrayOfSymbol
- assert.optionalArrayOfObject
Enhanced _utils:
Node.js assert module:
See more on Node.js assert module: https://nodejs.org/api/assert.html
assert._utils.register(target, definitions, options)->target
Register assertions sets.
argument | type | details |
---|
target | Object or Function | The target where to save the generated assertion methods. If it's null or undefined then registration is processed on the exported module. |
definitions | Object | The definitions object will wrap the definitions of the different assertions that need to be added. |
options | Object (optional) | The options object will store the states to know if we should cancel the generation of methods by types. Any registration type can be disabled using options ({ [type]: false }). |
Example:
const definitions = {
custom: {
check: (arg) => (arg instanceof Custom),
operator: 'instanceof',
actual: assert._utils.getClassname
}
};
assert._utils.register(null, definitions, { optionalArrayOf: false });
assert._utils.registerStandardAssertion(target, name, definition)->target
Register standard assertion.
argument | type | details |
---|
target | Object or Function | The target where to save the generated assertion methods. If it's null or undefined then registration is processed on the exported module. |
name | String | The assertion method name. |
definition | Object | The definitions object. |
Example:
assert._utils.registerStandardAssert(null, 'custom', {
check: (arg) => (arg instanceof Custom),
operator: 'instanceof',
actual: assert._utils.getClassname
});
assert._utils.registerOptionalAssertion(target, name, definition)->target
Register optional assertion.
argument | type | details |
---|
target | Object or Function | The target where to save the generated assertion methods. If it's null or undefined then registration is processed on the exported module. |
name | String | The assertion method name. |
definition | Object | The definitions object. |
Example:
assert._utils.registerOptionalAssertion(null, 'custom', {
check: (arg) => (arg instanceof Custom),
operator: 'instanceof',
actual: assert._utils.getClassname
});
assert._utils.registerArrayOfAssertion(target, name, definition)->target
Register arrayOf assertion.
argument | type | details |
---|
target | Object or Function | The target where to save the generated assertion methods. If it's null or undefined then registration is processed on the exported module. |
name | String | The assertion method name. |
definition | Object | The definitions object. |
Example:
assert._utils.registerArrayOfAssertion(null, 'custom', {
check: (arg) => (arg instanceof Custom),
operator: 'instanceof',
actual: assert._utils.getClassname
});
assert._utils.registerOptionalArrayOfAssertion(target, name, definition)->target
Register optional arrayOf assertion.
argument | type | details |
---|
target | Object or Function | The target where to save the generated assertion methods. If it's null or undefined then registration is processed on the exported module. |
name | String | The assertion method name. |
definition | Object | The definitions object. |
Example:
assert._utils.registerOptionalArrayOfAssertion(null, 'custom', {
check: (arg) => (arg instanceof Custom),
operator: 'instanceof',
actual: assert._utils.getClassname
});
assert._utils.getClassname(arg)->string
Get an object classname, it's used to seed the actual
property from the definitions.
argument | type | details |
---|
arg | any | |
assert._utils.getTypeof(arg)->string
Get a typeof, it's used to seed the actual
property from the definitions.
argument | type | details |
---|
arg | any | |