apacuana-sdk-core 1.0.0 → 1.1.0

package/tests/index.test.js

@@ -0,0 +1,131 @@
+// tests/index.test.js
+import apacuana from "../src/index.js";
+import { setConfig, getConfig } from "../src/config/index.js";
+import { initHttpClient, setAuthToken } from "../src/utils/httpClient.js";
+import ApacuanaSuccess from "../src/success/index.js";
+import { getCustomer } from "../src/api/users.js";
+
+// Mockear todas las dependencias del index.js
+jest.mock("../src/config/index.js", () => ({
+  setConfig: jest.fn(),
+  getConfig: jest.fn(),
+}));
+jest.mock("../src/utils/httpClient.js", () => ({
+  initHttpClient: jest.fn(),
+  setAuthToken: jest.fn(), // Agregar el mock de setAuthToken
+}));
+jest.mock("../src/api/users.js", () => ({
+  __esModule: true,
+  default: jest.fn(),
+  getCustomer: jest.fn(),
+}));
+
+describe("Apacuana SDK Initialization (init)", () => {
+  const mockConfig = {
+    apiUrl: "http://test-api.com",
+    secretKey: "mock-secret",
+    apiKey: "mock-api-key",
+    verificationId: "mock-verify-id",
+    customerId: "mock-customer-id",
+  };
+
+  beforeEach(() => {
+    // Limpiar todos los mocks antes de cada prueba.
+    jest.clearAllMocks();
+
+    // Configurar el mock de getConfig para devolver una configuración válida por defecto.
+    getConfig.mockReturnValue(mockConfig);
+
+    // Mockear la respuesta exitosa de getCustomer para la mayoría de las pruebas.
+    getCustomer.mockResolvedValue({
+      success: true,
+      data: {
+        token: "mock-session-token",
+        userData: { id: "mock-user-id" },
+      },
+    });
+
+    // Opcional: Mockear console.log para no ensuciar la consola durante las pruebas.
+    jest.spyOn(console, "log").mockImplementation(() => {});
+    jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restaurar los mocks de console después de cada prueba.
+    console.log.mockRestore();
+    console.error.mockRestore();
+  });
+
+  test("debe llamar a setConfig, initHttpClient y getCustomer en orden y devolver true al finalizar", async () => {
+    const result = await apacuana.init(mockConfig);
+
+    // 1. Verificar que setConfig fue llamado con los parámetros correctos.
+    expect(setConfig).toHaveBeenCalledWith(mockConfig);
+
+    // 2. Verificar que initHttpClient fue llamado sin argumentos.
+    expect(initHttpClient).toHaveBeenCalled();
+
+    // 3. Verificar que getCustomer fue llamado.
+    expect(getCustomer).toHaveBeenCalledWith();
+
+    // 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 con sesión de usuario.",
+    });
+
+    // 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
+    expect(initHttpClient).toHaveBeenCalledTimes(1);
+    expect(getCustomer).toHaveBeenCalledTimes(1);
+  });
+
+  test("debe lanzar un error si la configuración inicial está incompleta", async () => {
+    // Sobrescribir el mock de setConfig para que lance un error.
+    setConfig.mockImplementationOnce(() => {
+      throw new Error("Apacuana SDK: La configuración inicial debe incluir...");
+    });
+
+    // Verificar que el método init lanza el error esperado.
+    await expect(apacuana.init({})).rejects.toThrow(
+      "Apacuana SDK: La configuración inicial debe incluir..."
+    );
+
+    // Verificar que initHttpClient y getCustomer no fueron llamados.
+    expect(initHttpClient).not.toHaveBeenCalled();
+    expect(getCustomer).not.toHaveBeenCalled();
+  });
+
+  test("debe lanzar un error si getCustomer falla", async () => {
+    // Configurar el mock de getCustomer para que rechace la promesa.
+    getCustomer.mockRejectedValueOnce(
+      new Error("Error del servidor al obtener token")
+    );
+
+    // Verificar que el método init propaga el error de getCustomer.
+    await expect(apacuana.init(mockConfig)).rejects.toThrow(
+      "Error del servidor al obtener token"
+    );
+
+    // Verificar que setConfig e initHttpClient sí fueron llamados, pero getCustomer falló.
+    expect(setConfig).toHaveBeenCalledWith(mockConfig);
+    expect(initHttpClient).toHaveBeenCalled();
+  });
+
+  test("debe llamar a getConfig y setConfig para guardar el token", async () => {
+    const result = await apacuana.init(mockConfig);
+
+    // La primera llamada a setConfig se hace con la configuración inicial.
+    // La segunda llamada se hace para guardar el token y userData.
+    expect(setConfig).toHaveBeenCalledTimes(2);
+    expect(setConfig).toHaveBeenLastCalledWith({
+      ...mockConfig,
+      token: "mock-session-token",
+      userData: { id: "mock-user-id" },
+    });
+
+    // Verificar que la respuesta es una instancia de ApacuanaSuccess.
+    expect(result).toBeInstanceOf(ApacuanaSuccess);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "esnext",
+    "lib": ["es2022", "dom"],
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "./dist",
+    "strict": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true
+  },
+  "include": ["src"],
+  "exclude": ["nodev_modules", "dist", "tests"]
+}