apacuana-sdk-core 1.0.0 → 1.2.0

package/tests/api/signatures.test.js

@@ -0,0 +1,530 @@
+import { getConfig } from "../../src/config";
+import { httpRequest } from "../../src/utils/httpClient";
+import { ApacuanaAPIError } from "../../src/errors";
+import ApacuanaSuccess from "../../src/success";
+import {
+  addSigner,
+  getDocs,
+  getDigest,
+  signDocument,
+  uploadSignatureVariant,
+  getSignatureVariant,
+  deleteSignatureVariant,
+} from "../../src/api/signatures";
+import helpers from "../../src/utils/helpers";
+import { INTEGRATION_TYPE } from "../../src/utils/constant";
+
+jest.mock("../../src/config");
+jest.mock("../../src/utils/httpClient");
+jest.mock("../../src/utils/helpers", () => ({
+  validateOnBoardingSignerData: jest.fn(),
+  validateSignOnBoardingData: jest.fn(),
+  validateSignOnPremiseData: jest.fn(),
+  signDigest: jest.fn(),
+  validateGetDocsData: jest.fn(),
+  validateGetDigestData: jest.fn(),
+  validateOnBoardingSignDocumentData: jest.fn(),
+  createPayloadGetDigest: jest.fn(),
+}));
+
+describe("API - Signatures", () => {
+  beforeAll(() => {
+    // FormData no existe en el entorno de Node.js de Jest.
+    // Creamos una simulación (mock) que incluye los métodos 'append' y 'forEach'.
+    global.FormData = class FormData {
+      constructor() {
+        this.data = new Map();
+      }
+      append(key, value) {
+        this.data.set(key, value);
+      }
+      forEach(callback) {
+        // Delegamos la llamada forEach al Map interno.
+        this.data.forEach((value, key) => callback(value, key));
+      }
+    };
+  });
+
+  afterAll(() => {
+    // Limpiamos la simulación global después de las pruebas.
+    delete global.FormData;
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("addSigner", () => {
+    it("should call addSignerOnBoarding for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const signerData = { typedoc: "V", doc: "12345678" };
+
+      const formData = new FormData();
+      formData.append("typedoc", "V");
+      formData.append("doc", "12345678");
+
+      helpers.validateOnBoardingSignerData.mockReturnValue(formData);
+      httpRequest.mockResolvedValue({ success: true });
+
+      await addSigner(signerData);
+
+      expect(helpers.validateOnBoardingSignerData).toHaveBeenCalledWith(
+        signerData
+      );
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/documents/signingsdk",
+        formData,
+        "POST"
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+      const signerData = { name: "John Doe" };
+
+      await expect(addSigner(signerData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Adding signers is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      const signerData = { name: "test" };
+      await expect(addSigner(signerData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+
+    it("should throw an error if signerData is invalid", async () => {
+      await expect(addSigner(null)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Signer data (signerData) is required and must be a non-empty object.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+  });
+
+  describe("getDocs", () => {
+    const paginationData = { page: 1, size: 10 };
+
+    it("should call httpRequest with correct URL when status is provided", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+        customerId: "test-customer",
+      });
+      const dataWithStatus = { ...paginationData, status: 1 };
+      httpRequest.mockResolvedValue({ docs: [] });
+
+      await getDocs(dataWithStatus);
+
+      expect(helpers.validateGetDocsData).toHaveBeenCalledWith(dataWithStatus);
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/documents/listcustomer?page=1&customerid=test-customer&size=10&status=1",
+        {},
+        "GET"
+      );
+    });
+
+    it("should throw an error for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+        customerId: "test-customer",
+      });
+      httpRequest.mockResolvedValue({ docs: [] });
+
+      await expect(getDocs(paginationData)).rejects.toThrow(
+        "Document retrieval is not supported for integration type: ONPREMISE"
+      );
+    });
+
+    it("should throw an error if page or size are missing", async () => {
+      const validationError = new ApacuanaAPIError(
+        "Parameters 'page' and 'size' are required.",
+        400,
+        "INVALID_PARAMETER"
+      );
+      helpers.validateGetDocsData.mockImplementation(() => {
+        throw validationError;
+      });
+
+      await expect(getDocs({})).rejects.toThrow(validationError);
+    });
+
+    it("should throw an error if status is invalid", async () => {
+      const validationError = new ApacuanaAPIError(
+        "Parameter 'status' is not valid.",
+        400,
+        "INVALID_PARAMETER"
+      );
+      helpers.validateGetDocsData.mockImplementationOnce(() => {
+        throw validationError;
+      });
+
+      await expect(getDocs({ ...paginationData, status: 99 })).rejects.toThrow(
+        validationError
+      );
+    });
+
+    it("should throw an error for non-on-premise integrations when customerId is missing", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      await expect(getDocs(paginationData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "'customerId' is not configured. Please configure the SDK.",
+          400,
+          "CONFIGURATION_ERROR"
+        )
+      );
+    });
+  });
+
+  describe("getDigest", () => {
+    const signData = {
+      cert: "test-cert",
+      signatureId: "test-signature-id",
+    };
+
+    it("should get digest for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockResponse = { data: { digest: "test-digest" } };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const expectedFormData = new FormData();
+      expectedFormData.append("publickey", "test-cert");
+      helpers.createPayloadGetDigest.mockReturnValue(expectedFormData);
+
+      const result = await getDigest(signData);
+
+      expect(helpers.validateGetDigestData).toHaveBeenCalledWith(signData);
+      expect(helpers.createPayloadGetDigest).toHaveBeenCalledWith(signData);
+      expect(httpRequest).toHaveBeenCalledWith(
+        `services/api/documents/getdigest/${signData.signatureId}`,
+        expectedFormData,
+        "POST"
+      );
+      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 () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      httpRequest.mockResolvedValue({ data: {} });
+
+      await expect(getDigest(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Signature generation failed: digest not found in the response.",
+          500,
+          "API_RESPONSE_ERROR"
+        )
+      );
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getDigest(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Digest retrieval is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(getDigest(signData)).rejects.toThrow(
+        "Document retrieval is not supported for an unknown integration type: UNSUPPORTED"
+      );
+    });
+  });
+
+  describe("signDocument", () => {
+    const signData = {
+      signature: {
+        id: "test-signature-id",
+        positions: [{ x: 0.1, y: 0.2, page: 1 }],
+      },
+      cert: "test-cert",
+      signedDigest: "test-signed-digest",
+    };
+
+    it("should sign document for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockResponse = { success: true };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const expectedFormData = new FormData();
+      expectedFormData.append(
+        "positions",
+        JSON.stringify(
+          signData.signature.positions.map((p) => ({
+            x: p.x,
+            y: p.y,
+            page: p.page,
+            status: 1,
+          }))
+        )
+      );
+      expectedFormData.append("publickey", signData.cert);
+      expectedFormData.append("signeddigest", signData.signedDigest);
+
+      helpers.validateOnBoardingSignDocumentData.mockReturnValue(
+        expectedFormData
+      );
+
+      const result = await signDocument(signData);
+
+      expect(helpers.validateOnBoardingSignDocumentData).toHaveBeenCalledWith(
+        signData
+      );
+      expect(httpRequest).toHaveBeenCalledWith(
+        `services/api/documents/sign/${signData.signature.id}`,
+        expectedFormData,
+        "PUT"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(signDocument(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Document signing is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(signDocument(signData)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("uploadSignatureVariant", () => {
+    beforeAll(() => {
+      // Define a global mock for File to simulate a browser environment
+      global.File = class MockFile {
+        constructor(parts, filename, options) {
+          this.type = options ? options.type : "";
+        }
+      };
+    });
+
+    afterAll(() => {
+      // Clean up the global mock
+      delete global.File;
+    });
+
+    it("should throw an error if data or data.file is not provided", async () => {
+      await expect(uploadSignatureVariant(null)).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El parámetro 'file' es requerido.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+      await expect(uploadSignatureVariant({})).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El parámetro 'file' es requerido.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+
+    it("should throw an error if file is not a File instance", async () => {
+      await expect(uploadSignatureVariant({ file: {} })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El parámetro 'file' debe ser una instancia de 'File'.",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+
+    it("should throw an error if file is not a PNG", async () => {
+      const invalidFile = new File([], "test.txt", { type: "text/plain" });
+      await expect(
+        uploadSignatureVariant({ file: invalidFile })
+      ).rejects.toThrow(
+        new ApacuanaAPIError(
+          "El archivo debe ser de tipo PNG (image/png).",
+          400,
+          "INVALID_PARAMETER"
+        )
+      );
+    });
+
+    it("should upload file for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const validFile = new File([], "signature.png", { type: "image/png" });
+      const data = { file: validFile };
+      httpRequest.mockResolvedValue({ success: true, id: "123" });
+
+      const result = await uploadSignatureVariant(data);
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/signaturephoto",
+        { file: validFile },
+        "POST"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual({ success: true, id: "123" });
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+      const validFile = new File([], "signature.png", { type: "image/png" });
+      await expect(uploadSignatureVariant({ file: validFile })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Uploading signature variants is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      const validFile = new File([], "signature.png", { type: "image/png" });
+      await expect(uploadSignatureVariant({ file: validFile })).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("getSignatureVariant", () => {
+    it("should get signature variant for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+        customerId: "test-customer",
+      });
+      const mockResponse = { success: true, file: "base64-encoded-file" };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await getSignatureVariant();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/getsignaturephotosdk/test-customer",
+        {},
+        "GET"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(getSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Getting signature variants is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(getSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+
+  describe("deleteSignatureVariant", () => {
+    it("should delete signature variant for ONBOARDING integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONBOARDING,
+      });
+      const mockResponse = { success: true, message: "Deleted" };
+      httpRequest.mockResolvedValue(mockResponse);
+
+      const result = await deleteSignatureVariant();
+
+      expect(httpRequest).toHaveBeenCalledWith(
+        "services/api/customer/cleansignaturephoto",
+        {},
+        "DELETE"
+      );
+      expect(result).toBeInstanceOf(ApacuanaSuccess);
+      expect(result.data).toEqual(mockResponse);
+    });
+
+    it("should throw not implemented for ONPREMISE integration", async () => {
+      getConfig.mockReturnValue({
+        integrationType: INTEGRATION_TYPE.ONPREMISE,
+      });
+
+      await expect(deleteSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Deleting signature variants is not supported for integration type: ONPREMISE",
+          501,
+          "NOT_IMPLEMENTED"
+        )
+      );
+    });
+
+    it("should throw an error for unsupported integration type", async () => {
+      getConfig.mockReturnValue({ integrationType: "UNSUPPORTED" });
+      await expect(deleteSignatureVariant()).rejects.toThrow(
+        new ApacuanaAPIError(
+          "Unsupported integration type: UNSUPPORTED",
+          400,
+          "UNSUPPORTED_INTEGRATION_TYPE"
+        )
+      );
+    });
+  });
+});

package/tests/api/users.test.js

@@ -0,0 +1,117 @@
+// tests/api/users.test.js
+import { httpRequest } from "../../src/utils/httpClient.js";
+import { getConfig } from "../../src/config/index.js";
+import { ApacuanaAPIError } from "../../src/errors/index.js";
+import ApacuanaSuccess from "../../src/success/index.js";
+import { getCustomer } from "../../src/api/users.js";
+
+// Mockear las dependencias:
+jest.mock("../../src/utils/httpClient.js", () => ({
+  httpRequest: jest.fn(),
+}));
+
+jest.mock("../../src/config/index.js", () => ({
+  getConfig: jest.fn(),
+}));
+
+describe("getCustomer", () => {
+  const mockConfig = {
+    verificationId: "mock-verify-id",
+    customerId: "mock-customer-id",
+  };
+
+  beforeEach(() => {
+    httpRequest.mockClear();
+    getConfig.mockClear();
+    getConfig.mockReturnValue(mockConfig);
+    jest.spyOn(console, "log").mockImplementation(() => {});
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.log.mockRestore();
+    console.error.mockRestore();
+  });
+
+  test("debe llamar a httpRequest con los parámetros de la configuración y devolver un objeto con token y userData", async () => {
+    const mockResponse = {
+      success: true,
+      sessionid: "mock-session-id-12345",
+      entry: {
+        userId: "mock-user",
+        name: "John Doe",
+        email: "john@example.com",
+      },
+    };
+    httpRequest.mockResolvedValueOnce(mockResponse);
+
+    const result = await getCustomer();
+
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+    expect(httpRequest).toHaveBeenCalledWith(
+      "services/api/register/init",
+      {
+        verificationid: mockConfig.verificationId,
+        customerid: mockConfig.customerId,
+      },
+      "POST"
+    );
+
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
+    expect(result.data).toEqual({
+      token: "mock-session-id-12345",
+      userData: {
+        userId: "mock-user",
+        name: "John Doe",
+        email: "john@example.com",
+      },
+    });
+  });
+
+  test("should throw an error if configuration is incomplete", async () => {
+    getConfig.mockReturnValue({
+      verificationId: "mock-verify-id",
+      customerId: null,
+    });
+
+    await expect(getCustomer()).rejects.toThrow(
+      "Both 'verificationId' and 'customerId' must be configured."
+    );
+    expect(httpRequest).not.toHaveBeenCalled();
+  });
+
+  test("should throw ApacuanaAPIError if backend does not return sessionid or entry", async () => {
+    httpRequest.mockResolvedValueOnce({
+      success: true,
+      message: "Backend error, token could not be generated.",
+      entry: { userId: "mock-user" },
+    });
+
+    await expect(getCustomer()).rejects.toThrow(
+      "The API response does not contain the user."
+    );
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+  });
+
+  test("should rethrow ApacuanaAPIError if httpClient request fails", async () => {
+    const apiError = new ApacuanaAPIError(
+      "Authentication error",
+      401,
+      "AUTH_ERROR"
+    );
+    httpRequest.mockRejectedValueOnce(apiError);
+
+    await expect(getCustomer()).rejects.toThrow(apiError);
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+  });
+
+  test("should throw ApacuanaAPIError on unexpected error", async () => {
+    const genericError = new Error("Network or unknown error");
+    httpRequest.mockRejectedValueOnce(genericError);
+
+    await expect(getCustomer()).rejects.toThrow(
+      "Unexpected failure getting token: Network or unknown error"
+    );
+    expect(httpRequest).toHaveBeenCalledTimes(1);
+  });
+});