@locustjs/test

This library provides a simple test runner for unit-testing.

Install

npm i @locustjs/test

Current Version

2.0.2

Usage

import { TestRunner } from '@locustjs/test';

const tests = [
  ['test 1', () => expect(2 + 2).toBe(4)],
  ['test 2', () => expect(undefined).toBeUndefined()],
  ['test 3', () => expect(5).toBeGt(10)],  // this test fails
  ...
];

const runner = new TestRunner();

await runner.run(tests);

runner.report();  // detailed report
runner.log(); // save report to file

Sample output:

1. Test 1: number: passed (0 sec)

2. Test 2: string: passed (0 sec)

3. Test 3: empty array: passed (0 sec)

4. Test 4: array: passed (0 sec)

5. Test 5: empty object: passed (0 sec)

6. Test 6: object: passed (0 sec)

7. Test 7: error: failed (0.001 sec)

8. Test 8: not satisfied: expect not used (0 sec)

9. Test 9: error without expect: faulted (0 sec)

10. Test 10: class: passed (0 sec)

Test result types

• passed: Test passed.
• failed: Test failed (at least one expect did not succeed).
• faulted: Test crashed (no expect was called).
• unknown: Test executed, however, no expect was seen.

Pay attention: TestRunner runs test simultaneously. Thus, tests should not have side-effects.

Various examples:

import { Test, TestRunner } from '@locustjs/test';

const t1 = new Test('test 1', () => expect(2 + 2).toBe(4));
const t2 = () => expect(2 + 2).toBe(4);
const t3 = [t1]
const t4 = [t1, t2]
const t5 = ['test 5', () => expect(2 + 2).toBe(4)]

TestRunner.start(t1, t2, t3, t4, t5)

expect

Positive

• toBe(value)
• toBeGt(value)
• toBeGreaterThan(value)
• toBeGte(value)
• toBeGreaterThanOrEqualTo(value)
• toBeLt(value)
• toBeLowerThan(value)
• toBeLte(value)
• toBeLowerThanOrEqualTo(value)
• toBeBetween(n, m)
• toBeOfType(type)
• toBeString()
• toBeSomeString()
• toBeNumber()
• toBeNumeric()
• toBeDate()
• toBeBool()
• toBeBasicType()
• toBePrimitive()
• toBeEmpty()
• toBeObject()
• toBeSomeObject()
• toBeFunction()
• toBeArray()
• toBeEmptyArray()
• toBeSomeArray()
• toBeIterable()
• toBeSubClassOf(type)
• toBeInstanceOf(type)
• toMatch(pattern, flags)
• toBeDefined()
• toBeUndefined()
• toBeNull()
• toBeNullOrUndefined()
• toBeValid(fnValidation)
• toThrow()
• toThrow(ex, shape = false, strict = false)
• async toThrowAsync()
• async toThrowAsync(ex, shape = false, strict = false)
• toBeTruthy()
• toBeTrue()
• toBeFalsy()
• toBeFalse()
• toBeNaN()

Negative

• notToBe(value)
• notToBeBetween(n, m)
• notToBeOfType(type)
• notToBeString()
• notToBeSomeString()
• notToBeNumber()
• notToBeDate()
• notToBeBool()
• notToBeBasicType()
• notToBePrimitive()
• notToBeEmpty()
• notToBeObject()
• notToBeSomeObject()
• notToBeFunction()
• notToBeNumeric()
• notToBeArray()
• notToBeSomeArray()
• notToBeIterable()
• notToBeSubClassOf(type)
• notToBeInstanceOf(type)
• notToMatch(pattern, flags)
• doesNotMatch(pattern, flags)
• notToBeDefined()
• notToBeUndefined()
• notToBeNull()
• notToBeNullOrUndefined()
• notToBeValid(fnValidation)
• notToThrow()
• notToThrow(ex, shape = false, strict = false)
• async notToThrowAsync()
• async notToThrowAsync(ex, shape = false, strict = false)
• notToBeNaN()

Quick Testing

TestRunner has a static method start() that simplifies running tests.

const tests = [
  ...
];

TestRunner.start(tests);

It is possible to pass multiple tests to start() method.

import tests1 from './test1.js'
import tests2 from './test2.js'
import tests3 from './test3.js'

TestRunner.start(tests1, tests2, tests3);

The above example is equal to merging all tests and pass one array to start().

TestRunner.start([...tests1, ...tests2, ...tests3])

By default, test runner shows detailed output only when there is at least one error. However, by passing true as the last argument of start() method, we can ask the detailed output to be always shown.

TestRunner.start(tests, true);
TestRunner.start(tests1, tests2, tests3, true);