apacuana-sdk-core 0.9.0 → 0.11.0

package/tests/api/certs.test.js

@@ -2,7 +2,14 @@ import { getConfig } from "../../src/config/index";
 import { httpRequest } from "../../src/utils/httpClient";
 import helpers from "../../src/utils/helpers";
 import { ApacuanaAPIError } from "../../src/errors";
-import { generateCert, getCertStatus } from "../../src/api/certs";
+import ApacuanaSuccess from "../../src/success";
+import {
+  generateCert,
+  getCertStatus,
+  getCertTypes,
+  getRequerimentsByTypeUser,
+  requestCertificate,
+} from "../../src/api/certs";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
 jest.mock("../../src/config/index");
@@ -38,10 +45,10 @@ describe("Certificate API - certs.js", () => {
         mockEncryptedCsr,
         "POST"
       );
-      expect(result).toEqual({
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({
         cert: "onboarding-cert",
         certifiedid: "onboarding-certified-id",
-        success: true,
       });
     });
 
@@ -88,7 +95,205 @@ describe("Certificate API - certs.js", () => {
         mockUserData,
         true
       );
-      expect(result).toEqual({ status: "VALID", success: true });
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ status: "VALID" });
     });
   });
+
+  describe("getCertTypes", () => {
+    it("should call getCertTypesOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockApiResponse = { types: [{ id: "1", name: "Type 1" }] };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await getCertTypes();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/typeusers",
+        {},
+        "GET"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ types: mockApiResponse.types });
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getCertTypes()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting certificate types is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(getCertTypes()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("getRequerimentsByTypeUser", () => {
+    it("should call getRequerimentsByTypeUserOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockApiResponse = {
+        requirements: [{ id: "1", description: "Requirement 1" }],
+      };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await getRequerimentsByTypeUser({ type: 1 });
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/documentspref?typeuser=1",
+        {},
+        "GET"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({
+        requirements: mockApiResponse.requirements,
+      });
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting requirements by user type is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should throw an error if params are invalid", async () => {
+      await expect(getRequerimentsByTypeUser()).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+      await expect(getRequerimentsByTypeUser({})).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+      await expect(getRequerimentsByTypeUser({ type: "1" })).rejects.toThrow(
+        'The "params" object with a numeric "type" property is required.'
+      );
+    });
+    it("should throw a generic error for other failures", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const genericError = new Error("Network failure");
+      httpRequest.mockRejectedValue(genericError);
+
+      await expect(getRequerimentsByTypeUser({ type: 1 })).rejects.toThrow(
+        `Failed to get requirements: ${genericError.message}`
+      );
+    });
+  });
+});
+
+describe("requestCertificate", () => {
+  const validParams = { type: 1, documents: [] };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should throw an error if params are invalid", async () => {
+    await expect(requestCertificate()).rejects.toThrow(
+      'The "params" object with a numeric "type" property and a "documents" array is required.'
+    );
+    await expect(requestCertificate({ type: 1 })).rejects.toThrow(
+      'The "params" object with a numeric "type" property and a "documents" array is required.'
+    );
+    await expect(requestCertificate({ documents: [] })).rejects.toThrow(
+      'The "params" object with a numeric "type" property and a "documents" array is required.'
+    );
+  });
+
+  it("should request a certificate for ONBOARDING integration", async () => {
+    getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
+    const mockResponse = { message: "Certificate requested" };
+    httpRequest.mockResolvedValue(mockResponse);
+
+    const result = await requestCertificate(validParams);
+
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
+    expect(result.data).toEqual(mockResponse);
+    expect(httpRequest).toHaveBeenCalledWith(
+      "services/api/customer/request-certificate",
+      validParams,
+      "POST"
+    );
+  });
+
+  it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
+    getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONPREMISE });
+
+    await expect(requestCertificate(validParams)).rejects.toThrow(
+      new ApacuanaAPIError(
+        "Requesting a certificate is not supported for integration type: ONPREMISE",
+        501,
+        "NOT_IMPLEMENTED"
+      )
+    );
+  });
+
+  it("should throw an UNSUPPORTED_INTEGRATION_TYPE error for unsupported integration types", async () => {
+    getConfig.mockReturnValue({ integrationType: "unsupported-type" });
+
+    await expect(requestCertificate(validParams)).rejects.toThrow(
+      new ApacuanaAPIError(
+        "Unsupported integration type: unsupported-type",
+        400,
+        "UNSUPPORTED_INTEGRATION_TYPE"
+      )
+    );
+  });
+
+  it("should re-throw ApacuanaAPIError if caught", async () => {
+    getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
+    const apiError = new ApacuanaAPIError("API Error", 500, "API_ERROR");
+    httpRequest.mockRejectedValue(apiError);
+
+    await expect(requestCertificate(validParams)).rejects.toThrow(apiError);
+  });
+
+  it("should throw a generic error for other failures", async () => {
+    getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
+    const genericError = new Error("Network failure");
+    httpRequest.mockRejectedValue(genericError);
+
+    await expect(requestCertificate(validParams)).rejects.toThrow(
+      `Failed to request certificate: ${genericError.message}`
+    );
+  });
 });

package/tests/api/faceLiveness.test.js

@@ -0,0 +1,172 @@
+import * as faceLiveness from "../../src/api/faceLiveness";
+import { httpRequest } from "../../src/utils/httpClient";
+import { getConfig } from "../../src/config";
+import { ApacuanaAPIError } from "../../src/errors";
+import ApacuanaSuccess from "../../src/success";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/utils/httpClient", () => ({
+  httpRequest: jest.fn(),
+}));
+
+jest.mock("../../src/config", () => ({
+  getConfig: jest.fn(),
+}));
+
+describe("FaceLiveness API", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
+  });
+
+  describe("createFaceLivenessSession", () => {
+    it("should create a session for ONBOARDING integration", async () => {
+      httpRequest.mockResolvedValue({ sessionId: "test-session-id" });
+
+      const result = await faceLiveness.createFaceLivenessSession();
+
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ sessionId: "test-session-id" });
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/faceliveness/create",
+        {},
+        "POST"
+      );
+    });
+
+    it("should throw an error if API response does not contain sessionId for ONBOARDING", async () => {
+      httpRequest.mockResolvedValue({}); // No sessionId
+
+      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "The API response does not contain the session ID.",
+          undefined,
+          "INVALID_API_RESPONSE"
+        )
+      );
+    });
+
+    it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Creating a Face Liveness session is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an UNSUPPORTED_INTEGRATION_TYPE error for unsupported integration types", async () => {
+      getConfig.mockReturnValue({ integrationType: "unsupported-type" });
+
+      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: unsupported-type",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should re-throw ApacuanaAPIError if caught during session creation", async () => {
+      const apiError = new ApacuanaAPIError("API Error", 500, "API_ERROR");
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+        apiError
+      );
+    });
+
+    it("should throw a generic error for other failures during session creation", async () => {
+      const genericError = new Error("Network Error");
+      httpRequest.mockRejectedValue(genericError);
+
+      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+        `Failed to create Face Liveness session: ${genericError.message}`
+      );
+    });
+  });
+
+  describe("validateFaceLiveness", () => {
+    const sessionId = "test-session-id";
+
+    it("should throw an error if sessionId is not provided", async () => {
+      await expect(faceLiveness.validateFaceLiveness({})).rejects.toThrow(
+        new ApacuanaAPIError(
+          "sessionId is a required parameter.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+
+    it("should return 'verified' on status 200", async () => {
+      httpRequest.mockResolvedValue({ someData: "data" });
+
+      const result = await faceLiveness.validateFaceLiveness({ sessionId });
+
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ status: "verified", someData: "data" });
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/faceliveness/validate",
+        { sessionid: sessionId },
+        "POST"
+      );
+    });
+
+    it.each([
+      [402, "waitingForScan"],
+      [403, "rejected"],
+      [406, "processing"],
+      [408, "expired"],
+    ])(
+      "should return status '%s' for statusCode %i",
+      async (statusCode, status) => {
+        const apiError = new ApacuanaAPIError(
+          "Error",
+          statusCode,
+          "API_ERROR"
+        );
+        httpRequest.mockRejectedValue(apiError);
+
+        const result = await faceLiveness.validateFaceLiveness({ sessionId });
+
+        expect(result).toBeInstanceOf(ApacuanaSuccess);
+        expect(result.data).toEqual({ status });
+      }
+    );
+
+    it("should throw an error for unhandled status codes", async () => {
+      const apiError = new ApacuanaAPIError(
+        "Unhandled Error",
+        500,
+        "API_ERROR"
+      );
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(
+        faceLiveness.validateFaceLiveness({ sessionId })
+      ).rejects.toThrow(apiError);
+    });
+
+    it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(
+        faceLiveness.validateFaceLiveness({ sessionId })
+      ).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Validating a Face Liveness session is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+  });
+});

package/tests/api/revocations.test.js

@@ -1,10 +1,11 @@
-import { httpRequest } from "../../src/utils/httpClient";
-import { ApacuanaAPIError } from "../../src/errors";
 import {
   requestRevocation,
   getRevocationReasons,
 } from "../../src/api/revocations";
+import { httpRequest } from "../../src/utils/httpClient";
 import { getConfig } from "../../src/config";
+import { ApacuanaAPIError } from "../../src/errors";
+import ApacuanaSuccess from "../../src/success";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
 jest.mock("../../src/utils/httpClient");
@@ -13,67 +14,72 @@ jest.mock("../../src/config");
 describe("Revocations API", () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    getConfig.mockReturnValue({ integrationType: INTEGRATION_TYPE.ONBOARDING });
   });
 
   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."
+        'The "params" object with a numeric "reasonCode" property is required.'
+      );
+      await expect(requestRevocation({})).rejects.toThrow(
+        'The "params" object with a numeric "reasonCode" property is required.'
       );
     });
 
     it("should make a POST request to the correct endpoint with the reasonCode", async () => {
-      const reasonCode = "COMPROMISED";
-      const mockResponse = { success: true, message: "Revocation requested" };
+      const params = { reasonCode: 1 };
+      const mockResponse = { success: true };
       httpRequest.mockResolvedValue(mockResponse);
 
-      const result = await requestRevocation(reasonCode);
+      const result = await requestRevocation(params);
 
       expect(httpRequest).toHaveBeenCalledWith(
-        "services/api/onboardingclient/requestcert",
-        { reason: reasonCode },
+        "services/api/certificate/revocation",
+        params,
         "POST"
       );
-      expect(result).toEqual(mockResponse);
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
     });
 
     it("should throw a generic error if the httpRequest fails", async () => {
-      const reasonCode = "COMPROMISED";
-      const apiError = new Error("Network error");
+      const params = { reasonCode: 1 };
+      const apiError = new Error("Something went wrong");
       httpRequest.mockRejectedValue(apiError);
 
-      await expect(requestRevocation(reasonCode)).rejects.toThrow(
-        `Fallo en la solicitud de revocación: ${apiError.message}`
+      await expect(requestRevocation(params)).rejects.toThrow(
+        `Failed to request revocation: ${apiError.message}`
       );
     });
+
+    it("should re-throw ApacuanaAPIError if caught", async () => {
+      const params = { reasonCode: 1 };
+      const apiError = new ApacuanaAPIError("API Error");
+      httpRequest.mockRejectedValue(apiError);
+
+      await expect(requestRevocation(params)).rejects.toThrow(apiError);
+    });
   });
 
   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" },
-      ];
+      const mockReasons = [{ code: 1, reason: "Test Reason" }];
       httpRequest.mockResolvedValue({ records: mockReasons });
 
       const result = await getRevocationReasons();
 
       expect(httpRequest).toHaveBeenCalledWith(
-        "GET",
-        "config/api/revocation/reasonsonboarding",
-        {}
+        "services/api/certificate/revocation-reasons",
+        {},
+        "GET"
       );
-      expect(result).toEqual(mockReasons);
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).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
+      httpRequest.mockResolvedValue({ data: [] }); // Invalid response
 
       await expect(getRevocationReasons()).rejects.toThrow(
         new ApacuanaAPIError("Failed to fetch revocation reasons.")
@@ -81,24 +87,18 @@ describe("Revocations API", () => {
     });
 
     it("should re-throw ApacuanaAPIError if caught", async () => {
-      getConfig.mockReturnValue({
-        integrationType: INTEGRATION_TYPE.ONBOARDING,
-      });
-      const apiError = new ApacuanaAPIError("API is down", 500);
+      const apiError = new ApacuanaAPIError("API Error");
       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."
+        `Failed to get revocation reasons: ${genericError.message}`
       );
     });
 
@@ -109,7 +109,7 @@ describe("Revocations API", () => {
 
       await expect(getRevocationReasons()).rejects.toThrow(
         new ApacuanaAPIError(
-          "Get revocation reasons is not supported for integration type: ONPREMISE",
+          "Getting revocation reasons is not supported for integration type: ONPREMISE",
           501,
           "NOT_IMPLEMENTED"
         )

package/tests/api/signatures.test.js

@@ -1,6 +1,7 @@
 import { getConfig } from "../../src/config";
 import { httpRequest } from "../../src/utils/httpClient";
 import { ApacuanaAPIError } from "../../src/errors";
+import ApacuanaSuccess from "../../src/success";
 import {
   addSigner,
   getDocs,
@@ -184,7 +185,8 @@ describe("API - Signatures", () => {
         { publickey: signData.cert },
         "POST"
       );
-      expect(result).toEqual({ digest: "test-digest", success: true });
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ digest: "test-digest" });
     });
 
     it("should throw an error if digest is not in response for ONBOARDING", async () => {
@@ -257,7 +259,8 @@ describe("API - Signatures", () => {
         },
         "PUT"
       );
-      expect(result).toEqual(mockResponse);
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
     });
 
     it("should throw not implemented for ONPREMISE integration", async () => {
@@ -346,7 +349,8 @@ describe("API - Signatures", () => {
         { file: validFile },
         "POST"
       );
-      expect(result).toEqual({ success: true, id: "123" });
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ success: true, id: "123" });
     });
 
     it("should throw not implemented for ONPREMISE integration", async () => {
@@ -392,7 +396,8 @@ describe("API - Signatures", () => {
         {},
         "GET"
       );
-      expect(result).toEqual(mockResponse);
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
     });
 
     it("should throw not implemented for ONPREMISE integration", async () => {
@@ -436,7 +441,8 @@ describe("API - Signatures", () => {
         {},
         "DELETE"
       );
-      expect(result).toEqual(mockResponse);
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
     });
 
     it("should throw not implemented for ONPREMISE integration", async () => {

package/tests/api/users.test.js

@@ -3,6 +3,7 @@ import { httpRequest } from "../../src/utils/httpClient.js";
 import { getConfig } from "../../src/config/index.js";
 import { ApacuanaAPIError } from "../../src/errors/index.js";
 import getCustomer from "../../src/api/users.js";
+import ApacuanaSuccess from "../../src/success/index.js";
 
 // Mockear las dependencias:
 jest.mock("../../src/utils/httpClient.js", () => ({
@@ -56,8 +57,8 @@ describe("getCustomer", () => {
       "POST"
     );
 
-    expect(result).toEqual({
-      success: true,
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
+    expect(result.data).toEqual({
       token: "mock-session-id-12345",
       userData: {
         userId: "mock-user",