edsger 0.50.0 → 0.52.0

package/dist/commands/workflow/core/__tests__/feature-filter.test.js

@@ -1,316 +0,0 @@
-/**
- * Unit tests for feature-filter module
- * Pure functions for filtering and selecting features for processing
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { filterAvailableFeatures, filterCompletedFeatures, filterFailedFeatures, filterProcessingFeatures, findNextFeature, hasReachedMaxRetries, isFeatureCompleted, isFeatureFailed, isFeatureProcessing, shouldProcessFeature, } from '../feature-filter.js';
-// ---- Helpers ----
-function makeFeature(overrides = {}) {
-    return {
-        id: 'feat-1',
-        name: 'Test Feature',
-        status: 'ready_for_ai',
-        product_id: 'prod-1',
-        ...overrides,
-    };
-}
-function makeState(overrides = {}) {
-    return {
-        featureId: 'feat-1',
-        retryCount: 0,
-        lastAttempt: new Date('2025-01-01T00:00:00Z'),
-        status: 'processing',
-        ...overrides,
-    };
-}
-function makeStates(...entries) {
-    const map = new Map();
-    for (const entry of entries) {
-        map.set(entry.featureId, entry);
-    }
-    return map;
-}
-// ---- shouldProcessFeature ----
-void describe('shouldProcessFeature', () => {
-    const maxRetries = 3;
-    const check = shouldProcessFeature(maxRetries);
-    void it('should return true when feature has never been processed', () => {
-        const feature = makeFeature();
-        const states = makeStates();
-        assert.strictEqual(check(feature, states), true);
-    });
-    void it('should return false when feature is completed', () => {
-        const feature = makeFeature();
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'completed' }));
-        assert.strictEqual(check(feature, states), false);
-    });
-    void it('should return false when feature is currently processing', () => {
-        const feature = makeFeature();
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'processing' }));
-        assert.strictEqual(check(feature, states), false);
-    });
-    void it('should return true when feature failed and retries are within limit', () => {
-        const feature = makeFeature();
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'failed', retryCount: 2 }));
-        assert.strictEqual(check(feature, states), true);
-    });
-    void it('should return false when feature failed and retries exceed limit', () => {
-        const feature = makeFeature();
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'failed', retryCount: 3 }));
-        assert.strictEqual(check(feature, states), false);
-    });
-    void it('should return false when feature failed and retries are above limit', () => {
-        const feature = makeFeature();
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'failed', retryCount: 5 }));
-        assert.strictEqual(check(feature, states), false);
-    });
-    void it('should return true when feature was updated after last attempt', () => {
-        const feature = makeFeature({
-            updated_at: '2025-06-01T00:00:00Z',
-        });
-        const states = makeStates(makeState({
-            featureId: 'feat-1',
-            status: 'completed',
-            lastAttempt: new Date('2025-01-01T00:00:00Z'),
-        }));
-        assert.strictEqual(check(feature, states), true);
-    });
-    void it('should return false when feature was updated before last attempt and is completed', () => {
-        const feature = makeFeature({
-            updated_at: '2024-01-01T00:00:00Z',
-        });
-        const states = makeStates(makeState({
-            featureId: 'feat-1',
-            status: 'completed',
-            lastAttempt: new Date('2025-01-01T00:00:00Z'),
-        }));
-        assert.strictEqual(check(feature, states), false);
-    });
-    void it('should return true when feature has no updated_at, was never processed', () => {
-        const feature = makeFeature({ updated_at: undefined });
-        const states = makeStates();
-        assert.strictEqual(check(feature, states), true);
-    });
-    void it('should return false when feature has no updated_at and is completed', () => {
-        const feature = makeFeature({ updated_at: undefined });
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'completed' }));
-        assert.strictEqual(check(feature, states), false);
-    });
-    void it('should use the provided maxRetries value', () => {
-        const strictCheck = shouldProcessFeature(0);
-        const feature = makeFeature();
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'failed', retryCount: 0 }));
-        assert.strictEqual(strictCheck(feature, states), false);
-    });
-});
-// ---- findNextFeature ----
-void describe('findNextFeature', () => {
-    const maxRetries = 3;
-    void it('should return undefined for an empty feature list', () => {
-        const result = findNextFeature([], makeStates(), maxRetries);
-        assert.strictEqual(result, undefined);
-    });
-    void it('should return undefined when all features are completed', () => {
-        const features = [makeFeature({ id: 'a' }), makeFeature({ id: 'b' })];
-        const states = makeStates(makeState({ featureId: 'a', status: 'completed' }), makeState({ featureId: 'b', status: 'completed' }));
-        const result = findNextFeature(features, states, maxRetries);
-        assert.strictEqual(result, undefined);
-    });
-    void it('should return the first available feature', () => {
-        const features = [
-            makeFeature({ id: 'a' }),
-            makeFeature({ id: 'b' }),
-            makeFeature({ id: 'c' }),
-        ];
-        const states = makeStates(makeState({ featureId: 'a', status: 'completed' }));
-        const result = findNextFeature(features, states, maxRetries);
-        assert.strictEqual(result?.id, 'b');
-    });
-    void it('should return a failed feature that can be retried', () => {
-        const features = [makeFeature({ id: 'a' })];
-        const states = makeStates(makeState({ featureId: 'a', status: 'failed', retryCount: 1 }));
-        const result = findNextFeature(features, states, maxRetries);
-        assert.strictEqual(result?.id, 'a');
-    });
-    void it('should skip processing features and find next available', () => {
-        const features = [makeFeature({ id: 'a' }), makeFeature({ id: 'b' })];
-        const states = makeStates(makeState({ featureId: 'a', status: 'processing' }));
-        const result = findNextFeature(features, states, maxRetries);
-        assert.strictEqual(result?.id, 'b');
-    });
-});
-// ---- isFeatureProcessing ----
-void describe('isFeatureProcessing', () => {
-    void it('should return true when feature status is processing', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'processing' }));
-        assert.strictEqual(isFeatureProcessing('feat-1', states), true);
-    });
-    void it('should return false when feature status is completed', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'completed' }));
-        assert.strictEqual(isFeatureProcessing('feat-1', states), false);
-    });
-    void it('should return false when feature status is failed', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'failed' }));
-        assert.strictEqual(isFeatureProcessing('feat-1', states), false);
-    });
-    void it('should return false when feature is not in states', () => {
-        const states = makeStates();
-        assert.strictEqual(isFeatureProcessing('unknown', states), false);
-    });
-});
-// ---- isFeatureCompleted ----
-void describe('isFeatureCompleted', () => {
-    void it('should return true when feature status is completed', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'completed' }));
-        assert.strictEqual(isFeatureCompleted('feat-1', states), true);
-    });
-    void it('should return false when feature status is processing', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'processing' }));
-        assert.strictEqual(isFeatureCompleted('feat-1', states), false);
-    });
-    void it('should return false when feature is not in states', () => {
-        const states = makeStates();
-        assert.strictEqual(isFeatureCompleted('unknown', states), false);
-    });
-});
-// ---- isFeatureFailed ----
-void describe('isFeatureFailed', () => {
-    void it('should return true when feature status is failed', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'failed' }));
-        assert.strictEqual(isFeatureFailed('feat-1', states), true);
-    });
-    void it('should return false when feature status is processing', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', status: 'processing' }));
-        assert.strictEqual(isFeatureFailed('feat-1', states), false);
-    });
-    void it('should return false when feature is not in states', () => {
-        const states = makeStates();
-        assert.strictEqual(isFeatureFailed('unknown', states), false);
-    });
-});
-// ---- hasReachedMaxRetries ----
-void describe('hasReachedMaxRetries', () => {
-    void it('should return true when retryCount equals maxRetries', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', retryCount: 3 }));
-        assert.strictEqual(hasReachedMaxRetries('feat-1', states, 3), true);
-    });
-    void it('should return true when retryCount exceeds maxRetries', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', retryCount: 5 }));
-        assert.strictEqual(hasReachedMaxRetries('feat-1', states, 3), true);
-    });
-    void it('should return false when retryCount is below maxRetries', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', retryCount: 1 }));
-        assert.strictEqual(hasReachedMaxRetries('feat-1', states, 3), false);
-    });
-    void it('should return false when feature is not in states', () => {
-        const states = makeStates();
-        assert.strictEqual(hasReachedMaxRetries('unknown', states, 3), false);
-    });
-    void it('should return true when maxRetries is 0 and retryCount is 0', () => {
-        const states = makeStates(makeState({ featureId: 'feat-1', retryCount: 0 }));
-        assert.strictEqual(hasReachedMaxRetries('feat-1', states, 0), true);
-    });
-});
-// ---- filterProcessingFeatures ----
-void describe('filterProcessingFeatures', () => {
-    void it('should return empty array for empty feature list', () => {
-        const result = filterProcessingFeatures([], makeStates());
-        assert.deepStrictEqual(result, []);
-    });
-    void it('should return only processing features', () => {
-        const features = [
-            makeFeature({ id: 'a' }),
-            makeFeature({ id: 'b' }),
-            makeFeature({ id: 'c' }),
-        ];
-        const states = makeStates(makeState({ featureId: 'a', status: 'processing' }), makeState({ featureId: 'b', status: 'completed' }), makeState({ featureId: 'c', status: 'processing' }));
-        const result = filterProcessingFeatures(features, states);
-        assert.strictEqual(result.length, 2);
-        assert.strictEqual(result[0].id, 'a');
-        assert.strictEqual(result[1].id, 'c');
-    });
-    void it('should return empty array when no features are processing', () => {
-        const features = [makeFeature({ id: 'a' })];
-        const states = makeStates(makeState({ featureId: 'a', status: 'completed' }));
-        const result = filterProcessingFeatures(features, states);
-        assert.deepStrictEqual(result, []);
-    });
-});
-// ---- filterCompletedFeatures ----
-void describe('filterCompletedFeatures', () => {
-    void it('should return empty array for empty feature list', () => {
-        const result = filterCompletedFeatures([], makeStates());
-        assert.deepStrictEqual(result, []);
-    });
-    void it('should return only completed features', () => {
-        const features = [
-            makeFeature({ id: 'a' }),
-            makeFeature({ id: 'b' }),
-            makeFeature({ id: 'c' }),
-        ];
-        const states = makeStates(makeState({ featureId: 'a', status: 'completed' }), makeState({ featureId: 'b', status: 'failed' }), makeState({ featureId: 'c', status: 'completed' }));
-        const result = filterCompletedFeatures(features, states);
-        assert.strictEqual(result.length, 2);
-        assert.strictEqual(result[0].id, 'a');
-        assert.strictEqual(result[1].id, 'c');
-    });
-});
-// ---- filterFailedFeatures ----
-void describe('filterFailedFeatures', () => {
-    void it('should return empty array for empty feature list', () => {
-        const result = filterFailedFeatures([], makeStates());
-        assert.deepStrictEqual(result, []);
-    });
-    void it('should return only failed features', () => {
-        const features = [
-            makeFeature({ id: 'a' }),
-            makeFeature({ id: 'b' }),
-            makeFeature({ id: 'c' }),
-        ];
-        const states = makeStates(makeState({ featureId: 'a', status: 'failed' }), makeState({ featureId: 'b', status: 'processing' }), makeState({ featureId: 'c', status: 'failed' }));
-        const result = filterFailedFeatures(features, states);
-        assert.strictEqual(result.length, 2);
-        assert.strictEqual(result[0].id, 'a');
-        assert.strictEqual(result[1].id, 'c');
-    });
-});
-// ---- filterAvailableFeatures ----
-void describe('filterAvailableFeatures', () => {
-    const maxRetries = 3;
-    void it('should return empty array for empty feature list', () => {
-        const result = filterAvailableFeatures([], makeStates(), maxRetries);
-        assert.deepStrictEqual(result, []);
-    });
-    void it('should return features that have never been processed', () => {
-        const features = [makeFeature({ id: 'a' }), makeFeature({ id: 'b' })];
-        const states = makeStates();
-        const result = filterAvailableFeatures(features, states, maxRetries);
-        assert.strictEqual(result.length, 2);
-    });
-    void it('should include retryable failed features and exclude completed/processing', () => {
-        const features = [
-            makeFeature({ id: 'a' }),
-            makeFeature({ id: 'b' }),
-            makeFeature({ id: 'c' }),
-            makeFeature({ id: 'd' }),
-        ];
-        const states = makeStates(makeState({ featureId: 'a', status: 'completed' }), makeState({ featureId: 'b', status: 'processing' }), makeState({ featureId: 'c', status: 'failed', retryCount: 1 }), makeState({ featureId: 'd', status: 'failed', retryCount: 5 }));
-        const result = filterAvailableFeatures(features, states, maxRetries);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].id, 'c');
-    });
-    void it('should include features updated after last attempt regardless of status', () => {
-        const features = [
-            makeFeature({ id: 'a', updated_at: '2025-12-01T00:00:00Z' }),
-        ];
-        const states = makeStates(makeState({
-            featureId: 'a',
-            status: 'completed',
-            lastAttempt: new Date('2025-01-01T00:00:00Z'),
-        }));
-        const result = filterAvailableFeatures(features, states, maxRetries);
-        assert.strictEqual(result.length, 1);
-        assert.strictEqual(result[0].id, 'a');
-    });
-});

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

@@ -1,4 +0,0 @@
-/**
- * Unit tests for pipeline result evaluation utilities
- */
-export {};