digital-products 2.1.3 → 2.4.0

package/test/features/flags.test.ts

@@ -1,259 +0,0 @@
-/**
- * Tests for Feature Flags
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  FeatureFlag,
-  createFeatureFlag,
-  FeatureFlagManager,
-  createFeatureFlagManager,
-  FlagEvaluationContext,
-} from '../../src/features/flags.js'
-
-describe('Feature Flags', () => {
-  describe('FeatureFlag()', () => {
-    it('creates a simple boolean flag', () => {
-      const flag = FeatureFlag({
-        key: 'new-dashboard',
-        name: 'New Dashboard',
-        type: 'boolean',
-        defaultValue: false,
-      })
-
-      expect(flag.key).toBe('new-dashboard')
-      expect(flag.type).toBe('boolean')
-      expect(flag.defaultValue).toBe(false)
-    })
-
-    it('creates a string flag with variants', () => {
-      const flag = FeatureFlag({
-        key: 'theme',
-        name: 'Theme',
-        type: 'string',
-        defaultValue: 'light',
-        variants: ['light', 'dark', 'system'],
-      })
-
-      expect(flag.variants).toEqual(['light', 'dark', 'system'])
-    })
-
-    it('creates a number flag with range', () => {
-      const flag = FeatureFlag({
-        key: 'rate-limit',
-        name: 'Rate Limit',
-        type: 'number',
-        defaultValue: 100,
-        min: 10,
-        max: 1000,
-      })
-
-      expect(flag.min).toBe(10)
-      expect(flag.max).toBe(1000)
-    })
-
-    it('creates a JSON flag', () => {
-      const flag = FeatureFlag({
-        key: 'ui-config',
-        name: 'UI Config',
-        type: 'json',
-        defaultValue: { showBanner: true, bannerText: 'Welcome' },
-      })
-
-      expect(flag.defaultValue).toEqual({ showBanner: true, bannerText: 'Welcome' })
-    })
-
-    it('supports targeting rules', () => {
-      const flag = FeatureFlag({
-        key: 'beta-feature',
-        name: 'Beta Feature',
-        type: 'boolean',
-        defaultValue: false,
-        rules: [
-          {
-            condition: { attribute: 'plan', operator: 'equals', value: 'enterprise' },
-            value: true,
-          },
-          {
-            condition: { attribute: 'userId', operator: 'in', value: ['user-1', 'user-2'] },
-            value: true,
-          },
-        ],
-      })
-
-      expect(flag.rules).toHaveLength(2)
-    })
-
-    it('supports percentage rollout', () => {
-      const flag = FeatureFlag({
-        key: 'gradual-release',
-        name: 'Gradual Release',
-        type: 'boolean',
-        defaultValue: false,
-        rolloutPercentage: 25,
-      })
-
-      expect(flag.rolloutPercentage).toBe(25)
-    })
-  })
-
-  describe('FeatureFlagManager', () => {
-    let manager: FeatureFlagManager
-
-    beforeEach(() => {
-      manager = createFeatureFlagManager()
-    })
-
-    it('registers and retrieves flags', () => {
-      const flag = FeatureFlag({
-        key: 'test-flag',
-        name: 'Test',
-        type: 'boolean',
-        defaultValue: true,
-      })
-
-      manager.register(flag)
-      expect(manager.get('test-flag')).toEqual(flag)
-    })
-
-    it('evaluates boolean flag with default', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'simple',
-          name: 'Simple',
-          type: 'boolean',
-          defaultValue: false,
-        })
-      )
-
-      const result = manager.evaluate('simple', {})
-      expect(result).toBe(false)
-    })
-
-    it('evaluates flag with targeting rules', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'premium-only',
-          name: 'Premium Only',
-          type: 'boolean',
-          defaultValue: false,
-          rules: [
-            {
-              condition: { attribute: 'plan', operator: 'equals', value: 'premium' },
-              value: true,
-            },
-          ],
-        })
-      )
-
-      const context: FlagEvaluationContext = {
-        userId: 'user-123',
-        attributes: { plan: 'premium' },
-      }
-
-      expect(manager.evaluate('premium-only', context)).toBe(true)
-    })
-
-    it('evaluates flag with percentage rollout', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'rollout',
-          name: 'Rollout',
-          type: 'boolean',
-          defaultValue: false,
-          rolloutPercentage: 100, // 100% should always be true
-        })
-      )
-
-      const result = manager.evaluate('rollout', { userId: 'any-user' })
-      expect(result).toBe(true)
-    })
-
-    it('returns default for 0% rollout', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'disabled',
-          name: 'Disabled',
-          type: 'boolean',
-          defaultValue: false,
-          rolloutPercentage: 0,
-        })
-      )
-
-      const result = manager.evaluate('disabled', { userId: 'any-user' })
-      expect(result).toBe(false)
-    })
-
-    it('evaluates string flag variants', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'theme',
-          name: 'Theme',
-          type: 'string',
-          defaultValue: 'light',
-          rules: [
-            {
-              condition: { attribute: 'darkModeEnabled', operator: 'equals', value: true },
-              value: 'dark',
-            },
-          ],
-        })
-      )
-
-      const result = manager.evaluate('theme', {
-        attributes: { darkModeEnabled: true },
-      })
-      expect(result).toBe('dark')
-    })
-
-    it('tracks flag evaluations', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'tracked',
-          name: 'Tracked',
-          type: 'boolean',
-          defaultValue: true,
-        })
-      )
-
-      manager.evaluate('tracked', { userId: 'user-1' })
-      manager.evaluate('tracked', { userId: 'user-2' })
-
-      const stats = manager.getEvaluationStats('tracked')
-      expect(stats.totalEvaluations).toBe(2)
-    })
-
-    it('supports overrides for testing', () => {
-      manager.register(
-        FeatureFlag({
-          key: 'overridable',
-          name: 'Overridable',
-          type: 'boolean',
-          defaultValue: false,
-        })
-      )
-
-      manager.setOverride('overridable', true)
-      expect(manager.evaluate('overridable', {})).toBe(true)
-
-      manager.clearOverride('overridable')
-      expect(manager.evaluate('overridable', {})).toBe(false)
-    })
-
-    it('lists all flags', () => {
-      manager.register(FeatureFlag({ key: 'f1', name: 'F1', type: 'boolean', defaultValue: true }))
-      manager.register(FeatureFlag({ key: 'f2', name: 'F2', type: 'string', defaultValue: 'a' }))
-
-      expect(manager.list()).toHaveLength(2)
-    })
-
-    it('removes flags', () => {
-      manager.register(FeatureFlag({ key: 'temp', name: 'Temp', type: 'boolean', defaultValue: true }))
-      expect(manager.get('temp')).toBeDefined()
-
-      manager.remove('temp')
-      expect(manager.get('temp')).toBeUndefined()
-    })
-  })
-})

package/test/features/toggles.test.ts

@@ -1,178 +0,0 @@
-/**
- * Tests for Feature Toggles
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  FeatureToggle,
-  createToggle,
-  ToggleService,
-  createToggleService,
-  ToggleCategory,
-} from '../../src/features/toggles.js'
-
-describe('Feature Toggles', () => {
-  describe('FeatureToggle()', () => {
-    it('creates an ops toggle', () => {
-      const toggle = FeatureToggle({
-        name: 'kill-switch',
-        category: 'ops',
-        enabled: false,
-        description: 'Emergency kill switch',
-      })
-
-      expect(toggle.name).toBe('kill-switch')
-      expect(toggle.category).toBe('ops')
-      expect(toggle.enabled).toBe(false)
-    })
-
-    it('creates a release toggle', () => {
-      const toggle = FeatureToggle({
-        name: 'new-checkout',
-        category: 'release',
-        enabled: false,
-        releaseDate: new Date('2024-03-01'),
-      })
-
-      expect(toggle.category).toBe('release')
-      expect(toggle.releaseDate).toEqual(new Date('2024-03-01'))
-    })
-
-    it('creates an experiment toggle', () => {
-      const toggle = FeatureToggle({
-        name: 'checkout-experiment',
-        category: 'experiment',
-        enabled: true,
-        experimentId: 'exp-checkout-flow',
-      })
-
-      expect(toggle.category).toBe('experiment')
-      expect(toggle.experimentId).toBe('exp-checkout-flow')
-    })
-
-    it('creates a permission toggle', () => {
-      const toggle = FeatureToggle({
-        name: 'admin-panel',
-        category: 'permission',
-        enabled: true,
-        requiredRoles: ['admin', 'super-admin'],
-      })
-
-      expect(toggle.category).toBe('permission')
-      expect(toggle.requiredRoles).toEqual(['admin', 'super-admin'])
-    })
-
-    it('supports expiration date', () => {
-      const toggle = FeatureToggle({
-        name: 'promo-banner',
-        category: 'ops',
-        enabled: true,
-        expiresAt: new Date('2024-12-31'),
-      })
-
-      expect(toggle.expiresAt).toEqual(new Date('2024-12-31'))
-    })
-  })
-
-  describe('ToggleService', () => {
-    let service: ToggleService
-
-    beforeEach(() => {
-      service = createToggleService()
-    })
-
-    it('registers and checks toggles', () => {
-      service.register(
-        FeatureToggle({
-          name: 'feature-x',
-          category: 'release',
-          enabled: true,
-        })
-      )
-
-      expect(service.isEnabled('feature-x')).toBe(true)
-    })
-
-    it('returns false for unknown toggle', () => {
-      expect(service.isEnabled('unknown')).toBe(false)
-    })
-
-    it('enables and disables toggles', () => {
-      service.register(
-        FeatureToggle({
-          name: 'switchable',
-          category: 'ops',
-          enabled: false,
-        })
-      )
-
-      expect(service.isEnabled('switchable')).toBe(false)
-      service.enable('switchable')
-      expect(service.isEnabled('switchable')).toBe(true)
-      service.disable('switchable')
-      expect(service.isEnabled('switchable')).toBe(false)
-    })
-
-    it('checks permission toggles with context', () => {
-      service.register(
-        FeatureToggle({
-          name: 'admin-only',
-          category: 'permission',
-          enabled: true,
-          requiredRoles: ['admin'],
-        })
-      )
-
-      expect(service.isEnabled('admin-only', { roles: ['user'] })).toBe(false)
-      expect(service.isEnabled('admin-only', { roles: ['admin'] })).toBe(true)
-    })
-
-    it('respects expiration dates', () => {
-      service.register(
-        FeatureToggle({
-          name: 'expired',
-          category: 'ops',
-          enabled: true,
-          expiresAt: new Date('2020-01-01'), // Past date
-        })
-      )
-
-      expect(service.isEnabled('expired')).toBe(false)
-    })
-
-    it('lists toggles by category', () => {
-      service.register(FeatureToggle({ name: 't1', category: 'ops', enabled: true }))
-      service.register(FeatureToggle({ name: 't2', category: 'release', enabled: true }))
-      service.register(FeatureToggle({ name: 't3', category: 'ops', enabled: false }))
-
-      const ops = service.listByCategory('ops')
-      expect(ops).toHaveLength(2)
-    })
-
-    it('bulk enables/disables toggles', () => {
-      service.register(FeatureToggle({ name: 'b1', category: 'ops', enabled: false }))
-      service.register(FeatureToggle({ name: 'b2', category: 'ops', enabled: false }))
-
-      service.bulkEnable(['b1', 'b2'])
-      expect(service.isEnabled('b1')).toBe(true)
-      expect(service.isEnabled('b2')).toBe(true)
-
-      service.bulkDisable(['b1', 'b2'])
-      expect(service.isEnabled('b1')).toBe(false)
-    })
-
-    it('exports and imports toggle state', () => {
-      service.register(FeatureToggle({ name: 'export1', category: 'ops', enabled: true }))
-      service.register(FeatureToggle({ name: 'export2', category: 'release', enabled: false }))
-
-      const exported = service.export()
-      expect(exported).toHaveLength(2)
-
-      const newService = createToggleService()
-      newService.import(exported)
-      expect(newService.isEnabled('export1')).toBe(true)
-      expect(newService.isEnabled('export2')).toBe(false)
-    })
-  })
-})

package/test/lifecycle/stages.test.ts

@@ -1,233 +0,0 @@
-/**
- * Tests for Product Lifecycle Stages
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  LifecycleStage,
-  ProductLifecycle,
-  createProductLifecycle,
-  LifecycleManager,
-  createLifecycleManager,
-  LifecycleEvent,
-} from '../../src/lifecycle/stages.js'
-
-describe('Product Lifecycle Stages', () => {
-  describe('LifecycleStage', () => {
-    it('defines alpha stage', () => {
-      const stage: LifecycleStage = {
-        name: 'alpha',
-        displayName: 'Alpha',
-        description: 'Internal testing only',
-        order: 0,
-        isPublic: false,
-        supportLevel: 'none',
-      }
-
-      expect(stage.name).toBe('alpha')
-      expect(stage.isPublic).toBe(false)
-    })
-
-    it('defines beta stage', () => {
-      const stage: LifecycleStage = {
-        name: 'beta',
-        displayName: 'Beta',
-        description: 'External beta testing',
-        order: 1,
-        isPublic: true,
-        supportLevel: 'limited',
-        warningMessage: 'This feature is in beta and may change',
-      }
-
-      expect(stage.name).toBe('beta')
-      expect(stage.supportLevel).toBe('limited')
-    })
-
-    it('defines GA stage', () => {
-      const stage: LifecycleStage = {
-        name: 'ga',
-        displayName: 'Generally Available',
-        description: 'Production ready',
-        order: 2,
-        isPublic: true,
-        supportLevel: 'full',
-      }
-
-      expect(stage.supportLevel).toBe('full')
-    })
-
-    it('defines deprecated stage', () => {
-      const stage: LifecycleStage = {
-        name: 'deprecated',
-        displayName: 'Deprecated',
-        description: 'No longer recommended',
-        order: 3,
-        isPublic: true,
-        supportLevel: 'limited',
-        deprecationDate: new Date('2024-06-01'),
-        migrationGuide: 'https://docs.example.com/migrate',
-      }
-
-      expect(stage.deprecationDate).toBeDefined()
-      expect(stage.migrationGuide).toBeDefined()
-    })
-
-    it('defines sunset stage', () => {
-      const stage: LifecycleStage = {
-        name: 'sunset',
-        displayName: 'End of Life',
-        description: 'Will be removed',
-        order: 4,
-        isPublic: false,
-        supportLevel: 'none',
-        sunsetDate: new Date('2024-12-31'),
-      }
-
-      expect(stage.sunsetDate).toBeDefined()
-    })
-  })
-
-  describe('ProductLifecycle', () => {
-    let lifecycle: ProductLifecycle
-
-    beforeEach(() => {
-      lifecycle = createProductLifecycle({
-        productId: 'my-feature',
-        currentStage: 'beta',
-      })
-    })
-
-    it('creates lifecycle with initial stage', () => {
-      expect(lifecycle.productId).toBe('my-feature')
-      expect(lifecycle.currentStage).toBe('beta')
-    })
-
-    it('tracks lifecycle history', () => {
-      expect(lifecycle.history).toHaveLength(1)
-      expect(lifecycle.history[0].stage).toBe('beta')
-    })
-
-    it('advances to next stage', () => {
-      const updated = lifecycle.advance('ga')
-      expect(updated.currentStage).toBe('ga')
-      expect(updated.history).toHaveLength(2)
-    })
-
-    it('rejects invalid transitions', () => {
-      expect(() => lifecycle.advance('alpha')).toThrow('Cannot transition backwards')
-    })
-
-    it('supports custom transition validation', () => {
-      const strictLifecycle = createProductLifecycle({
-        productId: 'strict-feature',
-        currentStage: 'alpha',
-        validateTransition: (from, to) => {
-          // Only allow sequential transitions
-          const stages = ['alpha', 'beta', 'ga', 'deprecated', 'sunset']
-          const fromIdx = stages.indexOf(from)
-          const toIdx = stages.indexOf(to)
-          return toIdx === fromIdx + 1
-        },
-      })
-
-      expect(() => strictLifecycle.advance('ga')).toThrow()
-    })
-
-    it('includes metadata in history', () => {
-      const updated = lifecycle.advance('ga', {
-        reason: 'Passed all quality gates',
-        approvedBy: 'eng-lead',
-      })
-
-      expect(updated.history[1].metadata?.reason).toBe('Passed all quality gates')
-    })
-
-    it('calculates time in stage', () => {
-      const time = lifecycle.getTimeInCurrentStage()
-      expect(time).toBeGreaterThanOrEqual(0)
-    })
-  })
-
-  describe('LifecycleManager', () => {
-    let manager: LifecycleManager
-
-    beforeEach(() => {
-      manager = createLifecycleManager()
-    })
-
-    it('registers product lifecycle', () => {
-      manager.register({
-        productId: 'feature-a',
-        currentStage: 'beta',
-      })
-
-      expect(manager.get('feature-a')).toBeDefined()
-    })
-
-    it('advances product stage', () => {
-      manager.register({
-        productId: 'feature-b',
-        currentStage: 'beta',
-      })
-
-      manager.advanceStage('feature-b', 'ga')
-      expect(manager.get('feature-b')?.currentStage).toBe('ga')
-    })
-
-    it('lists products by stage', () => {
-      manager.register({ productId: 'p1', currentStage: 'alpha' })
-      manager.register({ productId: 'p2', currentStage: 'beta' })
-      manager.register({ productId: 'p3', currentStage: 'beta' })
-      manager.register({ productId: 'p4', currentStage: 'ga' })
-
-      const beta = manager.listByStage('beta')
-      expect(beta).toHaveLength(2)
-    })
-
-    it('finds deprecated products', () => {
-      manager.register({ productId: 'old', currentStage: 'deprecated' })
-      manager.register({ productId: 'newer', currentStage: 'ga' })
-
-      const deprecated = manager.listByStage('deprecated')
-      expect(deprecated).toHaveLength(1)
-      expect(deprecated[0].productId).toBe('old')
-    })
-
-    it('emits stage change events', () => {
-      const events: LifecycleEvent[] = []
-      manager.on('stage.changed', (e) => events.push(e))
-
-      manager.register({ productId: 'event-test', currentStage: 'beta' })
-      manager.advanceStage('event-test', 'ga')
-
-      expect(events).toHaveLength(1)
-      expect(events[0].fromStage).toBe('beta')
-      expect(events[0].toStage).toBe('ga')
-    })
-
-    it('schedules future stage transitions', () => {
-      manager.register({ productId: 'scheduled', currentStage: 'ga' })
-
-      manager.scheduleTransition('scheduled', 'deprecated', {
-        date: new Date('2024-12-01'),
-        reason: 'Planned deprecation',
-      })
-
-      const scheduled = manager.getScheduledTransitions('scheduled')
-      expect(scheduled).toHaveLength(1)
-    })
-
-    it('gets lifecycle summary', () => {
-      manager.register({ productId: 's1', currentStage: 'alpha' })
-      manager.register({ productId: 's2', currentStage: 'beta' })
-      manager.register({ productId: 's3', currentStage: 'ga' })
-      manager.register({ productId: 's4', currentStage: 'ga' })
-
-      const summary = manager.getSummary()
-      expect(summary.alpha).toBe(1)
-      expect(summary.beta).toBe(1)
-      expect(summary.ga).toBe(2)
-    })
-  })
-})