create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/workflow-intelligence/__tests__/wave-analyzer.test.js

@@ -0,0 +1,447 @@
+/**
+ * @fileoverview Unit tests for WaveAnalyzer
+ * @story WIS-4 - Wave Analysis Engine
+ */
+
+'use strict';
+
+const {
+  WaveAnalyzer,
+  CircularDependencyError,
+  createWaveAnalyzer,
+  analyzeWaves,
+  DEFAULT_TASK_DURATIONS,
+} = require('../engine/wave-analyzer');
+
+describe('WaveAnalyzer', () => {
+  let analyzer;
+
+  beforeEach(() => {
+    analyzer = new WaveAnalyzer();
+  });
+
+  describe('constructor', () => {
+    it('should create instance with default options', () => {
+      const instance = new WaveAnalyzer();
+      expect(instance.taskDurations).toEqual(DEFAULT_TASK_DURATIONS);
+    });
+
+    it('should accept custom task durations', () => {
+      const customDurations = { 'custom-task': 25 };
+      const instance = new WaveAnalyzer({ taskDurations: customDurations });
+      expect(instance.taskDurations['custom-task']).toBe(25);
+      expect(instance.taskDurations['default']).toBe(DEFAULT_TASK_DURATIONS.default);
+    });
+
+    it('should accept custom registry', () => {
+      const mockRegistry = { getWorkflow: jest.fn() };
+      const instance = new WaveAnalyzer({ registry: mockRegistry });
+      expect(instance.registry).toBe(mockRegistry);
+    });
+  });
+
+  describe('buildDependencyGraph', () => {
+    it('should build graph from tasks with dependencies', () => {
+      const tasks = [
+        { id: 'task-a', dependsOn: [] },
+        { id: 'task-b', dependsOn: [] },
+        { id: 'task-c', dependsOn: ['task-a', 'task-b'] },
+        { id: 'task-d', dependsOn: ['task-c'] },
+      ];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+
+      expect(graph.nodes.size).toBe(4);
+      expect(graph.nodes.has('task-a')).toBe(true);
+      expect(graph.nodes.has('task-b')).toBe(true);
+      expect(graph.nodes.has('task-c')).toBe(true);
+      expect(graph.nodes.has('task-d')).toBe(true);
+
+      // Check edges (a -> c, b -> c, c -> d)
+      expect(graph.edges.get('task-a').has('task-c')).toBe(true);
+      expect(graph.edges.get('task-b').has('task-c')).toBe(true);
+      expect(graph.edges.get('task-c').has('task-d')).toBe(true);
+
+      // Check in-edges
+      expect(graph.inEdges.get('task-a').size).toBe(0);
+      expect(graph.inEdges.get('task-b').size).toBe(0);
+      expect(graph.inEdges.get('task-c').size).toBe(2);
+      expect(graph.inEdges.get('task-d').size).toBe(1);
+    });
+
+    it('should handle tasks without dependencies', () => {
+      const tasks = [{ id: 'task-a' }, { id: 'task-b' }, { id: 'task-c' }];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+
+      expect(graph.nodes.size).toBe(3);
+      expect(graph.edges.get('task-a').size).toBe(0);
+      expect(graph.edges.get('task-b').size).toBe(0);
+      expect(graph.edges.get('task-c').size).toBe(0);
+    });
+
+    it('should use task name if id is missing', () => {
+      const tasks = [{ name: 'task-a' }, { name: 'task-b', dependsOn: ['task-a'] }];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+
+      expect(graph.nodes.has('task-a')).toBe(true);
+      expect(graph.nodes.has('task-b')).toBe(true);
+      expect(graph.edges.get('task-a').has('task-b')).toBe(true);
+    });
+
+    it('should ignore dependencies to non-existent nodes', () => {
+      const tasks = [{ id: 'task-a', dependsOn: ['non-existent'] }];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+
+      expect(graph.nodes.size).toBe(1);
+      expect(graph.inEdges.get('task-a').size).toBe(0);
+    });
+  });
+
+  describe('findCycle', () => {
+    it('should return null for acyclic graph', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [] },
+        { id: 'b', dependsOn: ['a'] },
+        { id: 'c', dependsOn: ['b'] },
+      ];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+      const cycle = analyzer.findCycle(graph);
+
+      expect(cycle).toBeNull();
+    });
+
+    it('should detect simple cycle', () => {
+      const tasks = [
+        { id: 'a', dependsOn: ['c'] },
+        { id: 'b', dependsOn: ['a'] },
+        { id: 'c', dependsOn: ['b'] },
+      ];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+      const cycle = analyzer.findCycle(graph);
+
+      expect(cycle).not.toBeNull();
+      expect(cycle.length).toBeGreaterThan(1);
+    });
+
+    it('should detect self-loop', () => {
+      const tasks = [{ id: 'a', dependsOn: ['a'] }];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+      const cycle = analyzer.findCycle(graph);
+
+      expect(cycle).not.toBeNull();
+      expect(cycle).toContain('a');
+    });
+
+    it('should detect cycle in diamond pattern with back-edge', () => {
+      const tasks = [
+        { id: 'a', dependsOn: ['d'] }, // Creates cycle: a -> b -> d -> a
+        { id: 'b', dependsOn: ['a'] },
+        { id: 'c', dependsOn: ['a'] },
+        { id: 'd', dependsOn: ['b', 'c'] },
+      ];
+
+      const graph = analyzer.buildDependencyGraph(tasks);
+      const cycle = analyzer.findCycle(graph);
+
+      expect(cycle).not.toBeNull();
+    });
+  });
+
+  describe('analyzeWaves with customTasks', () => {
+    it('should group independent tasks into same wave', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: [], duration: 3 },
+        { id: 'c', dependsOn: [], duration: 4 },
+      ];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      expect(result.waves.length).toBe(1);
+      expect(result.waves[0].tasks).toEqual(expect.arrayContaining(['a', 'b', 'c']));
+      expect(result.waves[0].parallel).toBe(true);
+    });
+
+    it('should create sequential waves for linear dependencies', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: ['a'], duration: 10 },
+        { id: 'c', dependsOn: ['b'], duration: 3 },
+        { id: 'd', dependsOn: ['c'], duration: 7 },
+      ];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      expect(result.waves.length).toBe(4);
+      expect(result.waves[0].tasks).toEqual(['a']);
+      expect(result.waves[1].tasks).toEqual(['b']);
+      expect(result.waves[2].tasks).toEqual(['c']);
+      expect(result.waves[3].tasks).toEqual(['d']);
+    });
+
+    it('should handle diamond dependency pattern', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: ['a'], duration: 10 },
+        { id: 'c', dependsOn: ['a'], duration: 8 },
+        { id: 'd', dependsOn: ['b', 'c'], duration: 5 },
+      ];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      expect(result.waves.length).toBe(3);
+      expect(result.waves[0].tasks).toEqual(['a']);
+      expect(result.waves[1].tasks).toEqual(expect.arrayContaining(['b', 'c']));
+      expect(result.waves[1].parallel).toBe(true);
+      expect(result.waves[2].tasks).toEqual(['d']);
+    });
+
+    it('should handle mixed parallel and sequential', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: [], duration: 3 },
+        { id: 'c', dependsOn: ['a'], duration: 10 },
+        { id: 'd', dependsOn: ['b'], duration: 8 },
+        { id: 'e', dependsOn: ['c', 'd'], duration: 5 },
+      ];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      expect(result.waves.length).toBe(3);
+      expect(result.waves[0].tasks).toEqual(expect.arrayContaining(['a', 'b']));
+      expect(result.waves[1].tasks).toEqual(expect.arrayContaining(['c', 'd']));
+      expect(result.waves[2].tasks).toEqual(['e']);
+    });
+
+    it('should calculate optimization gain', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 10 },
+        { id: 'b', dependsOn: [], duration: 10 },
+        { id: 'c', dependsOn: ['a', 'b'], duration: 10 },
+      ];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      // Sequential: 10 + 10 + 10 = 30min
+      // Parallel: 10 (wave 1: a,b parallel) + 10 (wave 2: c) = 20min
+      // Gain: (30 - 20) / 30 = 33%
+      expect(result.optimizationGain).toBe('33%');
+    });
+
+    it('should return empty result for empty tasks', () => {
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: [] });
+
+      expect(result.totalTasks).toBe(0);
+      expect(result.waves).toEqual([]);
+      expect(result.criticalPath).toEqual([]);
+    });
+
+    it('should handle single task workflow', () => {
+      const tasks = [{ id: 'a', dependsOn: [], duration: 5 }];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      expect(result.totalTasks).toBe(1);
+      expect(result.waves.length).toBe(1);
+      expect(result.waves[0].parallel).toBe(false);
+    });
+
+    it('should throw CircularDependencyError for cycles', () => {
+      const tasks = [
+        { id: 'a', dependsOn: ['c'], duration: 5 },
+        { id: 'b', dependsOn: ['a'], duration: 5 },
+        { id: 'c', dependsOn: ['b'], duration: 5 },
+      ];
+
+      expect(() => {
+        analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+      }).toThrow(CircularDependencyError);
+    });
+  });
+
+  describe('CircularDependencyError', () => {
+    it('should contain cycle information', () => {
+      const cycle = ['a', 'b', 'c', 'a'];
+      const error = new CircularDependencyError(cycle);
+
+      expect(error.name).toBe('CircularDependencyError');
+      expect(error.cycle).toEqual(cycle);
+      expect(error.message).toContain('a → b → c → a');
+    });
+
+    it('should provide resolution suggestion', () => {
+      const cycle = ['a', 'b', 'c', 'a'];
+      const error = new CircularDependencyError(cycle);
+
+      const suggestion = error.getSuggestion();
+      expect(suggestion).toBeTruthy();
+      expect(typeof suggestion).toBe('string');
+    });
+  });
+
+  describe('critical path calculation', () => {
+    it('should find longest path in graph', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: ['a'], duration: 20 },
+        { id: 'c', dependsOn: ['a'], duration: 3 },
+        { id: 'd', dependsOn: ['b', 'c'], duration: 5 },
+      ];
+
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: tasks });
+
+      // Critical path should be a -> b -> d (5 + 20 + 5 = 30)
+      // Not a -> c -> d (5 + 3 + 5 = 13)
+      expect(result.criticalPath).toEqual(expect.arrayContaining(['a', 'b', 'd']));
+    });
+
+    it('should return empty for empty workflow', () => {
+      const result = analyzer.analyzeWaves('test-workflow', { customTasks: [] });
+      expect(result.criticalPath).toEqual([]);
+    });
+  });
+
+  describe('getCurrentWave', () => {
+    it('should return current wave context for task', () => {
+      // Mock the analyzeWaves to return predictable result
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: ['a'], duration: 10 },
+        { id: 'c', dependsOn: ['b'], duration: 5 },
+      ];
+
+      const context = analyzer.getCurrentWave('test-workflow', 'b');
+
+      // Since we can't easily mock, this tests the error handling path
+      expect(context.workflowId).toBe('test-workflow');
+      expect(context.currentTask).toBe('b');
+    });
+  });
+
+  describe('formatOutput', () => {
+    const mockAnalysis = {
+      workflowId: 'test',
+      totalTasks: 3,
+      waves: [
+        { waveNumber: 1, tasks: ['a', 'b'], parallel: true, estimatedDuration: '5min' },
+        { waveNumber: 2, tasks: ['c'], parallel: false, estimatedDuration: '10min' },
+      ],
+      optimizationGain: '25%',
+      criticalPath: ['a', 'c'],
+      metrics: {
+        sequentialTime: '20min',
+        parallelTime: '15min',
+      },
+    };
+
+    it('should format as JSON when json option is true', () => {
+      const output = analyzer.formatOutput(mockAnalysis, { json: true });
+
+      expect(() => JSON.parse(output)).not.toThrow();
+      const parsed = JSON.parse(output);
+      expect(parsed.workflowId).toBe('test');
+    });
+
+    it('should include visual representation when visual option is true', () => {
+      const output = analyzer.formatOutput(mockAnalysis, { visual: true });
+
+      expect(output).toContain('Wave 1');
+      expect(output).toContain('──');
+    });
+
+    it('should include optimization metrics', () => {
+      const output = analyzer.formatOutput(mockAnalysis);
+
+      expect(output).toContain('25%');
+      expect(output).toContain('Critical Path');
+    });
+  });
+
+  describe('performance', () => {
+    it('should analyze small workflow in <10ms', () => {
+      const tasks = Array.from({ length: 5 }, (_, i) => ({
+        id: `task-${i}`,
+        dependsOn: i > 0 ? [`task-${i - 1}`] : [],
+        duration: 5,
+      }));
+
+      const start = Date.now();
+      const result = analyzer.analyzeWaves('perf-test', { customTasks: tasks });
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(10);
+      expect(result.metrics.analysisTime).toBeLessThan(10);
+    });
+
+    it('should analyze medium workflow in <30ms', () => {
+      const tasks = Array.from({ length: 20 }, (_, i) => ({
+        id: `task-${i}`,
+        dependsOn: i > 0 ? [`task-${Math.floor(i / 2)}`] : [],
+        duration: 5,
+      }));
+
+      const start = Date.now();
+      const result = analyzer.analyzeWaves('perf-test', { customTasks: tasks });
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(30);
+    });
+
+    it('should analyze large workflow in <50ms', () => {
+      const tasks = Array.from({ length: 50 }, (_, i) => ({
+        id: `task-${i}`,
+        dependsOn: i > 0 ? [`task-${Math.max(0, i - 3)}`] : [],
+        duration: 5,
+      }));
+
+      const start = Date.now();
+      const result = analyzer.analyzeWaves('perf-test', { customTasks: tasks });
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(50);
+    });
+  });
+});
+
+describe('Factory functions', () => {
+  describe('createWaveAnalyzer', () => {
+    it('should create WaveAnalyzer instance', () => {
+      const instance = createWaveAnalyzer();
+      expect(instance).toBeInstanceOf(WaveAnalyzer);
+    });
+
+    it('should pass options to constructor', () => {
+      const customDurations = { custom: 15 };
+      const instance = createWaveAnalyzer({ taskDurations: customDurations });
+      expect(instance.taskDurations.custom).toBe(15);
+    });
+  });
+
+  describe('analyzeWaves convenience function', () => {
+    it('should analyze waves without creating instance manually', () => {
+      const tasks = [
+        { id: 'a', dependsOn: [], duration: 5 },
+        { id: 'b', dependsOn: ['a'], duration: 10 },
+      ];
+
+      const result = analyzeWaves('test', { customTasks: tasks });
+
+      expect(result.workflowId).toBe('test');
+      expect(result.waves.length).toBe(2);
+    });
+  });
+});
+
+describe('DEFAULT_TASK_DURATIONS', () => {
+  it('should have expected default durations', () => {
+    expect(DEFAULT_TASK_DURATIONS.implement).toBe(30);
+    expect(DEFAULT_TASK_DURATIONS['write-tests']).toBe(10);
+    expect(DEFAULT_TASK_DURATIONS.default).toBe(10);
+  });
+});