assertior
Version:
Assertion library with soft assertions
549 lines (403 loc) • 9.86 kB
Markdown
# assertior
##### 🛠 Development in progress
## This library is a wrapper around nodejs "assert" module
### The main porpuse is build new assertion library with soft assertions based on "assert" module
#### allure/any other reporter ready
##### mocha example
```js
const {expect} = require('assertior');
describe('Suite', function() {
it('soft toEqual positive', function() {
const val = 2;
expect.soft(val).toEqual(2);
});
it('soft toDeepEqual positive', function() {
const val = {a: 2, b: 3, c: [1, 2, 3]};
expect.soft(val).toDeepEqual({a: 2, c: [1, 2, 3], b: 3});
});
});
```
##### mocha example with allure
```js
// Allure step
function allureStep(stepAssertionName: string, error, expected, current) {
const step = allure.startStep(stepAssertionName);
allure.attachment('Expected value', JSON.stringify(expected, null, 2), 'application/json');
allure.attachment('Current value', JSON.stringify(current, null, 2), 'application/json');
if (error) {
allure.attachment('Error', JSON.stringify(error, null, 2), 'application/json');
}
step.step.stepResult.status = error ? 'broken' : 'passed';
step.endStep();
}
const {expect, initStepDeclarator} = require('assertior');
initStepDeclarator(allureStep);
describe('Suite', function() {
it('soft toEqual positive', function() {
const val = 2;
expect.soft(val).toEqual(2);
});
it('toDeepEqual positive', function () {
const val = 2;
expect(val).toDeepEqual(2);
});
});
```
- [expect.soft](#expectsoft)
- [expect](#expect)
* [toDeepEqual](#todeepequal)
* [toEqual](#toequal)
* [toNotEqual](#tonotequal)
* [isGreaterThan](#isgreaterthan)
* [toNotDeepEqual](#tonotdeepequal)
* [toBeEmptyArray](#tobeemptyarray)
* [arrayHasLengthAbove](#arrayhaslengthabove)
* [arrayIncludesMembers](#arrayincludesmembers)
* [arrayNotIncludesMembers](#arraynotincludesmembers)
* [toBeNotEmptyArray](#tobenotemptyarray)
* [toMatchRegex](#tomatchregex)
* [objectIncludesKeys](#objectincludeskeys)
* [hasType](#hastype)
* [stringNotIncludesSubstring](#stringnotincludesubstring)
* [stringIncludesSubstring](#stringincludesubstring)
* [objectIsNotEmpty](#objectisnotempty)
* [objectIsEmpty](#objectisempty)
* [stringIsEmpty](#stringisempty)
* [toBePromise](#tobepromise)
* [toBeSymbol](#tobesymbol)
* [toBeBool](#tobebool)
* [toBeAsyncFunction](#tobeasyncfunction)
* [toBeFunction](#tobefunction)
* [toBeSet](#tobeset)
* [toBeUndefined](#tobeundefined)
* [toBeNumber](#tobenumber)
* [toBeNull](#tobenull)
* [toBeArray](#tobearray)
* [toBeObject](#tobeobject)
* [toBeString](#tobestring)
# expect
## toDeepEqual
```js
const {expect} = require('assertior');
expect([{foo: 'bar'}]).toDeepEqual([{foo: 'bar'}]);
```
## toNotDeepEqual
```js
const {expect} = require('assertior');
expect([{foo: 'bar'}]).toNotDeepEqual([{foo: 'foo'}]);
```
## toEqual
```js
const {expect} = require('assertior');
expect('bar').toEqual('bar');
```
## toNotEqual
```js
const {expect} = require('assertior');
expect('bar').toNotEqual('foo');
```
## toBeEmptyArray
```js
const {expect} = require('assertior');
expect([]).toBeEmptyArray();
```
## isGreaterThan
```js
const {expect} = require('assertior');
expect(10).isGreaterThan(9);
```
## arrayHasLengthAbove
```js
const {expect} = require('assertior');
expect([1, 2, 3]).arrayHasLengthAbove(2);
```
## toBeNotEmptyArray
```js
const {expect} = require('assertior');
expect([1,2,3]).toBeNotEmptyArray();
```
## objectIncludesKeys
```js
const {expect} = require('assertior');
expect({foo: 'bar'}).objectIncludesKeys(['foo']);
```
## hasType
```js
const {expect} = require('assertior');
expect({foo: 'bar'}).hasType('object');
expect([]).hasType('array');
expect(null).hasType('null');
```
## stringIncludesSubstring
```js
const {expect} = require('assertior');
expect('foo').stringIncludesSubstring('foo');
```
## stringNotIncludesSubstring
```js
const {expect} = require('assertior');
expect('foo').stringNotIncludesSubstring('foo');
```
## objectIsNotEmpty
```js
const {expect} = require('assertior');
expect({a: 1}).objectIsNotEmpty('foo');
```
## objectIsEmpty
```js
const {expect} = require('assertior');
expect({a: 1}).objectIsEmpty('foo');
```
## stringIsNotEmpty
```js
const {expect} = require('assertior');
expect('test').stringIsNotEmpty();
```
## isLessThan
```js
const {expect} = require('assertior');
expect(9).isLessThan(10);
```
## stringIsEmpty
```js
const {expect} = require('assertior');
expect('').stringIsEmpty();
```
## toBePromise
```js
const {expect} = require('assertior');
expect(Promise.resolve('test')).toBePromise;
```
## toBeSymbol
```js
const {expect} = require('assertior');
expect(Symbol('test')).toBeSymbol;
```
## toBeArray
```js
const {expect} = require('assertior');
expect([]).toBeArray;
```
## toBeBool
```js
const {expect} = require('assertior');
expect(false).toBeBool;
```
## toBeAsyncFunction
```js
const {expect} = require('assertior');
expect(async () => ({})).toBeAsyncFunction;
```
## toBeFunction
```js
const {expect} = require('assertior');
expect(() => ({})).toBeFunction;
```
## toBeSet
```js
const {expect} = require('assertior');
expect(new Set()).toBeSet;
```
## toBeUndefined
```js
const {expect} = require('assertior');
expect(undefined).toBeUndefined;
```
## toBeNumber
```js
const {expect} = require('assertior');
expect(1).toBeNumber;
```
## toBeNull
```js
const {expect} = require('assertior');
expect(null).toBeNull;
```
## toBeObject
```js
const {expect} = require('assertior');
expect({}).toBeObject;
```
## toBeString
```js
const {expect} = require('assertior');
expect('').toBeString;
```
## arrayIncludesMembers
```js
const {expect} = require('assertior');
expect([12,23]).arrayIncludesMembers(23);
```
## arrayNotIncludesMembers
```js
const {expect} = require('assertior');
expect([12,23]).arrayNotIncludesMembers(25);
```
## toMatchRegex
```js
const {expect} = require('assertior');
expect('test').toMatchRegex(/t/ig);
```
# expect.soft
## toEqual
```js
const {expect} = require('assertior');
expect.soft('bar').toEqual('bar');
```
## toDeepEqual
```js
const {expect} = require('assertior');
expect.soft({a: 'bar'}).toDeepEqual({a: 'bar'});
```
## toNotEqual
```js
const {expect} = require('assertior');
expect.soft('bar').toNotEqual('foo');
```
## toNotDeepEqual
```js
const {expect} = require('assertior');
expect.soft([{a: 'foo'}]).toNotDeepEqual([{a: 'bar'}]);
```
## toBeEmptyArray
```js
const {expect} = require('assertior');
expect.soft([]).toBeEmptyArray();
```
## toBeNotEmptyArray
```js
const {expect} = require('assertior');
expect.soft([1,2,3]).toBeNotEmptyArray();
```
## objectIncludesKeys
```js
const {expect} = require('assertior');
expect.soft({foo: 'bar'}).objectIncludesKeys(['foo']);
```
## hasType
```js
const {expect} = require('assertior');
expect.soft({foo: 'bar'}).hasType('object');
expect.soft([]).hasType('array');
expect.soft(null).hasType('null');
```
## stringIncludesSubstring
```js
const {expect} = require('assertior');
expect.soft('foo').stringIncludesSubstring('foo');
```
## stringNotIncludesSubstring
```js
const {expect} = require('assertior');
expect.soft('foo').stringNotIncludesSubstring('foo');
```
## objectIsNotEmpty
```js
const {expect} = require('assertior');
expect.soft({a: 1}).objectIsNotEmpty('foo');
```
## objectIsEmpty
```js
const {expect} = require('assertior');
expect.soft({a: 1}).objectIsEmpty('foo');
```
## stringIsNotEmpty
```js
const {expect} = require('assertior');
expect.soft('test').stringIsNotEmpty();
```
## stringIsEmpty
```js
const {expect} = require('assertior');
expect.soft('').stringIsEmpty();
```
## isGreaterThan
```js
const {expect} = require('assertior');
expect.soft(10).isGreaterThan(9);
```
## isLessThan
```js
const {expect} = require('assertior');
expect.soft(9).isLessThan(10);
```
## toBePromise
```js
const {expect} = require('assertior');
expect.soft(Promise.resolve('test')).toBePromise;
```
## toBeSymbol
```js
const {expect} = require('assertior');
expect.soft(Symbol('test')).toBeSymbol;
```
## toBeBool
```js
const {expect} = require('assertior');
expect.soft(false).toBeBool;
```
## toBeAsyncFunction
```js
const {expect} = require('assertior');
expect.soft(async () => ({})).toBeAsyncFunction;
```
## toBeFunction
```js
const {expect} = require('assertior');
expect.soft(() => ({})).toBeFunction;
```
## toBeSet
```js
const {expect} = require('assertior');
expect.soft(new Set()).toBeSet;
```
## toBeUndefined
```js
const {expect} = require('assertior');
expect.soft(undefined).toBeUndefined;
```
## toBeNumber
```js
const {expect} = require('assertior');
expect.soft(1).toBeNumber;
```
## toBeNull
```js
const {expect} = require('assertior');
expect.soft(null).toBeNull;
```
## toBeObject
```js
const {expect} = require('assertior');
expect.soft({}).toBeObject;
```
## toBeString
```js
const {expect} = require('assertior');
expect.soft('').toBeString;
```
## toBeArray
```js
const {expect} = require('assertior');
expect.soft([]).toBeArray;
```
## toMatchRegex
```js
const {expect} = require('assertior');
expect.soft('test').toMatchRegex(/t/ig);
```
## arrayIncludesMembers
```js
const {expect} = require('assertior');
expect.soft([12,23]).arrayIncludesMembers(23);
```
## arrayNotIncludesMembers
```js
const {expect} = require('assertior');
expect.soft([12,23]).arrayNotIncludesMembers(25);
```
## arrayHasLengthAbove
```js
const {expect} = require('assertior');
expect.soft([1, 2, 3]).arrayHasLengthAbove(2);
```