@willieee802/zigbee-herdsman 0.48.2 → 0.49.0

package/test/requests.bench.ts

@@ -0,0 +1,321 @@
+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 {BENCH_OPTIONS} from "./benchOptions";
+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(
+    Zcl.FrameType.GLOBAL,
+    Zcl.Direction.SERVER_TO_CLIENT,
+    true,
+    undefined,
+    10,
+    "readRsp",
+    Zcl.Clusters.genBasic.ID,
+    [
+        {
+            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();
+
+const BASIC_REQ_FRAME = Zcl.Frame.create(
+    Zcl.FrameType.GLOBAL,
+    Zcl.Direction.CLIENT_TO_SERVER,
+    true,
+    undefined,
+    10,
+    "read",
+    Zcl.Clusters.genBasic.ID,
+    [{attrId: Zcl.Clusters.genBasic.attributes.modelId.ID}],
+    {},
+);
+
+const BASIC_REQ = BASIC_REQ_FRAME.toBuffer();
+
+const TIME_REQ_FRAME = Zcl.Frame.create(
+    Zcl.FrameType.GLOBAL,
+    Zcl.Direction.CLIENT_TO_SERVER,
+    true,
+    undefined,
+    10,
+    "read",
+    Zcl.Clusters.genTime.ID,
+    [{attrId: Zcl.Clusters.genTime.attributes.localTime.ID}],
+    {},
+);
+
+const TIME_REQ = TIME_REQ_FRAME.toBuffer();
+
+describe("Requests", () => {
+    bench(
+        "device lqi",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            sendZdoResponse = Zdo.Buffalo.readResponse(true, Zdo.ClusterId.LQI_TABLE_RESPONSE, LQI_TABLE_RESPONSE);
+            const resp = await device.lqi();
+
+            if (resp[0].eui64 !== IEEE_ADDRESS1 || resp[1].eui64 !== IEEE_ADDRESS2) {
+                throw new Error("Invalid response");
+            }
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "device.endpoint write basic",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await endpoint.write("genBasic", {physicalEnv: 2, deviceEnabled: 1}, {sendPolicy: "immediate"});
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "device.endpoint read basic",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            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");
+            }
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "device.endpoint defaultRsp",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await endpoint.defaultResponse(0, 0, 0, 1);
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "device.endpoint command",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await endpoint.command("genOnOff", "offWithEffect", {effectid: 1, effectvariant: 2}, {sendPolicy: "immediate"});
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "device.endpoint commandResponse",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await endpoint.commandResponse("genAlarms", "alarm", {alarmcode: 123, clusterid: 456}, {sendPolicy: "immediate"});
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "group write basic",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await group.write("genBasic", {physicalEnv: 2, deviceEnabled: 1});
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "group read basic",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await group.read("genBasic", ["modelId", "manufacturerName"]);
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "group command",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await group.command("genRssiLocation", "getDeviceConfig", {targetAddr: IEEE_ADDRESS1}, {});
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "device receives read basic",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await device.onZclData(
+                {
+                    clusterID: Zcl.Clusters.genTime.ID,
+                    address: device.networkAddress,
+                    header: BASIC_REQ_FRAME.header,
+                    data: BASIC_REQ,
+                    endpoint: 1,
+                    linkquality: 100,
+                    groupID: 0,
+                    wasBroadcast: false,
+                    destinationEndpoint: endpoint.ID,
+                },
+                BASIC_REQ_FRAME,
+                endpoint,
+            );
+        },
+        {
+            ...BENCH_OPTIONS,
+            setup: async (task, mode) => {
+                await BENCH_OPTIONS.setup!(task, mode);
+                // make sure we have cluster attributes so we take the full code path
+                endpoint.saveClusterAttributeKeyValue("genBasic", {modelId: "zh"});
+            },
+        },
+    );
+
+    bench(
+        "device receives read time",
+        async () => {
+            sendZclFrameToEndpointResponse = undefined;
+            sendZdoResponse = undefined;
+
+            await device.onZclData(
+                {
+                    clusterID: Zcl.Clusters.genTime.ID,
+                    address: device.networkAddress,
+                    header: TIME_REQ_FRAME.header,
+                    data: TIME_REQ,
+                    endpoint: 1,
+                    linkquality: 100,
+                    groupID: 0,
+                    wasBroadcast: false,
+                    destinationEndpoint: endpoint.ID,
+                },
+                TIME_REQ_FRAME,
+                endpoint,
+            );
+        },
+        {
+            ...BENCH_OPTIONS,
+            setup: async (task, mode) => {
+                await BENCH_OPTIONS.setup!(task, mode);
+                // make sure we have cluster attributes so we take the full code path
+                endpoint.saveClusterAttributeKeyValue("genBasic", {modelId: "zh"});
+            },
+        },
+    );
+});

package/test/testUtils.ts

@@ -0,0 +1,20 @@
+function duplicateArray(amount, value) {
+    let result = [];
+    for (let i = 0; i < amount; i++) {
+        result = result.concat(value);
+    }
+
+    return result;
+}
+
+const ieeeaAddr1 = {
+    string: "0xae440112004b1200",
+    hex: [0x00, 0x12, 0x4b, 0x00, 0x12, 0x01, 0x44, 0xae],
+};
+
+const ieeeaAddr2 = {
+    string: "0xaf440112005b1200",
+    hex: [0x00, 0x12, 0x5b, 0x00, 0x12, 0x01, 0x44, 0xaf],
+};
+
+export {duplicateArray, ieeeaAddr1, ieeeaAddr2};

package/test/timeService.test.ts

@@ -0,0 +1,214 @@
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+import * as timeService from "../src/utils/timeService";
+
+describe("TimeService", () => {
+    beforeAll(() => {
+        vi.useFakeTimers();
+    });
+
+    afterAll(() => {
+        vi.useRealTimers();
+    });
+
+    beforeEach(() => {
+        timeService.clearCachedTimeData();
+    });
+
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
+
+    it.each([
+        {
+            testCase: "Timezone without DST",
+            timeZone: "Atlantic/Reykjavik",
+            localTime: "Wed Oct 01 2025 17:06:08 GMT+0000 (Greenwich Mean Time)",
+            expectedTime: 812653568,
+            expectedTimeZone: 0,
+            expectedDstStart: 0xffffffff,
+            expectedDstEnd: 0xffffffff,
+            expectedDstShift: 0,
+            expectedStandardTime: 812653568,
+            expectedLocalTime: 812653568,
+        },
+        {
+            testCase: "Northern Hemisphere, timezone with DST, DST active",
+            timeZone: "Europe/Berlin",
+            localTime: "Wed Oct 01 2025 18:49:34 GMT+0200 (Central European Summer Time)",
+            expectedTime: 812652574,
+            expectedTimeZone: 3600,
+            expectedDstStart: 796611600,
+            expectedDstEnd: 814755599,
+            expectedDstShift: 3600,
+            expectedStandardTime: 812656174,
+            expectedLocalTime: 812659774,
+        },
+        {
+            testCase: "Northern Hemisphere, timezone with DST, DST inactive",
+            timeZone: "Europe/Berlin",
+            localTime: "Mon Mar 02 2026 19:04:12 GMT+0100 (Central European Standard Time)",
+            expectedTime: 825789852,
+            expectedTimeZone: 3600,
+            expectedDstStart: 828061200,
+            expectedDstEnd: 846205199,
+            expectedDstShift: 3600,
+            expectedStandardTime: 825793452,
+            expectedLocalTime: 825793452,
+        },
+        {
+            testCase: "Southern Hemisphere, timezone with DST, DST inactive",
+            timeZone: "Australia/Sydney",
+            localTime: "Thu Oct 02 2025 03:03:25 GMT+1000 (Australian Eastern Standard Time)",
+            expectedTime: 812653405,
+            expectedTimeZone: 36000,
+            expectedDstStart: 812908800,
+            expectedDstEnd: 828633599,
+            expectedDstShift: 3600,
+            expectedStandardTime: 812689405,
+            expectedLocalTime: 812689405,
+        },
+        {
+            testCase: "Southern Hemisphere, timezone with DST, DST active with start in current year",
+            timeZone: "Australia/Sydney",
+            localTime: "Mon Nov 03 2025 03:07:49 GMT+1100 (Australian Eastern Daylight Time)",
+            expectedTime: 815414869,
+            expectedTimeZone: 36000,
+            expectedDstStart: 812908800,
+            expectedDstEnd: 828633599,
+            expectedDstShift: 3600,
+            expectedStandardTime: 815450869,
+            expectedLocalTime: 815454469,
+        },
+        {
+            testCase: "Southern Hemisphere, timezone with DST, DST active with start in previous year",
+            timeZone: "Australia/Sydney",
+            localTime: "Mon Jan 19 2026 03:08:11 GMT+1100 (Australian Eastern Daylight Time)",
+            expectedTime: 822067691,
+            expectedTimeZone: 36000,
+            expectedDstStart: 812908800,
+            expectedDstEnd: 828633599,
+            expectedDstShift: 3600,
+            expectedStandardTime: 822103691,
+            expectedLocalTime: 822107291,
+        },
+    ])("Should work correctly for specific dates ($testCase)", ({
+        timeZone,
+        localTime,
+        expectedTime,
+        expectedTimeZone,
+        expectedDstStart,
+        expectedDstEnd,
+        expectedDstShift,
+        expectedStandardTime,
+        expectedLocalTime,
+    }) => {
+        vi.stubEnv("TZ", timeZone);
+        vi.setSystemTime(new Date(localTime));
+
+        const timeClusterAttributes = timeService.getTimeClusterAttributes();
+
+        expect(timeClusterAttributes.time).toStrictEqual(expectedTime);
+        expect(timeClusterAttributes.timeStatus).toStrictEqual(0b1101);
+        expect(timeClusterAttributes.timeZone).toStrictEqual(expectedTimeZone);
+        expect(timeClusterAttributes.dstStart).toStrictEqual(expectedDstStart);
+        expect(timeClusterAttributes.dstEnd).toStrictEqual(expectedDstEnd);
+        expect(timeClusterAttributes.dstShift).toStrictEqual(expectedDstShift);
+        expect(timeClusterAttributes.standardTime).toStrictEqual(expectedStandardTime);
+        expect(timeClusterAttributes.localTime).toStrictEqual(expectedLocalTime);
+        expect(timeClusterAttributes.lastSetTime).toStrictEqual(expectedTime);
+        expect(timeClusterAttributes.validUntilTime).toStrictEqual(expectedTime + 24 * 60 * 60);
+    });
+
+    it.each([
+        {
+            testCase: "begins (Europe/Berlin)",
+            timeZone: "Europe/Berlin",
+            localTime: "Sun Mar 30 2025 01:59:59 GMT+0100 (Central European Standard Time)",
+            expectedShiftBefore: 0,
+            expectedShiftAfter: 3600,
+        },
+        {
+            testCase: "ends (Europe/Berlin)",
+            timeZone: "Europe/Berlin",
+            localTime: "Sun Oct 26 2025 02:59:59 GMT+0200 (Central European Summer Time)",
+            expectedShiftBefore: 3600,
+            expectedShiftAfter: 0,
+        },
+        {
+            testCase: "begins (Australia/Sydney)",
+            timeZone: "Australia/Sydney",
+            localTime: "Sun Oct 5 2025 01:59:59 GMT+1000 (Australian Eastern Standard Time)",
+            expectedShiftBefore: 0,
+            expectedShiftAfter: 3600,
+        },
+        {
+            testCase: "ends (Australia/Sydney)",
+            timeZone: "Australia/Sydney",
+            localTime: "Sun Apr 05 2026 02:59:59 GMT+1100 (Australian Eastern Daylight Time)",
+            expectedShiftBefore: 3600,
+            expectedShiftAfter: 0,
+        },
+    ])("Should handle daylight saving time $testCase correctly", ({timeZone, localTime, expectedShiftBefore, expectedShiftAfter}) => {
+        vi.stubEnv("TZ", timeZone);
+        vi.setSystemTime(Date.parse(localTime));
+
+        const firstRun = timeService.getTimeClusterAttributes();
+
+        // 1 second later
+        vi.advanceTimersByTime(1000);
+
+        const secondRun = timeService.getTimeClusterAttributes();
+
+        expect(firstRun.localTime - firstRun.standardTime).toStrictEqual(expectedShiftBefore);
+        expect(secondRun.localTime - secondRun.standardTime).toStrictEqual(expectedShiftAfter);
+    });
+
+    it("Should not use cached data for dynamic attributes", () => {
+        vi.stubEnv("TZ", "Europe/Berlin");
+        vi.setSystemTime(new Date(2025, 0));
+
+        const firstRun = timeService.getTimeClusterAttributes();
+
+        // 1 hour later
+        const delta = 60 * 60;
+        vi.advanceTimersByTime(delta * 1000);
+
+        const secondRun = timeService.getTimeClusterAttributes();
+
+        expect(secondRun.time).toStrictEqual(firstRun.time + delta);
+        expect(secondRun.standardTime).toStrictEqual(firstRun.standardTime + delta);
+        expect(secondRun.localTime).toStrictEqual(firstRun.localTime + delta);
+        expect(secondRun.lastSetTime).toStrictEqual(firstRun.lastSetTime + delta);
+    });
+
+    it("Should return cached information within 24 hours", () => {
+        vi.stubEnv("TZ", "Europe/Berlin");
+        vi.setSystemTime(new Date(2025, 0));
+
+        const firstRun = timeService.getTimeClusterAttributes();
+
+        // 23:59:59 later
+        const deltaHours = 23 * 60 * 60 * 1000;
+        const deltaMinutes = 59 * 60 * 1000;
+        const deltaSeconds = 59 * 1000;
+        vi.advanceTimersByTime(deltaHours + deltaMinutes + deltaSeconds);
+
+        const secondRun = timeService.getTimeClusterAttributes();
+
+        expect(secondRun.validUntilTime).toStrictEqual(firstRun.validUntilTime);
+    });
+
+    it("Should recalculate the cache after 24 hours", () => {
+        vi.stubEnv("TZ", "Europe/Berlin");
+        vi.setSystemTime(new Date(2025, 0));
+
+        const firstRun = timeService.getTimeClusterAttributes();
+
+        // 24 hours later
+        vi.advanceTimersByTime(24 * 60 * 60 * 1000);
+
+        const secondRun = timeService.getTimeClusterAttributes();
+
+        expect(secondRun.validUntilTime).not.toStrictEqual(firstRun.validUntilTime);
+    });
+});

package/test/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "extends": "../tsconfig",
+    "include": ["./**/*", "vitest.config.mts"],
+    "compilerOptions": {
+        "rootDir": "..",
+        "noEmit": true
+    },
+    "references": [{"path": ".."}]
+}

package/test/utils/math.ts

@@ -0,0 +1,19 @@
+export const uint16To8Array = (n: number): number[] => {
+    return [n & 0xff, (n >> 8) & 0xff];
+};
+
+export const uint32To8Array = (n: number): number[] => {
+    return [n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff];
+};
+
+export const uint56To8Array = (n: bigint): number[] => {
+    return [
+        Number(n & 0xffn),
+        Number(n >> 8n) & 0xff,
+        Number(n >> 16n) & 0xff,
+        Number(n >> 24n) & 0xff,
+        Number(n >> 32n) & 0xff,
+        Number(n >> 40n) & 0xff,
+        Number(n >> 48n) & 0xff,
+    ];
+};