Merge branch 'release/0.0.3'

src/components/Contexts/CertificateContext.jsx

@@ -1,21 +1,25 @@
 import React, { useContext, useState } from "react";
 
 import api from "../../services/certificatesAPI";
+import { CertTypes } from "../../utils/certificates";
 
 const CertificateContext = React.createContext();
 
-export const CertTypes = {
-  TBOX: "TBOX",
-  ICC: "ICC",
-  Charging: "Charging",
-  Aftersales: "Aftersales",
-};
-
 const validateCreate = (data) => {
   if (!data.type) throw new Error("type is required");
   if (!data.common_name) throw new Error("common name is required");
 };
 
+const callCreateCert = (data, token) => {
+  if (data.type === CertTypes.Aftersales) {
+    data.tool_id = data.common_name;
+    delete data.common_name;
+    return api.createAftersales(data, token);
+  }
+
+  return api.create(data, token);
+};
+
 export const CertificateProvider = ({ children }) => {
   const [busy, setBusy] = useState(false);
 
@@ -25,7 +29,8 @@ export const CertificateProvider = ({ children }) => {
 
       validateCreate(data);
 
-      const result = await api.create(data, token);
+      const result = await callCreateCert(data, token);
+
       if (result.error) {
         throw new Error(`Create certificate error. ${result.message}`);
       }

src/components/Contexts/CertificateContext.test.jsx

@@ -0,0 +1,105 @@
+jest.mock("../../services/certificatesAPI");
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@testing-library/react";
+import { useState } from "react";
+
+import {
+  CertificateProvider,
+  useCertificateContext,
+} from "./CertificateContext";
+
+describe("CertificateContext", () => {
+  beforeEach(() => {
+    const TestComp = () => {
+      const { createCert } = useCertificateContext();
+      const [result, setResult] = useState(null);
+      const testCreate = async (data) => {
+        const x = await createCert(data);
+        setResult(JSON.stringify(x));
+      };
+
+      return (
+        <>
+          <div data-testid="output">{result}</div>
+          <button
+            data-testid="createCertTBOX"
+            onClick={async () => {
+              await testCreate({
+                common_name: "11111111111111111",
+                type: "TBOX",
+              });
+            }}
+          />
+          <button
+            data-testid="createCertICC"
+            onClick={async () => {
+              await testCreate({
+                common_name: "11111111111111111",
+                type: "ICC",
+              });
+            }}
+          />
+          <button
+            data-testid="createCertAftersales"
+            onClick={async () => {
+              await testCreate({
+                common_name: "11111111111111112",
+                type: "Aftersales",
+              });
+            }}
+          />
+        </>
+      );
+    };
+
+    render(
+      <CertificateProvider>
+        <TestComp />
+      </CertificateProvider>
+    );
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("TBOX certificate", async () => {
+    await act(async () => {
+      fireEvent.click(screen.getByTestId("createCertTBOX"));
+      await waitFor(() =>
+        expect(screen.getByTestId("output").innerHTML).toBe(
+          '{"private_key":"-----BEGIN RSA PRIVATE KEY-----DATA-----END RSA PRIVATE KEY-----","public_key":"-----BEGIN CERTIFICATE-----DATA-----END CERTIFICATE-----","serial_number":"00:76:d2:ca:86:35:8c:88:52:fd:94:8e:55:d3:b6:a8:2e:73:68:00","type":"TBOX"}'
+        )
+      );
+    });
+  });
+
+  it("ICC certificate", async () => {
+    await act(async () => {
+      fireEvent.click(screen.getByTestId("createCertICC"));
+      await waitFor(() =>
+        expect(screen.getByTestId("output").innerHTML).toBe(
+          '{"private_key":"-----BEGIN RSA PRIVATE KEY-----DATA-----END RSA PRIVATE KEY-----","public_key":"-----BEGIN CERTIFICATE-----DATA-----END CERTIFICATE-----","serial_number":"00:76:d2:ca:86:35:8c:88:52:fd:94:8e:55:d3:b6:a8:2e:73:68:00","type":"ICC"}'
+        )
+      );
+    });
+  });
+
+  it("Aftersales certificate", async () => {
+    await act(async () => {
+      fireEvent.click(screen.getByTestId("createCertAftersales"));
+      await waitFor(() =>
+        expect(screen.getByTestId("output").innerHTML).toBe(
+          '{"private_key":"-----BEGIN RSA PRIVATE KEY-----DATA-----END RSA PRIVATE KEY-----","public_key":"-----BEGIN CERTIFICATE-----DATA-----END CERTIFICATE-----","serial_number":"00:76:d2:ca:86:35:8c:88:52:fd:94:8e:55:d3:b6:a8:2e:73:68:00","type":"Aftersales"}'
+        )
+      );
+    });
+  });
+});

src/components/Contexts/ManifestsContext.jsx

@@ -43,6 +43,23 @@ export const ManifestsProvider = ({ children }) => {
     return result;
   };
 
+  const updateManifest = async (id, data, token) => {
+    validateManifestUpdate(data);
+
+    let result;
+
+    try {
+      setBusy(true);
+      result = await api.updateManifest(id, data, token);
+      if (result.error)
+        throw new Error(`Update manifest error. ${result.message}`);
+    } finally {
+      setBusy(false);
+    }
+
+    return result;
+  }
+
   const deleteManifest = async (package_id, token) => {
     let result;
 
@@ -69,6 +86,7 @@ export const ManifestsProvider = ({ children }) => {
         busy,
         manifests,
         totalManifests,
+        updateManifest,
         getManifest,
         getManifests,
         deleteManifest,
@@ -79,4 +97,14 @@ export const ManifestsProvider = ({ children }) => {
   );
 };
 
+const validateManifestUpdate = (data) => {
+  if (data == null) throw new Error("No manifest data");
+
+  if (data.name == null || data.name.length>255) throw new Error("Invalid manifest name");
+
+  if (data.type == null || !["forced", "standard"].includes(data.type)) {
+    throw new Error("Invalid manifest type");
+  }
+}
+
 export const useManifestsContext = () => useContext(ManifestsContext);

src/components/Contexts/ManifestsContext.test.jsx

@@ -0,0 +1,109 @@
+jest.mock("../../services/manifestsAPI");
+
+import {
+  render,
+  cleanup,
+  screen,
+  fireEvent,
+  waitFor,
+} from "@testing-library/react";
+import { ManifestsProvider, useManifestsContext } from "./ManifestsContext";
+import { StatusProvider, useStatusContext } from "./StatusContext";
+
+const checkBaseResults = (error, busy) => {
+  expect(screen.getByTestId("error").innerHTML).toEqual(error);
+  expect(screen.getByTestId("busy").innerHTML).toEqual(busy);
+};
+
+describe("ManifestContext", () => {
+  describe("updateManifest", () => {
+    beforeEach(async () => {
+      const TestComp = () => {
+        const { busy, updateManifest } = useManifestsContext();
+        const { message, setMessage } = useStatusContext();
+        const update = async (data) => {
+          try {
+            await updateManifest(1, data);
+          } catch (e) {
+            setMessage(e.message);
+          }
+        };
+
+        return (
+          <>
+            <div data-testid="error">{message}</div>
+            <div data-testid="busy">{busy.toString()}</div>
+            <button
+              data-testid="updateManifestNull"
+              onClick={() => update(null)}
+            />
+            <button
+              data-testid="updateManifestNoName"
+              onClick={() => update({type:"forced"})}
+            />
+            <button
+              data-testid="updateManifestNoType"
+              onClick={() => update({name:"update"})}
+            />
+            <button
+              data-testid="updateManifest"
+              onClick={() =>
+                update({
+                  name: "new package",
+                  type: "forced",
+                })
+              }
+            />
+          </>
+        );
+      };
+      render(
+        <StatusProvider>
+          <ManifestsProvider>
+            <TestComp />
+          </ManifestsProvider>
+        </StatusProvider>
+      );
+    });
+
+    afterEach(() => {
+      cleanup();
+    });
+
+    it("initial state", () => {
+      checkBaseResults("", "false");
+    });
+
+    it("updateManifestNull", async () => {
+      fireEvent.click(screen.getByTestId("updateManifestNull"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("No manifest data", "false");
+    });
+
+    it("updateManifestNoName", async () => {
+      fireEvent.click(screen.getByTestId("updateManifestNoName"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("Invalid manifest name", "false");
+    });
+
+    it("updateManifestNoType", async () => {
+      fireEvent.click(screen.getByTestId("updateManifestNoType"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("Invalid manifest type", "false");
+    });
+
+    it("updateManifest", async () => {
+      fireEvent.click(screen.getByTestId("updateManifest"));
+      await waitFor(() =>
+        expect(screen.getByTestId("busy").innerHTML).toEqual("false")
+      );
+      checkBaseResults("", "false");
+    });
+  });
+});

src/components/Contexts/__mocks__/ManifestsContext.jsx

@@ -75,4 +75,5 @@ export const useManifestsContext = () => ({
   getManifest: jest.fn(() => manifest),
   getManifests: jest.fn(() => manifests),
   deleteManifest: jest.fn(),
+  updateManifest: jest.fn(() => manifest),
 });