log-vista/__tests__/logCollector.test.js

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

/**
 * Log Collector Tests
 * Tests the log collection functionality
 */

const LogCollector = require('../src/logCollector');
const fs = require('fs');
const path = require('path');
const os = require('os');

describe('LogCollector', () => {
  let tempDir;
  let logCollector;
  let testLogFile;

  beforeEach(() => {
    tempDir = path.join(os.tmpdir(), 'logvista-test-' + Date.now());
    fs.mkdirSync(tempDir, { recursive: true });
    
    testLogFile = path.join(tempDir, 'test.log');
    
    logCollector = new LogCollector();
  });

  afterEach(() => {
    if (logCollector && logCollector.stop) {
      logCollector.stop();
    }
    if (fs.existsSync(tempDir)) {
      fs.rmSync(tempDir, { recursive: true, force: true });
    }
  });

  test('should initialize with valid configuration', () => {
    expect(logCollector).toBeDefined();
    expect(logCollector.watchers).toBeDefined();
    expect(logCollector.logBuffer).toBeDefined();
    expect(logCollector.lastReadPositions).toBeDefined();
  });

  test('should start watching log files', async () => {
    // Create test log file
    fs.writeFileSync(testLogFile, '[2025-01-01 12:00:00] INFO: Initial log entry\n');

    const projectConfigs = [{
      project_name: 'Test Project',
      pwd_path: tempDir,
      custom_log_paths: [testLogFile],
      enabled: true
    }];

    // Start watching should not throw error
    await expect(logCollector.startWatching(projectConfigs)).resolves.toBeUndefined();
  });

  test('should parse log entries correctly', () => {
    const logEntry = '[2025-01-01 12:00:00] INFO: Test log message';
    const parsed = logCollector.parseLogLine(logEntry, '/test/path.log', 'Test Project');
    
    expect(parsed).toBeDefined();
    expect(parsed.message).toContain('Test log message');
    expect(parsed.level).toBe('INFO');
    expect(parsed.timestamp).toBeDefined();
    expect(parsed.source).toBe('/test/path.log');
    expect(parsed.projectName).toBe('Test Project');
  });

  test('should handle file rotation', () => {
    // Create log file
    fs.writeFileSync(testLogFile, 'Initial content\n');

    // Simulate log rotation by creating new file
    const rotatedFile = testLogFile + '.1';
    fs.renameSync(testLogFile, rotatedFile);
    fs.writeFileSync(testLogFile, 'New content after rotation\n');

    expect(fs.existsSync(testLogFile)).toBe(true);
    expect(fs.existsSync(rotatedFile)).toBe(true);

    // Cleanup
    fs.unlinkSync(rotatedFile);
  });

  test('should respect enabled/disabled project settings', async () => {
    const disabledConfig = [{
      project_name: 'Disabled Project',
      pwd_path: tempDir,
      custom_log_paths: [testLogFile],
      enabled: false
    }];

    // Should not start watching for disabled projects
    await expect(logCollector.startWatching(disabledConfig)).resolves.toBeUndefined();
    expect(logCollector.watchers.size).toBe(0);
  });

  test('should stop watching when requested', () => {
    logCollector.stopWatching();
    expect(logCollector.watchers.size).toBe(0);
  });
});