log-vista/__tests__/uploader.test.js

LogVista Agent - Lightweight system monitoring and log collection for any project/language

/**
 * Uploader Tests
 * Tests the data upload functionality to central system
 */

const Uploader = require('../src/uploader');
const axios = require('axios');

// Mock axios
jest.mock('axios');
const mockedAxios = axios;

describe('Uploader', () => {
  let uploader;
  let mockConfig;

  beforeEach(() => {
    mockConfig = {
      central_system: {
        url: 'http://localhost:3001',
        token: 'test-token-123'
      },
      collection: {
        batch_size: 100,
        retry_attempts: 3,
        retry_delay: 1000
      }
    };
    
    uploader = new Uploader(mockConfig);
    
    // Clear all mocks
    jest.clearAllMocks();
    
    // Mock axios instance methods
    uploader.axios = {
      post: mockedAxios.post,
      defaults: {
        baseURL: mockConfig.central_system.url,
        headers: {
          'Authorization': `Bearer ${mockConfig.central_system.token}`,
          'Content-Type': 'application/json'
        }
      }
    };
  });

  test('should initialize with valid configuration', () => {
    expect(uploader).toBeDefined();
    expect(uploader.config).toBeDefined();
    expect(uploader.config.central_system.url).toBe('http://localhost:3001');
    expect(uploader.config.central_system.token).toBe('test-token-123');
  });

  test('should upload logs successfully', async () => {
    const mockLogs = [
      {
        timestamp: new Date().toISOString(),
        level: 'info',
        message: 'Test log message 1',
        project: 'Test Project'
      },
      {
        timestamp: new Date().toISOString(),
        level: 'error',
        message: 'Test log message 2',
        project: 'Test Project'
      }
    ];

    mockedAxios.post.mockResolvedValueOnce({
      status: 200,
      data: { success: true, inserted: 2 }
    });

    const result = await uploader.uploadLogs(mockLogs);

    expect(mockedAxios.post).toHaveBeenCalledWith(
      '/api/logs',
      { 
        logs: mockLogs,
        agent: {
          version: expect.any(String),
          timestamp: expect.any(String)
        }
      }
    );

    expect(result).toBeDefined();
    expect(result.success).toBe(true);
  });

  test('should upload metrics successfully', async () => {
    const mockMetrics = [
      {
        timestamp: new Date().toISOString(),
        server_id: 'test-server-1',
        cpu_usage: 45.5,
        memory_usage: 60.2,
        disk_usage: 75.0
      }
    ];

    mockedAxios.post.mockResolvedValueOnce({
      status: 200,
      data: { success: true, inserted: 1 }
    });

    const result = await uploader.uploadMetrics(mockMetrics);

    expect(mockedAxios.post).toHaveBeenCalledWith(
      '/api/metrics',
      { 
        metrics: mockMetrics,
        agent: {
          version: expect.any(String),
          timestamp: expect.any(String)
        }
      }
    );

    expect(result).toBeDefined();
    expect(result.success).toBe(true);
  });

  test('should handle network errors with retry', async () => {
    const mockLogs = [{
      timestamp: new Date().toISOString(),
      level: 'info',
      message: 'Test log message',
      project: 'Test Project'
    }];

    // Mock network error
    mockedAxios.post.mockRejectedValueOnce(new Error('Network Error'));

    await expect(uploader.uploadLogs(mockLogs)).rejects.toThrow('Network Error');
    expect(mockedAxios.post).toHaveBeenCalledTimes(1);
  });

  test('should handle authentication errors', async () => {
    const mockLogs = [{
      timestamp: new Date().toISOString(),
      level: 'info',
      message: 'Test log message',
      project: 'Test Project'
    }];

    mockedAxios.post.mockRejectedValueOnce({
      response: {
        status: 401,
        data: { error: 'Unauthorized' }
      }
    });

    await expect(uploader.uploadLogs(mockLogs)).rejects.toMatchObject({
      response: {
        status: 401,
        data: { error: 'Unauthorized' }
      }
    });
    expect(mockedAxios.post).toHaveBeenCalledTimes(1);
  });

  test('should validate axios instance configuration', () => {
    expect(uploader.axios).toBeDefined();
    expect(uploader.axios.defaults.baseURL).toBe('http://localhost:3001');
    expect(uploader.axios.defaults.headers['Authorization']).toBe('Bearer test-token-123');
    expect(uploader.axios.defaults.headers['Content-Type']).toBe('application/json');
  });

  test('should handle empty data gracefully', async () => {
    // Test with empty logs array
    const result1 = await uploader.uploadLogs([]);
    expect(result1).toBeUndefined();

    // Test with empty metrics array  
    const result2 = await uploader.uploadMetrics([]);
    expect(result2).toBeUndefined();

    // Ensure no API calls were made
    expect(mockedAxios.post).not.toHaveBeenCalled();
  });
});