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

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

// 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
• expect
  • toDeepEqual
  • toEqual
  • toNotEqual
  • isGreaterThan
  • toNotDeepEqual
  • toBeEmptyArray
  • arrayHasLengthAbove
  • arrayIncludesMembers
  • arrayNotIncludesMembers
  • toBeNotEmptyArray
  • toMatchRegex
  • objectIncludesKeys
  • hasType
  • stringNotIncludesSubstring
  • stringIncludesSubstring
  • objectIsNotEmpty
  • objectIsEmpty
  • stringIsEmpty
  • toBePromise
  • toBeSymbol
  • toBeBool
  • toBeAsyncFunction
  • toBeFunction
  • toBeSet
  • toBeUndefined
  • toBeNumber
  • toBeNull
  • toBeArray
  • toBeObject
  • toBeString

expect

toDeepEqual

  const {expect} = require('assertior');
  expect([{foo: 'bar'}]).toDeepEqual([{foo: 'bar'}]);

toNotDeepEqual

  const {expect} = require('assertior');
  expect([{foo: 'bar'}]).toNotDeepEqual([{foo: 'foo'}]);

toEqual

  const {expect} = require('assertior');
  expect('bar').toEqual('bar');

toNotEqual

  const {expect} = require('assertior');
  expect('bar').toNotEqual('foo');

toBeEmptyArray

  const {expect} = require('assertior');
  expect([]).toBeEmptyArray();

isGreaterThan

  const {expect} = require('assertior');
  expect(10).isGreaterThan(9);

arrayHasLengthAbove

  const {expect} = require('assertior');
  expect([1, 2, 3]).arrayHasLengthAbove(2);

toBeNotEmptyArray

  const {expect} = require('assertior');
  expect([1,2,3]).toBeNotEmptyArray();

objectIncludesKeys

  const {expect} = require('assertior');
  expect({foo: 'bar'}).objectIncludesKeys(['foo']);

hasType

  const {expect} = require('assertior');
  expect({foo: 'bar'}).hasType('object');
  expect([]).hasType('array');
  expect(null).hasType('null');

stringIncludesSubstring

  const {expect} = require('assertior');
  expect('foo').stringIncludesSubstring('foo');

stringNotIncludesSubstring

  const {expect} = require('assertior');
  expect('foo').stringNotIncludesSubstring('foo');

objectIsNotEmpty

  const {expect} = require('assertior');
  expect({a: 1}).objectIsNotEmpty('foo');

objectIsEmpty

  const {expect} = require('assertior');
  expect({a: 1}).objectIsEmpty('foo');

stringIsNotEmpty

  const {expect} = require('assertior');
  expect('test').stringIsNotEmpty();

isLessThan

  const {expect} = require('assertior');
  expect(9).isLessThan(10);

stringIsEmpty

  const {expect} = require('assertior');
  expect('').stringIsEmpty();

toBePromise

  const {expect} = require('assertior');
  expect(Promise.resolve('test')).toBePromise;

toBeSymbol

  const {expect} = require('assertior');
  expect(Symbol('test')).toBeSymbol;

toBeArray

  const {expect} = require('assertior');
  expect([]).toBeArray;

toBeBool

  const {expect} = require('assertior');
  expect(false).toBeBool;

toBeAsyncFunction

  const {expect} = require('assertior');
  expect(async () => ({})).toBeAsyncFunction;

toBeFunction

  const {expect} = require('assertior');
  expect(() => ({})).toBeFunction;

toBeSet

  const {expect} = require('assertior');
  expect(new Set()).toBeSet;

toBeUndefined

  const {expect} = require('assertior');
  expect(undefined).toBeUndefined;

toBeNumber

  const {expect} = require('assertior');
  expect(1).toBeNumber;

toBeNull

  const {expect} = require('assertior');
  expect(null).toBeNull;

toBeObject

  const {expect} = require('assertior');
  expect({}).toBeObject;

toBeString

  const {expect} = require('assertior');
  expect('').toBeString;

arrayIncludesMembers

  const {expect} = require('assertior');
  expect([12,23]).arrayIncludesMembers(23);

arrayNotIncludesMembers

  const {expect} = require('assertior');
  expect([12,23]).arrayNotIncludesMembers(25);

toMatchRegex

  const {expect} = require('assertior');
  expect('test').toMatchRegex(/t/ig);

expect.soft

toEqual

  const {expect} = require('assertior');
  expect.soft('bar').toEqual('bar');

toDeepEqual

  const {expect} = require('assertior');
  expect.soft({a: 'bar'}).toDeepEqual({a: 'bar'});

toNotEqual

  const {expect} = require('assertior');
  expect.soft('bar').toNotEqual('foo');

toNotDeepEqual

  const {expect} = require('assertior');
  expect.soft([{a: 'foo'}]).toNotDeepEqual([{a: 'bar'}]);

toBeEmptyArray

  const {expect} = require('assertior');
  expect.soft([]).toBeEmptyArray();

toBeNotEmptyArray

  const {expect} = require('assertior');
  expect.soft([1,2,3]).toBeNotEmptyArray();

objectIncludesKeys

  const {expect} = require('assertior');
  expect.soft({foo: 'bar'}).objectIncludesKeys(['foo']);

hasType

  const {expect} = require('assertior');
  expect.soft({foo: 'bar'}).hasType('object');
  expect.soft([]).hasType('array');
  expect.soft(null).hasType('null');

stringIncludesSubstring

  const {expect} = require('assertior');
  expect.soft('foo').stringIncludesSubstring('foo');

stringNotIncludesSubstring

  const {expect} = require('assertior');
  expect.soft('foo').stringNotIncludesSubstring('foo');

objectIsNotEmpty

  const {expect} = require('assertior');
  expect.soft({a: 1}).objectIsNotEmpty('foo');

objectIsEmpty

  const {expect} = require('assertior');
  expect.soft({a: 1}).objectIsEmpty('foo');

stringIsNotEmpty

  const {expect} = require('assertior');
  expect.soft('test').stringIsNotEmpty();

stringIsEmpty

  const {expect} = require('assertior');
  expect.soft('').stringIsEmpty();

isGreaterThan

  const {expect} = require('assertior');
  expect.soft(10).isGreaterThan(9);

isLessThan

  const {expect} = require('assertior');
  expect.soft(9).isLessThan(10);

toBePromise

  const {expect} = require('assertior');
  expect.soft(Promise.resolve('test')).toBePromise;

toBeSymbol

  const {expect} = require('assertior');
  expect.soft(Symbol('test')).toBeSymbol;

toBeBool

  const {expect} = require('assertior');
  expect.soft(false).toBeBool;

toBeAsyncFunction

  const {expect} = require('assertior');
  expect.soft(async () => ({})).toBeAsyncFunction;

toBeFunction

  const {expect} = require('assertior');
  expect.soft(() => ({})).toBeFunction;

toBeSet

  const {expect} = require('assertior');
  expect.soft(new Set()).toBeSet;

toBeUndefined

  const {expect} = require('assertior');
  expect.soft(undefined).toBeUndefined;

toBeNumber

  const {expect} = require('assertior');
  expect.soft(1).toBeNumber;

toBeNull

  const {expect} = require('assertior');
  expect.soft(null).toBeNull;

toBeObject

  const {expect} = require('assertior');
  expect.soft({}).toBeObject;

toBeString

  const {expect} = require('assertior');
  expect.soft('').toBeString;

toBeArray

  const {expect} = require('assertior');
  expect.soft([]).toBeArray;

toMatchRegex

  const {expect} = require('assertior');
  expect.soft('test').toMatchRegex(/t/ig);

arrayIncludesMembers

  const {expect} = require('assertior');
  expect.soft([12,23]).arrayIncludesMembers(23);

arrayNotIncludesMembers

  const {expect} = require('assertior');
  expect.soft([12,23]).arrayNotIncludesMembers(25);

arrayHasLengthAbove

  const {expect} = require('assertior');
  expect.soft([1, 2, 3]).arrayHasLengthAbove(2);