edilkamin 1.8.0 → 1.9.0

package/src/library.test.ts

@@ -209,9 +209,35 @@ describe("library", () => {
       "setPowerOff",
       "setPowerOn",
       "getPower",
+      "setPowerLevel",
+      "getPowerLevel",
+      "setFan1Speed",
+      "setFan2Speed",
+      "setFan3Speed",
+      "getFan1Speed",
+      "getFan2Speed",
+      "getFan3Speed",
+      "setAirkare",
+      "setRelax",
+      "setStandby",
+      "getStandby",
+      "setStandbyTime",
+      "getStandbyTime",
+      "setAuto",
+      "getAuto",
       "getEnvironmentTemperature",
       "getTargetTemperature",
       "setTargetTemperature",
+      "setEnvironment2Temperature",
+      "getEnvironment2Temperature",
+      "setEnvironment3Temperature",
+      "getEnvironment3Temperature",
+      "setMeasureUnit",
+      "getMeasureUnit",
+      "setLanguage",
+      "getLanguage",
+      "getPelletInReserve",
+      "getPelletAutonomyTime",
     ];
     it("should create API methods with the correct baseURL", async () => {
       const baseURL = "https://example.com/api/";
@@ -243,10 +269,27 @@ describe("library", () => {
         temperatures: {
           enviroment: 19,
         },
+        flags: {
+          is_pellet_in_reserve: false,
+        },
+        pellet: {
+          autonomy_time: 180,
+        },
       },
       nvm: {
         user_parameters: {
           enviroment_1_temperature: 22,
+          enviroment_2_temperature: 18,
+          enviroment_3_temperature: 20,
+          manual_power: 3,
+          fan_1_ventilation: 2,
+          fan_2_ventilation: 3,
+          fan_3_ventilation: 4,
+          is_standby_active: true,
+          standby_waiting_time: 30,
+          is_auto: true,
+          is_fahrenheit: false,
+          language: 2,
         },
       },
     };
@@ -315,6 +358,30 @@ describe("library", () => {
           api.getPower(token, mac),
         expectedResult: true,
       },
+      {
+        method: "getPowerLevel",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getPowerLevel(token, mac),
+        expectedResult: 3,
+      },
+      {
+        method: "getFan1Speed",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getFan1Speed(token, mac),
+        expectedResult: 2,
+      },
+      {
+        method: "getFan2Speed",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getFan2Speed(token, mac),
+        expectedResult: 3,
+      },
+      {
+        method: "getFan3Speed",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getFan3Speed(token, mac),
+        expectedResult: 4,
+      },
       {
         method: "getEnvironmentTemperature",
         call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
@@ -327,6 +394,60 @@ describe("library", () => {
           api.getTargetTemperature(token, mac),
         expectedResult: 22,
       },
+      {
+        method: "getStandby",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getStandby(token, mac),
+        expectedResult: true,
+      },
+      {
+        method: "getStandbyTime",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getStandbyTime(token, mac),
+        expectedResult: 30,
+      },
+      {
+        method: "getAuto",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getAuto(token, mac),
+        expectedResult: true,
+      },
+      {
+        method: "getEnvironment2Temperature",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getEnvironment2Temperature(token, mac),
+        expectedResult: 18,
+      },
+      {
+        method: "getEnvironment3Temperature",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getEnvironment3Temperature(token, mac),
+        expectedResult: 20,
+      },
+      {
+        method: "getMeasureUnit",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getMeasureUnit(token, mac),
+        expectedResult: false,
+      },
+      {
+        method: "getLanguage",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getLanguage(token, mac),
+        expectedResult: 2,
+      },
+      {
+        method: "getPelletInReserve",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getPelletInReserve(token, mac),
+        expectedResult: false,
+      },
+      {
+        method: "getPelletAutonomyTime",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getPelletAutonomyTime(token, mac),
+        expectedResult: 180,
+      },
     ];
     getterTests.forEach(({ method, call, expectedResult }) => {
       it(`should call fetch and return the correct value for ${method}`, async () => {
@@ -349,6 +470,58 @@ describe("library", () => {
     });
     // Setter tests
     const setterTests = [
+      {
+        method: "setPowerLevel",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setPowerLevel(token, mac, value),
+        payload: {
+          name: "power_level",
+          value: 4,
+        },
+      },
+      {
+        method: "setFan1Speed",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setFan1Speed(token, mac, value),
+        payload: {
+          name: "fan_1_speed",
+          value: 3,
+        },
+      },
+      {
+        method: "setFan2Speed",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setFan2Speed(token, mac, value),
+        payload: {
+          name: "fan_2_speed",
+          value: 4,
+        },
+      },
+      {
+        method: "setFan3Speed",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setFan3Speed(token, mac, value),
+        payload: {
+          name: "fan_3_speed",
+          value: 5,
+        },
+      },
       {
         method: "setTargetTemperature",
         call: (
@@ -362,6 +535,58 @@ describe("library", () => {
           value: 20,
         },
       },
+      {
+        method: "setStandbyTime",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setStandbyTime(token, mac, value),
+        payload: {
+          name: "standby_time",
+          value: 45,
+        },
+      },
+      {
+        method: "setEnvironment2Temperature",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setEnvironment2Temperature(token, mac, value),
+        payload: {
+          name: "enviroment_2_temperature",
+          value: 21,
+        },
+      },
+      {
+        method: "setEnvironment3Temperature",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setEnvironment3Temperature(token, mac, value),
+        payload: {
+          name: "enviroment_3_temperature",
+          value: 23,
+        },
+      },
+      {
+        method: "setLanguage",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number,
+        ) => api.setLanguage(token, mac, value),
+        payload: {
+          name: "language",
+          value: 2,
+        },
+      },
     ];
     setterTests.forEach(({ method, call, payload }) => {
       it(`should call fetch and send the correct payload for ${method}`, async () => {
@@ -388,6 +613,108 @@ describe("library", () => {
         });
       });
     });
+
+    // Boolean setter tests (for mode controls)
+    const booleanSetterTests = [
+      {
+        method: "setAirkare",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          enabled: boolean,
+        ) => api.setAirkare(token, mac, enabled),
+        truePayload: { name: "airkare_function", value: 1 },
+        falsePayload: { name: "airkare_function", value: 0 },
+      },
+      {
+        method: "setRelax",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          enabled: boolean,
+        ) => api.setRelax(token, mac, enabled),
+        truePayload: { name: "relax_mode", value: true },
+        falsePayload: { name: "relax_mode", value: false },
+      },
+      {
+        method: "setStandby",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          enabled: boolean,
+        ) => api.setStandby(token, mac, enabled),
+        truePayload: { name: "standby_mode", value: true },
+        falsePayload: { name: "standby_mode", value: false },
+      },
+      {
+        method: "setAuto",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          enabled: boolean,
+        ) => api.setAuto(token, mac, enabled),
+        truePayload: { name: "auto_mode", value: true },
+        falsePayload: { name: "auto_mode", value: false },
+      },
+      {
+        method: "setMeasureUnit",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          enabled: boolean,
+        ) => api.setMeasureUnit(token, mac, enabled),
+        truePayload: { name: "measure_unit", value: true },
+        falsePayload: { name: "measure_unit", value: false },
+      },
+    ];
+    booleanSetterTests.forEach(
+      ({ method, call, truePayload, falsePayload }) => {
+        it(`should call fetch with correct payload for ${method}(true)`, async () => {
+          fetchStub.resolves(mockResponse({ success: true }));
+          const api = configure("https://example.com/api/");
+
+          await call(api, expectedToken, "mockMacAddress", true);
+
+          assert.ok(fetchStub.calledOnce);
+          assert.deepEqual(fetchStub.firstCall.args[1], {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${expectedToken}`,
+            },
+            body: JSON.stringify({
+              mac_address: "mockMacAddress",
+              ...truePayload,
+            }),
+          });
+        });
+
+        it(`should call fetch with correct payload for ${method}(false)`, async () => {
+          fetchStub.resolves(mockResponse({ success: true }));
+          const api = configure("https://example.com/api/");
+
+          await call(api, expectedToken, "mockMacAddress", false);
+
+          assert.ok(fetchStub.calledOnce);
+          assert.deepEqual(fetchStub.firstCall.args[1], {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${expectedToken}`,
+            },
+            body: JSON.stringify({
+              mac_address: "mockMacAddress",
+              ...falsePayload,
+            }),
+          });
+        });
+      },
+    );
   });
 
   describe("registerDevice", () => {
@@ -638,6 +965,51 @@ describe("library", () => {
 
       assert.equal(result, 22);
     });
+
+    it("should work with getPelletInReserve on compressed response", async () => {
+      const statusData = {
+        commands: { power: true },
+        temperatures: { enviroment: 19 },
+        flags: { is_pellet_in_reserve: true },
+        pellet: { autonomy_time: 120 },
+      };
+      const mockResponseData = {
+        status: createGzippedBuffer(statusData),
+        nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+      };
+
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
+
+      const result = await api.getPelletInReserve(
+        expectedToken,
+        "mockMacAddress",
+      );
+
+      assert.equal(result, true);
+    });
+
+    it("should work with getPelletAutonomyTime on response", async () => {
+      const mockResponseData = {
+        status: {
+          commands: { power: true },
+          temperatures: { enviroment: 19 },
+          flags: { is_pellet_in_reserve: false },
+          pellet: { autonomy_time: 240 },
+        },
+        nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+      };
+
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
+
+      const result = await api.getPelletAutonomyTime(
+        expectedToken,
+        "mockMacAddress",
+      );
+
+      assert.equal(result, 240);
+    });
   });
 
   describe("Error Handling", () => {