dlms-protocol/tests/DlmsDatas.test.js

DLMS Protocol parser for JavaScript

import DlmsDatas from "../src/typesDLMS/DlmsDatas";
import DlmsArray from "../src/typesDLMS/DlmsArray";
import DlmsArrayStruct from "../src/typesDLMS/DlmsArrayStruct";
import Boolean from "../src/typesDLMS/Boolean";
import DlmsBitstring from "../src/typesDLMS/DlmsBitstring";
import DlmsInt8 from "../src/typesDLMS/DlmsInt8";
import DlmsUint8 from "../src/typesDLMS/DlmsUint8";
import DlmsUint16 from "../src/typesDLMS/DlmsUint16";
import DlmsUint32 from "../src/typesDLMS/DlmsUint32";
import DlmsUint64 from "../src/typesDLMS/DlmsUint64";
import DlmsOctetString from "../src/typesDLMS/DlmsOctetString";
import DlmsString from "../src/typesDLMS/DlmsString";
import DlmsEnum from "../src/typesDLMS/DlmsEnum";
import DlmsCompactArray from "../src/typesDLMS/DlmsCompactArray";
import DlmsDataType from "../src/enum/DlmsDataType";

describe("DlmsDatas factory method", () => {
    test("should return a DlmsArray instance for DlmsDataType.ARRAY", () => {
        const instance = DlmsDatas.factory(DlmsDataType.ARRAY);
        expect(instance).toBeInstanceOf(DlmsArray);
    });

    test("should return a DlmsArrayStruct instance for DlmsDataType.STRUCT", () => {
        const instance = DlmsDatas.factory(DlmsDataType.STRUCT);
        expect(instance).toBeInstanceOf(DlmsArrayStruct);
    });

    test("should return a Boolean instance for DlmsDataType.BOOLEAN", () => {
        const instance = DlmsDatas.factory(DlmsDataType.BOOLEAN);
        expect(instance).toBeInstanceOf(Boolean);
    });

    test("should return a DlmsBitstring instance for DlmsDataType.BITSTRING", () => {
        const instance = DlmsDatas.factory(DlmsDataType.BITSTRING);
        expect(instance).toBeInstanceOf(DlmsBitstring);
    });

    test("should return a DlmsInt8 instance for DlmsDataType.INT8", () => {
        const instance = DlmsDatas.factory(DlmsDataType.INT8);
        expect(instance).toBeInstanceOf(DlmsInt8);
    });

    test("should return a DlmsUint8 instance for DlmsDataType.UINT8", () => {
        const instance = DlmsDatas.factory(DlmsDataType.UINT8);
        expect(instance).toBeInstanceOf(DlmsUint8);
    });

    test("should return a DlmsUint16 instance for DlmsDataType.UINT16", () => {
        const instance = DlmsDatas.factory(DlmsDataType.UINT16);
        expect(instance).toBeInstanceOf(DlmsUint16);
    });

    test("should return a DlmsUint32 instance for DlmsDataType.UINT32", () => {
        const instance = DlmsDatas.factory(DlmsDataType.UINT32);
        expect(instance).toBeInstanceOf(DlmsUint32);
    });

    test("should return a DlmsUint64 instance for DlmsDataType.UINT64", () => {
        const instance = DlmsDatas.factory(DlmsDataType.UINT64);
        expect(instance).toBeInstanceOf(DlmsUint64);
    });

    test("should return a DlmsOctetString instance for DlmsDataType.OCTET_STRING", () => {
        const instance = DlmsDatas.factory(DlmsDataType.OCTET_STRING);
        expect(instance).toBeInstanceOf(DlmsOctetString);
    });

    test("should return a DlmsString instance for DlmsDataType.STRING", () => {
        const instance = DlmsDatas.factory(DlmsDataType.STRING);
        expect(instance).toBeInstanceOf(DlmsString);
    });

    test("should return a DlmsEnum instance for DlmsDataType.ENUM", () => {
        const instance = DlmsDatas.factory(DlmsDataType.ENUM);
        expect(instance).toBeInstanceOf(DlmsEnum);
    });

    test("should return a DlmsCompactArray instance for DlmsDataType.COMPACT_ARRAY", () => {
        const instance = DlmsDatas.factory(DlmsDataType.COMPACT_ARRAY);
        expect(instance).toBeInstanceOf(DlmsCompactArray);
    });

    test("should throw an error for an unsupported DlmsDataType", () => {
        const invalidType = 9999; // An unsupported type
        expect(() => DlmsDatas.factory(invalidType)).toThrow(
            `Unsupported DlmsDataType: ${invalidType}`
        );
    });
});