dlms-protocol/tests/DlmsEnum.test.js

DLMS Protocol parser for JavaScript

import DlmsEnum from "../src/typesDLMS/DlmsEnum";
import DlmsDataType from "../src/enum/DlmsDataType";

describe("DlmsEnum class", () => {
    test("should initialize with default values when no data is provided", () => {
        const dlmsEnum = new DlmsEnum();

        expect(dlmsEnum.tag).toBe(DlmsDataType.ENUM);
        expect(dlmsEnum.totalBytes).toBe(0);
        expect(dlmsEnum.rawValue).toEqual([]);
        expect(dlmsEnum.bodyBytes).toEqual([]);
        expect(dlmsEnum.value).toBe(0);
    });

    test("should correctly initialize from a byte array", () => {
        const data = [DlmsDataType.ENUM, 0x05]; // ENUM tag and value
        const dlmsEnum = new DlmsEnum(data);

        expect(dlmsEnum.tag).toBe(DlmsDataType.ENUM);
        expect(dlmsEnum.totalBytes).toBe(2);
        expect(dlmsEnum.rawValue).toEqual([DlmsDataType.ENUM, 0x05]);
        expect(dlmsEnum.bodyBytes).toEqual([0x05]);
        expect(dlmsEnum.value).toBe(0x05);
    });

    test("should throw an error if tag does not match when initializing from a byte array", () => {
        const data = [0xFF, 0x05]; // Invalid tag
        expect(() => new DlmsEnum(data)).toThrow("Tag mismatch.");
    });

    test("should correctly initialize from a numeric value", () => {
        const dlmsEnum = new DlmsEnum(0x0A);

        expect(dlmsEnum.tag).toBe(DlmsDataType.ENUM);
        expect(dlmsEnum.totalBytes).toBe(2);
        expect(dlmsEnum.rawValue).toEqual([DlmsDataType.ENUM, 0x0A]);
        expect(dlmsEnum.bodyBytes).toEqual([0x0A]);
        expect(dlmsEnum.value).toBe(0x0A);
    });

    test("should return the correct standard length", () => {
        const dlmsEnum = new DlmsEnum();
        expect(dlmsEnum.getStandardLength()).toBe(2);
    });

    test("should return the correct value with getValue()", () => {
        const data = [DlmsDataType.ENUM, 0x03];
        const dlmsEnum = new DlmsEnum(data);

        expect(dlmsEnum.getValue()).toBe(0x03);
    });

    test("should correctly insert data from a byte array", () => {
        const dlmsEnum = new DlmsEnum();
        dlmsEnum.insertData([DlmsDataType.ENUM, 0x07]);

        expect(dlmsEnum.tag).toBe(DlmsDataType.ENUM);
        expect(dlmsEnum.totalBytes).toBe(2);
        expect(dlmsEnum.rawValue).toEqual([DlmsDataType.ENUM, 0x07]);
        expect(dlmsEnum.bodyBytes).toEqual([0x07]);
        expect(dlmsEnum.value).toBe(0x07);
    });

    test("should throw an error if tag does not match when inserting data", () => {
        const dlmsEnum = new DlmsEnum();
        expect(() => dlmsEnum.insertData([0xFF, 0x07])).toThrow("Tag mismatch.");
    });

    test("should correctly insert data from an enum value", () => {
        const dlmsEnum = new DlmsEnum();
        dlmsEnum.insertDataFromEnum(0x09);

        expect(dlmsEnum.tag).toBe(DlmsDataType.ENUM);
        expect(dlmsEnum.totalBytes).toBe(2);
        expect(dlmsEnum.rawValue).toEqual([DlmsDataType.ENUM, 0x09]);
        expect(dlmsEnum.bodyBytes).toEqual([0x09]);
        expect(dlmsEnum.value).toBe(0x09);
    });
});