zigbee-herdsman 4.4.1 → 5.0.0

package/test/mockDevices.ts

@@ -1,3 +1,4 @@
+import * as Zcl from "../src/zspec/zcl";
 import * as Zdo from "../src/zspec/zdo";
 import type * as ZdoTypes from "../src/zspec/zdo/definition/tstypes";
 
@@ -438,7 +439,10 @@ export const MOCK_DEVICES: {
         },
     },
     177: {
-        nodeDescriptor: [Zdo.Status.SUCCESS, {...NODE_DESC_DEFAULTS, nwkAddress: 177, logicalType: 0b001, manufacturerCode: 4129}],
+        nodeDescriptor: [
+            Zdo.Status.SUCCESS,
+            {...NODE_DESC_DEFAULTS, nwkAddress: 177, logicalType: 0b001, manufacturerCode: Zcl.ManufacturerCode.LEGRAND_GROUP},
+        ],
         activeEndpoints: [Zdo.Status.SUCCESS, {nwkAddress: 177, endpointList: [1]}],
         simpleDescriptor: {
             1: [
@@ -469,4 +473,126 @@ export const MOCK_DEVICES: {
             },
         },
     },
+    178: {
+        nodeDescriptor: [
+            Zdo.Status.SUCCESS,
+            {...NODE_DESC_DEFAULTS, nwkAddress: 178, logicalType: 0b001, manufacturerCode: Zcl.ManufacturerCode.LEGRAND_GROUP},
+        ],
+        activeEndpoints: [Zdo.Status.SUCCESS, {nwkAddress: 178, endpointList: [1, 2]}],
+        simpleDescriptor: {
+            1: [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: 178,
+                    length: 32,
+                    endpoint: 1,
+                    profileId: 260,
+                    deviceId: 514,
+                    deviceVersion: 1,
+                    inClusterList: [0, 3, 258, 4, 5, 15, 64513],
+                    outClusterList: [258, 0, 64513, 5, 25],
+                },
+            ],
+            2: [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: 178,
+                    length: 32,
+                    endpoint: 2,
+                    profileId: 260,
+                    deviceId: 514,
+                    deviceVersion: 1,
+                    inClusterList: [0, 3, 258, 4, 5, 15],
+                    outClusterList: [258, 0, 64513, 5, 25],
+                },
+            ],
+        },
+        attributes: {
+            1: {
+                modelId: " some other multi-endpoint device",
+                manufacturerName: "Legrand",
+                zclVersion: 2,
+                appVersion: 0,
+                hwVersion: 8,
+                dateCode: "241030",
+                swBuildId: "0039",
+                powerSource: 1,
+                stackVersion: 67,
+            },
+        },
+    },
+    179: {
+        nodeDescriptor: [
+            Zdo.Status.SUCCESS,
+            {...NODE_DESC_DEFAULTS, nwkAddress: 179, logicalType: 0b001, manufacturerCode: Zcl.ManufacturerCode.V_MARK_ENTERPRISES_INC},
+        ],
+        activeEndpoints: [Zdo.Status.SUCCESS, {nwkAddress: 179, endpointList: [1, 2, 3, 4]}],
+        simpleDescriptor: {
+            1: [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: 179,
+                    length: 32,
+                    endpoint: 1,
+                    profileId: 260,
+                    deviceId: 514,
+                    deviceVersion: 1,
+                    inClusterList: [0, 64561],
+                    outClusterList: [64561],
+                },
+            ],
+            2: [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: 179,
+                    length: 32,
+                    endpoint: 1,
+                    profileId: 260,
+                    deviceId: 514,
+                    deviceVersion: 1,
+                    inClusterList: [0, 64561],
+                    outClusterList: [64561],
+                },
+            ],
+            3: [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: 179,
+                    length: 32,
+                    endpoint: 1,
+                    profileId: 260,
+                    deviceId: 514,
+                    deviceVersion: 1,
+                    inClusterList: [0, 64561],
+                    outClusterList: [64561],
+                },
+            ],
+            4: [
+                Zdo.Status.SUCCESS,
+                {
+                    nwkAddress: 179,
+                    length: 32,
+                    endpoint: 1,
+                    profileId: 260,
+                    deviceId: 514,
+                    deviceVersion: 1,
+                    inClusterList: [0, 64561],
+                    outClusterList: [64561],
+                },
+            ],
+        },
+        attributes: {
+            1: {
+                modelId: "VZM30-SN",
+                manufacturerName: "Inovelli",
+                zclVersion: 3,
+                appVersion: 0,
+                hwVersion: 8,
+                dateCode: "2025",
+                swBuildId: "0001",
+                powerSource: 1,
+                stackVersion: 67,
+            },
+        },
+    },
 };

package/test/requests.bench.ts

@@ -0,0 +1,206 @@
+import {bench, describe} from "vitest";
+import type {Adapter} from "../src/adapter";
+import type {ZclPayload} from "../src/adapter/events";
+import Database from "../src/controller/database";
+import {Device, Entity, Group} from "../src/controller/model";
+import {InterviewState} from "../src/controller/model/device";
+import {setLogger} from "../src/utils/logger";
+import * as Zcl from "../src/zspec/zcl";
+import * as Zdo from "../src/zspec/zdo";
+import {uint16To8Array} from "./utils/math";
+
+let sendZclFrameToEndpointResponse: ZclPayload | undefined;
+let sendZdoResponse: unknown | undefined;
+
+// no-op, makes up for too much of the perf loss (with console logging by default)
+setLogger({
+    debug: () => {},
+    info: () => {},
+    warning: () => {},
+    error: () => {},
+});
+
+const database = Database.open("dummy");
+// no-op
+database.write = () => {};
+
+const adapter = {
+    sendZclFrameToEndpoint: async () => Promise.resolve(sendZclFrameToEndpointResponse),
+    sendZclFrameToGroup: async () => Promise.resolve(),
+    sendZdo: async () => Promise.resolve(sendZdoResponse),
+};
+
+Entity.injectDatabase(database);
+Entity.injectAdapter(adapter as unknown as Adapter);
+
+const device = Device.create(
+    "Router",
+    "0xfe34ac2385ff8311",
+    0x0001,
+    0x0102,
+    "Herdsman",
+    "Mains (single phase)",
+    "Herd-01",
+    InterviewState.Successful,
+    undefined,
+);
+const endpoint = device.createEndpoint(1);
+const group = Group.create(1);
+
+group.addMember(endpoint);
+
+const IEEE_ADDRESS1 = "0xfe34ac2385ff8311";
+const IEEE_ADDRESS1_BYTES = [0x11, 0x83, 0xff, 0x85, 0x23, 0xac, 0x34, 0xfe];
+const IEEE_ADDRESS2 = "0x28373fecd834ba37";
+const IEEE_ADDRESS2_BYTES = [0x37, 0xba, 0x34, 0xd8, 0xec, 0x3f, 0x37, 0x28];
+const NODE_ID1 = 0xfe32;
+const NODE_ID1_BYTES = uint16To8Array(NODE_ID1);
+const NODE_ID2 = 0xab39;
+const NODE_ID2_BYTES = uint16To8Array(NODE_ID2);
+const EXT_PAN_ID1 = [3, 43, 56, 23, 65, 23, 67, 23];
+const EXT_PAN_ID2 = [253, 231, 21, 3, 0, 44, 24, 46];
+const LQI_TABLE_RESPONSE = Buffer.from([
+    1,
+    Zdo.Status.SUCCESS,
+    2,
+    3,
+    2,
+    ...EXT_PAN_ID2,
+    ...IEEE_ADDRESS1_BYTES,
+    ...NODE_ID2_BYTES,
+    0b00100101,
+    0b00000001,
+    1,
+    235,
+    ...EXT_PAN_ID1,
+    ...IEEE_ADDRESS2_BYTES,
+    ...NODE_ID1_BYTES,
+    0b01000010,
+    0b00000000,
+    1,
+    179,
+]);
+
+const BASIC_RESP = Zcl.Frame.create(
+    0,
+    1,
+    true,
+    undefined,
+    10,
+    "readRsp",
+    0,
+    [
+        {
+            attrId: 5,
+            dataType: Zcl.DataType.CHAR_STR,
+            attrData: device.modelID,
+            status: 0,
+        },
+        {
+            attrId: 4,
+            dataType: Zcl.DataType.CHAR_STR,
+            attrData: device.manufacturerName,
+            status: 0,
+        },
+    ],
+    {},
+).toBuffer();
+
+describe("Requests", () => {
+    beforeEach(() => {
+        sendZclFrameToEndpointResponse = undefined;
+        sendZdoResponse = undefined;
+    });
+
+    bench(
+        "device lqi",
+        async () => {
+            sendZdoResponse = Zdo.Buffalo.readResponse(true, Zdo.ClusterId.LQI_TABLE_RESPONSE, LQI_TABLE_RESPONSE);
+            const resp = await device.lqi();
+
+            if (resp.neighbors[0].ieeeAddr !== IEEE_ADDRESS1 || resp.neighbors[1].ieeeAddr !== IEEE_ADDRESS2) {
+                throw new Error("Invalid response");
+            }
+        },
+        {throws: true},
+    );
+
+    bench(
+        "device.endpoint write basic",
+        async () => {
+            await endpoint.write("genBasic", {modelId: "Herd-02", manufacturerName: "HerdsmanNew"}, {sendPolicy: "immediate"});
+        },
+        {throws: true},
+    );
+
+    bench(
+        "device.endpoint read basic",
+        async () => {
+            sendZclFrameToEndpointResponse = {
+                clusterID: Zcl.Clusters.genBasic.ID,
+                header: Zcl.Header.fromBuffer(BASIC_RESP),
+                address: 0x0001,
+                data: BASIC_RESP,
+                endpoint: 1,
+                linkquality: 200,
+                groupID: 0,
+                wasBroadcast: false,
+                destinationEndpoint: 1,
+            };
+            const resp = await endpoint.read("genBasic", ["modelId", "manufacturerName"], {sendPolicy: "immediate"});
+
+            if (resp.modelId !== device.modelID || resp.manufacturerName !== device.manufacturerName) {
+                throw new Error("Invalid response");
+            }
+        },
+        {throws: true},
+    );
+
+    bench(
+        "device.endpoint defaultRsp",
+        async () => {
+            await endpoint.defaultResponse(0, 0, 0, 1);
+        },
+        {throws: true},
+    );
+
+    bench(
+        "device.endpoint command",
+        async () => {
+            await endpoint.command("genOnOff", "offWithEffect", {effectid: 1, effectvariant: 2}, {sendPolicy: "immediate"});
+        },
+        {throws: true},
+    );
+
+    bench(
+        "device.endpoint commandResponse",
+        async () => {
+            await endpoint.commandResponse("genAlarms", "alarm", {alarmcode: 123, clusterid: 456}, {sendPolicy: "immediate"});
+        },
+        {throws: true},
+    );
+
+    bench(
+        "group write basic",
+        async () => {
+            await group.write("genBasic", {modelId: "Herd-02", manufacturerName: "HerdsmanNew"});
+        },
+        {throws: true},
+    );
+
+    bench(
+        "group read basic",
+        async () => {
+            await group.read("genBasic", ["modelId", "manufacturerName"]);
+        },
+        {throws: true},
+    );
+
+    bench(
+        "group command",
+        async () => {
+            await group.command("genRssiLocation", "getDevCfg", {targetaddr: IEEE_ADDRESS1}, {});
+        },
+        {throws: true},
+    );
+});

package/test/vitest.config.mts

@@ -1,6 +1,8 @@
+import codspeedPlugin from "@codspeed/vitest-plugin";
 import {defineConfig} from "vitest/config";
 
 export default defineConfig({
+    plugins: [codspeedPlugin()],
     test: {
         globals: true,
         onConsoleLog(_log: string, _type: "stdout" | "stderr"): boolean | undefined {

package/test/zcl.test.ts

@@ -20,8 +20,6 @@ describe("Zcl", () => {
         // @ts-expect-error testing
         delete cluster1.getCommand;
         // @ts-expect-error testing
-        delete cluster1.hasAttribute;
-        // @ts-expect-error testing
         delete cluster1.getCommandResponse;
         const cluster2 = Zcl.Utils.getCluster("genBasic", undefined, {});
         // @ts-expect-error testing
@@ -29,8 +27,6 @@ describe("Zcl", () => {
         // @ts-expect-error testing
         delete cluster2.getCommand;
         // @ts-expect-error testing
-        delete cluster2.hasAttribute;
-        // @ts-expect-error testing
         delete cluster2.getCommandResponse;
         expect(cluster1).toStrictEqual(cluster2);
     });
@@ -43,10 +39,10 @@ describe("Zcl", () => {
 
     it("Cluster has attribute", () => {
         const cluster = Zcl.Utils.getCluster(0, undefined, {});
-        expect(cluster.hasAttribute("zclVersion")).toBeTruthy();
-        expect(cluster.hasAttribute("NOTEXISTING")).toBeFalsy();
-        expect(cluster.hasAttribute(0)).toBeTruthy();
-        expect(cluster.hasAttribute(910293)).toBeFalsy();
+        expect(cluster.getAttribute("zclVersion")).not.toBeUndefined();
+        expect(cluster.getAttribute("NOTEXISTING")).toBeUndefined();
+        expect(cluster.getAttribute(0)).not.toBeUndefined();
+        expect(cluster.getAttribute(910293)).toBeUndefined();
     });
 
     it("Get specific command by name", () => {
@@ -1917,26 +1913,26 @@ describe("Zcl", () => {
 
     it("Zcl utils get cluster attributes manufacturerCode wrong", () => {
         const cluster = Zcl.Utils.getCluster("closuresWindowCovering", 123, {});
-        expect(() => cluster.getAttribute(0x1000)).toThrow("Cluster 'closuresWindowCovering' has no attribute '4096'");
+        expect(cluster.getAttribute(0x1000)).toBeUndefined();
     });
 
     it("Zcl utils get command", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
         const command = cluster.getCommand(0);
-        expect(command.name).toEqual("off");
-        expect(cluster.getCommand("off")).toEqual(command);
+        expect(command.name).toStrictEqual("off");
+        expect(cluster.getCommand("off")).toStrictEqual(command);
     });
 
     it("Zcl utils get attribute", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
-        const command = cluster.getAttribute(16385);
-        expect(command.name).toEqual("onTime");
-        expect(cluster.getAttribute("onTime")).toEqual(command);
+        const attribute = cluster.getAttribute(16385);
+        expect(attribute?.name).toStrictEqual("onTime");
+        expect(cluster.getAttribute("onTime")).toStrictEqual(attribute);
     });
 
     it("Zcl utils get attribute non-existing", () => {
         const cluster = Zcl.Utils.getCluster("genOnOff", undefined, {});
-        expect(() => cluster.getAttribute("notExisting")).toThrow("Cluster 'genOnOff' has no attribute 'notExisting'");
+        expect(cluster.getAttribute("notExisting")).toBeUndefined();
     });
 
     it("Zcl utils get command non-existing", () => {

package/test/zspec/zcl/frame.test.ts

@@ -280,13 +280,13 @@ const MANUF_SPE_FRAME_STRING = `{"header":{"frameControl":{"reservedBits":0,"fra
 describe("ZCL Frame", () => {
     describe("Validates Parameter Condition", () => {
         it("STATUS_EQUAL", () => {
-            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.readRsp.parameters[2], {status: 0}, null)).toBeTruthy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.readRsp.parameters[2], {status: 1}, null)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.readRsp.parameters[2], {status: 0}, undefined)).toBeTruthy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.readRsp.parameters[2], {status: 1}, undefined)).toBeFalsy();
         });
 
         it("STATUS_NOT_EQUAL", () => {
-            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.writeRsp.parameters[1], {status: 1}, null)).toBeTruthy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.writeRsp.parameters[1], {status: 0}, null)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.writeRsp.parameters[1], {status: 1}, undefined)).toBeTruthy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Foundation.writeRsp.parameters[1], {status: 0}, undefined)).toBeFalsy();
         });
 
         it("MINIMUM_REMAINING_BUFFER_BYTES", () => {
@@ -296,34 +296,34 @@ describe("ZCL Frame", () => {
 
         it("DIRECTION_EQUAL", () => {
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[2], {direction: Zcl.Direction.CLIENT_TO_SERVER}, null),
+                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[2], {direction: Zcl.Direction.CLIENT_TO_SERVER}, undefined),
             ).toBeTruthy();
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[2], {direction: Zcl.Direction.SERVER_TO_CLIENT}, null),
+                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[2], {direction: Zcl.Direction.SERVER_TO_CLIENT}, undefined),
             ).toBeFalsy();
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[6], {direction: Zcl.Direction.SERVER_TO_CLIENT}, null),
+                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[6], {direction: Zcl.Direction.SERVER_TO_CLIENT}, undefined),
             ).toBeTruthy();
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[6], {direction: Zcl.Direction.CLIENT_TO_SERVER}, null),
+                Zcl.Frame.conditionsValid(Zcl.Foundation.configReport.parameters[6], {direction: Zcl.Direction.CLIENT_TO_SERVER}, undefined),
             ).toBeFalsy();
         });
 
         it("BITMASK_SET", () => {
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x4000}, null)).toBeTruthy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x4150}, null)).toBeTruthy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x0400}, null)).toBeFalsy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x1400}, null)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x4000}, undefined)).toBeTruthy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x4150}, undefined)).toBeTruthy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x0400}, undefined)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[8], {options: 0x1400}, undefined)).toBeFalsy();
         });
 
         it("BITFIELD_ENUM", () => {
             // {param:'options', offset: 0, size: 3, value: 0b000}
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b000}, null)).toBeTruthy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b1000}, null)).toBeTruthy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b001}, null)).toBeFalsy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b011}, null)).toBeFalsy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b100}, null)).toBeFalsy();
-            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b1010}, null)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b000}, undefined)).toBeTruthy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b1000}, undefined)).toBeTruthy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b001}, undefined)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b011}, undefined)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b100}, undefined)).toBeFalsy();
+            expect(Zcl.Frame.conditionsValid(Zcl.Clusters.greenPower.commands.notification.parameters[1], {options: 0b1010}, undefined)).toBeFalsy();
         });
 
         it("multiple including DATA_TYPE_CLASS_EQUAL", () => {
@@ -331,41 +331,41 @@ describe("ZCL Frame", () => {
                 Zcl.Frame.conditionsValid(
                     Zcl.Foundation.configReport.parameters[5],
                     {direction: Zcl.Direction.CLIENT_TO_SERVER, dataType: Zcl.DataType.UINT8},
-                    null,
+                    undefined,
                 ),
             ).toBeTruthy();
             expect(
                 Zcl.Frame.conditionsValid(
                     Zcl.Foundation.configReport.parameters[5],
                     {direction: Zcl.Direction.CLIENT_TO_SERVER, dataType: Zcl.DataType.DATA8},
-                    null,
+                    undefined,
                 ),
             ).toBeFalsy();
             expect(
                 Zcl.Frame.conditionsValid(
                     Zcl.Foundation.configReport.parameters[5],
                     {direction: Zcl.Direction.SERVER_TO_CLIENT, dataType: Zcl.DataType.UINT8},
-                    null,
+                    undefined,
                 ),
             ).toBeFalsy();
             expect(
                 Zcl.Frame.conditionsValid(
                     Zcl.Foundation.configReport.parameters[5],
                     {direction: Zcl.Direction.SERVER_TO_CLIENT, dataType: Zcl.DataType.DATA8},
-                    null,
+                    undefined,
                 ),
             ).toBeFalsy();
         });
 
         it("FIELD_EQUAL", () => {
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Clusters.touchlink.commandsResponse.scanResponse.parameters[13], {numberOfSubDevices: 1}, null),
+                Zcl.Frame.conditionsValid(Zcl.Clusters.touchlink.commandsResponse.scanResponse.parameters[13], {numberOfSubDevices: 1}, undefined),
             ).toBeTruthy();
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Clusters.touchlink.commandsResponse.scanResponse.parameters[13], {numberOfSubDevices: 0}, null),
+                Zcl.Frame.conditionsValid(Zcl.Clusters.touchlink.commandsResponse.scanResponse.parameters[13], {numberOfSubDevices: 0}, undefined),
             ).toBeFalsy();
             expect(
-                Zcl.Frame.conditionsValid(Zcl.Clusters.touchlink.commandsResponse.scanResponse.parameters[13], {numberOfSubDevices: 3}, null),
+                Zcl.Frame.conditionsValid(Zcl.Clusters.touchlink.commandsResponse.scanResponse.parameters[13], {numberOfSubDevices: 3}, undefined),
             ).toBeFalsy();
         });
     });

package/test/zspec/zcl/utils.test.ts

@@ -116,7 +116,6 @@ describe("ZCL Utils", () => {
         expect(cluster.getAttribute).toBeInstanceOf(Function);
         expect(cluster.getCommand).toBeInstanceOf(Function);
         expect(cluster.getCommandResponse).toBeInstanceOf(Function);
-        expect(cluster.hasAttribute).toBeInstanceOf(Function);
     });
 
     it("Creates empty cluster when getting by invalid ID", () => {
@@ -130,7 +129,6 @@ describe("ZCL Utils", () => {
         expect(cluster.getAttribute).toBeInstanceOf(Function);
         expect(cluster.getCommand).toBeInstanceOf(Function);
         expect(cluster.getCommandResponse).toBeInstanceOf(Function);
-        expect(cluster.hasAttribute).toBeInstanceOf(Function);
     });
 
     it("Throws when getting invalid cluster name", () => {
@@ -173,25 +171,19 @@ describe("ZCL Utils", () => {
     ])("Gets and checks cluster attribute %s", (_name, payload, expected) => {
         const cluster = Zcl.Utils.getCluster(expected.cluster.ID, payload.manufacturerCode, payload.customClusters);
         const attribute = cluster.getAttribute(payload.key);
-        expect(cluster.hasAttribute(payload.key)).toBeTruthy();
+        expect(attribute).not.toBeUndefined();
         expect(attribute).toStrictEqual(cluster.attributes[expected.name]);
     });
 
-    it("Throws when getting invalid attribute", () => {
+    it("Returns undefined when getting invalid attribute", () => {
         const cluster = Zcl.Utils.getCluster(Zcl.Clusters.genAlarms.ID, undefined, {});
-        expect(() => {
-            cluster.getAttribute("abcd");
-        }).toThrow();
-        expect(() => {
-            cluster.getAttribute(99999);
-        }).toThrow();
+        expect(cluster.getAttribute("abcd")).toBeUndefined();
+        expect(cluster.getAttribute(99999)).toBeUndefined();
     });
 
-    it("Throws when getting attribute with invalid manufacturer code", () => {
+    it("Returns undefined when getting attribute with invalid manufacturer code", () => {
         const cluster = Zcl.Utils.getCluster(Zcl.Clusters.haDiagnostic.ID, 123, {});
-        expect(() => {
-            cluster.getAttribute(Zcl.Clusters.haDiagnostic.attributes.danfossSystemStatusCode.ID);
-        }).toThrow();
+        expect(cluster.getAttribute(Zcl.Clusters.haDiagnostic.attributes.danfossSystemStatusCode.ID)).toBeUndefined();
     });
 
     it.each([