@willieee802/zigbee-herdsman 0.49.4 → 0.50.0

package/test/device.test.ts

@@ -0,0 +1,731 @@
+import {beforeEach, describe, expect, it, type MockInstance, vi} from "vitest";
+import type {ZclPayload} from "../src/adapter/events";
+import Database from "../src/controller/database";
+import {type Endpoint, Entity} from "../src/controller/model";
+import {Device, InterviewState} from "../src/controller/model/device";
+import {Clusters, DataType, Direction, FrameType, Status} from "../src/zspec/zcl";
+import {ZclFrame} from "../src/zspec/zcl/zclFrame";
+
+const database = Database.open("dummy");
+// no-op
+vi.spyOn(database, "write").mockImplementation(vi.fn());
+
+Entity.injectDatabase(database);
+
+describe("Device", () => {
+    let device: Device;
+    let endpoint: Endpoint;
+    let readResponseSpy: MockInstance;
+    let commandSpy: MockInstance;
+    let readSpy: MockInstance;
+    let defaultResponseSpy: MockInstance;
+
+    beforeEach(() => {
+        database.clear();
+        Device.resetCache();
+
+        device = Device.create(
+            "Router",
+            "0xfe34ac2385ff8311",
+            0x0001,
+            0x0102,
+            "Herdsman",
+            "Mains (single phase)",
+            "Herd-01",
+            InterviewState.Successful,
+            undefined,
+        );
+        endpoint = device.createEndpoint(1);
+        readResponseSpy = vi.spyOn(endpoint, "readResponse").mockImplementation(vi.fn());
+        commandSpy = vi.spyOn(endpoint, "command").mockImplementation(vi.fn());
+        readSpy = vi.spyOn(endpoint, "read").mockImplementation(vi.fn());
+        defaultResponseSpy = vi.spyOn(endpoint, "defaultResponse").mockImplementation(vi.fn());
+    });
+
+    it("replies to basic read", async () => {
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.CLIENT_TO_SERVER,
+            false,
+            undefined,
+            1,
+            "read",
+            "genBasic",
+            [{attrId: 0x0000}, {attrId: 0xfffa}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+        expect(readResponseSpy).toHaveBeenCalledWith(
+            Clusters.genBasic.ID,
+            frame.header.transactionSequenceNumber,
+            {
+                zclVersion: Clusters.genBasic.attributes.zclVersion.default,
+                65530: {value: undefined, type: DataType.NO_DATA},
+            },
+            {srcEndpoint: 1},
+        );
+    });
+
+    it("replies to time read", async () => {
+        // time is auto-generated, no saved attrs required
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.CLIENT_TO_SERVER,
+            false,
+            undefined,
+            1,
+            "read",
+            "genTime",
+            [{attrId: 0x0000}, {attrId: 0xfffa}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+        expect(readResponseSpy).toHaveBeenCalledWith(
+            Clusters.genTime.ID,
+            frame.header.transactionSequenceNumber,
+            {
+                time: expect.any(Number),
+                65530: {value: undefined, type: DataType.NO_DATA},
+            },
+            {srcEndpoint: 1},
+        );
+    });
+
+    it("replies to unsupported read", async () => {
+        const frame = ZclFrame.create(FrameType.GLOBAL, Direction.CLIENT_TO_SERVER, false, undefined, 1, "read", "genGroups", [{attrId: 0x0000}], {});
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+        expect(readResponseSpy).toHaveBeenCalledWith(
+            Clusters.genGroups.ID,
+            frame.header.transactionSequenceNumber,
+            {
+                0: {value: undefined, type: DataType.NO_DATA},
+            },
+            {srcEndpoint: 1},
+        );
+    });
+
+    it("replies to read with custom response", async () => {
+        device.customReadResponse = (_frame, _endpoint) => false;
+        const frame = ZclFrame.create(FrameType.GLOBAL, Direction.CLIENT_TO_SERVER, false, undefined, 1, "read", "genBasic", [{attrId: 0x0000}], {});
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("replies to read with override custom response", async () => {
+        device.customReadResponse = (_frame, _endpoint) => true;
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.CLIENT_TO_SERVER,
+            false,
+            undefined,
+            1,
+            "read",
+            "genBasic",
+            [{attrId: 0x0000, type: DataType.UINT8}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("does not send default response for default response", async () => {
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.CLIENT_TO_SERVER,
+            false,
+            undefined,
+            1,
+            "defaultRsp",
+            "genBasic",
+            {cmdId: 0x00, statusCode: Status.SUCCESS},
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("replies to IAS Zone Enroll request", async () => {
+        const frame = ZclFrame.create(
+            FrameType.SPECIFIC,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "enrollReq",
+            "ssIasZone",
+            {zonetype: 0x4567, manucode: 0x1234},
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledWith(
+            "ssIasZone",
+            "enrollRsp",
+            {enrollrspcode: 0, zoneid: 23},
+            {transactionSequenceNumber: 1, disableDefaultResponse: true},
+        );
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("fails to reply to IAS Zone Enroll request", async () => {
+        const frame = ZclFrame.create(
+            FrameType.SPECIFIC,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "enrollReq",
+            "ssIasZone",
+            {zonetype: 0x4567, manucode: 0x1234},
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        commandSpy.mockRejectedValueOnce(new Error("failure"));
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledWith(
+            "ssIasZone",
+            "enrollRsp",
+            {enrollrspcode: 0, zoneid: 23},
+            {transactionSequenceNumber: 1, disableDefaultResponse: true},
+        );
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.FAILURE, frame.cluster.ID, 1, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("replies to Poll Control Check-in", async () => {
+        device.checkinInterval = undefined;
+        const frame = ZclFrame.create(FrameType.SPECIFIC, Direction.SERVER_TO_CLIENT, false, undefined, 1, "checkin", "genPollCtrl", {}, {});
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        readSpy.mockResolvedValueOnce({checkinInterval: 100});
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(2);
+        expect(commandSpy).toHaveBeenNthCalledWith(
+            1,
+            "genPollCtrl",
+            "checkinRsp",
+            {startFastPolling: 1, fastPollTimeout: 0},
+            {transactionSequenceNumber: 1, disableDefaultResponse: true, sendPolicy: "immediate"},
+        );
+        expect(commandSpy).toHaveBeenNthCalledWith(2, "genPollCtrl", "fastPollStop", {}, {sendPolicy: "immediate"});
+        expect(readSpy).toHaveBeenCalledTimes(1);
+        expect(readSpy).toHaveBeenCalledWith("genPollCtrl", ["checkinInterval"], {sendPolicy: "immediate"});
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+
+        readResponseSpy.mockClear();
+        commandSpy.mockClear();
+        commandSpy.mockClear();
+        readSpy.mockClear();
+        defaultResponseSpy.mockClear();
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledWith(
+            "genPollCtrl",
+            "checkinRsp",
+            {startFastPolling: 0, fastPollTimeout: 0},
+            {transactionSequenceNumber: 1, disableDefaultResponse: true, sendPolicy: "immediate"},
+        );
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("fails to reply to Poll Control Check-in", async () => {
+        device.checkinInterval = undefined;
+        const frame = ZclFrame.create(FrameType.SPECIFIC, Direction.SERVER_TO_CLIENT, false, undefined, 1, "checkin", "genPollCtrl", {}, {});
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        commandSpy.mockRejectedValueOnce(new Error("failure"));
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(1);
+        expect(commandSpy).toHaveBeenCalledWith(
+            "genPollCtrl",
+            "checkinRsp",
+            {startFastPolling: 1, fastPollTimeout: 0},
+            {transactionSequenceNumber: 1, disableDefaultResponse: true, sendPolicy: "immediate"},
+        );
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.FAILURE, frame.cluster.ID, 1, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("fails to stop fast poll", async () => {
+        device.checkinInterval = undefined;
+        const frame = ZclFrame.create(FrameType.SPECIFIC, Direction.SERVER_TO_CLIENT, false, undefined, 1, "checkin", "genPollCtrl", {}, {});
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        readSpy.mockResolvedValueOnce({checkinInterval: 100});
+        commandSpy.mockImplementationOnce(() => {}).mockRejectedValueOnce(new Error("failure"));
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(2);
+        expect(commandSpy).toHaveBeenCalledWith(
+            "genPollCtrl",
+            "checkinRsp",
+            {startFastPolling: 1, fastPollTimeout: 0},
+            {transactionSequenceNumber: 1, disableDefaultResponse: true, sendPolicy: "immediate"},
+        );
+        expect(commandSpy).toHaveBeenNthCalledWith(2, "genPollCtrl", "fastPollStop", {}, {sendPolicy: "immediate"});
+        expect(readSpy).toHaveBeenCalledTimes(1);
+        expect(readSpy).toHaveBeenCalledWith("genPollCtrl", ["checkinInterval"], {sendPolicy: "immediate"});
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("replies to GLOBAL with SUCCESS default response by default", async () => {
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "readRsp",
+            "genOnOff",
+            [{attrId: 0x0000, status: Status.SUCCESS, dataType: DataType.BOOLEAN, attrData: 1}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.SUCCESS, frame.cluster.ID, 1, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("replies to SPECIFIC from SERVER with SUCCESS default response by default", async () => {
+        const frame = ZclFrame.create(
+            FrameType.SPECIFIC,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "removeRsp",
+            "genScenes",
+            {status: 0, groupid: 1, sceneid: 2},
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.SUCCESS, frame.cluster.ID, 1, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("replies to SPECIFIC from CLIENT with SUCCESS default response by default", async () => {
+        const frame = ZclFrame.create(
+            FrameType.SPECIFIC,
+            Direction.CLIENT_TO_SERVER,
+            false,
+            undefined,
+            1,
+            "identify",
+            "genIdentify",
+            {identifytime: 1},
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.SUCCESS, frame.cluster.ID, 1, {
+            direction: Direction.SERVER_TO_CLIENT,
+        });
+    });
+
+    it("replies with default response from caller", async () => {
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "readRsp",
+            "genOnOff",
+            [{attrId: 0x0000, status: Status.SUCCESS, dataType: DataType.BOOLEAN, attrData: 1}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, Status.INVALID_VALUE);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.INVALID_VALUE, frame.cluster.ID, 1, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("replies with non-SUCCESS default response even when disable default response is ON", async () => {
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.SERVER_TO_CLIENT,
+            true,
+            undefined,
+            1,
+            "report",
+            "genOnOff",
+            [{attrId: 0x0000, dataType: DataType.BOOLEAN, attrData: 0}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, Status.INVALID_VALUE);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenCalledWith(frame.command.ID, Status.INVALID_VALUE, frame.cluster.ID, 1, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("skips replying with default response when deviced option set", async () => {
+        device.skipDefaultResponse = true;
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "readRsp",
+            "genOnOff",
+            [{attrId: 0x0000, status: Status.SUCCESS, dataType: DataType.BOOLEAN, attrData: 1}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+    });
+
+    it("de-duplicates replying with default response", async () => {
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            0,
+            "readRsp",
+            "genOnOff",
+            [{attrId: 0x0000, status: Status.SUCCESS, dataType: DataType.BOOLEAN, attrData: 1}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(1);
+        expect(defaultResponseSpy).toHaveBeenNthCalledWith(1, frame.command.ID, Status.SUCCESS, frame.cluster.ID, 0, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+
+        device.resetTransient(false);
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(2);
+        expect(defaultResponseSpy).toHaveBeenNthCalledWith(2, frame.command.ID, Status.SUCCESS, frame.cluster.ID, 0, {
+            direction: Direction.CLIENT_TO_SERVER,
+        });
+    });
+
+    it("skips replying with default response when Tuya device option set", async () => {
+        process.env.DISABLE_TUYA_DEFAULT_RESPONSE = "1";
+        device.manufacturerName = "_TZ1234_5678";
+        const frame = ZclFrame.create(
+            FrameType.GLOBAL,
+            Direction.SERVER_TO_CLIENT,
+            false,
+            undefined,
+            1,
+            "readRsp",
+            "genOnOff",
+            [{attrId: 0x0000, status: Status.SUCCESS, dataType: DataType.BOOLEAN, attrData: 1}],
+            {},
+        );
+        const dataPayload: ZclPayload = {
+            clusterID: frame.cluster.ID,
+            address: 0x1234,
+            header: frame.header,
+            data: frame.toBuffer(),
+            endpoint: 1,
+            linkquality: 150,
+            groupID: 0,
+            wasBroadcast: false,
+            destinationEndpoint: 1,
+        };
+
+        await device.onZclData(dataPayload, frame, endpoint, undefined);
+
+        expect(readResponseSpy).toHaveBeenCalledTimes(0);
+        expect(commandSpy).toHaveBeenCalledTimes(0);
+        expect(readSpy).toHaveBeenCalledTimes(0);
+        expect(defaultResponseSpy).toHaveBeenCalledTimes(0);
+
+        delete process.env.DISABLE_TUYA_DEFAULT_RESPONSE;
+    });
+});