zigbee-herdsman 6.0.1 → 6.0.3

package/test/adapter/z-stack/constants.test.ts

@@ -1,33 +0,0 @@
-import {describe, expect, it} from "vitest";
-import * as Constants from "../../../src/adapter/z-stack/constants";
-
-describe("zstack-constants", () => {
-    it("Simple check", () => {
-        expect(Constants.AF.DEFAULT_RADIUS).toBe(30);
-    });
-
-    describe("utils", () => {
-        describe("getChannelMask", () => {
-            it("Get channel mask 11", () => {
-                expect(Constants.Utils.getChannelMask([11])).toStrictEqual([0, 8, 0, 0]);
-            });
-
-            it("Get channel mask 25", () => {
-                expect(Constants.Utils.getChannelMask([25])).toStrictEqual([0, 0, 0, 2]);
-            });
-
-            it("Get channel mask 11 and 25", () => {
-                expect(Constants.Utils.getChannelMask([11, 25])).toStrictEqual([0, 8, 0, 2]);
-            });
-        });
-
-        describe("statusDescription", () => {
-            it("formats known status", () => {
-                expect(Constants.Utils.statusDescription(0x10)).toBe("(0x10: MEM_ERROR)");
-            });
-            it("formats unknown status", () => {
-                expect(Constants.Utils.statusDescription(0x08)).toBe("(0x08: UNKNOWN)");
-            });
-        });
-    });
-});

package/test/adapter/z-stack/structs.test.ts

@@ -1,115 +0,0 @@
-import {describe, expect, it} from "vitest";
-import * as Structs from "../../../src/adapter/z-stack/structs";
-
-describe("Z-Stack Structs", () => {
-    it("should export js object from structure", () => {
-        const nib = Structs.nib();
-        nib.extendedPANID = Buffer.alloc(8, 0x01);
-        nib.nwkLogicalChannel = 21;
-
-        const obj = nib.toJSON();
-        expect(obj.extendedPANID.toString("hex")).toBe(Buffer.alloc(8, 0x01).toString("hex"));
-        expect(obj.nwkLogicalChannel).toBe(21);
-    });
-
-    it("should properly serialize structure in different alignment modes", () => {
-        const nib = Structs.nib(
-            Buffer.from(
-                "fb050279147900640000000105018f000700020d1e000000150000000000000000000000ffff0800000020000f0f0400010000000100000000779fd609004b1200010000000000000000000000000000000000000000000000000000000000000000000000003c0c0001780a0100000006020000",
-                "hex",
-            ),
-        );
-        expect(nib.serialize().toString("hex")).toBe(
-            "fb050279147900640000000105018f0700020d1e00001500000000000000000000ffff08000020000f0f0400010000000100000000779fd609004b1200010000000000000000000000000000000000000000000000000000000000000000000000003c0c0001780a010000060200",
-        );
-        expect(nib.serialize("unaligned", true, 0).toString("hex")).toBe(
-            "fb050279147900640000000105018f0700020d1e00001500000000000000000000ffff08000020000f0f0400010000000100000000779fd609004b1200010000000000000000000000000000000000000000000000000000000000000000000000003c0c0001780a010000060200",
-        );
-        expect(nib.serialize("aligned", true, 0).toString("hex")).toBe(
-            "fb050279147900640000000105018f000700020d1e000000150000000000000000000000ffff0800000020000f0f0400010000000100000000779fd609004b1200010000000000000000000000000000000000000000000000000000000000000000000000003c0c0001780a0100000006020000",
-        );
-        expect(nib.getLength("aligned")).toBe(116);
-        expect(nib.getLength("aligned", false)).toBe(115);
-        expect(nib.getLength("unaligned")).toBe(110);
-    });
-
-    it("should throw error on invalid uint8 array length", () => {
-        const nib = Structs.nib();
-        expect(() => {
-            nib.extendedPANID = Buffer.alloc(10, 0x01);
-        }).toThrowError("Invalid length for member extendedPANID (expected=8, got=10)");
-    });
-
-    it("should fail to initialize struct from invalid length source", () => {
-        expect(() => {
-            Structs.nib(Buffer.from("01020304", "hex"));
-        }).toThrowError("Struct length mismatch (expected=110/116, got=4");
-    });
-
-    it("should fail if table entries are not the same length", () => {
-        expect(() => {
-            Structs.securityManagerTable([Buffer.alloc(12, 0x00), Buffer.alloc(17, 0x00)], "unaligned");
-        }).toThrowError("All table entries need to be the same length");
-    });
-
-    it("should fail if table initialization buffer is indivisible by entry length", () => {
-        expect(() => {
-            Structs.securityManagerTable(Buffer.alloc(91, 0x00));
-        }).toThrowError("Table length not divisible by entry length (alignment=unaligned, data_length=91, entry_length=5)");
-    });
-
-    it("should fail if table initialization source is unsupported", () => {
-        expect(() => {
-            // biome-ignore lint/suspicious/noExplicitAny: API
-            Structs.securityManagerTable("das_garbage" as any);
-        }).toThrowError("Unsupported table data source");
-    });
-
-    it("should properly return table capacity metrics", () => {
-        const table = Structs.securityManagerTable(8);
-        expect(table.used.length).toBe(0);
-        expect(table.free.length).toBe(8);
-    });
-
-    it("should properly serialize unaligned and aligned table - with inline occupancy", () => {
-        const table = Structs.securityManagerTable(8);
-        expect(table.serialize().toString("hex")).toBe("0000feff000000feff000000feff000000feff000000feff000000feff000000feff000000feff000000");
-        expect(table.serialize("unaligned").toString("hex")).toBe(
-            "0000feff000000feff000000feff000000feff000000feff000000feff000000feff000000feff000000",
-        );
-        expect(table.serialize("aligned").toString("hex")).toBe(
-            "0000feff00000000feff00000000feff00000000feff00000000feff00000000feff00000000feff00000000feff00000000",
-        );
-    });
-
-    it("should properly evaluate security manager table occupancy", () => {
-        const table = Structs.securityManagerTable(8);
-        table.free[6].ami = 0xfffe;
-        table.free[6].authenticationOption = 0x00;
-        table.free[7].ami = 0x0000;
-        table.free[7].authenticationOption = 0x00;
-        expect(table.freeCount).toBe(8);
-        expect(table.usedCount).toBe(0);
-    });
-
-    it("should properly serialize unaligned and aligned table - without inline occupancy", () => {
-        const table = Structs.nwkSecMaterialDescriptorTable(8);
-        expect(table.serialize().toString("hex")).toBe(
-            "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        );
-        expect(table.serialize("unaligned").toString("hex")).toBe(
-            "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        );
-        expect(table.serialize("aligned").toString("hex")).toBe(
-            "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        );
-    });
-
-    it("should evaluate table struct", () => {
-        const table = Structs.nwkSecMaterialDescriptorTable(8);
-        expect(table.capacity).toBe(8);
-        expect(table.entries.length).toBe(8);
-        expect(table.freeCount).toBe(8);
-        expect(table.usedCount).toBe(0);
-    });
-});

package/test/adapter/z-stack/unpi.test.ts

@@ -1,213 +0,0 @@
-import {beforeEach, describe, expect, it, vi} from "vitest";
-import {Constants, Frame, Parser, Writer} from "../../../src/adapter/z-stack/unpi";
-
-describe("Parser", () => {
-    let parser;
-    let parsed = [];
-
-    beforeEach(() => {
-        parser = new Parser();
-        parser.on("parsed", (result) => parsed.push(result));
-        parsed = [];
-    });
-
-    it("Parse simple message", () => {
-        const buffer = Buffer.from([
-            0xfe, 0x0e, 0x61, 0x02, 0x02, 0x00, 0x02, 0x06, 0x03, 0xd9, 0x14, 0x34, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x92,
-        ]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(1);
-        expect(parsed[0].type).toBe(Constants.Type.SRSP);
-        expect(parsed[0].subsystem).toBe(Constants.Subsystem.SYS);
-        expect(parsed[0].commandID).toBe(2);
-        expect(parsed[0].data).toStrictEqual(Buffer.from([2, 0, 2, 6, 3, 217, 20, 52, 1, 2, 0, 0, 0, 0]));
-        expect(parsed[0].length).toBe(14);
-        expect(parsed[0].fcs).toBe(0x92);
-    });
-
-    it("Parse two messages", () => {
-        const buffer = Buffer.from([
-            0xfe, 0x0e, 0x61, 0x02, 0x02, 0x00, 0x02, 0x06, 0x03, 0xd9, 0x14, 0x34, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x92, 0xfe, 0x03, 0x61, 0x08,
-            0x00, 0x01, 0x55, 0x3e,
-        ]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(2);
-        expect(parsed[0].type).toBe(Constants.Type.SRSP);
-        expect(parsed[0].subsystem).toBe(Constants.Subsystem.SYS);
-        expect(parsed[0].commandID).toBe(2);
-        expect(parsed[0].data).toStrictEqual(Buffer.from([2, 0, 2, 6, 3, 217, 20, 52, 1, 2, 0, 0, 0, 0]));
-        expect(parsed[0].length).toBe(14);
-        expect(parsed[0].fcs).toBe(0x92);
-        expect(parsed[1].type).toBe(Constants.Type.SRSP);
-        expect(parsed[1].subsystem).toBe(Constants.Subsystem.SYS);
-        expect(parsed[1].commandID).toBe(8);
-        expect(parsed[1].data).toStrictEqual(Buffer.from([0, 1, 85]));
-        expect(parsed[1].length).toBe(3);
-        expect(parsed[1].fcs).toBe(0x3e);
-    });
-
-    it("Dont throw error on fcs mismatch", () => {
-        const buffer = Buffer.from([0xfe, 0x03, 0x61, 0x08, 0x00, 0x01, 0x55, 0x3f]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(0);
-    });
-
-    it("Message in two chunks", () => {
-        let buffer = Buffer.from([0xfe, 0x03, 0x61, 0x08, 0x00, 0x01]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(0);
-
-        buffer = Buffer.from([0x55, 0x3e]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(1);
-
-        expect(parsed[0].type).toBe(Constants.Type.SRSP);
-        expect(parsed[0].subsystem).toBe(Constants.Subsystem.SYS);
-        expect(parsed[0].commandID).toBe(8);
-        expect(parsed[0].data).toStrictEqual(Buffer.from([0, 1, 85]));
-        expect(parsed[0].length).toBe(3);
-        expect(parsed[0].fcs).toBe(0x3e);
-    });
-
-    it("Message in two chunks, fcs as separate", () => {
-        let buffer = Buffer.from([0xfe, 0x03, 0x61, 0x08, 0x00, 0x01, 0x55]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(0);
-
-        buffer = Buffer.from([0x3e]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(1);
-
-        expect(parsed[0].type).toBe(Constants.Type.SRSP);
-        expect(parsed[0].subsystem).toBe(Constants.Subsystem.SYS);
-        expect(parsed[0].commandID).toBe(8);
-        expect(parsed[0].data).toStrictEqual(Buffer.from([0, 1, 85]));
-        expect(parsed[0].length).toBe(3);
-        expect(parsed[0].fcs).toBe(0x3e);
-    });
-
-    it("Parse message when it doenst start with SOF and buffer is empty (throw away everything until SOF)", () => {
-        const buffer = Buffer.from([
-            95, 27, 37, 254, 3, 69, 196, 212, 23, 0, 65, 254, 27, 68, 129, 0, 0, 8, 0, 212, 23, 1, 1, 0, 55, 0, 153, 178, 219, 0, 0, 7, 8, 122, 10, 0,
-            0, 32, 243, 212, 23, 29, 160, 254, 7, 69, 196, 111, 244, 2, 122, 155, 246, 95, 87, 254, 27, 68, 129, 0, 0, 6, 0, 111, 244, 1, 1, 0, 118,
-            0, 245, 236, 220, 0, 0, 7, 8, 2, 10, 0, 0, 16, 0, 246, 95, 27, 85,
-        ]);
-        parser._transform(buffer, "", () => {});
-        expect(parsed.length).toBe(4);
-        expect(parsed[0].type).toBe(Constants.Type.AREQ);
-        expect(parsed[0].subsystem).toBe(Constants.Subsystem.ZDO);
-        expect(parsed[0].commandID).toBe(196);
-        expect(parsed[0].data).toStrictEqual(Buffer.from([0xd4, 0x17, 0x00]));
-        expect(parsed[0].length).toBe(3);
-        expect(parsed[0].fcs).toBe(65);
-        expect(parsed[1].type).toBe(Constants.Type.AREQ);
-        expect(parsed[1].subsystem).toBe(Constants.Subsystem.AF);
-        expect(parsed[1].commandID).toBe(129);
-        expect(parsed[1].data).toStrictEqual(
-            Buffer.from([0, 0, 8, 0, 212, 23, 1, 1, 0, 55, 0, 153, 178, 219, 0, 0, 7, 8, 122, 10, 0, 0, 32, 243, 212, 23, 29]),
-        );
-        expect(parsed[1].length).toBe(27);
-        expect(parsed[1].fcs).toBe(160);
-    });
-
-    it("Continue parsing on fcs mismatch", () => {
-        const buffer1 = Buffer.from([
-            0x01,
-            0x02,
-            0xfe,
-            0x03,
-            0x61,
-            0x08,
-            0x00,
-            0x01,
-            0x55,
-            0x3f, // fcs mismatch
-            0x08,
-            0x09,
-            0x12, // Noise
-        ]);
-
-        const buffer2 = Buffer.from([
-            0x08,
-            0x09,
-            0x12, // Noise
-        ]);
-
-        const buffer3 = Buffer.from([
-            0x08,
-            0x09,
-            0x12, // Noise
-            0xfe,
-            0x0e,
-            0x61,
-            0x02, // Valid message part 1
-        ]);
-
-        const buffer4 = Buffer.from([
-            0x02,
-            0x00,
-            0x02,
-            0x06,
-            0x03,
-            0xd9,
-            0x14,
-            0x34,
-            0x01,
-            0x02,
-            0x00,
-            0x00,
-            0x00,
-            0x00,
-            0x92, // Valid message part 2
-        ]);
-
-        parser._transform(buffer1, "", () => {});
-        parser._transform(buffer2, "", () => {});
-        parser._transform(buffer3, "", () => {});
-        parser._transform(buffer4, "", () => {});
-
-        expect(parsed.length).toBe(1);
-        expect(parsed[0].type).toBe(Constants.Type.SRSP);
-        expect(parsed[0].subsystem).toBe(Constants.Subsystem.SYS);
-        expect(parsed[0].commandID).toBe(2);
-        expect(parsed[0].data).toStrictEqual(Buffer.from([2, 0, 2, 6, 3, 217, 20, 52, 1, 2, 0, 0, 0, 0]));
-        expect(parsed[0].length).toBe(14);
-        expect(parsed[0].fcs).toBe(0x92);
-    });
-});
-
-describe("Frame", () => {
-    it("To buffer", () => {
-        const frame = new Frame(Constants.Type.SRSP, Constants.Subsystem.SYS, 3, Buffer.from([0x06, 0x01]));
-        const buffer = frame.toBuffer();
-        expect(buffer).toStrictEqual(Buffer.from([0xfe, 0x02, 0x61, 0x03, 0x06, 0x01, 0x67]));
-    });
-});
-
-describe("Writer", () => {
-    let writer;
-
-    beforeEach(() => {
-        writer = new Writer();
-    });
-
-    it("Write frame", () => {
-        const frame = new Frame(Constants.Type.SRSP, Constants.Subsystem.SYS, 3, Buffer.from([0x06, 0x01]));
-        const push = vi.spyOn(writer, "push").mockReturnValue(undefined);
-        writer.writeFrame(frame);
-        expect(push).toHaveBeenCalledTimes(1);
-        expect(push.mock.calls[0][0]).toStrictEqual(frame.toBuffer());
-    });
-
-    it("Write buffer", () => {
-        const buffer = Buffer.from([0x01, 0x02]);
-        const push = vi.spyOn(writer, "push").mockReturnValue(undefined);
-        writer.writeBuffer(buffer);
-        expect(push).toHaveBeenCalledTimes(1);
-        expect(push.mock.calls[0][0]).toStrictEqual(buffer);
-    });
-
-    it("Read should do nothing (satisfy coverage)", () => {
-        writer.read();
-    });
-});