validata/dist/enum.test.js

Type safe data validation and sanitization

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const array_1 = require("./array");
const enum_1 = require("./enum");
const object_1 = require("./object");
const types_1 = require("./types");
var MyEnum;
(function (MyEnum) {
    MyEnum[MyEnum["WATER"] = 0] = "WATER";
    MyEnum[MyEnum["GAS"] = 1] = "GAS";
    MyEnum[MyEnum["ELECTRIC"] = 2] = "ELECTRIC";
})(MyEnum || (MyEnum = {}));
var EnumWithStrings;
(function (EnumWithStrings) {
    EnumWithStrings["KEY_1"] = "VALUE_1";
    EnumWithStrings["KEY_2"] = "VALUE_2";
})(EnumWithStrings || (EnumWithStrings = {}));
describe('isEnum', () => {
    it('will accept correct value from enum', () => {
        const test = (0, enum_1.isEnum)(MyEnum).process(MyEnum.WATER);
        expect(test).toEqual({ value: MyEnum.WATER });
    });
    it('incorrect string value provided for a number enum', () => {
        const test = (0, enum_1.isEnum)(MyEnum).process(EnumWithStrings.KEY_1);
        expect(test.issues[0].reason).toBe('key-not-found');
    });
    it('incorrect type provided', () => {
        const test = (0, enum_1.isEnum)(MyEnum).process(true);
        expect(test.issues[0].reason).toBe('incorrect-type');
    });
    it('will not recognize the key of an enum as a valid input', () => {
        const test = (0, enum_1.isEnum)(MyEnum).process('WATER');
        expect(test.issues[0].reason).toBe('key-not-found');
    });
});
describe('maybeEnum', () => {
    it('will accept correct value from enum', () => {
        const test = (0, enum_1.maybeEnum)(MyEnum).process(MyEnum.WATER);
        expect(test).toEqual({ value: MyEnum.WATER });
    });
    it('incorrect string value provided for a number enum', () => {
        const test = (0, enum_1.maybeEnum)(MyEnum).process(EnumWithStrings.KEY_1);
        expect(test.issues[0].reason).toBe('key-not-found');
    });
    it('incorrect type provided', () => {
        const test = (0, enum_1.maybeEnum)(MyEnum).process(true);
        expect(test.issues[0].reason).toBe('incorrect-type');
    });
    it('will not recognize the key of an enum as a valid input', () => {
        const test = (0, enum_1.maybeEnum)(MyEnum).process('WATER');
        expect(test.issues[0].reason).toBe('key-not-found');
    });
    it('will accept null or undefined value', () => {
        const fut = (0, enum_1.maybeEnum)(MyEnum);
        const nullTest = fut.process(null);
        expect(nullTest).toEqual({ value: undefined });
        const undefinedTest = fut.process(undefined);
        expect(undefinedTest).toEqual({ value: undefined });
    });
});
describe('asEnum', () => {
    it('will accept correct value from enum', () => {
        const test = (0, enum_1.asEnum)(MyEnum).process(MyEnum.WATER);
        expect(test).toEqual({ value: MyEnum.WATER });
    });
    it('incorrect string value provided for a number enum', () => {
        const test = (0, enum_1.asEnum)(MyEnum).process(EnumWithStrings.KEY_1);
        expect(test.issues[0].reason).toBe('no-conversion');
    });
    it('incorrect type provided', () => {
        const test = (0, enum_1.asEnum)(MyEnum).process(true);
        expect(test.issues[0].reason).toBe('no-conversion');
    });
    it('will recognize the key of an enum as a valid input', () => {
        const test = (0, enum_1.asEnum)(MyEnum).process('WATER');
        expect(test).toEqual({ value: MyEnum.WATER });
    });
});
describe('maybeAsEnum', () => {
    it('will accept correct value from enum', () => {
        const test = (0, enum_1.maybeAsEnum)(MyEnum).process(MyEnum.WATER);
        expect(test).toEqual({ value: MyEnum.WATER });
    });
    it('incorrect string value provided for a number enum', () => {
        const test = (0, enum_1.maybeAsEnum)(MyEnum).process(EnumWithStrings.KEY_1);
        expect(test.issues[0].reason).toBe('no-conversion');
    });
    it('incorrect type provided', () => {
        const test = (0, enum_1.maybeAsEnum)(MyEnum).process(true);
        expect(test.issues[0].reason).toBe('no-conversion');
    });
    it('will recognize the key of an enum as a valid input', () => {
        const test = (0, enum_1.maybeAsEnum)(MyEnum).process('WATER');
        expect(test).toEqual({ value: MyEnum.WATER });
    });
    it('will accept null or undefined value', () => {
        const fut = (0, enum_1.maybeAsEnum)(MyEnum);
        const nullTest = fut.process(null);
        expect(nullTest).toEqual({ value: undefined });
        const undefinedTest = fut.process(undefined);
        expect(undefinedTest).toEqual({ value: undefined });
    });
});
describe('enums with isObject', () => {
    let Sauce;
    (function (Sauce) {
        Sauce[Sauce["MARINARA"] = 0] = "MARINARA";
        Sauce[Sauce["BBQ"] = 1] = "BBQ";
        Sauce[Sauce["ALFREDO"] = 2] = "ALFREDO";
    })(Sauce || (Sauce = {}));
    let Topping;
    (function (Topping) {
        Topping[Topping["CHEESE"] = 0] = "CHEESE";
        Topping[Topping["PEPPERONI"] = 1] = "PEPPERONI";
        Topping[Topping["HAM"] = 2] = "HAM";
        Topping[Topping["BACON"] = 3] = "BACON";
        Topping[Topping["OLIVES"] = 4] = "OLIVES";
        Topping[Topping["ONIONS"] = 5] = "ONIONS";
    })(Topping || (Topping = {}));
    const pizzaCheck = (0, object_1.isObject)({
        sauce: (0, enum_1.asEnum)(Sauce),
        toppings: (0, array_1.asArray)((0, enum_1.asEnum)(Topping)),
    });
    it('will do something', () => {
        const test = pizzaCheck.process({ sauce: 'MARINARA', toppings: ['CHEESE', 'PEPPERONI'] });
        if ((0, types_1.isIssue)(test)) {
            expect(false);
            return;
        }
        expect(test.value).toEqual({ sauce: Sauce.MARINARA, toppings: [Topping.CHEESE, Topping.PEPPERONI] });
    });
});
describe('', () => {
    let Topping;
    (function (Topping) {
        Topping[Topping["CHEESE"] = 0] = "CHEESE";
        Topping[Topping["PEPPERONI"] = 1] = "PEPPERONI";
        Topping[Topping["HAM"] = 2] = "HAM";
        Topping[Topping["BACON"] = 3] = "BACON";
        Topping[Topping["OLIVES"] = 4] = "OLIVES";
        Topping[Topping["ONIONS"] = 5] = "ONIONS";
    })(Topping || (Topping = {}));
    it('can optionally show valid keys', () => {
        let test = (0, enum_1.isEnum)(Topping).process('TESTING');
        expect(test.issues.length).toBe(1);
        expect(test.issues[0].info).toEqual({});
        test = (0, enum_1.isEnum)(Topping, { showValidKeys: true }).process('TESTING');
        expect(test.issues.length).toBe(1);
        expect(test.issues[0].info).toEqual({ validKeys: [0, 1, 2, 3, 4, 5] });
    });
    it('can optionally show valid values', () => {
        let test = (0, enum_1.isEnum)(Topping).process('TESTING');
        expect(test.issues.length).toBe(1);
        expect(test.issues[0].info).toEqual({});
        test = (0, enum_1.isEnum)(Topping, { showValidValues: true }).process('TESTING');
        expect(test.issues.length).toBe(1);
        expect(test.issues[0].info).toEqual({
            validValues: [
                'CHEESE',
                'PEPPERONI',
                'HAM',
                'BACON',
                'OLIVES',
                'ONIONS',
            ],
        });
    });
    it('can optionally show valid keys and values together', () => {
        let test = (0, enum_1.isEnum)(Topping).process('TESTING');
        expect(test.issues.length).toBe(1);
        expect(test.issues[0].info).toEqual({});
        test = (0, enum_1.isEnum)(Topping, { showValidKeys: true, showValidValues: true }).process('TESTING');
        expect(test.issues.length).toBe(1);
        expect(test.issues[0].info).toEqual({
            validKeys: [0, 1, 2, 3, 4, 5],
            validValues: [
                'CHEESE',
                'PEPPERONI',
                'HAM',
                'BACON',
                'OLIVES',
                'ONIONS',
            ],
        });
    });
});
//# sourceMappingURL=enum.test.js.map