edilkamin 1.6.2 → 1.7.3

package/src/library.test.ts

@@ -1,5 +1,5 @@
 import { strict as assert } from "assert";
-import axios from "axios";
+import * as amplifyAuth from "aws-amplify/auth";
 import pako from "pako";
 import sinon from "sinon";
 
@@ -10,7 +10,7 @@ import { API_URL } from "./constants";
  * Helper to create a gzip-compressed Buffer object for testing.
  */
 const createGzippedBuffer = (
-  data: unknown
+  data: unknown,
 ): { type: "Buffer"; data: number[] } => {
   const json = JSON.stringify(data);
   const compressed = pako.gzip(json);
@@ -20,16 +20,23 @@ const createGzippedBuffer = (
   };
 };
 
+/**
+ * Helper to create a mock Response object for fetch.
+ */
+const mockResponse = (data: unknown, status = 200): Response =>
+  ({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status >= 200 && status < 300 ? "OK" : "Error",
+    json: () => Promise.resolve(data),
+  }) as Response;
+
 describe("library", () => {
-  let axiosStub: sinon.SinonStub;
+  let fetchStub: sinon.SinonStub;
   const expectedToken = "mockJwtToken";
 
   beforeEach(() => {
-    axiosStub = sinon.stub(axios, "create").returns({
-      get: sinon.stub(),
-      put: sinon.stub(),
-      // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-    } as any);
+    fetchStub = sinon.stub(globalThis, "fetch");
   });
 
   afterEach(() => {
@@ -57,7 +64,7 @@ describe("library", () => {
       const authService = createAuthService(authStub as any);
       const token = await authService.signIn(
         expectedUsername,
-        expectedPassword
+        expectedPassword,
       );
       assert.deepEqual(authStub.signOut.args, [[]]);
       assert.deepEqual(signIn.args, [
@@ -87,7 +94,7 @@ describe("library", () => {
       const token = await authService.signIn(
         expectedUsername,
         expectedPassword,
-        true // legacy mode
+        true, // legacy mode
       );
       assert.equal(token, expectedToken);
     });
@@ -114,8 +121,82 @@ describe("library", () => {
         {
           name: "AssertionError",
           message: "Sign-in failed",
-        }
+        },
+      );
+    });
+  });
+
+  describe("getSession", () => {
+    it("should return idToken by default", async () => {
+      const mockAuth = {
+        signIn: sinon.stub().resolves({ isSignedIn: true }),
+        signOut: sinon.stub().resolves(),
+        fetchAuthSession: sinon.stub().resolves({
+          tokens: {
+            idToken: { toString: () => "mock-id-token" },
+            accessToken: { toString: () => "mock-access-token" },
+          },
+        }),
+      };
+      const { getSession, signIn } = createAuthService(
+        mockAuth as unknown as typeof amplifyAuth,
+      );
+      await signIn("user", "pass");
+      const token = await getSession();
+      assert.equal(token, "mock-id-token");
+    });
+
+    it("should return accessToken when legacy=true", async () => {
+      const mockAuth = {
+        signIn: sinon.stub().resolves({ isSignedIn: true }),
+        signOut: sinon.stub().resolves(),
+        fetchAuthSession: sinon.stub().resolves({
+          tokens: {
+            idToken: { toString: () => "mock-id-token" },
+            accessToken: { toString: () => "mock-access-token" },
+          },
+        }),
+      };
+      const { getSession, signIn } = createAuthService(
+        mockAuth as unknown as typeof amplifyAuth,
+      );
+      await signIn("user", "pass");
+      const token = await getSession(false, true);
+      assert.equal(token, "mock-access-token");
+    });
+
+    it("should throw error when no session exists", async () => {
+      const mockAuth = {
+        signIn: sinon.stub().resolves({ isSignedIn: true }),
+        signOut: sinon.stub().resolves(),
+        fetchAuthSession: sinon.stub().resolves({ tokens: null }),
+      };
+      const { getSession } = createAuthService(
+        mockAuth as unknown as typeof amplifyAuth,
+      );
+      await assert.rejects(async () => getSession(), {
+        name: "AssertionError",
+        message: "No session found - please sign in first",
+      });
+    });
+
+    it("should pass forceRefresh to fetchAuthSession", async () => {
+      const mockAuth = {
+        signIn: sinon.stub().resolves({ isSignedIn: true }),
+        signOut: sinon.stub().resolves(),
+        fetchAuthSession: sinon.stub().resolves({
+          tokens: {
+            idToken: { toString: () => "mock-id-token" },
+            accessToken: { toString: () => "mock-access-token" },
+          },
+        }),
+      };
+      const { getSession, signIn } = createAuthService(
+        mockAuth as unknown as typeof amplifyAuth,
       );
+      await signIn("user", "pass");
+      await getSession(true);
+      assert.ok(mockAuth.fetchAuthSession.calledWith({ forceRefresh: true }));
     });
   });
 
@@ -132,28 +213,24 @@ describe("library", () => {
       "getTargetTemperature",
       "setTargetTemperature",
     ];
-    it("should create API methods with the correct baseURL", () => {
-      const baseURL = "https://example.com/api";
+    it("should create API methods with the correct baseURL", async () => {
+      const baseURL = "https://example.com/api/";
+      fetchStub.resolves(mockResponse({ test: "data" }));
       const api = configure(baseURL);
-      assert.deepEqual(axiosStub.args, [
-        [
-          {
-            baseURL,
-          },
-        ],
-      ]);
       assert.deepEqual(Object.keys(api), expectedApi);
+      // Verify baseURL is used when making a request
+      await api.deviceInfo(expectedToken, "mockMac");
+      assert.ok(fetchStub.calledOnce);
+      assert.ok(fetchStub.firstCall.args[0].startsWith(baseURL));
     });
-    it("should create API methods with the default baseURL", () => {
+    it("should create API methods with the default baseURL", async () => {
+      fetchStub.resolves(mockResponse({ test: "data" }));
       const api = configure();
-      assert.deepEqual(axiosStub.args, [
-        [
-          {
-            baseURL: API_URL,
-          },
-        ],
-      ]);
       assert.deepEqual(Object.keys(api), expectedApi);
+      // Verify default baseURL is used when making a request
+      await api.deviceInfo(expectedToken, "mockMac");
+      assert.ok(fetchStub.calledOnce);
+      assert.ok(fetchStub.firstCall.args[0].startsWith(API_URL));
     });
   });
 
@@ -174,19 +251,19 @@ describe("library", () => {
       },
     };
 
-    it("should call axios for deviceInfo", async () => {
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockDeviceInfo }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+    it("should call fetch for deviceInfo", async () => {
+      fetchStub.resolves(mockResponse(mockDeviceInfo));
+      const api = configure("https://example.com/api/");
       const result = await api.deviceInfo(expectedToken, "mockMacAddress");
-      assert.deepEqual(mockAxios.get.args, [
-        [
-          "device/mockMacAddress/info",
-          { headers: { Authorization: `Bearer ${expectedToken}` } },
-        ],
-      ]);
+      assert.ok(fetchStub.calledOnce);
+      assert.equal(
+        fetchStub.firstCall.args[0],
+        "https://example.com/api/device/mockMacAddress/info",
+      );
+      assert.deepEqual(fetchStub.firstCall.args[1], {
+        method: "GET",
+        headers: { Authorization: `Bearer ${expectedToken}` },
+      });
       assert.deepEqual(result, mockDeviceInfo);
     });
 
@@ -205,29 +282,29 @@ describe("library", () => {
         expectedValue: 0,
       },
     ].forEach(({ method, call, expectedValue }) => {
-      it(`should call axios for ${method}`, async () => {
-        const mockAxios = {
-          put: sinon.stub().resolves({ status: 200 }),
-        };
-        axiosStub.returns(mockAxios);
-        const api = configure("https://example.com/api");
+      it(`should call fetch for ${method}`, async () => {
+        fetchStub.resolves(mockResponse({ success: true }));
+        const api = configure("https://example.com/api/");
 
         // Invoke the method using the mapped call function
-        const result = await call(api);
-        assert.deepEqual(mockAxios.put.args, [
-          [
-            "mqtt/command",
-            {
-              mac_address: "mockMacAddress",
-              name: "power",
-              value: expectedValue,
-            },
-            {
-              headers: { Authorization: "Bearer mockToken" },
-            },
-          ],
-        ]);
-        assert.equal(result.status, 200);
+        await call(api);
+        assert.ok(fetchStub.calledOnce);
+        assert.equal(
+          fetchStub.firstCall.args[0],
+          "https://example.com/api/mqtt/command",
+        );
+        assert.deepEqual(fetchStub.firstCall.args[1], {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer mockToken",
+          },
+          body: JSON.stringify({
+            mac_address: "mockMacAddress",
+            name: "power",
+            value: expectedValue,
+          }),
+        });
       });
     });
 
@@ -252,21 +329,21 @@ describe("library", () => {
       },
     ];
     getterTests.forEach(({ method, call, expectedResult }) => {
-      it(`should call axios and return the correct value for ${method}`, async () => {
-        const mockAxios = {
-          get: sinon.stub().resolves({ data: mockDeviceInfo }),
-        };
-        axiosStub.returns(mockAxios);
-        const api = configure("https://example.com/api");
+      it(`should call fetch and return the correct value for ${method}`, async () => {
+        fetchStub.resolves(mockResponse(mockDeviceInfo));
+        const api = configure("https://example.com/api/");
 
         const result = await call(api, expectedToken, "mockMacAddress");
 
-        assert.deepEqual(mockAxios.get.args, [
-          [
-            "device/mockMacAddress/info",
-            { headers: { Authorization: `Bearer ${expectedToken}` } },
-          ],
-        ]);
+        assert.ok(fetchStub.calledOnce);
+        assert.equal(
+          fetchStub.firstCall.args[0],
+          "https://example.com/api/device/mockMacAddress/info",
+        );
+        assert.deepEqual(fetchStub.firstCall.args[1], {
+          method: "GET",
+          headers: { Authorization: `Bearer ${expectedToken}` },
+        });
         assert.equal(result, expectedResult);
       });
     });
@@ -278,7 +355,7 @@ describe("library", () => {
           api: ReturnType<typeof configure>,
           token: string,
           mac: string,
-          value: number
+          value: number,
         ) => api.setTargetTemperature(token, mac, value),
         payload: {
           name: "enviroment_1_temperature",
@@ -287,155 +364,140 @@ describe("library", () => {
       },
     ];
     setterTests.forEach(({ method, call, payload }) => {
-      it(`should call axios and send the correct payload for ${method}`, async () => {
-        const mockAxios = {
-          put: sinon.stub().resolves({ status: 200 }),
-        };
-        axiosStub.returns(mockAxios);
-        const api = configure("https://example.com/api");
-
-        const result = await call(
-          api,
-          expectedToken,
-          "mockMacAddress",
-          payload.value
-        );
+      it(`should call fetch and send the correct payload for ${method}`, async () => {
+        fetchStub.resolves(mockResponse({ success: true }));
+        const api = configure("https://example.com/api/");
 
-        assert.deepEqual(mockAxios.put.args, [
-          [
-            "mqtt/command",
-            {
-              mac_address: "mockMacAddress",
-              ...payload,
-            },
-            {
-              headers: { Authorization: `Bearer ${expectedToken}` },
-            },
-          ],
-        ]);
-        assert.equal(result.status, 200);
+        await call(api, expectedToken, "mockMacAddress", payload.value);
+
+        assert.ok(fetchStub.calledOnce);
+        assert.equal(
+          fetchStub.firstCall.args[0],
+          "https://example.com/api/mqtt/command",
+        );
+        assert.deepEqual(fetchStub.firstCall.args[1], {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${expectedToken}`,
+          },
+          body: JSON.stringify({
+            mac_address: "mockMacAddress",
+            ...payload,
+          }),
+        });
       });
     });
   });
 
   describe("registerDevice", () => {
     it("should call POST /device with correct payload", async () => {
-      const mockResponse = {
+      const mockResponseData = {
         macAddress: "AABBCCDDEEFF",
         deviceName: "Test Stove",
         deviceRoom: "Living Room",
         serialNumber: "EDK123",
       };
-      const mockAxios = {
-        post: sinon.stub().resolves({ data: mockResponse }),
-        get: sinon.stub(),
-        put: sinon.stub(),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.registerDevice(
         expectedToken,
         "AA:BB:CC:DD:EE:FF",
         "EDK123",
         "Test Stove",
-        "Living Room"
+        "Living Room",
       );
 
-      assert.deepEqual(mockAxios.post.args, [
-        [
-          "device",
-          {
-            macAddress: "AABBCCDDEEFF",
-            deviceName: "Test Stove",
-            deviceRoom: "Living Room",
-            serialNumber: "EDK123",
-          },
-          { headers: { Authorization: `Bearer ${expectedToken}` } },
-        ],
-      ]);
-      assert.deepEqual(result, mockResponse);
+      assert.ok(fetchStub.calledOnce);
+      assert.equal(
+        fetchStub.firstCall.args[0],
+        "https://example.com/api/device",
+      );
+      assert.deepEqual(fetchStub.firstCall.args[1], {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${expectedToken}`,
+        },
+        body: JSON.stringify({
+          macAddress: "AABBCCDDEEFF",
+          deviceName: "Test Stove",
+          deviceRoom: "Living Room",
+          serialNumber: "EDK123",
+        }),
+      });
+      assert.deepEqual(result, mockResponseData);
     });
 
     it("should normalize MAC address by removing colons", async () => {
-      const mockAxios = {
-        post: sinon.stub().resolves({ data: {} }),
-        get: sinon.stub(),
-        put: sinon.stub(),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse({}));
+      const api = configure("https://example.com/api/");
 
       await api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123");
 
-      assert.equal(mockAxios.post.args[0][1].macAddress, "AABBCCDDEEFF");
+      const body = JSON.parse(fetchStub.firstCall.args[1].body);
+      assert.equal(body.macAddress, "AABBCCDDEEFF");
     });
 
     it("should use empty strings as defaults for name and room", async () => {
-      const mockAxios = {
-        post: sinon.stub().resolves({ data: {} }),
-        get: sinon.stub(),
-        put: sinon.stub(),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse({}));
+      const api = configure("https://example.com/api/");
 
       await api.registerDevice(expectedToken, "AABBCCDDEEFF", "EDK123");
 
-      assert.equal(mockAxios.post.args[0][1].deviceName, "");
-      assert.equal(mockAxios.post.args[0][1].deviceRoom, "");
+      const body = JSON.parse(fetchStub.firstCall.args[1].body);
+      assert.equal(body.deviceName, "");
+      assert.equal(body.deviceRoom, "");
     });
   });
 
   describe("editDevice", () => {
     it("should call PUT /device/{mac} with correct payload", async () => {
-      const mockResponse = {
+      const mockResponseData = {
         macAddress: "AABBCCDDEEFF",
         deviceName: "Updated Name",
         deviceRoom: "Basement",
         serialNumber: "EDK123",
       };
-      const mockAxios = {
-        put: sinon.stub().resolves({ data: mockResponse }),
-        get: sinon.stub(),
-        post: sinon.stub(),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.editDevice(
         expectedToken,
         "AA:BB:CC:DD:EE:FF",
         "Updated Name",
-        "Basement"
+        "Basement",
       );
 
-      assert.deepEqual(mockAxios.put.args, [
-        [
-          "device/AABBCCDDEEFF",
-          {
-            deviceName: "Updated Name",
-            deviceRoom: "Basement",
-          },
-          { headers: { Authorization: `Bearer ${expectedToken}` } },
-        ],
-      ]);
-      assert.deepEqual(result, mockResponse);
+      assert.ok(fetchStub.calledOnce);
+      assert.equal(
+        fetchStub.firstCall.args[0],
+        "https://example.com/api/device/AABBCCDDEEFF",
+      );
+      assert.deepEqual(fetchStub.firstCall.args[1], {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${expectedToken}`,
+        },
+        body: JSON.stringify({
+          deviceName: "Updated Name",
+          deviceRoom: "Basement",
+        }),
+      });
+      assert.deepEqual(result, mockResponseData);
     });
 
     it("should use empty strings as defaults for name and room", async () => {
-      const mockAxios = {
-        put: sinon.stub().resolves({ data: {} }),
-        get: sinon.stub(),
-        post: sinon.stub(),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse({}));
+      const api = configure("https://example.com/api/");
 
       await api.editDevice(expectedToken, "AABBCCDDEEFF");
 
-      assert.equal(mockAxios.put.args[0][1].deviceName, "");
-      assert.equal(mockAxios.put.args[0][1].deviceRoom, "");
+      const body = JSON.parse(fetchStub.firstCall.args[1].body);
+      assert.equal(body.deviceName, "");
+      assert.equal(body.deviceRoom, "");
     });
   });
 
@@ -445,7 +507,7 @@ describe("library", () => {
         commands: { power: true },
         temperatures: { enviroment: 19, board: 25 },
       };
-      const mockResponse = {
+      const mockResponseData = {
         status: createGzippedBuffer(statusData),
         nvm: {
           user_parameters: {
@@ -454,11 +516,8 @@ describe("library", () => {
         },
       };
 
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockResponse }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.deviceInfo(expectedToken, "mockMacAddress");
 
@@ -475,7 +534,7 @@ describe("library", () => {
           is_sound_active: true,
         },
       };
-      const mockResponse = {
+      const mockResponseData = {
         status: {
           commands: { power: true },
           temperatures: { enviroment: 19 },
@@ -483,11 +542,8 @@ describe("library", () => {
         nvm: createGzippedBuffer(nvmData),
       };
 
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockResponse }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.deviceInfo(expectedToken, "mockMacAddress");
 
@@ -508,16 +564,13 @@ describe("library", () => {
           is_sound_active: false,
         },
       };
-      const mockResponse = {
+      const mockResponseData = {
         status: createGzippedBuffer(statusData),
         nvm: createGzippedBuffer(nvmData),
       };
 
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockResponse }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.deviceInfo(expectedToken, "mockMacAddress");
 
@@ -530,16 +583,13 @@ describe("library", () => {
         commands: { power: true },
         temperatures: { enviroment: 19 },
       };
-      const mockResponse = {
+      const mockResponseData = {
         status: createGzippedBuffer(statusData),
         nvm: { user_parameters: { enviroment_1_temperature: 22 } },
       };
 
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockResponse }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.getPower(expectedToken, "mockMacAddress");
 
@@ -551,20 +601,17 @@ describe("library", () => {
         commands: { power: true },
         temperatures: { enviroment: 19, board: 25 },
       };
-      const mockResponse = {
+      const mockResponseData = {
         status: createGzippedBuffer(statusData),
         nvm: { user_parameters: { enviroment_1_temperature: 22 } },
       };
 
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockResponse }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.getEnvironmentTemperature(
         expectedToken,
-        "mockMacAddress"
+        "mockMacAddress",
       );
 
       assert.equal(result, 19);
@@ -576,23 +623,49 @@ describe("library", () => {
           enviroment_1_temperature: 22,
         },
       };
-      const mockResponse = {
+      const mockResponseData = {
         status: { commands: { power: true }, temperatures: { enviroment: 19 } },
         nvm: createGzippedBuffer(nvmData),
       };
 
-      const mockAxios = {
-        get: sinon.stub().resolves({ data: mockResponse }),
-      };
-      axiosStub.returns(mockAxios);
-      const api = configure("https://example.com/api");
+      fetchStub.resolves(mockResponse(mockResponseData));
+      const api = configure("https://example.com/api/");
 
       const result = await api.getTargetTemperature(
         expectedToken,
-        "mockMacAddress"
+        "mockMacAddress",
       );
 
       assert.equal(result, 22);
     });
   });
+
+  describe("Error Handling", () => {
+    const errorTests = [
+      { status: 400, statusText: "Bad Request" },
+      { status: 401, statusText: "Unauthorized" },
+      { status: 404, statusText: "Not Found" },
+      { status: 500, statusText: "Internal Server Error" },
+    ];
+
+    errorTests.forEach(({ status, statusText }) => {
+      it(`should throw error when fetch returns ${status}`, async () => {
+        const errorResponse = {
+          ok: false,
+          status,
+          statusText,
+          json: () => Promise.resolve({ error: statusText }),
+        } as Response;
+        fetchStub.resolves(errorResponse);
+        const api = configure("https://example.com/api/");
+
+        await assert.rejects(
+          async () => api.deviceInfo(expectedToken, "mockMac"),
+          {
+            message: `HTTP ${status}: ${statusText}`,
+          },
+        );
+      });
+    });
+  });
 });