@decentra/enums/tests/enums-test.spec.js

An enums helper written in JS 2022

import {Enum, INCREMENT, makeEnumeration, produceEnumeration} from "../src/index.js";
import {fail, ok, strictEqual} from "node:assert/strict";


class EnumTest extends Enum {

}

describe(`test enums functionality`, () => {
    it('Test auto-incrementing enums', () => {
        let [TestEnumeration, TestResolver] = makeEnumeration(EnumTest, {
            Test1: INCREMENT,
            Test2: INCREMENT
        });

        strictEqual(TestResolver(0), TestEnumeration.Test1);
        strictEqual(TestResolver(1), TestEnumeration.Test2);
    });

    it('Test enumeration resolver', () => {
        let [TestEnumeration, TestResolver] = makeEnumeration(EnumTest, {
            Test1: INCREMENT,
            Test2: INCREMENT,
            Test3: INCREMENT
        });

        strictEqual(TestResolver('Test1'), TestEnumeration.Test1);
        strictEqual(TestResolver(1), TestEnumeration.Test2);
        strictEqual(TestResolver(TestEnumeration.Test3), TestEnumeration.Test3);

    });

    it('Check all members list functionality', () => {
        class SmallPrimeNumber extends Enum {
        }

        let [PrimeNumbers, PrimesResolver, AllPrimes] = makeEnumeration(SmallPrimeNumber, {
            'one': 1,
            'two': 2,
            'three': 3,
            'five': 5,
            'seven': 7,
            'eleven': 11
        });
        strictEqual(AllPrimes.length, Object.entries(PrimeNumbers).length);
        for (let prime of AllPrimes) {
            strictEqual(prime.isNumber, true);
            strictEqual(prime, PrimesResolver(prime));
            strictEqual(prime, PrimesResolver(prime.asNumber));
        }
    });

    class Color extends Enum {
    }

    it('Test enumeration freeze', () => {
        let [Colors, ColorsResolver, AllColors] = makeEnumeration(Color, {
            red: '#FF0000',
            green: `#00FF00`,
            blue: `#0000FF`
        });
        ok(Object.isFrozen(Colors));
        ok(typeof ColorsResolver === "function");
        try {
            Colors.black = new Color('black', '#000000');
            fail('Expected error not thrown on adding enum member');
        } catch (err) {
            ok(true);
        }

        try {
            Colors.red = new Color('red', '#FF000088');
            fail('Expected error not thrown on enum member replace');
        } catch (err) {
            ok(true);
        }

        try {
            AllColors['push'](null);
            fail('Expected error not thrown on try to push new value to all values list')
        } catch (err) {
            ok(true)
        }
    });

    it(`test produceEnumeration API`, () => {
        class Flavour extends Enum {
            constructor(name, value) {
                super(name, value);
            }
        }

        let [Flavours, FlavoursResolver] = produceEnumeration(Flavour, {
            DEFAULT: INCREMENT,
            APPLE: INCREMENT,
            PINEAPPLE: INCREMENT,
            ORANGE: INCREMENT,
            MANGO : new Flavour('manga0', 99)
        });

        strictEqual(FlavoursResolver.byName("DEFAULT"), Flavours.DEFAULT);
        strictEqual(FlavoursResolver.byKey('APPLE'), Flavours.APPLE);
        strictEqual(FlavoursResolver.byKey('MANGO'), Flavours.MANGO);
        strictEqual(FlavoursResolver.byName('manga0'), Flavours.MANGO);
        strictEqual(FlavoursResolver.byNameOrValue('ORANGE'), Flavours.ORANGE);
        strictEqual(FlavoursResolver.byNumericValue(99), Flavours.MANGO);
        strictEqual(FlavoursResolver.resolve("PINEAPPLE"), Flavours.PINEAPPLE);
        try {
            FlavoursResolver.resolve(new Flavour('Rose', -1));
            fail("Failed to recognize unknown enum value by resolve");
        } catch (err) {
            //test was successful
            ok(true);
        }

        strictEqual(FlavoursResolver.enumerateValues().length, Object.keys(Flavours).length);
    })
});