apacuana-sdk-core 0.10.0 → 0.12.0

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

@@ -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 },
+        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: "01", description: "Test Reason" }];
       httpRequest.mockResolvedValue({ records: mockReasons });
 
       const result = await getRevocationReasons();
 
       expect(httpRequest).toHaveBeenCalledWith(
-        "GET",
         "config/api/revocation/reasonsonboarding",
-        {}
+        {},
+        "GET"
       );
-      expect(result).toEqual(mockReasons);
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ reasons: 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",

package/tests/index.test.js

@@ -1,8 +1,9 @@
 // tests/index.test.js
 import apacuana from "../src/index.js";
 import { setConfig, getConfig } from "../src/config/index.js";
-import { initHttpClient } from "../src/utils/httpClient.js";
+import { initHttpClient, setAuthToken } from "../src/utils/httpClient.js";
 import getCustomer from "../src/api/users.js";
+import ApacuanaSuccess from "../src/success/index.js";
 
 // Mockear todas las dependencias del index.js
 jest.mock("../src/config/index.js", () => ({
@@ -36,8 +37,11 @@ describe("Apacuana SDK Initialization (init)", () => {
 
     // Mockear la respuesta exitosa de getCustomer para la mayoría de las pruebas.
     getCustomer.mockResolvedValue({
-      token: "mock-session-token",
-      userData: { id: "mock-user-id" }
+      success: true,
+      data: {
+        token: "mock-session-token",
+        userData: { id: "mock-user-id" },
+      },
     });
 
     // Opcional: Mockear console.log para no ensuciar la consola durante las pruebas.
@@ -63,8 +67,12 @@ describe("Apacuana SDK Initialization (init)", () => {
     // 3. Verificar que getCustomer fue llamado.
     expect(getCustomer).toHaveBeenCalledWith();
 
-    // 4. Verificar que se retorna true al finalizar la inicialización.
-    expect(result).toBe(true);
+    // 4. Verificar que se retorna una instancia de ApacuanaSuccess al finalizar la inicialización.
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
+    expect(result.data).toEqual({
+      initialized: true,
+      message: "SDK inicializado correctamente.",
+    });
 
     // 5. Verificar que las funciones se llamaron el número correcto de veces.
     expect(setConfig).toHaveBeenCalledTimes(2); // Una vez inicial, una vez para guardar token
@@ -113,10 +121,10 @@ describe("Apacuana SDK Initialization (init)", () => {
     expect(setConfig).toHaveBeenLastCalledWith({
       ...mockConfig,
       token: "mock-session-token",
-      userData: { id: "mock-user-id" }
+      userData: { id: "mock-user-id" },
     });
 
-    // Verificar que el token es devuelto.
-    expect(result).toBe(true);
+    // Verificar que la respuesta es una instancia de ApacuanaSuccess.
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
   });
 });