zigbee-herdsman 3.5.1 → 4.0.0

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,212 @@
+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();
+    });
+});