@zerosls/clm-sdk 1.0.0

package/tests/modules/legacy/areas/areas-api.test.ts

@@ -0,0 +1,232 @@
+// tests/modules/areas/areas-api.test.ts
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, AREAS_TEST_DATA } from '../../../utils/test-utils';
+
+describe('AreasApi', () => {
+  let sdk: ClmSdk;
+  const TOKEN = AUTH_TEST_DATA.loginToken;
+  
+  beforeEach(() => {
+    sdk = new ClmSdk({
+      baseUrl: 'http://216.250.117.119/ZeroServicesQA/api/v1',
+      organization: 'default-org',
+      token: TOKEN
+    });
+  });
+  
+  describe('getAreas', () => {
+    it('debe obtener todas las áreas correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'GET',
+          response: {
+            status: 200,
+            data: AREAS_TEST_DATA.areasList
+          }
+        }
+      ]);
+      
+      const result = await sdk.areas.getAreas();
+      
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+      
+      const calledUrl = (global.fetch as any).mock.calls[0][0];
+      expect(calledUrl).toBe('http://216.250.117.119/ZeroServicesQA/api/v1/catalog/areas');
+      
+      const options = (global.fetch as any).mock.calls[0][1];
+      expect(options.method).toBe('GET');
+      
+      expect(result).toEqual(AREAS_TEST_DATA.areasList);
+      expect(result.dataResult.length).toBeGreaterThan(0);
+      expect(result.statusResponse.success).toBe(true);
+    });
+    
+    it('debe manejar respuestas vacías', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'GET',
+          response: {
+            status: 200,
+            data: {
+              dataResult: [],
+              statusResponse: {
+                code: 200,
+                success: true,
+                message: 'success'
+              }
+            }
+          }
+        }
+      ]);
+      
+      const result = await sdk.areas.getAreas();
+      
+      expect(result.dataResult).toEqual([]);
+      expect(result.statusResponse.success).toBe(true);
+    });
+    
+    it('debe recibir respuesta de error del servidor', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'GET',
+          response: {
+            status: 500,
+            data: {
+              dataResult: [],
+              statusResponse: {
+                code: 500,
+                success: false,
+                message: 'Internal server error'
+              }
+            }
+          }
+        }
+      ]);
+      
+      const result = await sdk.areas.getAreas();
+      
+      // Verificar que la respuesta contiene el error
+      expect(result.statusResponse.success).toBe(false);
+      expect(result.statusResponse.code).toBe(500);
+      expect(result.statusResponse.message).toContain('error');
+    });
+  });
+  
+  describe('createArea', () => {
+    it('debe crear un área correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'POST',
+          response: {
+            status: 200,
+            data: AREAS_TEST_DATA.createAreaResponse
+          }
+        }
+      ]);
+      
+      const result = await sdk.areas.createArea(AREAS_TEST_DATA.newAreaRequest);
+      
+      const options = (global.fetch as any).mock.calls[0][1];
+      expect(options.method).toBe('POST');
+      
+      const body = JSON.parse(options.body);
+      expect(body.name).toBe('Testing QA');
+      expect(body.description).toBe('Área de pruebas y aseguramiento de calidad');
+      
+      expect(result.statusResponse.success).toBe(true);
+      expect(result.statusResponse.code).toBe(200);
+    });
+    
+    it('debe enviar todos los campos requeridos', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'POST',
+          response: {
+            status: 200,
+            data: AREAS_TEST_DATA.createAreaResponse
+          }
+        }
+      ]);
+      
+      await sdk.areas.createArea(AREAS_TEST_DATA.newAreaRequest);
+      
+      const options = (global.fetch as any).mock.calls[0][1];
+      const body = JSON.parse(options.body);
+      
+      expect(body).toHaveProperty('createdBy');
+      expect(body).toHaveProperty('createdByName');
+      expect(body).toHaveProperty('createdOn');
+      expect(body).toHaveProperty('lastModBy');
+      expect(body).toHaveProperty('lastModByName');
+      expect(body).toHaveProperty('lastModOn');
+      expect(body).toHaveProperty('name');
+      expect(body).toHaveProperty('description');
+    });
+  });
+  
+  describe('updateArea', () => {
+    it('debe actualizar un área correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'PATCH',
+          response: {
+            status: 200,
+            data: AREAS_TEST_DATA.updateAreaResponse
+          }
+        }
+      ]);
+      
+      const result = await sdk.areas.updateArea(AREAS_TEST_DATA.updateAreaRequest);
+      
+      const options = (global.fetch as any).mock.calls[0][1];
+      expect(options.method).toBe('PATCH');
+      
+      const body = JSON.parse(options.body);
+      expect(body.id).toBe(26);
+      expect(body.name).toBe('Testing QA - Actualizado');
+      
+      expect(result.statusResponse.success).toBe(true);
+    });
+  });
+  
+  describe('deleteArea', () => {
+    it('debe eliminar un área correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/areas',
+          method: 'DELETE',
+          response: {
+            status: 200,
+            data: AREAS_TEST_DATA.deleteAreaResponse
+          }
+        }
+      ]);
+      
+      const result = await sdk.areas.deleteArea({ id: 26 });
+      
+      const options = (global.fetch as any).mock.calls[0][1];
+      const calledUrl = (global.fetch as any).mock.calls[0][0];
+      
+      expect(options.method).toBe('DELETE');
+      
+      // Tu ApiClient envía el ID como query param
+      expect(calledUrl).toContain('id=26');
+      
+      expect(result.statusResponse.success).toBe(true);
+    });
+  });
+  
+  describe('generateAuditData', () => {
+    it('debe generar datos de auditoría correctamente', () => {
+      const auditData = sdk.areas.generateAuditData('USR001', 'Juan Pérez');
+      
+      expect(auditData).toHaveProperty('createdBy', 'USR001');
+      expect(auditData).toHaveProperty('createdByName', 'Juan Pérez');
+      expect(auditData).toHaveProperty('createdOn');
+      expect(auditData).toHaveProperty('lastModBy', 'USR001');
+      expect(auditData).toHaveProperty('lastModByName', 'Juan Pérez');
+      expect(auditData).toHaveProperty('lastModOn');
+      
+      expect(new Date(auditData.createdOn).toISOString()).toBe(auditData.createdOn);
+      expect(new Date(auditData.lastModOn).toISOString()).toBe(auditData.lastModOn);
+    });
+    
+    it('debe generar fechas actuales', () => {
+      const before = new Date().getTime();
+      const auditData = sdk.areas.generateAuditData('USR001', 'Test User');
+      const after = new Date().getTime();
+      
+      const createdTime = new Date(auditData.createdOn).getTime();
+      
+      expect(createdTime).toBeGreaterThanOrEqual(before);
+      expect(createdTime).toBeLessThanOrEqual(after);
+    });
+  });
+});

package/tests/modules/legacy/classification-types/classification-types-api.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, CLASSIFICATION_TYPES_TEST_DATA } from '../../../utils/test-utils';
+
+describe('ClassificationTypesApi', () => {
+  let sdk: ClmSdk;
+  const TOKEN = AUTH_TEST_DATA.loginToken;
+  
+  beforeEach(() => {
+    sdk = new ClmSdk({
+      baseUrl: 'http://216.250.117.119/ZeroServicesQA/api/v1',
+      organization: 'default-org',
+      token: TOKEN
+    });
+  });
+  
+  describe('getClassificationTypes', () => {
+    it('debe obtener todos los tipos de clasificación', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/clasificationtype',
+          method: 'GET',
+          response: {
+            status: 200,
+            data: CLASSIFICATION_TYPES_TEST_DATA.classificationTypesList
+          }
+        }
+      ]);
+      
+      const result = await sdk.classificationTypes.getClassificationTypes();
+      
+      expect(result.dataResult.length).toBeGreaterThan(0);
+      expect(result.statusResponse.success).toBe(true);
+      expect(result.dataResult[0]).toHaveProperty('id');
+      expect(result.dataResult[0]).toHaveProperty('name');
+    });
+  });
+  
+  describe('createClassificationType', () => {
+    it('debe crear un tipo de clasificación correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/clasificationtype',
+          method: 'POST',
+          response: {
+            status: 200,
+            data: CLASSIFICATION_TYPES_TEST_DATA.createClassificationTypeResponse
+          }
+        }
+      ]);
+      
+      const result = await sdk.classificationTypes.createClassificationType(
+        CLASSIFICATION_TYPES_TEST_DATA.newClassificationTypeRequest
+      );
+      
+      expect(result.statusResponse.success).toBe(true);
+      expect(result.dataResult?.name).toBe("Contrato de Prueba");
+    });
+  });
+  
+  describe('updateClassificationType', () => {
+    it('debe actualizar un tipo de clasificación correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/clasificationtype',
+          method: 'PUT',
+          response: {
+            status: 200,
+            data: CLASSIFICATION_TYPES_TEST_DATA.updateClassificationTypeResponse
+          }
+        }
+      ]);
+      
+      const result = await sdk.classificationTypes.updateClassificationType(
+        CLASSIFICATION_TYPES_TEST_DATA.updateClassificationTypeRequest
+      );
+      
+      expect(result.statusResponse.success).toBe(true);
+    });
+  });
+  
+  describe('deleteClassificationType', () => {
+    it('debe eliminar un tipo de clasificación correctamente', async () => {
+      setupFetchMock([
+        {
+          url: '/catalog/clasificationtype',
+          method: 'DELETE',
+          response: {
+            status: 200,
+            data: CLASSIFICATION_TYPES_TEST_DATA.deleteClassificationTypeResponse
+          }
+        }
+      ]);
+      
+      const result = await sdk.classificationTypes.deleteClassificationType({ id: 20 });
+      
+      expect(result.statusResponse.success).toBe(true);
+    });
+  });
+});

package/tests/modules/v1/auth/auth-api.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA } from '../../../utils/test-utils';
+
+describe('AuthApi', () => {
+  let sdk: ClmSdk;
+  
+  beforeEach(() => {
+    // Crear una instancia nueva del SDK para cada prueba
+    sdk = new ClmSdk({
+      baseUrl: 'https://dev-api.zeroclm.io',
+      organization: 'default-org'
+    });
+  });
+  
+  describe('login', () => {
+    it('debe autenticar correctamente con credenciales válidas', async () => {
+      // Configurar el mock de fetch para la petición de login
+      setupFetchMock([
+        {
+          url: '/auth/login',
+          method: 'GET',
+          response: {
+            status: 200,
+            data: AUTH_TEST_DATA.loginToken
+          }
+        }
+      ]);
+      
+      // Realizar login
+      const token = await sdk.auth.login({
+        email: 'test@example.com',
+        password: 'password123'
+      });
+      
+      // Verificar que se hizo la petición correcta
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://dev-api.zeroclm.io/auth/login',
+        expect.objectContaining({
+          method: 'GET',
+          headers: expect.any(Headers),
+          credentials: 'include'
+        })
+      );
+      
+      // Verificar que el header de autorización usa Basic Auth
+      const headers = (global.fetch as any).mock.calls[0][1].headers;
+      expect(headers.get('Authorization')).toMatch(/^Basic /);
+      
+      // Verificar que devolvió el token correcto
+      expect(token).toBe(AUTH_TEST_DATA.loginToken);
+      
+      // Verificar que el token se guardó en el cliente
+      expect(sdk.auth.isAuthenticated()).toBe(true);
+    });
+    
+    it('debe manejar errores de autenticación', async () => {
+      // Configurar mock para una respuesta de error
+      setupFetchMock([
+        {
+          url: '/auth/login',
+          method: 'GET',
+          response: {
+            status: 401,
+            data: { 
+              statusCode: 401, 
+              message: 'Invalid credentials', 
+              error: 'Unauthorized' 
+            }
+          }
+        }
+      ]);
+      
+      // Intentar login con credenciales incorrectas y esperar que falle
+      await expect(
+        sdk.auth.login({
+          email: 'wrong@example.com',
+          password: 'wrongpassword'
+        })
+      ).rejects.toThrow('Invalid credentials');
+      
+      // Verificar que el usuario no está autenticado después del error
+      expect(sdk.auth.isAuthenticated()).toBe(false);
+    });
+  });
+    
+  describe('setToken', () => {
+    it('debe establecer el token correctamente', () => {
+      // Establecer el token
+      sdk.auth.setToken(AUTH_TEST_DATA.loginToken);
+      
+      // Verificar que el token se estableció
+      expect(sdk.auth.isAuthenticated()).toBe(true);
+    });
+
+    it('debe emitir el evento tokenChanged cuando se actualiza el token', () => {
+        const eventHandler = vi.fn();
+        sdk.on('tokenChanged', eventHandler);
+        
+        // Establecer token
+        sdk.auth.setToken(AUTH_TEST_DATA.loginToken);
+        expect(eventHandler).toHaveBeenCalledWith(AUTH_TEST_DATA.loginToken);
+        
+        // Limpiar token
+        sdk.auth.setToken(null);
+        expect(eventHandler).toHaveBeenCalledWith(null);
+      });
+    
+    it('debe limpiar el token cuando se pasa null', () => {
+      // Primero establecer un token
+      console.log(AUTH_TEST_DATA.loginToken);
+      sdk.auth.setToken(AUTH_TEST_DATA.loginToken);
+      expect(sdk.auth.isAuthenticated()).toBe(true);
+      
+      // Luego limpiarlo
+      sdk.auth.setToken(null);
+      
+      // Verificar que el token se eliminó
+      expect(sdk.auth.isAuthenticated()).toBe(false);
+    });
+  });
+  
+  describe('isAuthenticated', () => {
+    it('debe devolver true cuando hay un token', () => {
+      sdk.auth.setToken(AUTH_TEST_DATA.loginToken);
+      expect(sdk.auth.isAuthenticated()).toBe(true);
+    });
+    
+    it('debe devolver false cuando no hay token', () => {
+      expect(sdk.auth.isAuthenticated()).toBe(false);
+    });
+  });
+});

package/tests/modules/v1/users/users-api.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClmSdk } from '../../../../src/index';
+import { setupFetchMock, AUTH_TEST_DATA, USERS_TEST_DATA } from '../../../utils/test-utils';
+
+describe('UsersApi - getAll', () => {
+  let sdk: ClmSdk;
+  const TOKEN = AUTH_TEST_DATA.loginToken;
+  
+  beforeEach(() => {
+    // Inicializar SDK con un token de autenticación
+    sdk = new ClmSdk({
+      baseUrl: 'https://dev-api.zeroclm.io',
+      organization: 'default-org',
+      token: TOKEN
+    });
+  });
+  
+  it('debe obtener todos los usuarios con paginación predeterminada', async () => {
+    // Configurar mock para la petición de usuarios
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: USERS_TEST_DATA.usersList
+        }
+      }
+    ]);
+    
+    // Obtener usuarios
+    const result = await sdk.users.getAll();
+    
+    // Verificar que se hizo la petición correcta
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://dev-api.zeroclm.io/users',
+      {
+        method: 'GET',
+        headers: expect.objectContaining({
+          'Authorization': `Bearer ${TOKEN}`,
+          'Content-Type': 'application/json',
+          'X-Organization': 'default-org'
+        }),
+        credentials: 'include'
+      }
+    );
+    
+    // Verificar la respuesta
+    expect(result).toEqual(USERS_TEST_DATA.usersList);
+    expect(result.data.length).toBe(1);
+    expect(result.data[0].email).toBe('test@example.com');
+  });
+  
+  it('debe aplicar parámetros de consulta correctamente', async () => {
+    // Configurar mock para la petición con parámetros
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: {
+            data: [],
+            meta: { total: 0, page: 1, limit: 10, pages: 0 }
+          }
+        }
+      }
+    ]);
+    
+    // Parámetros de consulta a enviar
+    const queryParams = {
+      page: 1,
+      limit: 10,
+      email: 'ivan@zeroclm.com',
+      role_id: 1
+    };
+    
+    // Obtener usuarios con parámetros
+    await sdk.users.getAll(queryParams);
+    
+    // Verificar que la URL incluye los parámetros correctos
+    const calledUrl = (global.fetch as any).mock.calls[0][0];
+    expect(calledUrl).toContain('page=1');
+    expect(calledUrl).toContain('limit=10');
+    expect(calledUrl).toContain('email=ivan%40zeroclm.com');
+    expect(calledUrl).toContain('role_id=1');
+  });
+  
+  it('debe manejar respuestas vacías', async () => {
+    // Configurar mock para respuesta vacía
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 200,
+          data: {
+            data: [],
+            meta: { total: 0, page: 1, limit: 20, pages: 0 }
+          }
+        }
+      }
+    ]);
+    
+    // Obtener usuarios
+    const result = await sdk.users.getAll();
+    
+    // Verificar respuesta vacía
+    expect(result.data).toEqual([]);
+    expect(result.meta.total).toBe(0);
+  });
+  
+  it('debe manejar errores del servidor', async () => {
+    // Configurar mock para respuesta de error
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 500,
+          data: { 
+            statusCode: 500, 
+            message: 'Internal server error', 
+            error: 'Server Error' 
+          }
+        }
+      }
+    ]);
+    
+    // Intentar obtener usuarios y esperar que falle
+    await expect(sdk.users.getAll()).rejects.toThrow('Internal server error');
+  });
+  
+  it('debe manejar errores de autorización', async () => {
+    // Configurar mock para respuesta de error de autorización
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 401,
+          data: { 
+            statusCode: 401, 
+            message: 'Unauthorized', 
+            error: 'Unauthorized' 
+          }
+        }
+      }
+    ]);
+    
+    // Intentar obtener usuarios con token inválido y esperar que falle
+    await expect(sdk.users.getAll()).rejects.toThrow('Unauthorized');
+  });
+  
+  it('debe manejar errores de permisos', async () => {
+    // Configurar mock para respuesta de error de permisos
+    setupFetchMock([
+      {
+        url: '/users',
+        method: 'GET',
+        response: {
+          status: 403,
+          data: { 
+            statusCode: 403, 
+            message: 'Insufficient scope', 
+            error: 'Forbidden' 
+          }
+        }
+      }
+    ]);
+    
+    // Intentar obtener usuarios sin permisos suficientes y esperar que falle
+    await expect(sdk.users.getAll()).rejects.toThrow('Insufficient scope');
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,12 @@
+import { beforeAll, afterEach, vi } from 'vitest';
+
+// Setup global fetch mock
+beforeAll(() => {
+  global.fetch = vi.fn();
+  global.btoa = vi.fn((str) => Buffer.from(str).toString('base64'));
+});
+
+// Reset all mocks after each test
+afterEach(() => {
+  vi.resetAllMocks();
+});