async-test-util

Utility-functions that can be usefull when you have asynchronous tests in javascript.

Installation

1$ npm install async-test-util --save-dev

1// es6
2import AsyncTestUtil from 'async-test-util';
3
4// es5
5var AsyncTestUtil = require('async-test-util');

wait()

Waits until the given time has expired and then resolves.

1it('should wait', async() => {
2    await AsyncTestUtil.wait(200);
3    console.log('200 ms is over');
4});

waitResolveable()

Waits until the given timeout has expired or the resolve was triggered manually

1it('should wait until observable fired or time is over', async() => {
2    const resolveable = AsyncTestUtil.waitResolveable(200);
3    myObservable.subscribe(sth => {
4        console.log('got first event');
5        resolveable.resolve();
6    });
7    await resolveable.promise;
8});

waitUntil()

Waits until the given predicate-function returns a truthy value. Throws if the optional timeout has passed before.

1it('should wait until server is online', async() => {
2    const checkServer = async() => {
3        try{
4            await fetch('http://example.com/api/');
5            return true;
6        }catch(err) {
7            return false;
8        }
9    };
10    await AsyncTestUtil.waitUntil(checkServer);
11});

With timeout:

1it('should wait until server is online (maxtime: 1000ms)', async() => {
2    const checkServer = async() => {
3        try{
4            await fetch('http://example.com/api/');
5            return true;
6        }catch(err) {
7            return false;
8        }
9    };
10    await AsyncTestUtil.waitUntil(checkServer, 1000);
11});

With return value:

1it('should wait until server is online (maxtime: 1000ms)', async() => {
2    const checkServer = async() => {
3        try{
4            const response = await fetch('http://example.com/api/');
5            return await response.json();
6        }catch(err) {
7            return false;
8        }
9    };
10    const firstSuccessfullResponse = await AsyncTestUtil.waitUntil(checkServer, 1000);
11});

waitForever()

Waits forever, never resolves.

1it('should never resolve', async() => {
2    let resolved = false;
3    AsyncTestUtil
4        .waitForever()
5        .then(() => resolved = true);
6    await AsyncTestUtil.wait(100);
7    assert.equal(false, resolved);
8});

runForever()

Runs the given predicate-function forever. Between each run, the interval-time is awaited.

1it('should run forever', async() => {
2    let t = 0;
3    const pred = () => t++;
4    AsyncTestUtil.runForever(
5        pred, // predicate-function
6        10    // interval
7     );
8
9    await AsyncTestUtil.wait(100);
10    assert.ok(t > 4);
11    const lastT = t;
12    await AsyncTestUtil.wait(100);
13    assert.ok(t > lastT);
14});

assertThrows()

Async-Form of assert.throws. Asserts that the given function throws with the defined error, throws if not.

1// with error-type
2it('should throw because route does not exist', async() => {
3    const getServerVersion = async() => {
4        const response = await fetch('http://example.com/foobar/');
5        return response;
6    };
7    await AsyncTestUtil.assertThrows(
8        () => getServerVersion(),       // function that throws (required)
9        Error                   // Error-type           (optional)
10    );
11});
12
13// with error-text-flag
14it('should throw because route does not exist', async() => {
15    const pingServer = async() => {
16        try{
17            await fetch('http://example.com/foobar/');            
18        }catch(err) {
19            throw new Error('route not reachable');
20        }
21    };
22    await AsyncTestUtil.assertThrows(
23        () => pingServer(),       // function that throws                                    (required)
24        Error,                    // Error-type                                              (optional)
25        'reachable'               // text-flag, throw if error-message does not include this (optional)  
26    );
27
28    // or you can pass a string-array to ensure all is in error message
29    await AsyncTestUtil.assertThrows(
30        () => pingServer(),       // function that throws                                    (required)
31        Error,                    // Error-type                                              (optional)
32        ['route', 'reachable']    // text-flag, throw if error-message does not include this (optional)  
33    );
34});
35
36// assertThrows returns the error
37it('should have the custom error-property', async() => {
38    const throwingFunction = async()=>{
39        const error = new Error('error message');
40        error.foo = 'bar';
41        throw error;
42    }
43    const thrown = await AsyncTestUtil.assertThrows(
44        () => pingServer(),       // function that throws                                    (required)
45        Error,                    // Error-type                                              (optional)
46        'message'               // text-flag, throw if error-message does not include this (optional)  
47    );
48    assert.equal(thrown.foo, 'bar');
49});

resolveValues()

Recieves an object with promises as values. Returns ans object with the resolved promises as values. Use this in test-setups to improve the test-speed by running everything in parallel.

1// instead of this
2const database = await connectDatabase();
3const user1 = await getUser();
4const user2 = await getUser();
5
6// do this
7const {
8    database,
9    user1,
10    user2
11} = await AsyncTestUtil.resolveValues({
12    database: connectDatabase();
13    user1: getUser();
14    user2: getUser();
15});

isPromise()

Returns true if the given value is a Promise;

1const is = AsyncTestUtil.isPromise(myAsyncFunction()); // true
2const is = AsyncTestUtil.isPromise('foobar'); // false

promisify

Transforms the given value to a promise if it was no promise before.

1const ensurePromise = AsyncTestUtil.promisify(maybeAsyncFunction());
2
3// now you are sure this is a promise
4ensurePromise.then(/* ... */)

randomString()

Creates a random string. Takes length as first parameter an custom charset as second.

1console.log(AsyncTestUtil.randomString());
2// > 'rhfkx'
3
4console.log(AsyncTestUtil.randomString(10));
5// > 'dhcvkledzu'
6
7console.log(AsyncTestUtil.randomString(
8    6,    // (optional) length
9    'abc' // (optional) charset, only this will be used to create the string
10));
11// > 'acbcba'

randomNumber()

Creates a random number. Optional range can be given.

1console.log(AsyncTestUtil.randomNumber());
2// > 56
3
4console.log(AsyncTestUtil.randomNumber(
5    1000, // min-value (default=0)
6    2000 // max-value (default=1000)
7));
8// > 1768

randomBoolean()

Creates a random boolean. Returns true or false.

1console.log(AsyncTestUtil.randomBoolean());
2// > true

clone()

Reference to clone. Does exactly the same thing.

1it('should not modify the original object', () => {
2    const original = {
3        foo: 'bar',
4        level: 1
5    };
6    const cloned = AsyncTestUtil.clone(original);
7    cloned.level = 2;
8    assert.equal(original.level, 1);
9});

deepEqual()

Reference to deep-equal. Does exactly the same thing.

1it('the 2 objects should be equal', () => {
2    const obj1 = {
3        foo: 'bar',
4        level: 1
5    };
6    const obj2 = {
7        foo: 'bar',
8        level: 1
9    };
10    assert.ok(AsyncTestUtil.deepEqual(obj1, obj2));
11});

performanceNow()

Works equal to performance.now but works in browsers and nodeJs.

1it('should take less then 200 milliseconds', () => {
2    const now = AsyncTestUtil.performanceNow(); // in milliseconds
3    await doSomething();
4    const later = AsyncTestUtil.performanceNow(); // in milliseconds
5    assert.ok((now + 50 * 1000 ) > later);
6});