apacuana-sdk-core 0.8.0 → 0.10.0

package/tests/api/revocations.test.js

@@ -1,6 +1,119 @@
-// tests/api/revocations.test.js
-describe('Revocations API', () => {
-  test('placeholder test', () => {
-    expect(true).toBe(true);
+import { httpRequest } from "../../src/utils/httpClient";
+import { ApacuanaAPIError } from "../../src/errors";
+import {
+  requestRevocation,
+  getRevocationReasons,
+} from "../../src/api/revocations";
+import { getConfig } from "../../src/config";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/config");
+
+describe("Revocations API", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
   });
-});
+
+  describe("requestRevocation", () => {
+    it("should throw an error if reasonCode is not provided", async () => {
+      await expect(requestRevocation(null)).rejects.toThrow(
+        "Código de motivo es requerido para requestRevocation."
+      );
+    });
+
+    it("should make a POST request to the correct endpoint with the reasonCode", async () => {
+      const reasonCode = "COMPROMISED";
+      const mockResponse = { success: true, message: "Revocation requested" };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await requestRevocation(reasonCode);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/onboardingclient/requestcert",
+        { reason: reasonCode },
+        "POST"
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it("should throw a generic error if the httpRequest fails", async () => {
+      const reasonCode = "COMPROMISED";
+      const apiError = new Error("Network error");
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(requestRevocation(reasonCode)).rejects.toThrow(
+        `Fallo en la solicitud de revocación: ${apiError.message}`
+      );
+    });
+  });
+
+  describe("getRevocationReasons", () => {
+    it("should make a GET request and return the reasons for ONBOARDING", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockReasons = [
+        { code: "0", description: "Unspecified" },
+        { code: "1", description: "Key Compromise" },
+      ];
+      httpRequest.mockResolvedValue({ records: mockReasons });
+
+      const result = await getRevocationReasons();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "GET",
+        "config/api/revocation/reasonsonboarding",
+        {}
+      );
+      expect(result).toEqual(mockReasons);
+    });
+
+    it("should throw an error if the API response does not contain 'records'", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      httpRequest.mockResolvedValue({ data: [] }); // Respuesta inválida
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        new ApacuanaAPIError("Failed to fetch revocation reasons.")
+      );
+    });
+
+    it("should re-throw ApacuanaAPIError if caught", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const apiError = new ApacuanaAPIError("API is down", 500);
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(getRevocationReasons()).rejects.toThrow(apiError);
+    });
+
+    it("should throw a generic error for other types of errors", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const genericError = new Error("Something went wrong");
+      httpRequest.mockRejectedValue(genericError);
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        "Failed to get revocation reasons. Please try again later."
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Get revocation reasons is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+  });
+});

package/tests/api/signatures.test.js

@@ -6,6 +6,9 @@ import {
   getDocs,
   getDigest,
   signDocument,
+  uploadSignatureVariant,
+  getSignatureVariant,
+  deleteSignatureVariant,
 } from "../../src/api/signatures";
 import helpers from "../../src/utils/helpers";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
@@ -19,6 +22,7 @@ jest.mock("../../src/utils/helpers", () => ({
   signDigest: jest.fn(),
   validateGetDocsData: jest.fn(),
   validateGetDigestData: jest.fn(),
+  validateOnBoardingSignDocumentData: jest.fn(),
 }));
 
 describe("API - Signatures", () => {
@@ -158,4 +162,306 @@ describe("API - Signatures", () => {
       );
     });
   });
+
+  describe("getDigest", () => {
+    const signData = {
+      cert: "test-cert",
+      signatureId: "test-signature-id",
+    };
+
+    it("should get digest for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockResponse = { data: { digest: "test-digest" } };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await getDigest(signData);
+
+      expect(helpers.validateGetDigestData).toHaveBeenCalledWith(signData);
+      expect(httpRequest).toHaveBeenCalledWith(
+        `services/api/documents/getdigest/${signData.signatureId}`,
+        { publickey: signData.cert },
+        "POST"
+      );
+      expect(result).toEqual({ digest: "test-digest", success: true });
+    });
+
+    it("should throw an error if digest is not in response for ONBOARDING", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      httpRequest.mockResolvedValue({ data: {} });
+
+      await expect(getDigest(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Signature generation failed: digest not found in the response.",
+          500,
+          "API_RESPONSE_ERROR"
+        )
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getDigest(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Digest retrieval is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(getDigest(signData)).rejects.toThrow(
+        "Document retrieval is not supported for an unknown integration type: UNSUPPORTED"
+      );
+    });
+  });
+
+  describe("signDocument", () => {
+    const signData = {
+      signature: {
+        id: "test-signature-id",
+        positions: [{ x: 0.1, y: 0.2, page: 1 }],
+      },
+      cert: "test-cert",
+      signedDigest: "test-signed-digest",
+    };
+
+    it("should sign document for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockResponse = { success: true };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await signDocument(signData);
+
+      expect(
+        helpers.validateOnBoardingSignDocumentData
+      ).toHaveBeenCalledWith(signData);
+      expect(httpRequest).toHaveBeenCalledWith(
+        `services/api/documents/sign/${signData.signature.id}`,
+        {
+          positions: JSON.stringify([
+            { x: 0.1, y: 0.2, page: 1, status: 1 },
+          ]),
+          publickey: signData.cert,
+          signeddigest: signData.signedDigest,
+        },
+        "PUT"
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(signDocument(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Document signing is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(signDocument(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("uploadSignatureVariant", () => {
+    beforeAll(() => {
+      // Define a global mock for File to simulate a browser environment
+      global.File = class MockFile {
+        constructor(parts, filename, options) {
+          this.type = options ? options.type : "";
+        }
+      };
+    });
+
+    afterAll(() => {
+      // Clean up the global mock
+      delete global.File;
+    });
+
+    it("should throw an error if data or data.file is not provided", async () => {
+      await expect(uploadSignatureVariant(null)).rejects.toThrow(
+        new ApacuanaAPIError("El parámetro 'file' es requerido.", 400, "INVALID_PARAMETER")
+      );
+      await expect(uploadSignatureVariant({})).rejects.toThrow(
+        new ApacuanaAPIError("El parámetro 'file' es requerido.", 400, "INVALID_PARAMETER")
+      );
+    });
+
+    it("should throw an error if file is not a File instance", async () => {
+      await expect(uploadSignatureVariant({ file: {} })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El parámetro 'file' debe ser una instancia de 'File'.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+
+    it("should throw an error if file is not a PNG", async () => {
+      const invalidFile = new File([], "test.txt", { type: "text/plain" });
+      await expect(uploadSignatureVariant({ file: invalidFile })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El archivo debe ser de tipo PNG (image/png).",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+
+    it("should upload file for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const validFile = new File([], "signature.png", { type: "image/png" });
+      const data = { file: validFile };
+      httpRequest.mockResolvedValue({ success: true, id: "123" });
+
+      const result = await uploadSignatureVariant(data);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/signaturephoto",
+        { file: validFile },
+        "POST"
+      );
+      expect(result).toEqual({ success: true, id: "123" });
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+      const validFile = new File([], "signature.png", { type: "image/png" });
+      await expect(uploadSignatureVariant({ file: validFile })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Uploading signature variants is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      const validFile = new File([], "signature.png", { type: "image/png" });
+      await expect(uploadSignatureVariant({ file: validFile })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("getSignatureVariant", () => {
+    it("should get signature variant for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+        customerId: "test-customer",
+      });
+      const mockResponse = { success: true, file: "base64-encoded-file" };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await getSignatureVariant();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/getsignaturephotosdk/test-customer",
+        {},
+        "GET"
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting signature variants is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(getSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("deleteSignatureVariant", () => {
+    it("should delete signature variant for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockResponse = { success: true, message: "Deleted" };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await deleteSignatureVariant();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/cleansignaturephoto",
+        {},
+        "DELETE"
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(deleteSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Deleting signature variants is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(deleteSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
 });