apacuana-sdk-core 1.0.0 → 1.1.0

package/tests/api/certs.test.js

@@ -0,0 +1,311 @@
+import { getConfig } from "../../src/config/index";
+import { httpRequest } from "../../src/utils/httpClient";
+import helpers from "../../src/utils/helpers";
+import { ApacuanaAPIError } from "../../src/errors";
+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");
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/utils/helpers");
+
+describe("Certificate API - certs.js", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("generateCert", () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    // TEST 1: Probar el camino feliz de ONBOARDING
+    it("should call generateCertOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockEncryptedCsr = { csr: "onboarding-csr" };
+      const mockApiResponse = {
+        cert: "onboarding-cert",
+        certifiedid: "onboarding-certified-id",
+      };
+      httpRequest.mockResolvedValue(mockApiResponse);
+
+      const result = await generateCert(mockEncryptedCsr);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/register/certificate", // Endpoint de Onboarding
+        mockEncryptedCsr,
+        "POST"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({
+        cert: "onboarding-cert",
+        certifiedid: "onboarding-certified-id",
+      });
+    });
+
+    // TEST 2: Probar el error de ONPREMISE
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Certificate generation is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    // TEST 3: Probar el error para un tipo inválido
+    it("should throw an error for an unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "INVALID_TYPE" });
+
+      await expect(generateCert("some-csr")).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: INVALID_TYPE",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    // Se eliminan los otros tests que asumían un comportamiento "estándar"
+  });
+
+  describe("getCertStatus", () => {
+    it("should return the certificate status from helpers", () => {
+      const mockUserData = { certStatus: "SOLICITUD" };
+      getConfig.mockReturnValue({
+        userData: mockUserData,
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      helpers.getCertificateStatus.mockReturnValue("SOLICITUD");
+
+      const result = getCertStatus(true);
+
+      expect(helpers.getCertificateStatus).toHaveBeenCalledWith(
+        mockUserData,
+        true,
+        INTEGRATION_TYPE.ONBOARDING
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+
+      // --- CORRECCIÓN AQUÍ: El objeto esperado debe estar anidado en la clave 'status' ---
+      expect(result.data).toEqual({
+        status: {
+          text: "Por verificar",
+          descriptionText:
+            "La información y documentos enviados están siendo revisados por la Autoridad de Registro.",
+        },
+      });
+    });
+  });
+
+  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,170 @@
+import {
+  createFaceLivenessSession,
+  validateFaceLiveness,
+} from "../../src/api/faceLiveness";
+import { httpRequest } from "../../src/utils/httpClient";
+import ApacuanaSuccess from "../../src/success";
+import { setConfig, getConfig } from "../../src/config";
+import { ApacuanaAPIError } from "../../src/errors";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/utils/httpClient", () => ({
+  httpRequest: jest.fn(),
+}));
+
+jest.mock("../../src/config", () => ({
+  getConfig: jest.fn(),
+  setConfig: 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 () => {
+      const mockSessionId = "session-onboarding-123";
+      httpRequest.mockResolvedValue({ sessionid: mockSessionId });
+      setConfig({ onboardingId: "some-onboarding-id" });
+
+      const result = await createFaceLivenessSession();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/faceliveness/create",
+        {},
+        "POST"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ sessionId: mockSessionId });
+    });
+
+    it("should throw an error if session ID is missing for ONBOARDING", async () => {
+      httpRequest.mockResolvedValue({}); // No sessionId
+
+      await expect(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(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(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(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(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(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 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 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(validateFaceLiveness({ sessionId })).rejects.toThrow(
+        apiError
+      );
+    });
+
+    it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(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

@@ -0,0 +1,119 @@
+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");
+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(
+        '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 params = { reasonCode: 1 };
+      const mockResponse = { success: true };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await requestRevocation(params);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/onboardingclient/requestcert",
+        { reason: params.reasonCode },
+        "POST"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
+    });
+
+    it("should throw a generic error if the httpRequest fails", async () => {
+      const params = { reasonCode: 1 };
+      const apiError = new Error("Something went wrong");
+      httpRequest.mockRejectedValue(apiError);
+
+      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 () => {
+      const mockReasons = [{ code: "01", description: "Test Reason" }];
+      httpRequest.mockResolvedValue({ records: mockReasons });
+
+      const result = await getRevocationReasons();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "config/api/revocation/reasonsonboarding",
+        {},
+        "GET"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ reasons: mockReasons });
+    });
+
+    it("should throw an error if the API response does not contain 'records'", async () => {
+      httpRequest.mockResolvedValue({ data: [] }); // Invalid response
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        new ApacuanaAPIError("Failed to fetch revocation reasons.")
+      );
+    });
+
+    it("should re-throw ApacuanaAPIError if caught", async () => {
+      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 () => {
+      const genericError = new Error("Something went wrong");
+      httpRequest.mockRejectedValue(genericError);
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        `Failed to get revocation reasons: ${genericError.message}`
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getRevocationReasons()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting revocation reasons is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+  });
+});