fraim-framework 2.0.55 → 2.0.57

package/dist/tests/test-ai-coach-edge-cases.js

@@ -1,420 +0,0 @@
-"use strict";
-/**
- * Tests for AI Coach edge cases and error scenarios
- * Ensures robust handling of unusual inputs and error conditions
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_test_1 = require("node:test");
-const node_assert_1 = __importDefault(require("node:assert"));
-const ai_manager_js_1 = require("../src/ai-manager/ai-manager.js");
-const phase_flow_js_1 = require("../src/ai-manager/phase-flow.js");
-(0, node_test_1.describe)('AI Coach Edge Cases and Error Scenarios', () => {
-    let coach;
-    let emptyFileIndex;
-    let partialFileIndex;
-    (0, node_test_1.before)(() => {
-        // Create different file index scenarios for testing
-        emptyFileIndex = new Map();
-        partialFileIndex = new Map();
-        partialFileIndex.set('ai-manager-rules/shared-phases/finalize.md', {
-            fullPath: './registry/ai-manager-rules/shared-phases/finalize.md'
-        });
-        coach = new ai_manager_js_1.AICoach(emptyFileIndex);
-    });
-    (0, node_test_1.describe)('Invalid Input Handling', () => {
-        (0, node_test_1.it)('should reject null or undefined workflow type', async () => {
-            const testCases = [null, undefined, ''];
-            for (const workflowType of testCases) {
-                try {
-                    await coach.handleCoachingRequest({
-                        workflowType: workflowType,
-                        currentPhase: 'spec-spec',
-                        status: 'starting',
-                        issueNumber: '123'
-                    });
-                    node_assert_1.default.fail(`Should have thrown error for workflowType: ${workflowType}`);
-                }
-                catch (error) {
-                    node_assert_1.default.ok(error instanceof Error);
-                    node_assert_1.default.ok(error.message.includes('Invalid workflow type') ||
-                        error.message.includes('workflow') ||
-                        error.message.includes('required'));
-                }
-            }
-        });
-        (0, node_test_1.it)('should reject invalid workflow types', async () => {
-            const invalidTypes = ['invalid', 'SPEC', 'Implement', 'test123', 'spec-workflow'];
-            for (const workflowType of invalidTypes) {
-                try {
-                    await coach.handleCoachingRequest({
-                        workflowType,
-                        currentPhase: 'some-phase',
-                        status: 'starting',
-                        issueNumber: '123'
-                    });
-                    node_assert_1.default.fail(`Should have thrown error for workflowType: ${workflowType}`);
-                }
-                catch (error) {
-                    node_assert_1.default.ok(error instanceof Error);
-                    node_assert_1.default.ok(error.message.includes('Invalid workflow type'));
-                }
-            }
-        });
-        (0, node_test_1.it)('should reject null or undefined phase names', async () => {
-            const testCases = [null, undefined, ''];
-            for (const currentPhase of testCases) {
-                try {
-                    await coach.handleCoachingRequest({
-                        workflowType: 'spec',
-                        currentPhase: currentPhase,
-                        status: 'starting',
-                        issueNumber: '123'
-                    });
-                    node_assert_1.default.fail(`Should have thrown error for currentPhase: ${currentPhase}`);
-                }
-                catch (error) {
-                    node_assert_1.default.ok(error instanceof Error);
-                }
-            }
-        });
-        (0, node_test_1.it)('should reject invalid phase names for workflow types', async () => {
-            const testCases = [
-                { workflow: 'spec', phase: 'implement-scoping' },
-                { workflow: 'spec', phase: 'design-design' },
-                { workflow: 'implement', phase: 'spec-spec' },
-                { workflow: 'implement', phase: 'design-completeness-review' },
-                { workflow: 'design', phase: 'implement-code' },
-                { workflow: 'design', phase: 'spec-completeness-review' }
-            ];
-            for (const { workflow, phase } of testCases) {
-                try {
-                    await coach.handleCoachingRequest({
-                        workflowType: workflow,
-                        currentPhase: phase,
-                        status: 'starting',
-                        issueNumber: '123',
-                        evidence: { issueType: 'feature' }
-                    });
-                    node_assert_1.default.fail(`Should have thrown error for ${workflow}/${phase}`);
-                }
-                catch (error) {
-                    node_assert_1.default.ok(error instanceof Error);
-                    node_assert_1.default.ok(error.message.toLowerCase().includes('invalid phase'));
-                }
-            }
-        });
-        (0, node_test_1.it)('should reject invalid status values', async () => {
-            const invalidStatuses = ['invalid', 'COMPLETE', 'Complete', 'done', 'finished'];
-            for (const status of invalidStatuses) {
-                try {
-                    await coach.handleCoachingRequest({
-                        workflowType: 'spec',
-                        currentPhase: 'spec-spec',
-                        status: status,
-                        issueNumber: '123'
-                    });
-                    node_assert_1.default.fail(`Should have thrown error for status: ${status}`);
-                }
-                catch (error) {
-                    node_assert_1.default.ok(error instanceof Error);
-                    // Note: Some invalid statuses might be handled gracefully
-                }
-            }
-        });
-        (0, node_test_1.it)('should handle missing issue number gracefully', async () => {
-            const testCases = [null, undefined, '', '   '];
-            for (const issueNumber of testCases) {
-                // This should not throw an error, but should handle gracefully
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: issueNumber
-                });
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Missing File Handling', () => {
-        (0, node_test_1.it)('should handle missing phase files gracefully', async () => {
-            const coachWithEmptyIndex = new ai_manager_js_1.AICoach(emptyFileIndex);
-            const result = await coachWithEmptyIndex.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: { issueType: 'feature' }
-            });
-            // Should return valid phase instructions (fallback mechanism works)
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-            node_assert_1.default.ok(result.includes('# Phase: Spec-Spec') || result.includes('INTENT'));
-        });
-        (0, node_test_1.it)('should provide helpful error messages for missing files', async () => {
-            const coachWithEmptyIndex = new ai_manager_js_1.AICoach(emptyFileIndex);
-            const result = await coachWithEmptyIndex.handleCoachingRequest({
-                workflowType: 'implement',
-                currentPhase: 'implement-scoping',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: { issueType: 'bug' }
-            });
-            // Should return valid phase instructions (fallback mechanism works)
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-            node_assert_1.default.ok(result.includes('# Phase: Implement-Scoping') || result.includes('INTENT'));
-        });
-        (0, node_test_1.it)('should list available phases when file not found', async () => {
-            const coachWithEmptyIndex = new ai_manager_js_1.AICoach(emptyFileIndex);
-            const result = await coachWithEmptyIndex.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: { issueType: 'feature' }
-            });
-            // Should return valid phase instructions (fallback mechanism works)
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-            node_assert_1.default.ok(result.includes('# Phase: Spec-Spec') || result.includes('INTENT'));
-        });
-    });
-    (0, node_test_1.describe)('Malformed Data Handling', () => {
-        (0, node_test_1.it)('should handle malformed evidence objects', async () => {
-            const malformedEvidence = [
-                { issueType: null },
-                { issueType: 123 },
-                { issueType: [] },
-                { issueType: {} },
-                'not an object',
-                123,
-                null
-            ];
-            for (const evidence of malformedEvidence) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: '123',
-                    evidence: evidence
-                });
-                // Should handle gracefully, not throw
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-        });
-        (0, node_test_1.it)('should handle malformed findings objects', async () => {
-            const malformedFindings = [
-                { uncertainties: 'not an array' },
-                { uncertainties: 123 },
-                { uncertainties: null },
-                'not an object',
-                123,
-                null
-            ];
-            for (const findings of malformedFindings) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'implement',
-                    currentPhase: 'implement-code',
-                    status: 'incomplete',
-                    issueNumber: '123',
-                    evidence: { issueType: 'bug' },
-                    findings: findings
-                });
-                // Should handle gracefully
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-        });
-        (0, node_test_1.it)('should handle extremely long input strings', async () => {
-            const longString = 'x'.repeat(10000);
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: longString,
-                evidence: { issueType: 'feature' }
-            });
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-        });
-        (0, node_test_1.it)('should handle special characters in input', async () => {
-            const specialChars = ['<script>', '"; DROP TABLE;', '\\n\\r\\t', '🎉💻🚀', '中文测试'];
-            for (const specialChar of specialChars) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: specialChar,
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Phase Flow Edge Cases', () => {
-        (0, node_test_1.it)('should handle invalid phase transitions', () => {
-            // Test invalid phases that don't exist in any workflow
-            const invalidPhases = ['nonexistent-phase', 'random-phase', 'phase-123'];
-            for (const phase of invalidPhases) {
-                node_assert_1.default.throws(() => {
-                    (0, phase_flow_js_1.getNextPhase)(phase, 'spec');
-                }, /Invalid phase/);
-            }
-        });
-        (0, node_test_1.it)('should handle missing issue type for implement workflow', () => {
-            node_assert_1.default.throws(() => {
-                (0, phase_flow_js_1.getNextPhase)('implement-scoping', 'implement');
-            }, /Issue type is required/);
-            node_assert_1.default.throws(() => {
-                (0, phase_flow_js_1.getNextPhase)('implement-scoping', 'implement', undefined);
-            }, /Issue type is required/);
-        });
-        (0, node_test_1.it)('should validate phase names case-sensitively', () => {
-            const caseSensitiveTests = [
-                { phase: 'SPEC-SPEC', workflow: 'spec', shouldBeValid: false },
-                { phase: 'Spec-Spec', workflow: 'spec', shouldBeValid: false },
-                { phase: 'spec-SPEC', workflow: 'spec', shouldBeValid: false },
-                { phase: 'implement-SCOPING', workflow: 'implement', shouldBeValid: false },
-                { phase: 'IMPLEMENT-scoping', workflow: 'implement', shouldBeValid: false }
-            ];
-            for (const test of caseSensitiveTests) {
-                const isValid = (0, phase_flow_js_1.isPhaseValidForWorkflow)(test.phase, test.workflow, 'feature');
-                node_assert_1.default.strictEqual(isValid, test.shouldBeValid, `Phase ${test.phase} should ${test.shouldBeValid ? 'be' : 'not be'} valid for ${test.workflow}`);
-            }
-        });
-        (0, node_test_1.it)('should handle boundary conditions in phase flows', () => {
-            // Test last phase in each workflow - retrospective is now the final phase
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('retrospective', 'spec'), null);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('retrospective', 'design'), null);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('retrospective', 'implement', 'bug'), null);
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('retrospective', 'implement', 'feature'), null);
-            // Test that wait-for-pr-review transitions to retrospective
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', 'spec'), 'retrospective');
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', 'design'), 'retrospective');
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', 'implement', 'bug'), 'retrospective');
-            node_assert_1.default.strictEqual((0, phase_flow_js_1.getNextPhase)('wait-for-pr-review', 'implement', 'feature'), 'retrospective');
-        });
-    });
-    (0, node_test_1.describe)('Concurrent Access Handling', () => {
-        (0, node_test_1.it)('should handle multiple simultaneous requests', async () => {
-            const requests = Array.from({ length: 10 }, (_, i) => coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: `${i}`,
-                evidence: { issueType: 'feature' }
-            }));
-            const results = await Promise.all(requests);
-            // All requests should complete successfully
-            node_assert_1.default.strictEqual(results.length, 10);
-            for (const result of results) {
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-        });
-        (0, node_test_1.it)('should handle mixed workflow types concurrently', async () => {
-            const workflows = ['spec', 'design', 'implement'];
-            const phases = ['spec-spec', 'design-design', 'implement-scoping'];
-            const requests = workflows.map((workflow, i) => coach.handleCoachingRequest({
-                workflowType: workflow,
-                currentPhase: phases[i],
-                status: 'starting',
-                issueNumber: `${i}`,
-                evidence: { issueType: 'feature' }
-            }));
-            const results = await Promise.all(requests);
-            node_assert_1.default.strictEqual(results.length, 3);
-            for (const result of results) {
-                node_assert_1.default.ok(typeof result === 'string');
-                node_assert_1.default.ok(result.length > 0);
-            }
-        });
-    });
-    (0, node_test_1.describe)('Memory and Performance Edge Cases', () => {
-        (0, node_test_1.it)('should handle large evidence objects', async () => {
-            const largeEvidence = {
-                issueType: 'feature',
-                largeData: Array.from({ length: 1000 }, (_, i) => `item-${i}`),
-                nestedObject: {
-                    level1: {
-                        level2: {
-                            level3: Array.from({ length: 100 }, (_, i) => ({ id: i, data: `data-${i}` }))
-                        }
-                    }
-                }
-            };
-            const result = await coach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: largeEvidence
-            });
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-        });
-        (0, node_test_1.it)('should handle rapid sequential requests', async () => {
-            const startTime = Date.now();
-            for (let i = 0; i < 50; i++) {
-                const result = await coach.handleCoachingRequest({
-                    workflowType: 'spec',
-                    currentPhase: 'spec-spec',
-                    status: 'starting',
-                    issueNumber: `${i}`,
-                    evidence: { issueType: 'feature' }
-                });
-                node_assert_1.default.ok(typeof result === 'string');
-            }
-            const duration = Date.now() - startTime;
-            console.log(`50 sequential requests completed in ${duration}ms`);
-            // Should complete reasonably quickly (less than 10 seconds)
-            node_assert_1.default.ok(duration < 10000, 'Sequential requests should complete in reasonable time');
-        });
-    });
-    (0, node_test_1.describe)('File System Edge Cases', () => {
-        (0, node_test_1.it)('should handle file system errors gracefully', async () => {
-            // Test that the system handles corrupted file index gracefully
-            // This tests the robustness of the fallback mechanism
-            const corruptedIndex = new Map();
-            corruptedIndex.set('ai-manager-rules/spec-phases/spec-spec.md', {
-                fullPath: '/completely/nonexistent/path/that/will/never/exist.md'
-            });
-            const corruptedCoach = new ai_manager_js_1.AICoach(corruptedIndex);
-            const result = await corruptedCoach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: { issueType: 'feature' }
-            });
-            // Should handle gracefully - either return error message or fallback to working file
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-            // The system should either show an error or successfully fall back to the working file
-            node_assert_1.default.ok(result.includes('**Error**') || result.includes('Phase instructions not found') || result.includes('# Phase: Spec-Spec'));
-        });
-        (0, node_test_1.it)('should handle corrupted file index', async () => {
-            const corruptedIndex = new Map();
-            corruptedIndex.set('ai-manager-rules/spec-phases/spec-spec.md', null);
-            corruptedIndex.set('ai-manager-rules/spec-phases/spec-completeness-review.md', undefined);
-            corruptedIndex.set('ai-manager-rules/shared-phases/finalize.md', 'not an object');
-            const corruptedCoach = new ai_manager_js_1.AICoach(corruptedIndex);
-            const result = await corruptedCoach.handleCoachingRequest({
-                workflowType: 'spec',
-                currentPhase: 'spec-spec',
-                status: 'starting',
-                issueNumber: '123',
-                evidence: { issueType: 'feature' }
-            });
-            // Should handle gracefully
-            node_assert_1.default.ok(typeof result === 'string');
-            node_assert_1.default.ok(result.length > 0);
-        });
-    });
-});