edilkamin 1.4.0 → 1.5.0

package/src/library.test.ts

@@ -1,15 +1,19 @@
 import { strict as assert } from "assert";
-import sinon from "sinon";
 import axios from "axios";
-import { configure } from "../src/library";
+import sinon from "sinon";
+
+import { configure, createAuthService } from "../src/library";
+import { API_URL } from "./constants";
 
 describe("library", () => {
   let axiosStub: 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);
   });
 
@@ -17,60 +21,256 @@ describe("library", () => {
     sinon.restore();
   });
 
+  describe("signIn", () => {
+    it("should sign in and return the JWT token", async () => {
+      const expectedUsername = "testuser";
+      const expectedPassword = "testpassword";
+      const signIn = sinon.stub().resolves({ isSignedIn: true });
+      const signOut = sinon.stub();
+      const fetchAuthSession = sinon.stub().resolves({
+        tokens: {
+          accessToken: { toString: () => expectedToken },
+        },
+      });
+      const authStub = {
+        signIn,
+        signOut,
+        fetchAuthSession,
+      };
+      // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+      const authService = createAuthService(authStub as any);
+      const token = await authService.signIn(
+        expectedUsername,
+        expectedPassword
+      );
+      assert.deepEqual(authStub.signOut.args, [[]]);
+      assert.deepEqual(signIn.args, [
+        [{ username: expectedUsername, password: expectedPassword }],
+      ]);
+      assert.equal(token, expectedToken);
+    });
+
+    it("should throw an error if sign-in fails", async () => {
+      const expectedUsername = "testuser";
+      const expectedPassword = "testpassword";
+      const signIn = sinon.stub().resolves({ isSignedIn: false });
+      const signOut = sinon.stub();
+      const fetchAuthSession = sinon.stub().resolves({
+        tokens: {
+          accessToken: { toString: () => expectedToken },
+        },
+      });
+      const authStub = {
+        signIn,
+        signOut,
+        fetchAuthSession,
+      };
+      // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+      const authService = createAuthService(authStub as any);
+      await assert.rejects(
+        async () => authService.signIn(expectedUsername, expectedPassword),
+        {
+          name: "AssertionError",
+          message: "Sign-in failed",
+        }
+      );
+    });
+  });
+
   describe("configure", () => {
+    const expectedApi = [
+      "deviceInfo",
+      "setPower",
+      "setPowerOff",
+      "setPowerOn",
+      "getPower",
+      "getEnvironmentTemperature",
+      "getTargetTemperature",
+      "setTargetTemperature",
+    ];
     it("should create API methods with the correct baseURL", () => {
       const baseURL = "https://example.com/api";
       const api = configure(baseURL);
-      assert.ok(axiosStub.calledOnce);
-      assert.deepEqual(axiosStub.firstCall.args[0], { baseURL });
-      assert.deepEqual(Object.keys(api), [
-        "deviceInfo",
-        "setPower",
-        "setPowerOff",
-        "setPowerOn",
+      assert.deepEqual(axiosStub.args, [
+        [
+          {
+            baseURL,
+          },
+        ],
       ]);
+      assert.deepEqual(Object.keys(api), expectedApi);
+    });
+    it("should create API methods with the default baseURL", () => {
+      const api = configure();
+      assert.deepEqual(axiosStub.args, [
+        [
+          {
+            baseURL: API_URL,
+          },
+        ],
+      ]);
+      assert.deepEqual(Object.keys(api), expectedApi);
     });
   });
 
   describe("API Methods", () => {
+    const mockDeviceInfo = {
+      status: {
+        commands: {
+          power: true,
+        },
+        temperatures: {
+          enviroment: 19,
+        },
+      },
+      nvm: {
+        user_parameters: {
+          enviroment_1_temperature: 22,
+        },
+      },
+    };
+
     it("should call axios for deviceInfo", async () => {
       const mockAxios = {
-        get: sinon
-          .stub()
-          .resolves({ data: { id: "123", name: "Mock Device" } }),
+        get: sinon.stub().resolves({ data: mockDeviceInfo }),
       };
-      axiosStub.returns(mockAxios as any);
+      axiosStub.returns(mockAxios);
       const api = configure("https://example.com/api");
-      const result = await api.deviceInfo("mockToken", "mockMacAddress");
-      assert.ok(mockAxios.get.calledOnce);
-      assert.equal(
-        mockAxios.get.firstCall.args[0],
-        "device/mockMacAddress/info"
-      );
-      assert.deepEqual(mockAxios.get.firstCall.args[1], {
-        headers: { Authorization: "Bearer mockToken" },
+      const result = await api.deviceInfo(expectedToken, "mockMacAddress");
+      assert.deepEqual(mockAxios.get.args, [
+        [
+          "device/mockMacAddress/info",
+          { headers: { Authorization: `Bearer ${expectedToken}` } },
+        ],
+      ]);
+      assert.deepEqual(result, mockDeviceInfo);
+    });
+
+    // Tests for setPowerOn and setPowerOff
+    [
+      {
+        method: "setPowerOn",
+        call: (api: ReturnType<typeof configure>) =>
+          api.setPowerOn("mockToken", "mockMacAddress"),
+        expectedValue: 1,
+      },
+      {
+        method: "setPowerOff",
+        call: (api: ReturnType<typeof configure>) =>
+          api.setPowerOff("mockToken", "mockMacAddress"),
+        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");
+
+        // 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);
       });
-      assert.deepEqual(result.data, { id: "123", name: "Mock Device" });
     });
 
-    it("should call axios for setPowerOn", async () => {
-      const mockAxios = {
-        put: sinon.stub().resolves({ status: 200 }),
-      };
-      axiosStub.returns(mockAxios as any);
-      const api = configure("https://example.com/api");
-      const result = await api.setPowerOn("mockToken", "mockMacAddress");
-      assert.ok(mockAxios.put.calledOnce);
-      assert.equal(mockAxios.put.firstCall.args[0], "mqtt/command");
-      assert.deepEqual(mockAxios.put.firstCall.args[1], {
-        mac_address: "mockMacAddress",
-        name: "power",
-        value: 1,
+    const getterTests = [
+      {
+        method: "getPower",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getPower(token, mac),
+        expectedResult: true,
+      },
+      {
+        method: "getEnvironmentTemperature",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getEnvironmentTemperature(token, mac),
+        expectedResult: 19,
+      },
+      {
+        method: "getTargetTemperature",
+        call: (api: ReturnType<typeof configure>, token: string, mac: string) =>
+          api.getTargetTemperature(token, mac),
+        expectedResult: 22,
+      },
+    ];
+    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");
+
+        const result = await call(api, expectedToken, "mockMacAddress");
+
+        assert.deepEqual(mockAxios.get.args, [
+          [
+            "device/mockMacAddress/info",
+            { headers: { Authorization: `Bearer ${expectedToken}` } },
+          ],
+        ]);
+        assert.equal(result, expectedResult);
       });
-      assert.deepEqual(mockAxios.put.firstCall.args[2], {
-        headers: { Authorization: "Bearer mockToken" },
+    });
+    // Setter tests
+    const setterTests = [
+      {
+        method: "setTargetTemperature",
+        call: (
+          api: ReturnType<typeof configure>,
+          token: string,
+          mac: string,
+          value: number
+        ) => api.setTargetTemperature(token, mac, value),
+        payload: {
+          name: "enviroment_1_temperature",
+          value: 20,
+        },
+      },
+    ];
+    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
+        );
+
+        assert.deepEqual(mockAxios.put.args, [
+          [
+            "mqtt/command",
+            {
+              mac_address: "mockMacAddress",
+              ...payload,
+            },
+            {
+              headers: { Authorization: `Bearer ${expectedToken}` },
+            },
+          ],
+        ]);
+        assert.equal(result.status, 200);
       });
-      assert.equal(result.status, 200);
     });
   });
 });

package/src/library.ts

@@ -2,43 +2,86 @@ import { strict as assert } from "assert";
 import { Amplify } from "aws-amplify";
 import * as amplifyAuth from "aws-amplify/auth";
 import axios, { AxiosInstance } from "axios";
-import { DeviceInfoType } from "./types";
+
 import { API_URL } from "./constants";
+import { DeviceInfoType } from "./types";
 
 const amplifyconfiguration = {
   aws_project_region: "eu-central-1",
   aws_user_pools_id: "eu-central-1_BYmQ2VBlo",
   aws_user_pools_web_client_id: "7sc1qltkqobo3ddqsk4542dg2h",
 };
-Amplify.configure(amplifyconfiguration);
 
+/**
+ * Generates headers with a JWT token for authenticated requests.
+ * @param {string} jwtToken - The JWT token for authorization.
+ * @returns {object} - The headers object with the Authorization field.
+ */
 const headers = (jwtToken: string) => ({ Authorization: `Bearer ${jwtToken}` });
 
 /**
- * Sign in to return the JWT token.
+ * Configures Amplify if not already configured.
+ * Ensures the configuration is only applied once.
+ */
+const configureAmplify = () => {
+  const currentConfig = Amplify.getConfig();
+  if (Object.keys(currentConfig).length !== 0) return;
+  Amplify.configure(amplifyconfiguration);
+};
+
+/**
+ * Creates an authentication service with sign-in functionality.
+ * @param {typeof amplifyAuth} auth - The authentication module to use.
+ * @returns {object} - An object containing authentication-related methods.
  */
-const signIn = async (username: string, password: string): Promise<string> => {
-  // in case the user is already signed in, refs:
-  // https://github.com/aws-amplify/amplify-js/issues/13813
-  await amplifyAuth.signOut();
-  const { isSignedIn } = await amplifyAuth.signIn({
-    username,
-    password,
-  });
-  assert.ok(isSignedIn);
-  const { tokens } = await amplifyAuth.fetchAuthSession();
-  assert.ok(tokens);
-  return tokens.accessToken.toString();
+const createAuthService = (auth: typeof amplifyAuth) => {
+  /**
+   * Signs in a user with the provided credentials.
+   * @param {string} username - The username of the user.
+   * @param {string} password - The password of the user.
+   * @returns {Promise<string>} - The JWT token of the signed-in user.
+   * @throws {Error} - If sign-in fails or no tokens are retrieved.
+   */
+  const signIn = async (
+    username: string,
+    password: string
+  ): Promise<string> => {
+    configureAmplify();
+    await auth.signOut(); // Ensure the user is signed out first
+    const { isSignedIn } = await auth.signIn({ username, password });
+    assert.ok(isSignedIn, "Sign-in failed");
+    const { tokens } = await auth.fetchAuthSession();
+    assert.ok(tokens, "No tokens found");
+    return tokens.accessToken.toString();
+  };
+  return { signIn };
 };
 
+// Create the default auth service using amplifyAuth
+const { signIn } = createAuthService(amplifyAuth);
+
 const deviceInfo =
-  (axiosInstance: AxiosInstance) => (jwtToken: string, macAddress: string) =>
-    axiosInstance.get<DeviceInfoType>(`device/${macAddress}/info`, {
-      headers: headers(jwtToken),
-    });
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Retrieves information about a device by its MAC address.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @returns {Promise<DeviceInfoType>} - A promise that resolves to the device info.
+   */
+  async (jwtToken: string, macAddress: string) => {
+    const response = await axiosInstance.get<DeviceInfoType>(
+      `device/${macAddress}/info`,
+      {
+        headers: headers(jwtToken),
+      }
+    );
+    return response.data;
+  };
 
 const mqttCommand =
   (axiosInstance: AxiosInstance) =>
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
   (jwtToken: string, macAddress: string, payload: any) =>
     axiosInstance.put(
       "mqtt/command",
@@ -48,28 +91,139 @@ const mqttCommand =
 
 const setPower =
   (axiosInstance: AxiosInstance) =>
+  /**
+   * Sends a command to set the power state of a device.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @param {number} value - The desired power state (1 for ON, 0 for OFF).
+   * @returns {Promise<string>} - A promise that resolves to the command response.
+   */
   (jwtToken: string, macAddress: string, value: number) =>
     mqttCommand(axiosInstance)(jwtToken, macAddress, { name: "power", value });
 
 const setPowerOn =
-  (axiosInstance: AxiosInstance) => (jwtToken: string, macAddress: string) =>
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Turns a device ON by setting its power state.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @returns {Promise<string>} - A promise that resolves to the command response.
+   *
+   * @example
+   * const response = await api.setPowerOn(jwtToken, macAddress);
+   * console.log(response);
+   */
+  (jwtToken: string, macAddress: string) =>
     setPower(axiosInstance)(jwtToken, macAddress, 1);
+
 const setPowerOff =
-  (axiosInstance: AxiosInstance) => (jwtToken: string, macAddress: string) =>
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Turns a device OFF by setting its power state.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @returns {Promise<string>} - A promise that resolves to the command response.
+   *
+   * @example
+   * const response = await api.setPowerOff(jwtToken, macAddress);
+   * console.log(response);
+   */
+  (jwtToken: string, macAddress: string) =>
     setPower(axiosInstance)(jwtToken, macAddress, 0);
 
+const getPower =
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Retrieves the power status of the device.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @returns {Promise<boolean>} - A promise that resolves to the power status.
+   */
+  async (jwtToken: string, macAddress: string): Promise<boolean> => {
+    const info = await deviceInfo(axiosInstance)(jwtToken, macAddress);
+    return info.status.commands.power;
+  };
+
+const getEnvironmentTemperature =
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Retrieves the environment temperature from the device's sensors.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @returns {Promise<number>} - A promise that resolves to the temperature value.
+   */
+  async (jwtToken: string, macAddress: string): Promise<number> => {
+    const info = await deviceInfo(axiosInstance)(jwtToken, macAddress);
+    return info.status.temperatures.enviroment;
+  };
+
+const getTargetTemperature =
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Retrieves the target temperature value set on the device.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @returns {Promise<number>} - A promise that resolves to the target temperature (degree celsius).
+   */
+  async (jwtToken: string, macAddress: string): Promise<number> => {
+    const info = await deviceInfo(axiosInstance)(jwtToken, macAddress);
+    return info.nvm.user_parameters.enviroment_1_temperature;
+  };
+
+const setTargetTemperature =
+  (axiosInstance: AxiosInstance) =>
+  /**
+   * Sends a command to set the target temperature (degree celsius) of a device.
+   *
+   * @param {string} jwtToken - The JWT token for authentication.
+   * @param {string} macAddress - The MAC address of the device.
+   * @param {number} temperature - The desired target temperature (degree celsius).
+   * @returns {Promise<string>} - A promise that resolves to the command response.
+   */
+  (jwtToken: string, macAddress: string, temperature: number) =>
+    mqttCommand(axiosInstance)(jwtToken, macAddress, {
+      name: "enviroment_1_temperature",
+      value: temperature,
+    });
+
+/**
+ * Configures the library for API interactions.
+ * Initializes API methods with a specified base URL.
+ *
+ * @param {string} [baseURL=API_URL] - The base URL for the API.
+ * @returns {object} - An object containing methods for interacting with the API.
+ *
+ * @example
+ * const api = configure();
+ * const power = await api.getPower(jwtToken, macAddress);
+ */
 const configure = (baseURL: string = API_URL) => {
   const axiosInstance = axios.create({ baseURL });
   const deviceInfoInstance = deviceInfo(axiosInstance);
   const setPowerInstance = setPower(axiosInstance);
   const setPowerOffInstance = setPowerOff(axiosInstance);
   const setPowerOnInstance = setPowerOn(axiosInstance);
+  const getPowerInstance = getPower(axiosInstance);
+  const getEnvironmentTemperatureInstance =
+    getEnvironmentTemperature(axiosInstance);
+  const getTargetTemperatureInstance = getTargetTemperature(axiosInstance);
+  const setTargetTemperatureInstance = setTargetTemperature(axiosInstance);
   return {
     deviceInfo: deviceInfoInstance,
     setPower: setPowerInstance,
     setPowerOff: setPowerOffInstance,
     setPowerOn: setPowerOnInstance,
+    getPower: getPowerInstance,
+    getEnvironmentTemperature: getEnvironmentTemperatureInstance,
+    getTargetTemperature: getTargetTemperatureInstance,
+    setTargetTemperature: setTargetTemperatureInstance,
   };
 };
 
-export { signIn, configure };
+export { configure, createAuthService, headers, signIn };