dlms-protocol/tests/DlmsArray.test.js

DLMS Protocol parser for JavaScript

import DlmsDataType from "../src/enum/DlmsDataType";
import DlmsDatas from "../src/typesDLMS/DlmsDatas";
import DlmsArray from "../src/typesDLMS/DlmsArray";

jest.mock("../src/typesDLMS/DlmsDatas"); // Mock da classe DlmsDatas

describe("DlmsArray class", () => {
    beforeEach(() => {
        DlmsDatas.factory.mockClear();
    });

    test("should initialize with default values when no data is provided", () => {
        const dlmsArray = new DlmsArray();

        expect(dlmsArray.tag).toBe(DlmsDataType.ARRAY);
        expect(dlmsArray.totalBytes).toBe(0);
        expect(dlmsArray.rawValue).toEqual([]);
        expect(dlmsArray.bodyBytes).toEqual([]);
        expect(dlmsArray.size).toBe(0);
        expect(dlmsArray.value).toEqual([]);
    });

    test("should throw an error if tag does not match when inserting data", () => {
        const data = [0xFF, 2]; // Tag inválida
        const dlmsArray = new DlmsArray();

        expect(() => dlmsArray.insertData(data)).toThrow("Tag mismatch.");
    });

    test("should correctly parse data with insertData()", () => {
        // Mockando um item de DlmsDatas
        const mockDlmsData = {
            totalBytes: 2,
            rawValue: [0x02, 0x01],
            insertData: jest.fn(),
        };
        DlmsDatas.factory.mockReturnValueOnce(mockDlmsData);

        const data = [DlmsDataType.ARRAY, 1, 0x02, 0x01];
        const dlmsArray = new DlmsArray();
        dlmsArray.insertData(data);

        expect(dlmsArray.size).toBe(1);
        expect(dlmsArray.bodyBytes).toEqual([0x02, 0x01]);
        expect(dlmsArray.value.length).toBe(1);
        expect(dlmsArray.value[0]).toBe(mockDlmsData);
        expect(dlmsArray.rawValue).toEqual([DlmsDataType.ARRAY, 1, 0x02, 0x01]);
        expect(dlmsArray.totalBytes).toBe(4);
        expect(mockDlmsData.insertData).toHaveBeenCalledWith([0x02, 0x01]);
    });

    test("should correctly insert data from a list of DlmsDatas with insertDataFromList()", () => {
        const mockDlmsData1 = { rawValue: [0x02, 0x01] };
        const mockDlmsData2 = { rawValue: [0x03, 0x04] };

        const dlmsArray = new DlmsArray();
        dlmsArray.insertDataFromList([mockDlmsData1, mockDlmsData2]);

        expect(dlmsArray.size).toBe(2);
        expect(dlmsArray.bodyBytes).toEqual([0x02, 0x01, 0x03, 0x04]);
        expect(dlmsArray.value).toEqual([mockDlmsData1, mockDlmsData2]);
        expect(dlmsArray.rawValue).toEqual([DlmsDataType.ARRAY, 2, 0x02, 0x01, 0x03, 0x04]);
        expect(dlmsArray.totalBytes).toBe(6);
    });

    test("should return the correct value with getValue()", () => {
        const mockDlmsData = { rawValue: [0x02, 0x01] };
        const dlmsArray = new DlmsArray(null, [mockDlmsData]);

        expect(dlmsArray.getValue()).toEqual([mockDlmsData]);
    });

    test("should throw an error if getStandardLength() is called", () => {
        const dlmsArray = new DlmsArray();

        expect(() => dlmsArray.getStandardLength()).toThrow("Method not implemented.");
    });
});