@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/tests/unit/workers/base-worker.test.ts

@@ -1,341 +0,0 @@
-/**
- * Agentic QE v3 - Base Worker Unit Tests
- * ADR-014: Background Workers for QE Monitoring
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { BaseWorker } from '../../../src/workers/base-worker';
-import {
-  WorkerConfig,
-  WorkerContext,
-  WorkerResult,
-  WorkerMetrics,
-  WorkerFinding,
-  WorkerRecommendation,
-} from '../../../src/workers/interfaces';
-
-// Test implementation of BaseWorker
-class TestWorker extends BaseWorker {
-  public executionCount = 0;
-  public shouldFail = false;
-  public executionDelay = 0;
-
-  constructor(config?: Partial<WorkerConfig>) {
-    super({
-      id: 'test-worker',
-      name: 'Test Worker',
-      description: 'A test worker for unit testing',
-      intervalMs: 60000,
-      priority: 'normal',
-      targetDomains: ['test-execution'],
-      enabled: true,
-      timeoutMs: 5000,
-      retryCount: 2,
-      retryDelayMs: 100,
-      ...config,
-    });
-  }
-
-  protected async doExecute(context: WorkerContext): Promise<WorkerResult> {
-    this.executionCount++;
-
-    if (this.executionDelay > 0) {
-      await new Promise(resolve => setTimeout(resolve, this.executionDelay));
-    }
-
-    if (this.shouldFail) {
-      throw new Error('Test execution failure');
-    }
-
-    const metrics: WorkerMetrics = {
-      itemsAnalyzed: 10,
-      issuesFound: 2,
-      healthScore: 85,
-      trend: 'stable',
-      domainMetrics: { testMetric: 'value' },
-    };
-
-    const findings: WorkerFinding[] = [
-      {
-        type: 'test-finding',
-        severity: 'medium',
-        domain: 'test-execution',
-        title: 'Test Finding',
-        description: 'A test finding for unit testing',
-      },
-    ];
-
-    const recommendations: WorkerRecommendation[] = [
-      {
-        priority: 'p2',
-        domain: 'test-execution',
-        action: 'Test Action',
-        description: 'A test recommendation',
-        estimatedImpact: 'medium',
-        effort: 'low',
-        autoFixable: true,
-      },
-    ];
-
-    return this.createResult(100, metrics, findings, recommendations);
-  }
-}
-
-function createMockContext(): WorkerContext {
-  return {
-    eventBus: {
-      publish: vi.fn().mockResolvedValue(undefined),
-    },
-    memory: {
-      get: vi.fn().mockResolvedValue(undefined),
-      set: vi.fn().mockResolvedValue(undefined),
-      search: vi.fn().mockResolvedValue([]),
-    },
-    logger: {
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-    },
-    domains: {
-      getDomainAPI: vi.fn().mockReturnValue(undefined),
-      getDomainHealth: vi.fn().mockReturnValue({ status: 'healthy', errors: [] }),
-    },
-    signal: new AbortController().signal,
-  };
-}
-
-describe('BaseWorker', () => {
-  let worker: TestWorker;
-  let context: WorkerContext;
-
-  beforeEach(() => {
-    worker = new TestWorker();
-    context = createMockContext();
-  });
-
-  describe('initialization', () => {
-    it('should have correct initial status', () => {
-      expect(worker.status).toBe('idle');
-      expect(worker.lastResult).toBeUndefined();
-      expect(worker.lastRunAt).toBeUndefined();
-    });
-
-    it('should initialize successfully', async () => {
-      await worker.initialize();
-      expect(worker.status).toBe('idle');
-      expect(worker.nextRunAt).toBeDefined();
-    });
-
-    it('should have correct config values', () => {
-      expect(worker.config.id).toBe('test-worker');
-      expect(worker.config.priority).toBe('normal');
-      expect(worker.config.enabled).toBe(true);
-    });
-  });
-
-  describe('execute', () => {
-    it('should execute successfully', async () => {
-      const result = await worker.execute(context);
-
-      expect(result.success).toBe(true);
-      expect(result.workerId).toBe('test-worker');
-      expect(result.metrics.itemsAnalyzed).toBe(10);
-      expect(result.findings).toHaveLength(1);
-      expect(result.recommendations).toHaveLength(1);
-    });
-
-    it('should track execution count', async () => {
-      await worker.execute(context);
-      expect(worker.executionCount).toBe(1);
-
-      await worker.execute(context);
-      expect(worker.executionCount).toBe(2);
-    });
-
-    it('should update lastResult after execution', async () => {
-      await worker.execute(context);
-
-      expect(worker.lastResult).toBeDefined();
-      expect(worker.lastResult?.success).toBe(true);
-    });
-
-    it('should update lastRunAt after execution', async () => {
-      const before = Date.now();
-      await worker.execute(context);
-      const after = Date.now();
-
-      expect(worker.lastRunAt).toBeDefined();
-      expect(worker.lastRunAt!.getTime()).toBeGreaterThanOrEqual(before);
-      expect(worker.lastRunAt!.getTime()).toBeLessThanOrEqual(after);
-    });
-
-    it('should schedule next run after execution', async () => {
-      await worker.execute(context);
-
-      expect(worker.nextRunAt).toBeDefined();
-      expect(worker.nextRunAt!.getTime()).toBeGreaterThan(Date.now());
-    });
-
-    it('should publish event after execution', async () => {
-      await worker.execute(context);
-
-      expect(context.eventBus.publish).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'worker.executed',
-          workerId: 'test-worker',
-        })
-      );
-    });
-  });
-
-  describe('failure handling', () => {
-    it('should handle execution failure', async () => {
-      worker.shouldFail = true;
-
-      const result = await worker.execute(context);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Test execution failure');
-    });
-
-    it('should retry on failure', async () => {
-      let attemptCount = 0;
-      worker.shouldFail = true;
-
-      // Override to track attempts
-      const originalDoExecute = worker['doExecute'].bind(worker);
-      worker['doExecute'] = async (ctx: WorkerContext) => {
-        attemptCount++;
-        return originalDoExecute(ctx);
-      };
-
-      await worker.execute(context);
-
-      // Initial attempt + 2 retries = 3 attempts
-      expect(attemptCount).toBe(3);
-    });
-
-    it('should log warnings on retry', async () => {
-      worker.shouldFail = true;
-
-      await worker.execute(context);
-
-      expect(context.logger.warn).toHaveBeenCalled();
-    });
-
-    it('should set status to error on failure', async () => {
-      worker.shouldFail = true;
-
-      await worker.execute(context);
-
-      expect(worker.status).toBe('error');
-    });
-  });
-
-  describe('timeout handling', () => {
-    it('should timeout long-running executions', async () => {
-      worker = new TestWorker({ timeoutMs: 50 });
-      worker.executionDelay = 200;
-
-      const result = await worker.execute(context);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('timed out');
-    });
-  });
-
-  describe('abort handling', () => {
-    it('should handle abort signal', async () => {
-      const abortController = new AbortController();
-      context = {
-        ...context,
-        signal: abortController.signal,
-      };
-
-      worker.executionDelay = 100;
-
-      const executePromise = worker.execute(context);
-      setTimeout(() => abortController.abort(), 20);
-
-      const result = await executePromise;
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('aborted');
-    });
-  });
-
-  describe('pause/resume', () => {
-    it('should pause worker', () => {
-      worker.pause();
-      expect(worker.status).toBe('paused');
-    });
-
-    it('should resume worker', () => {
-      worker.pause();
-      worker.resume();
-      expect(worker.status).toBe('idle');
-    });
-
-    it('should not change status if stopped', async () => {
-      await worker.stop();
-      worker.pause();
-      expect(worker.status).toBe('stopped');
-    });
-  });
-
-  describe('stop', () => {
-    it('should stop worker', async () => {
-      await worker.stop();
-      expect(worker.status).toBe('stopped');
-    });
-  });
-
-  describe('health tracking', () => {
-    it('should track health correctly after success', async () => {
-      await worker.execute(context);
-
-      const health = worker.getHealth();
-
-      expect(health.status).toBe('idle');
-      expect(health.totalExecutions).toBe(1);
-      expect(health.successfulExecutions).toBe(1);
-      expect(health.failedExecutions).toBe(0);
-      expect(health.healthScore).toBe(100);
-    });
-
-    it('should track health correctly after failure', async () => {
-      worker.shouldFail = true;
-      await worker.execute(context);
-
-      const health = worker.getHealth();
-
-      expect(health.status).toBe('error');
-      expect(health.totalExecutions).toBe(1);
-      expect(health.successfulExecutions).toBe(0);
-      expect(health.failedExecutions).toBe(1);
-      expect(health.healthScore).toBe(0);
-    });
-
-    it('should track recent results', async () => {
-      await worker.execute(context);
-      await worker.execute(context);
-
-      const health = worker.getHealth();
-
-      expect(health.recentResults).toHaveLength(2);
-      expect(health.recentResults[0].success).toBe(true);
-    });
-
-    it('should calculate average duration', async () => {
-      await worker.execute(context);
-      await worker.execute(context);
-
-      const health = worker.getHealth();
-
-      // Duration is tracked even if very fast (0ms is valid)
-      expect(health.avgDurationMs).toBeGreaterThanOrEqual(0);
-      expect(health.recentResults.length).toBe(2);
-    });
-  });
-});

package/tests/unit/workers/daemon.test.ts

@@ -1,291 +0,0 @@
-/**
- * Agentic QE v3 - Daemon Unit Tests
- * ADR-014: Background Workers for QE Monitoring
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  QEDaemon,
-  createDaemon,
-  getDaemon,
-  resetDaemon,
-} from '../../../src/workers/daemon';
-
-describe('QEDaemon', () => {
-  let daemon: QEDaemon;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    resetDaemon();
-  });
-
-  afterEach(async () => {
-    if (daemon?.running) {
-      await daemon.stop();
-    }
-    vi.useRealTimers();
-    resetDaemon();
-  });
-
-  describe('createDaemon', () => {
-    it('should create a daemon with default config', () => {
-      daemon = createDaemon();
-      expect(daemon).toBeDefined();
-      expect(daemon.running).toBe(false);
-    });
-
-    it('should create a daemon with custom config', () => {
-      daemon = createDaemon({
-        autoStart: false,
-        logLevel: 'debug',
-      });
-      expect(daemon).toBeDefined();
-    });
-  });
-
-  describe('getDaemon', () => {
-    it('should return singleton instance', () => {
-      const daemon1 = getDaemon();
-      const daemon2 = getDaemon();
-      expect(daemon1).toBe(daemon2);
-    });
-
-    it('should create new instance after reset', () => {
-      const daemon1 = getDaemon();
-      resetDaemon();
-      const daemon2 = getDaemon();
-      expect(daemon1).not.toBe(daemon2);
-    });
-  });
-
-  describe('start', () => {
-    it('should start the daemon', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-      expect(daemon.running).toBe(true);
-    });
-
-    it('should register all workers by default', async () => {
-      // Use autoStart: false to just check registration without running workers
-      // Workers now throw errors when domain APIs are unavailable, so we can't
-      // actually auto-start them in unit tests without proper domain setup
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-
-      const manager = daemon.getWorkerManager();
-      const workers = manager.list();
-
-      // All workers should have been registered
-      expect(workers.length).toBe(10); // All 10 QE workers
-    });
-
-    it('should not auto-start workers when disabled', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-
-      const manager = daemon.getWorkerManager();
-      const workers = manager.list();
-
-      // Workers registered but not started
-      workers.forEach(worker => {
-        expect(worker.lastRunAt).toBeUndefined();
-      });
-    });
-
-    it('should handle multiple start calls gracefully', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-      await daemon.start();
-      expect(daemon.running).toBe(true);
-    });
-  });
-
-  describe('stop', () => {
-    it('should stop the daemon', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-      await daemon.stop();
-      expect(daemon.running).toBe(false);
-    });
-
-    it('should handle stop when not running', async () => {
-      daemon = createDaemon();
-      await daemon.stop();
-      expect(daemon.running).toBe(false);
-    });
-  });
-
-  describe('restart', () => {
-    it('should restart the daemon', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-      await daemon.restart();
-      expect(daemon.running).toBe(true);
-    });
-  });
-
-  describe('uptime', () => {
-    it('should return 0 when not started', () => {
-      daemon = createDaemon();
-      expect(daemon.uptime).toBe(0);
-    });
-
-    it('should track uptime', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-
-      vi.advanceTimersByTime(5000);
-      expect(daemon.uptime).toBe(5);
-
-      vi.advanceTimersByTime(10000);
-      expect(daemon.uptime).toBe(15);
-    });
-
-    it('should reset uptime after restart', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-
-      vi.advanceTimersByTime(5000);
-      expect(daemon.uptime).toBe(5);
-
-      await daemon.restart();
-      expect(daemon.uptime).toBe(0);
-    });
-  });
-
-  describe('getStatus', () => {
-    it('should return status when not running', () => {
-      daemon = createDaemon();
-      const status = daemon.getStatus();
-
-      expect(status.running).toBe(false);
-      expect(status.pid).toBe(process.pid);
-      expect(status.uptime).toBe(0);
-      expect(status.startedAt).toBeUndefined();
-    });
-
-    it('should return status when running', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-      const status = daemon.getStatus();
-
-      expect(status.running).toBe(true);
-      expect(status.startedAt).toBeDefined();
-      expect(status.workerManager).toBeDefined();
-    });
-
-    it('should include worker manager health', async () => {
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-      const status = daemon.getStatus();
-
-      expect(status.workerManager.totalWorkers).toBe(10);
-    });
-  });
-
-  describe('getWorkerManager', () => {
-    it('should return the worker manager', () => {
-      daemon = createDaemon();
-      const manager = daemon.getWorkerManager();
-      expect(manager).toBeDefined();
-      expect(manager.list).toBeDefined();
-    });
-  });
-
-  describe('runWorker', () => {
-    it('should attempt to run a specific worker and fail without domain setup', async () => {
-      // Use real timers for this test since the worker uses async retries
-      vi.useRealTimers();
-
-      daemon = createDaemon({ autoStart: false });
-      await daemon.start();
-
-      // Workers now properly throw errors when domain APIs are unavailable
-      // instead of silently returning empty metrics
-      const consoleSpy = vi.spyOn(console, 'warn');
-
-      // Run the worker - it will fail after retries
-      await daemon.runWorker('test-health');
-
-      // After all retries fail, the worker should log warnings about the failure
-      // The warning message contains both the worker name and the error
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringMatching(/\[test-health\].*domain not available/)
-      );
-
-      consoleSpy.mockRestore();
-
-      // Restore fake timers for other tests
-      vi.useFakeTimers();
-    }, 30000); // Allow 30 seconds for retries
-  });
-
-  describe('enabledWorkers config', () => {
-    it('should only register enabled workers', () => {
-      daemon = createDaemon({
-        enabledWorkers: ['test-health', 'coverage-tracker'],
-      });
-
-      const manager = daemon.getWorkerManager();
-      const workers = manager.list();
-
-      expect(workers).toHaveLength(2);
-      expect(workers.map(w => w.config.id)).toContain('test-health');
-      expect(workers.map(w => w.config.id)).toContain('coverage-tracker');
-    });
-  });
-
-  describe('health checks', () => {
-    it('should perform periodic health checks', async () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
-
-      daemon = createDaemon({
-        autoStart: false,
-        healthCheckIntervalMs: 1000,
-      });
-      await daemon.start();
-
-      // Advance past health check interval
-      vi.advanceTimersByTime(2000);
-
-      // Health check should have run (no warnings if healthy)
-      // We just verify it doesn't throw
-      expect(daemon.running).toBe(true);
-
-      consoleSpy.mockRestore();
-    });
-  });
-});
-
-describe('WORKER_REGISTRY', () => {
-  it('should export all 10 workers in registry', async () => {
-    const { WORKER_REGISTRY } = await import('../../../src/workers');
-
-    expect(Object.keys(WORKER_REGISTRY)).toHaveLength(10);
-    expect(WORKER_REGISTRY['test-health']).toBeDefined();
-    expect(WORKER_REGISTRY['coverage-tracker']).toBeDefined();
-    expect(WORKER_REGISTRY['flaky-detector']).toBeDefined();
-    expect(WORKER_REGISTRY['security-scan']).toBeDefined();
-    expect(WORKER_REGISTRY['quality-gate']).toBeDefined();
-    expect(WORKER_REGISTRY['learning-consolidation']).toBeDefined();
-    expect(WORKER_REGISTRY['defect-predictor']).toBeDefined();
-    expect(WORKER_REGISTRY['regression-monitor']).toBeDefined();
-    expect(WORKER_REGISTRY['performance-baseline']).toBeDefined();
-    expect(WORKER_REGISTRY['compliance-checker']).toBeDefined();
-  });
-
-  it('should have correct intervals for each worker', async () => {
-    const { WORKER_REGISTRY } = await import('../../../src/workers');
-
-    expect(WORKER_REGISTRY['test-health'].intervalMs).toBe(5 * 60 * 1000);
-    expect(WORKER_REGISTRY['coverage-tracker'].intervalMs).toBe(10 * 60 * 1000);
-    expect(WORKER_REGISTRY['flaky-detector'].intervalMs).toBe(15 * 60 * 1000);
-    expect(WORKER_REGISTRY['security-scan'].intervalMs).toBe(30 * 60 * 1000);
-    expect(WORKER_REGISTRY['quality-gate'].intervalMs).toBe(5 * 60 * 1000);
-    expect(WORKER_REGISTRY['learning-consolidation'].intervalMs).toBe(30 * 60 * 1000);
-    expect(WORKER_REGISTRY['defect-predictor'].intervalMs).toBe(15 * 60 * 1000);
-    expect(WORKER_REGISTRY['regression-monitor'].intervalMs).toBe(10 * 60 * 1000);
-    expect(WORKER_REGISTRY['performance-baseline'].intervalMs).toBe(60 * 60 * 1000);
-    expect(WORKER_REGISTRY['compliance-checker'].intervalMs).toBe(30 * 60 * 1000);
-  });
-});