apacuana-sdk-core 0.2.0 → 0.3.0

package/tests/api/certs.test.js

@@ -1,128 +1,112 @@
-import { generateCert, getCertStatus } from "../../src/api/certs";
-import { getConfig } from "../../src/config";
+import { getConfig } from "../../src/config/index";
 import { httpRequest } from "../../src/utils/httpClient";
+import helpers from "../../src/utils/helpers";
 import { ApacuanaAPIError } from "../../src/errors";
-import {
-  INTEGRATION_TYPE,
-  STATUS_CERTIFICATE,
-} from "../../src/utils/constant";
+import { generateCert, getCertStatus } from "../../src/api/certs";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
+jest.mock("../../src/config/index");
 jest.mock("../../src/utils/httpClient");
-jest.mock("../../src/config");
+jest.mock("../../src/utils/helpers");
 
-describe("API de Certificados - certs.js", () => {
-  const validBase64Csr = "dGVzdA=="; // "test" in base64
-
-  afterEach(() => {
+describe("Certificate API - certs.js", () => {
+  beforeEach(() => {
     jest.clearAllMocks();
   });
 
   describe("generateCert", () => {
-    it("debería generar un certificado con éxito para ONBOARDING", async () => {
-      const mockResponse = { cert: "new-cert", success: true };
-      httpRequest.mockResolvedValue(mockResponse);
+    it("should generate a certificate for ONBOARDING integration", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONBOARDING,
       });
+      helpers.encryptedCsr.mockReturnValue("encrypted-csr");
+      httpRequest.mockResolvedValue({ cert: "new-cert", success: true });
 
-      const result = await generateCert(validBase64Csr);
+      const result = await generateCert("some-csr");
 
-      expect(result).toEqual(mockResponse);
+      expect(helpers.validateCsr).toHaveBeenCalledWith("some-csr");
+      expect(helpers.encryptedCsr).toHaveBeenCalledWith("some-csr");
       expect(httpRequest).toHaveBeenCalledWith(
         "services/api/register/certificate",
-        expect.any(Object),
+        "encrypted-csr",
         "POST"
       );
+      expect(result).toEqual({ cert: "new-cert", success: true });
     });
 
-    it("debería lanzar un error si el CSR no se proporciona", async () => {
+    it("should throw an error if API response does not contain a certificate", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONBOARDING,
       });
-      await expect(generateCert()).rejects.toThrow(
+      helpers.encryptedCsr.mockReturnValue("encrypted-csr");
+      httpRequest.mockResolvedValue({ success: false });
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
         new ApacuanaAPIError(
-          "La solicitud de firma de certificado (CSR) es requerida.",
-          400,
-          "CSR_REQUIRED"
+          "The API response does not contain the certificate.",
+          undefined,
+          "INVALID_API_RESPONSE"
         )
       );
     });
 
-    it("debería lanzar un error si el CSR no es un string", async () => {
+    it("should throw an error for ONPREMISE", async () => {
       getConfig.mockReturnValue({
-        integrationType: INTEGRATION_TYPE.ONBOARDING,
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
       });
-      await expect(generateCert(12345)).rejects.toThrow(
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
         new ApacuanaAPIError(
-          "El CSR debe ser una cadena de texto válida y no puede estar vacía.",
-          400,
-          "INVALID_CSR_FORMAT"
+          "Certificate generation is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
         )
       );
     });
 
-    it("debería lanzar un error si el CSR no está en formato Base64", async () => {
-      getConfig.mockReturnValue({
-        integrationType: INTEGRATION_TYPE.ONBOARDING,
-      });
-      await expect(generateCert("csr-invalido")).rejects.toThrow(
-        new ApacuanaAPIError(
-          "El CSR debe estar codificado en formato base64 válido.",
-          400,
-          "INVALID_CSR_ENCODING"
-        )
+    it("should throw an error if integration type is not supported", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        "Unsupported integration type: INVALID_TYPE"
       );
     });
 
-    it("debería manejar la lógica para ONPREMISE", async () => {
-      getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONPREMISE });
-      const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => {});
-      await generateCert(validBase64Csr);
-      expect(consoleSpy).toHaveBeenCalledWith("-> Lógica para On-premise");
-      consoleSpy.mockRestore();
-    });
+    it("should re-throw ApacuanaAPIError if httpRequest fails", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const apiError = new ApacuanaAPIError("API Error", 500, "API_ERROR");
+      httpRequest.mockRejectedValue(apiError);
 
-    it("debería lanzar un error para tipos de integración no soportados", async () => {
-      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED_TYPE" });
-      await expect(generateCert(validBase64Csr)).rejects.toThrow(
-        new ApacuanaAPIError(
-          "Tipo de integración no soportado: UNSUPPORTED_TYPE",
-          400,
-          "UNSUPPORTED_INTEGRATION_TYPE"
-        )
-      );
+      await expect(generateCert("some-csr")).rejects.toThrow(apiError);
     });
 
-    it("debería lanzar un ApacuanaAPIError si la respuesta de la API no contiene el certificado", async () => {
-      httpRequest.mockResolvedValue({ success: true }); // No 'cert' property
+    it("should throw a generic error if something else fails", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONBOARDING,
       });
+      const genericError = new Error("Something failed");
+      httpRequest.mockRejectedValue(genericError);
 
-      await expect(generateCert(validBase64Csr)).rejects.toThrow(
-        new ApacuanaAPIError(
-          "La respuesta de la API no contiene el certificado.",
-          undefined,
-          "INVALID_API_RESPONSE"
-        )
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        "Certificate generation failed: Something failed"
       );
     });
   });
 
   describe("getCertStatus", () => {
-    it("debería devolver el estado del certificado correctamente", () => {
-      const mockUserData = {
-        cert: "some-cert-data",
-        verificationstatus: { id: 1 }, // VERIFICATION_STATUS.APPROVED
-        certificationId: "some-cert-id",
-        approvedUser: true,
-      };
+    it("should return the certificate status from helpers", () => {
+      const mockUserData = { certStatus: "VALID" };
       getConfig.mockReturnValue({ userData: mockUserData });
+      helpers.getCertificateStatus.mockReturnValue("VALID");
+
       const result = getCertStatus(true);
-      expect(result).toEqual({
-        status: STATUS_CERTIFICATE.current,
-        success: true,
-      });
+
+      expect(helpers.getCertificateStatus).toHaveBeenCalledWith(
+        mockUserData,
+        true
+      );
+      expect(result).toEqual({ status: "VALID", success: true });
     });
   });
-});
+});

package/tests/api/signatures.test.js

@@ -1,7 +1,7 @@
 import { getConfig } from "../../src/config";
 import { httpRequest } from "../../src/utils/httpClient";
 import { ApacuanaAPIError } from "../../src/errors";
-import { addSigner, getDocs } from "../../src/api/signatures";
+import { addSigner, getDocs, getDigest, signDocument } from "../../src/api/signatures";
 import helpers from "../../src/utils/helpers";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
@@ -13,6 +13,7 @@ jest.mock("../../src/utils/helpers", () => ({
   validateSignOnPremiseData: jest.fn(),
   signDigest: jest.fn(),
   validateGetDocsData: jest.fn(),
+  validateGetDigestData: jest.fn(),
 }));
 
 describe("API - Signatures", () => {
@@ -38,18 +39,19 @@ describe("API - Signatures", () => {
       );
     });
 
-    it("should call addSignerOnPremise for ONPREMISE integration", async () => {
+    it("should throw not implemented for ONPREMISE integration", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONPREMISE,
       });
       const signerData = { name: "John Doe" };
 
-      const result = await addSigner(signerData);
-
-      expect(result).toEqual({
-        signerId: "on-premise-signer-id",
-        status: "added",
-      });
+      await expect(addSigner(signerData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Adding signers is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
     });
 
     it("should throw an error for unsupported integration type", async () => {
@@ -57,7 +59,7 @@ describe("API - Signatures", () => {
       const signerData = { name: "test" };
       await expect(addSigner(signerData)).rejects.toThrow(
         new ApacuanaAPIError(
-          "Tipo de integración no soportado: UNSUPPORTED",
+          "Unsupported integration type: UNSUPPORTED",
           400,
           "UNSUPPORTED_INTEGRATION_TYPE"
         )
@@ -67,70 +69,13 @@ describe("API - Signatures", () => {
     it("should throw an error if signerData is invalid", async () => {
       await expect(addSigner(null)).rejects.toThrow(
         new ApacuanaAPIError(
-          "Los datos del firmante (signerData) son requeridos y deben ser un objeto no vacío.",
-          400,
-          "INVALID_PARAMETER"
-        )
-      );
-    });
-  });
-
-  /*
-  describe("signDocument", () => {
-    const onBoardingData = {
-      documentData: { id: "doc1" },
-      signatureData: { id: "sig1" },
-    };
-    const onPremiseData = {
-      signature: { id: "sig1", positions: [] },
-      cert: "my-cert",
-      privateKey: "my-key",
-    };
-
-    it("should call signDocumentOnBoarding for ONBOARDING integration", async () => {
-      getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
-      const mockResponse = {
-        success: true,
-        id: "signed-doc-id",
-        message: "Firmado",
-      };
-      httpRequest.mockResolvedValue(mockResponse);
-
-      const result = await signDocument(onBoardingData);
-
-      expect(httpRequest).toHaveBeenCalledWith(
-        "/docs/sign",
-        onBoardingData,
-        "POST"
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it("should throw TypeError for ONPREMISE integration due to implementation issue", async () => {
-      getConfig.mockReturnValue({
-        integrationType: INTEGRATION_TYPE.ONPREMISE,
-      });
-      httpRequest
-        .mockResolvedValueOnce({ data: { digest: "test-digest" } })
-        .mockResolvedValueOnce({ data: "signed-response" });
-      helpers.signDigest.mockResolvedValue("signed-digest");
-
-      await expect(signDocument(onPremiseData)).rejects.toThrow(
-        "Fallo en la firma del documento (on-premise): Cannot read properties of undefined (reading 'map')"
-      );
-    });
-
-    it("should throw an error if data is invalid", async () => {
-      await expect(signDocument({})).rejects.toThrow(
-        new ApacuanaAPIError(
-          "El parámetro 'data' es requerido y debe ser un objeto no vacío.",
+          "Signer data (signerData) is required and must be a non-empty object.",
           400,
           "INVALID_PARAMETER"
         )
       );
     });
   });
-  */
 
   describe("getDocs", () => {
     const paginationData = { page: 1, size: 10 };
@@ -153,7 +98,7 @@ describe("API - Signatures", () => {
       );
     });
 
-    it("should throw an error for ONPREMISE integration due to implementation issue", async () => {
+    it("should throw an error for ONPREMISE integration", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONPREMISE,
         customerId: "test-customer",
@@ -161,13 +106,13 @@ describe("API - Signatures", () => {
       httpRequest.mockResolvedValue({ docs: [] });
 
       await expect(getDocs(paginationData)).rejects.toThrow(
-        "La obtención de documentos no está soportada para el tipo de integración: ONBOARDING"
+        "Document retrieval is not supported for integration type: ONBOARDING"
       );
     });
 
     it("should throw an error if page or size are missing", async () => {
       const validationError = new ApacuanaAPIError(
-        "Los parámetros 'page' y 'size' son requeridos.",
+        "Parameters 'page' and 'size' are required.",
         400,
         "INVALID_PARAMETER"
       );
@@ -180,7 +125,7 @@ describe("API - Signatures", () => {
 
     it("should throw an error if status is invalid", async () => {
       const validationError = new ApacuanaAPIError(
-        "El parámetro 'status' no es válido.",
+        "Parameter 'status' is not valid.",
         400,
         "INVALID_PARAMETER"
       );
@@ -193,13 +138,13 @@ describe("API - Signatures", () => {
       );
     });
 
-    it("should throw an error for non-on-premise integrations", async () => {
+    it("should throw an error for non-on-premise integrations when customerId is missing", async () => {
       getConfig.mockReturnValue({
         integrationType: INTEGRATION_TYPE.ONBOARDING,
       });
       await expect(getDocs(paginationData)).rejects.toThrow(
         new ApacuanaAPIError(
-          "El 'customerId' no está configurado. Por favor, configure el SDK.",
+          "'customerId' is not configured. Please configure the SDK.",
           400,
           "CONFIGURATION_ERROR"
         )

package/tests/api/users.test.js

@@ -67,34 +67,34 @@ describe("getCustomer", () => {
     });
   });
 
-  test("debe lanzar un error si la configuración está incompleta", async () => {
+  test("should throw an error if configuration is incomplete", async () => {
     getConfig.mockReturnValue({
       verificationId: "mock-verify-id",
       customerId: null,
     });
 
     await expect(getCustomer()).rejects.toThrow(
-      "El 'body' con 'userId' es un parámetro requerido para getCustomer."
+      "Both 'verificationId' and 'customerId' must be configured."
     );
     expect(httpRequest).not.toHaveBeenCalled();
   });
 
-  test("debe lanzar un ApacuanaAPIError si el backend no devuelve sessionid o entry", async () => {
+  test("should throw ApacuanaAPIError if backend does not return sessionid or entry", async () => {
     httpRequest.mockResolvedValueOnce({
       success: true,
-      message: "Error en el backend, no se pudo generar el token.",
+      message: "Backend error, token could not be generated.",
       entry: { userId: "mock-user" },
     });
 
     await expect(getCustomer()).rejects.toThrow(
-      "La respuesta de la API no contiene el usuario."
+      "The API response does not contain the user."
     );
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });
 
-  test("debe relanzar el ApacuanaAPIError si la petición falla en el httpClient", async () => {
+  test("should rethrow ApacuanaAPIError if httpClient request fails", async () => {
     const apiError = new ApacuanaAPIError(
-      "Error de autenticación",
+      "Authentication error",
       401,
       "AUTH_ERROR"
     );
@@ -104,12 +104,12 @@ describe("getCustomer", () => {
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });
 
-  test("debe lanzar un ApacuanaAPIError si ocurre un error inesperado", async () => {
-    const genericError = new Error("Error de red o desconocido");
+  test("should throw ApacuanaAPIError on unexpected error", async () => {
+    const genericError = new Error("Network or unknown error");
     httpRequest.mockRejectedValueOnce(genericError);
 
     await expect(getCustomer()).rejects.toThrow(
-      "Fallo inesperado al obtener el token: Error de red o desconocido"
+      "Unexpected failure getting token: Network or unknown error"
     );
     expect(httpRequest).toHaveBeenCalledTimes(1);
   });