edsger 0.45.0 → 0.45.1

package/dist/commands/workflow/core/__tests__/pipeline-evaluator.test.js

@@ -1,397 +0,0 @@
-/**
- * Unit tests for pipeline result evaluation utilities
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { calculatePipelineStats, countFailedPhases, countSuccessfulPhases, evaluatePipelineResults, getFailedPhases, getFirstFailure, getLastPhaseResult, getSuccessfulPhases, hasAnyPipelineFailures, isPipelineCompleteFailure, isPipelineEmpty, isPipelineFullySuccessful, isPipelinePartiallySuccessful, } from '../pipeline-evaluator.js';
-// Helper factory for creating test results
-const makeResult = (overrides) => ({
-    featureId: 'feat-1',
-    status: 'success',
-    message: `Phase ${overrides.phase} completed`,
-    ...overrides,
-});
-const successResult = (phase) => makeResult({ phase, status: 'success', message: `${phase} succeeded` });
-const errorResult = (phase) => makeResult({ phase, status: 'error', message: `${phase} failed` });
-const blockedResult = (phase) => makeResult({ phase, status: 'blocked', message: `${phase} blocked` });
-void describe('Pipeline Evaluator', () => {
-    void describe('evaluatePipelineResults', () => {
-        void it('should return true for empty results', () => {
-            assert.strictEqual(evaluatePipelineResults([]), true, 'Empty array should vacuously satisfy every()');
-        });
-        void it('should return true when all results are successful', () => {
-            const results = [
-                successResult('analysis'),
-                successResult('design'),
-                successResult('implementation'),
-            ];
-            assert.strictEqual(evaluatePipelineResults(results), true);
-        });
-        void it('should return false when any result is an error', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-            ];
-            assert.strictEqual(evaluatePipelineResults(results), false);
-        });
-        void it('should return false when any result is blocked', () => {
-            const results = [successResult('analysis'), blockedResult('design')];
-            assert.strictEqual(evaluatePipelineResults(results), false, 'Blocked status should cause evaluation to fail');
-        });
-        void it('should return false when all results are errors', () => {
-            const results = [errorResult('analysis'), errorResult('design')];
-            assert.strictEqual(evaluatePipelineResults(results), false);
-        });
-    });
-    void describe('hasAnyPipelineFailures', () => {
-        void it('should return false for empty results', () => {
-            assert.strictEqual(hasAnyPipelineFailures([]), false);
-        });
-        void it('should return false when all results are successful', () => {
-            const results = [successResult('analysis'), successResult('design')];
-            assert.strictEqual(hasAnyPipelineFailures(results), false);
-        });
-        void it('should return true when at least one result is an error', () => {
-            const results = [successResult('analysis'), errorResult('design')];
-            assert.strictEqual(hasAnyPipelineFailures(results), true);
-        });
-        void it('should return true when at least one result is blocked', () => {
-            const results = [successResult('analysis'), blockedResult('design')];
-            assert.strictEqual(hasAnyPipelineFailures(results), true);
-        });
-    });
-    void describe('countSuccessfulPhases', () => {
-        void it('should return 0 for empty results', () => {
-            assert.strictEqual(countSuccessfulPhases([]), 0);
-        });
-        void it('should count only successful phases', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-                blockedResult('testing'),
-            ];
-            assert.strictEqual(countSuccessfulPhases(results), 2);
-        });
-        void it('should return total count when all are successful', () => {
-            const results = [
-                successResult('analysis'),
-                successResult('design'),
-                successResult('implementation'),
-            ];
-            assert.strictEqual(countSuccessfulPhases(results), 3);
-        });
-    });
-    void describe('countFailedPhases', () => {
-        void it('should return 0 for empty results', () => {
-            assert.strictEqual(countFailedPhases([]), 0);
-        });
-        void it('should count error and blocked phases as failed', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                blockedResult('implementation'),
-                successResult('testing'),
-            ];
-            assert.strictEqual(countFailedPhases(results), 2, 'Both error and blocked should count as failed');
-        });
-        void it('should return 0 when all are successful', () => {
-            const results = [successResult('analysis'), successResult('design')];
-            assert.strictEqual(countFailedPhases(results), 0);
-        });
-    });
-    void describe('getFailedPhases', () => {
-        void it('should return empty array for empty results', () => {
-            assert.deepStrictEqual(getFailedPhases([]), []);
-        });
-        void it('should return only non-success phases', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                blockedResult('implementation'),
-                successResult('testing'),
-            ];
-            const failed = getFailedPhases(results);
-            assert.strictEqual(failed.length, 2);
-            assert.strictEqual(failed[0].phase, 'design');
-            assert.strictEqual(failed[0].status, 'error');
-            assert.strictEqual(failed[1].phase, 'implementation');
-            assert.strictEqual(failed[1].status, 'blocked');
-        });
-        void it('should return empty array when all are successful', () => {
-            const results = [successResult('analysis'), successResult('design')];
-            assert.deepStrictEqual(getFailedPhases(results), []);
-        });
-    });
-    void describe('getSuccessfulPhases', () => {
-        void it('should return empty array for empty results', () => {
-            assert.deepStrictEqual(getSuccessfulPhases([]), []);
-        });
-        void it('should return only successful phases', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-            ];
-            const successful = getSuccessfulPhases(results);
-            assert.strictEqual(successful.length, 2);
-            assert.strictEqual(successful[0].phase, 'analysis');
-            assert.strictEqual(successful[1].phase, 'implementation');
-        });
-    });
-    void describe('getFirstFailure', () => {
-        void it('should return undefined for empty results', () => {
-            assert.strictEqual(getFirstFailure([]), undefined);
-        });
-        void it('should return undefined when all are successful', () => {
-            const results = [successResult('analysis'), successResult('design')];
-            assert.strictEqual(getFirstFailure(results), undefined);
-        });
-        void it('should return the first error result', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                errorResult('implementation'),
-            ];
-            const first = getFirstFailure(results);
-            assert.strictEqual(first?.phase, 'design', 'Should return the first failure');
-        });
-        void it('should return blocked result as a failure', () => {
-            const results = [
-                successResult('analysis'),
-                blockedResult('design'),
-                errorResult('implementation'),
-            ];
-            const first = getFirstFailure(results);
-            assert.strictEqual(first?.phase, 'design', 'Blocked should be treated as a failure');
-            assert.strictEqual(first?.status, 'blocked');
-        });
-        void it('should return the only result if it is a failure', () => {
-            const results = [errorResult('analysis')];
-            const first = getFirstFailure(results);
-            assert.strictEqual(first?.phase, 'analysis');
-        });
-    });
-    void describe('getLastPhaseResult', () => {
-        void it('should return undefined for empty results', () => {
-            assert.strictEqual(getLastPhaseResult([]), undefined);
-        });
-        void it('should return the last result regardless of status', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-            ];
-            const last = getLastPhaseResult(results);
-            assert.strictEqual(last?.phase, 'implementation');
-            assert.strictEqual(last?.status, 'success');
-        });
-        void it('should return the single result for a single-element array', () => {
-            const results = [errorResult('analysis')];
-            const last = getLastPhaseResult(results);
-            assert.strictEqual(last?.phase, 'analysis');
-            assert.strictEqual(last?.status, 'error');
-        });
-    });
-    void describe('isPipelineFullySuccessful', () => {
-        void it('should return false for empty results', () => {
-            assert.strictEqual(isPipelineFullySuccessful([]), false, 'Empty pipeline is not fully successful');
-        });
-        void it('should return true when all results are successful', () => {
-            const results = [
-                successResult('analysis'),
-                successResult('design'),
-                successResult('implementation'),
-            ];
-            assert.strictEqual(isPipelineFullySuccessful(results), true);
-        });
-        void it('should return false when any result failed', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-            ];
-            assert.strictEqual(isPipelineFullySuccessful(results), false);
-        });
-        void it('should return true for a single successful result', () => {
-            assert.strictEqual(isPipelineFullySuccessful([successResult('analysis')]), true);
-        });
-    });
-    void describe('isPipelinePartiallySuccessful', () => {
-        void it('should return false for empty results', () => {
-            assert.strictEqual(isPipelinePartiallySuccessful([]), false);
-        });
-        void it('should return false when all results are successful', () => {
-            const results = [successResult('analysis'), successResult('design')];
-            assert.strictEqual(isPipelinePartiallySuccessful(results), false, 'Fully successful is not partially successful');
-        });
-        void it('should return false when all results failed', () => {
-            const results = [errorResult('analysis'), errorResult('design')];
-            assert.strictEqual(isPipelinePartiallySuccessful(results), false, 'Complete failure is not partially successful');
-        });
-        void it('should return true when some succeed and some fail', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-            ];
-            assert.strictEqual(isPipelinePartiallySuccessful(results), true);
-        });
-        void it('should return true with a mix of success and blocked', () => {
-            const results = [successResult('analysis'), blockedResult('design')];
-            assert.strictEqual(isPipelinePartiallySuccessful(results), true);
-        });
-    });
-    void describe('isPipelineCompleteFailure', () => {
-        void it('should return false for empty results', () => {
-            assert.strictEqual(isPipelineCompleteFailure([]), false);
-        });
-        void it('should return true when no results are successful', () => {
-            const results = [
-                errorResult('analysis'),
-                blockedResult('design'),
-                errorResult('implementation'),
-            ];
-            assert.strictEqual(isPipelineCompleteFailure(results), true);
-        });
-        void it('should return false when at least one result is successful', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                errorResult('implementation'),
-            ];
-            assert.strictEqual(isPipelineCompleteFailure(results), false);
-        });
-        void it('should return true for a single error result', () => {
-            assert.strictEqual(isPipelineCompleteFailure([errorResult('analysis')]), true);
-        });
-    });
-    void describe('isPipelineEmpty', () => {
-        void it('should return true for empty results', () => {
-            assert.strictEqual(isPipelineEmpty([]), true);
-        });
-        void it('should return false when results exist', () => {
-            assert.strictEqual(isPipelineEmpty([successResult('analysis')]), false);
-        });
-    });
-    void describe('calculatePipelineStats', () => {
-        void it('should return zeros for empty results', () => {
-            const stats = calculatePipelineStats([]);
-            assert.deepStrictEqual(stats, {
-                total: 0,
-                successful: 0,
-                failed: 0,
-                successRate: 0,
-            });
-        });
-        void it('should calculate stats for all successful results', () => {
-            const results = [
-                successResult('analysis'),
-                successResult('design'),
-                successResult('implementation'),
-            ];
-            const stats = calculatePipelineStats(results);
-            assert.strictEqual(stats.total, 3);
-            assert.strictEqual(stats.successful, 3);
-            assert.strictEqual(stats.failed, 0);
-            assert.strictEqual(stats.successRate, 1);
-        });
-        void it('should calculate stats for all failed results', () => {
-            const results = [errorResult('analysis'), errorResult('design')];
-            const stats = calculatePipelineStats(results);
-            assert.strictEqual(stats.total, 2);
-            assert.strictEqual(stats.successful, 0);
-            assert.strictEqual(stats.failed, 2);
-            assert.strictEqual(stats.successRate, 0);
-        });
-        void it('should calculate correct successRate for mixed results', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-                blockedResult('testing'),
-            ];
-            const stats = calculatePipelineStats(results);
-            assert.strictEqual(stats.total, 4);
-            assert.strictEqual(stats.successful, 2);
-            assert.strictEqual(stats.failed, 2);
-            assert.strictEqual(stats.successRate, 0.5);
-        });
-        void it('should treat blocked as failed in stats', () => {
-            const results = [
-                successResult('analysis'),
-                blockedResult('design'),
-                blockedResult('implementation'),
-            ];
-            const stats = calculatePipelineStats(results);
-            assert.strictEqual(stats.successful, 1);
-            assert.strictEqual(stats.failed, 2);
-            assert.ok(Math.abs(stats.successRate - 1 / 3) < 0.0001, 'successRate should be approximately 1/3');
-        });
-        void it('should calculate successRate for a single successful result', () => {
-            const stats = calculatePipelineStats([successResult('analysis')]);
-            assert.strictEqual(stats.total, 1);
-            assert.strictEqual(stats.successful, 1);
-            assert.strictEqual(stats.failed, 0);
-            assert.strictEqual(stats.successRate, 1);
-        });
-        void it('should have total equal to successful plus failed', () => {
-            const results = [
-                successResult('analysis'),
-                errorResult('design'),
-                successResult('implementation'),
-                blockedResult('testing'),
-                successResult('review'),
-            ];
-            const stats = calculatePipelineStats(results);
-            assert.strictEqual(stats.total, stats.successful + stats.failed, 'total should equal successful + failed');
-        });
-    });
-    void describe('Integration - pipeline status categories are mutually exclusive', () => {
-        void it('should have exactly one category true for all-success pipeline', () => {
-            const results = [successResult('analysis'), successResult('design')];
-            const full = isPipelineFullySuccessful(results);
-            const partial = isPipelinePartiallySuccessful(results);
-            const complete = isPipelineCompleteFailure(results);
-            const empty = isPipelineEmpty(results);
-            assert.strictEqual(full, true);
-            assert.strictEqual(partial, false);
-            assert.strictEqual(complete, false);
-            assert.strictEqual(empty, false);
-        });
-        void it('should have exactly one category true for mixed pipeline', () => {
-            const results = [successResult('analysis'), errorResult('design')];
-            const full = isPipelineFullySuccessful(results);
-            const partial = isPipelinePartiallySuccessful(results);
-            const complete = isPipelineCompleteFailure(results);
-            const empty = isPipelineEmpty(results);
-            assert.strictEqual(full, false);
-            assert.strictEqual(partial, true);
-            assert.strictEqual(complete, false);
-            assert.strictEqual(empty, false);
-        });
-        void it('should have exactly one category true for all-failure pipeline', () => {
-            const results = [errorResult('analysis'), errorResult('design')];
-            const full = isPipelineFullySuccessful(results);
-            const partial = isPipelinePartiallySuccessful(results);
-            const complete = isPipelineCompleteFailure(results);
-            const empty = isPipelineEmpty(results);
-            assert.strictEqual(full, false);
-            assert.strictEqual(partial, false);
-            assert.strictEqual(complete, true);
-            assert.strictEqual(empty, false);
-        });
-        void it('should have exactly one category true for empty pipeline', () => {
-            const results = [];
-            const full = isPipelineFullySuccessful(results);
-            const partial = isPipelinePartiallySuccessful(results);
-            const complete = isPipelineCompleteFailure(results);
-            const empty = isPipelineEmpty(results);
-            assert.strictEqual(full, false);
-            assert.strictEqual(partial, false);
-            assert.strictEqual(complete, false);
-            assert.strictEqual(empty, true);
-        });
-    });
-});

package/dist/commands/workflow/core/__tests__/state-manager.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for workflow state management utilities
- */
-export {};