apacuana-sdk-core 0.11.0 → 0.12.0

package/tests/api/faceLiveness.test.js

@@ -1,8 +1,11 @@
-import * as faceLiveness from "../../src/api/faceLiveness";
+import {
+  createFaceLivenessSession,
+  validateFaceLiveness,
+} 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 { setConfig, getConfig } from "../../src/config";
+import { ApacuanaAPIError } from "../../src/errors";
 import { INTEGRATION_TYPE } from "../../src/utils/constant";
 
 jest.mock("../../src/utils/httpClient", () => ({
@@ -11,6 +14,7 @@ jest.mock("../../src/utils/httpClient", () => ({
 
 jest.mock("../../src/config", () => ({
   getConfig: jest.fn(),
+  setConfig: jest.fn(),
 }));
 
 describe("FaceLiveness API", () => {
@@ -21,23 +25,25 @@ describe("FaceLiveness API", () => {
 
   describe("createFaceLivenessSession", () => {
     it("should create a session for ONBOARDING integration", async () => {
-      httpRequest.mockResolvedValue({ sessionId: "test-session-id" });
+      const mockSessionId = "session-onboarding-123";
+      httpRequest.mockResolvedValue({ sessionid: mockSessionId });
+      setConfig({ onboardingId: "some-onboarding-id" });
 
-      const result = await faceLiveness.createFaceLivenessSession();
+      const result = await createFaceLivenessSession();
 
-      expect(result).toBeInstanceOf(ApacuanaSuccess);
-      expect(result.data).toEqual({ sessionId: "test-session-id" });
       expect(httpRequest).toHaveBeenCalledWith(
         "services/api/faceliveness/create",
         {},
         "POST"
       );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ sessionId: mockSessionId });
     });
 
-    it("should throw an error if API response does not contain sessionId for ONBOARDING", async () => {
+    it("should throw an error if session ID is missing for ONBOARDING", async () => {
       httpRequest.mockResolvedValue({}); // No sessionId
 
-      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+      await expect(createFaceLivenessSession()).rejects.toThrow(
         new ApacuanaAPIError(
           "The API response does not contain the session ID.",
           undefined,
@@ -51,7 +57,7 @@ describe("FaceLiveness API", () => {
         integrationType: INTEGRATION_TYPE.ONPREMISE,
       });
 
-      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+      await expect(createFaceLivenessSession()).rejects.toThrow(
         new ApacuanaAPIError(
           "Creating a Face Liveness session is not supported for integration type: ONPREMISE",
           501,
@@ -63,7 +69,7 @@ describe("FaceLiveness API", () => {
     it("should throw an UNSUPPORTED_INTEGRATION_TYPE error for unsupported integration types", async () => {
       getConfig.mockReturnValue({ integrationType: "unsupported-type" });
 
-      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+      await expect(createFaceLivenessSession()).rejects.toThrow(
         new ApacuanaAPIError(
           "Unsupported integration type: unsupported-type",
           400,
@@ -76,16 +82,14 @@ describe("FaceLiveness API", () => {
       const apiError = new ApacuanaAPIError("API Error", 500, "API_ERROR");
       httpRequest.mockRejectedValue(apiError);
 
-      await expect(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
-        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(faceLiveness.createFaceLivenessSession()).rejects.toThrow(
+      await expect(createFaceLivenessSession()).rejects.toThrow(
         `Failed to create Face Liveness session: ${genericError.message}`
       );
     });
@@ -95,7 +99,7 @@ describe("FaceLiveness API", () => {
     const sessionId = "test-session-id";
 
     it("should throw an error if sessionId is not provided", async () => {
-      await expect(faceLiveness.validateFaceLiveness({})).rejects.toThrow(
+      await expect(validateFaceLiveness({})).rejects.toThrow(
         new ApacuanaAPIError(
           "sessionId is a required parameter.",
           400,
@@ -107,7 +111,7 @@ describe("FaceLiveness API", () => {
     it("should return 'verified' on status 200", async () => {
       httpRequest.mockResolvedValue({ someData: "data" });
 
-      const result = await faceLiveness.validateFaceLiveness({ sessionId });
+      const result = await validateFaceLiveness({ sessionId });
 
       expect(result).toBeInstanceOf(ApacuanaSuccess);
       expect(result.data).toEqual({ status: "verified", someData: "data" });
@@ -126,14 +130,10 @@ describe("FaceLiveness API", () => {
     ])(
       "should return status '%s' for statusCode %i",
       async (statusCode, status) => {
-        const apiError = new ApacuanaAPIError(
-          "Error",
-          statusCode,
-          "API_ERROR"
-        );
+        const apiError = new ApacuanaAPIError("Error", statusCode, "API_ERROR");
         httpRequest.mockRejectedValue(apiError);
 
-        const result = await faceLiveness.validateFaceLiveness({ sessionId });
+        const result = await validateFaceLiveness({ sessionId });
 
         expect(result).toBeInstanceOf(ApacuanaSuccess);
         expect(result.data).toEqual({ status });
@@ -148,9 +148,9 @@ describe("FaceLiveness API", () => {
       );
       httpRequest.mockRejectedValue(apiError);
 
-      await expect(
-        faceLiveness.validateFaceLiveness({ sessionId })
-      ).rejects.toThrow(apiError);
+      await expect(validateFaceLiveness({ sessionId })).rejects.toThrow(
+        apiError
+      );
     });
 
     it("should throw a NOT_IMPLEMENTED error for ONPREMISE integration", async () => {
@@ -158,9 +158,7 @@ describe("FaceLiveness API", () => {
         integrationType: INTEGRATION_TYPE.ONPREMISE,
       });
 
-      await expect(
-        faceLiveness.validateFaceLiveness({ sessionId })
-      ).rejects.toThrow(
+      await expect(validateFaceLiveness({ sessionId })).rejects.toThrow(
         new ApacuanaAPIError(
           "Validating a Face Liveness session is not supported for integration type: ONPREMISE",
           501,
@@ -169,4 +167,4 @@ describe("FaceLiveness API", () => {
       );
     });
   });
-});
+});

package/tests/api/revocations.test.js

@@ -35,7 +35,7 @@ describe("Revocations API", () => {
       const result = await requestRevocation(params);
 
       expect(httpRequest).toHaveBeenCalledWith(
-        "services/api/certificate/revocation",
+        "services/api/onboardingclient/requestcert",
         params,
         "POST"
       );
@@ -64,18 +64,18 @@ describe("Revocations API", () => {
 
   describe("getRevocationReasons", () => {
     it("should make a GET request and return the reasons for ONBOARDING", async () => {
-      const mockReasons = [{ code: 1, reason: "Test Reason" }];
+      const mockReasons = [{ code: "01", description: "Test Reason" }];
       httpRequest.mockResolvedValue({ records: mockReasons });
 
       const result = await getRevocationReasons();
 
       expect(httpRequest).toHaveBeenCalledWith(
-        "services/api/certificate/revocation-reasons",
+        "config/api/revocation/reasonsonboarding",
         {},
         "GET"
       );
       expect(result).toBeInstanceOf(ApacuanaSuccess);
-      expect(result.data).toEqual(mockReasons);
+      expect(result.data).toEqual({ reasons: mockReasons });
     });
 
     it("should throw an error if the API response does not contain 'records'", async () => {

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);
   });
 });