ts-prime/dist/commonjs/guards.test.js

A utility library for JavaScript and Typescript.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var guards_1 = require("./guards");
function assertType(data) {
    return data;
}
var dataProvider = function (t) {
    switch (t) {
        case 'number':
            return 5;
        case 'array':
            return [1, 2, 3];
        case 'boolean':
            return false;
        case 'date':
            return new Date();
        case 'function':
            return function () { };
        case 'null':
            return null;
        case 'promise':
            return Promise.resolve(5);
        case 'string':
            return 'text';
        case 'object':
            return { a: 'asd' };
        case 'error':
            return new Error('asd');
    }
    return 'text';
};
describe('Describe guards behavior', function () {
    test('isString: should work as type guard', function () {
        var data = dataProvider('string');
        if (guards_1.isString(data)) {
            expect(typeof data).toEqual('string');
            assertType(data);
        }
    });
    test('isString: should work even if data type is unknown', function () {
        var data = dataProvider('string');
        if (guards_1.isString(data)) {
            expect(typeof data).toEqual('string');
            assertType(data);
        }
    });
    test('isString: should work with literal types', function () {
        var data = function () {
            return 'a';
        };
        var x = data();
        if (guards_1.isString(x)) {
            expect(typeof x).toEqual('string');
            assertType(x);
        }
    });
    test('isString: should work as type guard in array', function () {
        var data = [
            dataProvider('error'),
            dataProvider('string'),
            dataProvider('function'),
            dataProvider('null'),
            dataProvider('array'),
            dataProvider('boolean'),
        ].filter(guards_1.isString);
        expect(data.every(function (c) { return typeof c === 'string'; })).toEqual(true);
        assertType(data);
    });
    test('isBoolean: should work as type guard', function () {
        var data = dataProvider('boolean');
        if (guards_1.isBoolean(data)) {
            expect(typeof data).toEqual('boolean');
            assertType(data);
        }
        var data1 = dataProvider('boolean');
        if (guards_1.isBoolean(data1)) {
            expect(typeof data1).toEqual('boolean');
            assertType(data1);
        }
        var data2 = dataProvider('boolean');
        if (guards_1.isBoolean(data2)) {
            expect(typeof data2).toEqual('boolean');
            assertType(data2);
        }
    });
    test('isBoolean: should work as type guard in filter', function () {
        var data = [
            dataProvider('error'),
            dataProvider('array'),
            dataProvider('function'),
            dataProvider('null'),
            dataProvider('array'),
            dataProvider('boolean'),
        ].filter(guards_1.isBoolean);
        expect(data.every(function (c) { return typeof c === 'boolean'; })).toEqual(true);
        assertType(data);
    });
    test('isArray: should work as type guard', function () {
        var data = dataProvider('array');
        if (guards_1.isArray(data)) {
            expect(Array.isArray(data)).toEqual(true);
            assertType(data);
        }
        var data1 = dataProvider('array');
        if (guards_1.isArray(data1)) {
            expect(Array.isArray(data1)).toEqual(true);
            assertType(data1);
        }
    });
    test('isArray: should work as type guard in filter', function () {
        var data = [
            dataProvider('error'),
            dataProvider('array'),
            dataProvider('function'),
            dataProvider('null'),
            dataProvider('array'),
            dataProvider('date'),
        ].filter(guards_1.isArray);
        expect(data.every(function (c) { return Array.isArray(c); })).toEqual(true);
        assertType(data);
    });
    test('isDefined": should work as type guard', function () {
        var data = dataProvider('date');
        if (guards_1.isDefined(data)) {
            expect(data instanceof Date).toEqual(true);
            assertType(data);
        }
    });
    test('isDefined: should work as type guard in filter', function () {
        var data = [
            dataProvider('error'),
            dataProvider('array'),
            dataProvider('function'),
            dataProvider('null'),
            dataProvider('number'),
        ].filter(guards_1.isDefined);
        expect(data.length === 4).toEqual(true);
        assertType(data);
    });
    test('isNil: should work as type guard', function () {
        var data = dataProvider('null');
        if (guards_1.isNil(data)) {
            expect(data).toEqual(null);
            assertType(data);
        }
    });
    test('isNil: should work as type guard in filter', function () {
        var data = [
            dataProvider('error'),
            dataProvider('array'),
            dataProvider('function'),
            dataProvider('function'),
            dataProvider('null'),
            dataProvider('number'),
        ].filter(guards_1.isNil);
        expect(data.every(function (c) { return c == null; })).toEqual(true);
        assertType(data);
    });
    test('isFunction: should work as type guard', function () {
        var data = dataProvider('null');
        if (guards_1.isFunction(data)) {
            expect(data).toEqual(null);
            assertType(data);
        }
    });
    test('isFunction: should work as type guard in filter', function () {
        var data = [
            dataProvider('error'),
            dataProvider('array'),
            dataProvider('function'),
            dataProvider('function'),
            dataProvider('object'),
            dataProvider('number'),
        ].filter(guards_1.isFunction);
        expect(data.every(function (c) { return typeof c === 'function'; })).toEqual(true);
        assertType(data);
    });
    test('isError: should work as type guard', function () {
        var data = dataProvider('error');
        if (guards_1.isError(data)) {
            expect(data instanceof Error).toEqual(true);
            assertType(data);
        }
    });
    test('isError: should work as type guard in filter', function () {
        var data = [
            dataProvider('error'),
            dataProvider('array'),
            dataProvider('boolean'),
            dataProvider('function'),
            dataProvider('object'),
            dataProvider('number'),
        ].filter(guards_1.isError);
        expect(data.every(function (c) { return c instanceof Error; })).toEqual(true);
        assertType(data);
    });
    test('isNumber: should work as type guard', function () {
        var data = dataProvider('number');
        if (guards_1.isNumber(data)) {
            expect(typeof data).toEqual('number');
            assertType(data);
        }
    });
    test('isNumber: should work as type guard in filter', function () {
        var data = [
            dataProvider('promise'),
            dataProvider('array'),
            dataProvider('boolean'),
            dataProvider('function'),
            dataProvider('object'),
            dataProvider('number'),
        ].filter(guards_1.isNumber);
        expect(data.every(function (c) { return typeof c === 'number'; })).toEqual(true);
        assertType(data);
    });
    test('isObject: should work as type guard', function () {
        var data = dataProvider('object');
        if (guards_1.isObject(data)) {
            expect(typeof data).toEqual('object');
            assertType(data);
        }
    });
    test('isObject: should work as type guard', function () {
        var data = { data: 5 };
        if (guards_1.isObject(data)) {
            expect(typeof data).toEqual('object');
            assertType(data);
        }
    });
    test('isObject: should work as type guard', function () {
        var data = { data: 5 };
        if (guards_1.isObject(data)) {
            expect(typeof data).toEqual('object');
            assertType(data);
        }
    });
    test('isObject: should work as type guard in filter', function () {
        var data = [
            dataProvider('promise'),
            dataProvider('array'),
            dataProvider('boolean'),
            dataProvider('function'),
            dataProvider('object'),
        ].filter(guards_1.isObject);
        expect(data.every(function (c) { return typeof c === 'object' && !Array.isArray(c); })).toEqual(true);
        assertType(data);
    });
    test('isPromise: should work as type guard', function () {
        var data = dataProvider('promise');
        if (guards_1.isPromise(data)) {
            expect(data instanceof Promise).toEqual(true);
            assertType(data);
        }
    });
    test('isPromise: should work as type guard in filter', function () {
        var data = [
            dataProvider('promise'),
            dataProvider('array'),
            dataProvider('boolean'),
            dataProvider('function'),
        ].filter(guards_1.isPromise);
        expect(data.every(function (c) { return c instanceof Promise; })).toEqual(true);
        assertType(data);
    });
    test('haveKeys: should work as type guard in filter', function () {
        var data = [
            {
                x: 4,
            },
            {
                a: 1,
                b: 2,
            },
            {
                a: 1,
                b: 5,
            },
        ].filter(guards_1.haveKeys(['a', 'b']));
        expect(data).toEqual([
            {
                a: 1,
                b: 2,
            },
            {
                a: 1,
                b: 5,
            },
        ]);
        assertType(data);
    });
    test('haveKeys: should work as type guard in filter', function () {
        var definedKeys = guards_1.haveKeys(['a', 'b']);
        var obj = {
            x: 4,
        };
        if (definedKeys(obj)) {
            assertType(obj);
        }
    });
    test('isNot: should work as type guard', function () {
        var data = dataProvider('promise');
        if (guards_1.isNot(guards_1.isString)(data)) {
            assertType(data);
            expect(data instanceof Promise).toEqual(true);
        }
    });
    test('isNot: should work as type guard in filter', function () {
        var data = [
            dataProvider('promise'),
            dataProvider('array'),
            dataProvider('boolean'),
            dataProvider('function'),
        ];
        var result = data.filter(guards_1.isNot(guards_1.isPromise));
        expect(result.some(function (c) { return c instanceof Promise; })).toEqual(false);
        assertType(result);
    });
});