zigbee-herdsman 6.0.1 → 6.0.3

package/test/requests.bench.ts

@@ -1,206 +0,0 @@
-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/testUtils.ts

@@ -1,20 +0,0 @@
-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/tsconfig.json

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

package/test/utils/math.ts

@@ -1,19 +0,0 @@
-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,
-    ];
-};

package/test/utils.test.ts

@@ -1,279 +0,0 @@
-import {describe, expect, it, vi} from "vitest";
-import {checkInstallCode} from "../src/controller/helpers/installCodes";
-import {Queue, Utils, Waitress, wait} from "../src/utils";
-import {logger, setLogger} from "../src/utils/logger";
-
-const mockLogger = {
-    debug: vi.fn(),
-    info: vi.fn(),
-    warning: vi.fn(),
-    error: vi.fn(),
-};
-
-describe("Utils", () => {
-    it("Is Number Array", () => {
-        expect(Utils.isNumberArray([1, 2, 3])).toBeTruthy();
-        expect(Utils.isNumberArray([1, 2, "3"])).toBeFalsy();
-        expect(Utils.isNumberArray("nonarray")).toBeFalsy();
-    });
-
-    it("Is Number Array of length", () => {
-        expect(Utils.isNumberArrayOfLength([1, 2, 3], 3)).toBeTruthy();
-        expect(Utils.isNumberArrayOfLength([1, 2], 3)).toBeFalsy();
-        expect(Utils.isNumberArrayOfLength([1, 2, "3"], 3)).toBeFalsy();
-        expect(Utils.isNumberArrayOfLength("nonarray", 3)).toBeFalsy();
-    });
-
-    it("Is object empty", () => {
-        expect(Utils.isObjectEmpty({})).toBeTruthy();
-        expect(Utils.isObjectEmpty({a: 1})).toBeFalsy();
-    });
-
-    it("Assert string", () => {
-        expect(Utils.assertString("bla")).toBeUndefined();
-
-        expect(() => {
-            Utils.assertString(1);
-        }).toThrow("Input must be a string!");
-    });
-
-    it("Test wait", () => {
-        const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout").mockImplementationOnce(
-            // @ts-expect-error mocked
-            () => {},
-        );
-        wait(1000).then(() => {});
-        expect(setTimeout).toHaveBeenCalledTimes(1);
-        expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 1000);
-        setTimeoutSpy.mockRestore();
-    });
-
-    it("Test waitress", async () => {
-        vi.useFakeTimers();
-        const validator = (payload: string, matcher: number): boolean => {
-            if (payload === "one" && matcher === 1) return true;
-            if (payload === "two" && matcher === 2) return true;
-            return false;
-        };
-        const waitress = new Waitress<string, number>(validator, (_, timeout) => `Timedout '${timeout}'`);
-
-        const wait1 = waitress.waitFor(1, 10000).start();
-        waitress.resolve("one");
-        expect(await wait1.promise).toBe("one");
-
-        const wait2_1 = waitress.waitFor(2, 10000).start();
-        const wait2_2 = waitress.waitFor(2, 10000).start();
-        const wait2_3 = waitress.waitFor(2, 10000).start();
-        const wait2_4 = waitress.waitFor(2, 5000).start();
-        const wait2_5 = waitress.waitFor(2, 5000).start();
-
-        waitress.remove(wait2_3.ID);
-        vi.advanceTimersByTime(6000);
-        waitress.remove(wait2_5.ID);
-        waitress.resolve("two");
-        expect(await wait2_1.promise).toBe("two");
-        expect(await wait2_2.promise).toBe("two");
-
-        let error2;
-        try {
-            await wait2_4.promise;
-        } catch (e) {
-            error2 = e;
-        }
-        expect(error2).toStrictEqual(new Error("Timedout '5000'"));
-
-        let error3;
-        try {
-            await wait2_5.promise;
-        } catch (e) {
-            error3 = e;
-        }
-        expect(error3).toStrictEqual(new Error("Timedout '5000'"));
-
-        vi.useRealTimers();
-
-        // reject test
-        const wait1b = waitress.waitFor(1, 5000).start();
-        let error1_;
-        wait(1000).then(() => {
-            waitress.reject("one", "drop");
-        });
-        try {
-            await wait1b.promise;
-        } catch (e) {
-            error1_ = e;
-        }
-        expect(error1_).toStrictEqual(new Error("drop"));
-
-        vi.useFakeTimers();
-        const wait2 = waitress.waitFor(2, 5000).start();
-        const handled1 = waitress.reject("tree", "drop");
-        expect(handled1).toBe(false);
-        let error2_;
-        vi.advanceTimersByTime(6000);
-        try {
-            await wait2.promise;
-        } catch (e) {
-            error2_ = e;
-        }
-        expect(error2_).toStrictEqual(new Error("Timedout '5000'"));
-        const handled2 = waitress.reject("two", "drop");
-        expect(handled2).toBe(false);
-
-        waitress.waitFor(2, 10000).start().promise;
-        waitress.waitFor(2, 10000).start().promise;
-
-        await vi.advanceTimersByTimeAsync(2000);
-        waitress.clear();
-        await vi.advanceTimersByTimeAsync(12000);
-
-        // @ts-expect-error private
-        expect(waitress.waiters.size).toStrictEqual(0);
-
-        vi.useRealTimers();
-    });
-
-    it("Test queue", async () => {
-        const queue = new Queue(4);
-        const finished: number[] = [];
-
-        let job1Promise: (() => void) | undefined;
-        let job2Promise: (() => void) | undefined;
-        const job1 = new Promise<void>((resolve) => {
-            job1Promise = resolve;
-        });
-        const job2 = new Promise<void>((resolve) => {
-            job2Promise = resolve;
-        });
-        const job5 = new Promise((_resolve) => {});
-        const job6 = new Promise((_resolve) => {});
-        const job7 = new Promise((_resolve) => {});
-
-        const job1Result = queue.execute<string>(async () => {
-            await job1;
-            finished.push(1);
-            return "finished";
-        });
-
-        const job2Result = queue.execute<void>(async () => {
-            await job2;
-            finished.push(2);
-        }, "mykey");
-
-        queue.execute<void>(async () => {
-            finished.push(3);
-            await Promise.resolve();
-        }, "mykey");
-
-        queue.execute<void>(async () => {
-            finished.push(4);
-            await Promise.resolve();
-        }, "mykey2");
-
-        queue.execute<void>(async () => {
-            await job5;
-            finished.push(5);
-        });
-
-        queue.execute<void>(async () => {
-            await job6;
-            finished.push(6);
-        });
-
-        queue.execute<void>(async () => {
-            await job7;
-            finished.push(7);
-        });
-
-        queue.execute<void>(async () => {
-            finished.push(8);
-            await Promise.resolve();
-        });
-
-        expect(finished).toEqual([4]);
-        job1Promise?.();
-        expect(await job1Result).toBe("finished");
-        await job1Result;
-        expect(finished).toEqual([4, 1]);
-        job2Promise?.();
-        await job2Result;
-        expect(finished).toEqual([4, 1, 2, 3]);
-        expect(queue.count()).toBe(5);
-    });
-
-    it("Logs", () => {
-        const debugSpy = vi.spyOn(console, "debug");
-        const infoSpy = vi.spyOn(console, "info");
-        const warningSpy = vi.spyOn(console, "warn");
-        const errorSpy = vi.spyOn(console, "error");
-        logger.debug("debug", "zh");
-        expect(debugSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ\] zh: debug$/));
-        logger.info("info", "zh");
-        expect(infoSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ\] zh: info$/));
-        logger.warning("warning", "zh");
-        expect(warningSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ\] zh: warning$/));
-        logger.error("error", "zh");
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\d\d\dZ\] zh: error$/));
-
-        setLogger(mockLogger);
-        expect(logger).toEqual(mockLogger);
-        logger.debug("debug", "zh");
-        expect(mockLogger.debug).toHaveBeenCalledWith("debug", "zh");
-        logger.info("info", "zh");
-        expect(mockLogger.info).toHaveBeenCalledWith("info", "zh");
-        logger.warning("warning", "zh");
-        expect(mockLogger.warning).toHaveBeenCalledWith("warning", "zh");
-        logger.error("error", "zh");
-        expect(mockLogger.error).toHaveBeenCalledWith("error", "zh");
-    });
-
-    it("Checks install codes of all lengths", () => {
-        expect(() => checkInstallCode(Buffer.from("001122", "hex"))).toThrow("Install code 001122 has invalid size");
-
-        const code8Valid = Buffer.from("83FED3407A932B70", "hex");
-        const code8Invalid = Buffer.from("FFFED3407A939723", "hex");
-        const code8InvalidFixed = Buffer.from("FFFED3407A93DE84", "hex");
-        const code8MissingCRC = Buffer.from("83FED3407A93", "hex");
-
-        expect(checkInstallCode(code8Valid)).toStrictEqual([code8Valid, undefined]);
-        expect(checkInstallCode(code8Invalid)).toStrictEqual([code8InvalidFixed, "invalid CRC"]);
-        expect(() => checkInstallCode(code8Invalid, false)).toThrow(`Install code ${code8Invalid.toString("hex")} failed CRC validation`);
-        expect(checkInstallCode(code8MissingCRC)).toStrictEqual([code8Valid, "missing CRC"]);
-        expect(() => checkInstallCode(code8MissingCRC, false)).toThrow(`Install code ${code8MissingCRC.toString("hex")} failed CRC validation`);
-
-        const code10Valid = Buffer.from("83FED3407A93972397FC", "hex");
-        const code10Invalid = Buffer.from("FFFED3407A939723A5C6", "hex");
-        const code10InvalidFixed = Buffer.from("FFFED3407A9397238C4F", "hex");
-        // consired as 8-length with invalid CRC
-        const code10MissingCRC = Buffer.from("83FED3407A939723", "hex");
-        const code10MissingCRCFixed = Buffer.from("83FED3407A932B70", "hex");
-
-        expect(checkInstallCode(code10Valid)).toStrictEqual([code10Valid, undefined]);
-        expect(checkInstallCode(code10Invalid)).toStrictEqual([code10InvalidFixed, "invalid CRC"]);
-        expect(() => checkInstallCode(code10Invalid, false)).toThrow(`Install code ${code10Invalid.toString("hex")} failed CRC validation`);
-        expect(checkInstallCode(code10MissingCRC)).toStrictEqual([code10MissingCRCFixed, "invalid CRC"]);
-        expect(() => checkInstallCode(code10MissingCRC, false)).toThrow(`Install code ${code10MissingCRC.toString("hex")} failed CRC validation`);
-
-        const code14Valid = Buffer.from("83FED3407A939723A5C639FF4C12", "hex");
-        const code14Invalid = Buffer.from("FFFED3407A939723A5C639FF4C12", "hex");
-        const code14InvalidFixed = Buffer.from("FFFED3407A939723A5C639FFDE74", "hex");
-        const code14MissingCRC = Buffer.from("83FED3407A939723A5C639FF", "hex");
-
-        expect(checkInstallCode(code14Valid)).toStrictEqual([code14Valid, undefined]);
-        expect(checkInstallCode(code14Invalid)).toStrictEqual([code14InvalidFixed, "invalid CRC"]);
-        expect(() => checkInstallCode(code14Invalid, false)).toThrow(`Install code ${code14Invalid.toString("hex")} failed CRC validation`);
-        expect(checkInstallCode(code14MissingCRC)).toStrictEqual([code14Valid, "missing CRC"]);
-        expect(() => checkInstallCode(code14MissingCRC, false)).toThrow(`Install code ${code14MissingCRC.toString("hex")} failed CRC validation`);
-
-        const code18Valid = Buffer.from("83FED3407A939723A5C639B26916D505C3B5", "hex");
-        const code18Invalid = Buffer.from("FFFED3407A939723A5C639B26916D505C3B5", "hex");
-        const code18InvalidFixed = Buffer.from("FFFED3407A939723A5C639B26916D505EEB1", "hex");
-        const code18MissingCRC = Buffer.from("83FED3407A939723A5C639B26916D505", "hex");
-
-        expect(checkInstallCode(code18Valid)).toStrictEqual([code18Valid, undefined]);
-        expect(checkInstallCode(code18Invalid)).toStrictEqual([code18InvalidFixed, "invalid CRC"]);
-        expect(() => checkInstallCode(code18Invalid, false)).toThrow(`Install code ${code18Invalid.toString("hex")} failed CRC validation`);
-        expect(checkInstallCode(code18MissingCRC)).toStrictEqual([code18Valid, "missing CRC"]);
-        expect(() => checkInstallCode(code18MissingCRC, false)).toThrow(`Install code ${code18MissingCRC.toString("hex")} failed CRC validation`);
-    });
-});

package/test/vitest.config.mts

@@ -1,27 +0,0 @@
-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 {
-            return false;
-        },
-        coverage: {
-            enabled: false,
-            provider: "v8",
-            include: ["src/**"],
-            extension: [".ts"],
-            // exclude: [],
-            clean: true,
-            cleanOnRerun: true,
-            reportsDirectory: "coverage",
-            reporter: ["text", "html"],
-            reportOnFailure: false,
-            thresholds: {
-                100: true,
-            },
-        },
-    },
-});