apacuana-sdk-core 0.10.0 → 0.11.0

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",