digital-products 2.1.3 → 2.3.0

package/test/analytics/experiments.test.ts

@@ -1,327 +0,0 @@
-/**
- * Tests for A/B Experiments Integration
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  ProductExperiment,
-  createProductExperiment,
-  ExperimentManager,
-  createExperimentManager,
-  ExperimentVariant,
-  ExperimentAssignment,
-} from '../../src/analytics/experiments.js'
-
-describe('Product Experiments', () => {
-  describe('ProductExperiment', () => {
-    it('creates an A/B experiment', () => {
-      const experiment = createProductExperiment({
-        id: 'checkout-flow',
-        name: 'Checkout Flow Test',
-        description: 'Testing new checkout flow',
-        variants: [
-          { id: 'control', name: 'Original', weight: 50 },
-          { id: 'treatment', name: 'New Flow', weight: 50 },
-        ],
-      })
-
-      expect(experiment.id).toBe('checkout-flow')
-      expect(experiment.variants).toHaveLength(2)
-    })
-
-    it('creates a multivariate experiment', () => {
-      const experiment = createProductExperiment({
-        id: 'cta-test',
-        name: 'CTA Button Test',
-        variants: [
-          { id: 'a', name: 'Get Started', weight: 33 },
-          { id: 'b', name: 'Try Free', weight: 33 },
-          { id: 'c', name: 'Sign Up', weight: 34 },
-        ],
-      })
-
-      expect(experiment.variants).toHaveLength(3)
-    })
-
-    it('validates variant weights sum to 100', () => {
-      expect(() =>
-        createProductExperiment({
-          id: 'invalid',
-          name: 'Invalid',
-          variants: [
-            { id: 'a', name: 'A', weight: 30 },
-            { id: 'b', name: 'B', weight: 30 },
-          ],
-        })
-      ).toThrow('Variant weights must sum to 100')
-    })
-
-    it('supports targeting rules', () => {
-      const experiment = createProductExperiment({
-        id: 'targeted',
-        name: 'Targeted Experiment',
-        variants: [
-          { id: 'control', name: 'Control', weight: 50 },
-          { id: 'treatment', name: 'Treatment', weight: 50 },
-        ],
-        targeting: {
-          tiers: ['pro', 'enterprise'],
-          countries: ['US', 'CA', 'UK'],
-        },
-      })
-
-      expect(experiment.targeting?.tiers).toContain('pro')
-    })
-
-    it('supports date ranges', () => {
-      const experiment = createProductExperiment({
-        id: 'time-bound',
-        name: 'Time Bound Test',
-        variants: [
-          { id: 'control', name: 'Control', weight: 50 },
-          { id: 'treatment', name: 'Treatment', weight: 50 },
-        ],
-        startDate: new Date('2024-01-01'),
-        endDate: new Date('2024-03-01'),
-      })
-
-      expect(experiment.startDate).toBeDefined()
-      expect(experiment.endDate).toBeDefined()
-    })
-
-    it('supports goal metrics', () => {
-      const experiment = createProductExperiment({
-        id: 'with-goals',
-        name: 'Conversion Test',
-        variants: [
-          { id: 'control', name: 'Control', weight: 50 },
-          { id: 'treatment', name: 'Treatment', weight: 50 },
-        ],
-        goals: [
-          { event: 'signup.completed', type: 'conversion' },
-          { event: 'subscription.created', type: 'conversion' },
-          { event: 'time.on.page', type: 'duration' },
-        ],
-      })
-
-      expect(experiment.goals).toHaveLength(3)
-    })
-  })
-
-  describe('ExperimentManager', () => {
-    let manager: ExperimentManager
-
-    beforeEach(() => {
-      manager = createExperimentManager()
-    })
-
-    it('registers experiments', () => {
-      const experiment = createProductExperiment({
-        id: 'test-exp',
-        name: 'Test',
-        variants: [
-          { id: 'control', name: 'Control', weight: 50 },
-          { id: 'treatment', name: 'Treatment', weight: 50 },
-        ],
-      })
-
-      manager.register(experiment)
-      expect(manager.get('test-exp')).toEqual(experiment)
-    })
-
-    it('assigns users to variants', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'assignment-test',
-          name: 'Assignment Test',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-        })
-      )
-
-      const assignment = manager.assign('assignment-test', 'user-123')
-      expect(['control', 'treatment']).toContain(assignment.variantId)
-      expect(assignment.userId).toBe('user-123')
-    })
-
-    it('returns consistent assignments for same user', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'sticky-test',
-          name: 'Sticky Test',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-        })
-      )
-
-      const first = manager.assign('sticky-test', 'user-456')
-      const second = manager.assign('sticky-test', 'user-456')
-      const third = manager.assign('sticky-test', 'user-456')
-
-      expect(first.variantId).toBe(second.variantId)
-      expect(second.variantId).toBe(third.variantId)
-    })
-
-    it('respects targeting rules', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'targeted-exp',
-          name: 'Targeted',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-          targeting: {
-            tiers: ['enterprise'],
-          },
-        })
-      )
-
-      const freeUserAssignment = manager.assign('targeted-exp', 'free-user', {
-        tier: 'free',
-      })
-      expect(freeUserAssignment.variantId).toBeNull() // Not eligible
-
-      const enterpriseAssignment = manager.assign('targeted-exp', 'enterprise-user', {
-        tier: 'enterprise',
-      })
-      expect(enterpriseAssignment.variantId).not.toBeNull()
-    })
-
-    it('respects date ranges', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'date-exp',
-          name: 'Date Test',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-          startDate: new Date('2020-01-01'),
-          endDate: new Date('2020-12-31'),
-        })
-      )
-
-      const assignment = manager.assign('date-exp', 'user-789')
-      expect(assignment.variantId).toBeNull() // Experiment ended
-    })
-
-    it('tracks experiment events', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'tracked-exp',
-          name: 'Tracked',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-          goals: [{ event: 'purchase.completed', type: 'conversion' }],
-        })
-      )
-
-      manager.assign('tracked-exp', 'user-track')
-      manager.trackEvent('tracked-exp', 'user-track', 'purchase.completed', {
-        amount: 99,
-      })
-
-      const results = manager.getResults('tracked-exp')
-      expect(results.events).toHaveLength(1)
-    })
-
-    it('calculates experiment results', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'results-exp',
-          name: 'Results Test',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-          goals: [{ event: 'conversion', type: 'conversion' }],
-        })
-      )
-
-      // Simulate some assignments and events
-      for (let i = 0; i < 100; i++) {
-        manager.assign('results-exp', `user-${i}`)
-      }
-
-      const results = manager.getResults('results-exp')
-      expect(results.totalAssignments).toBe(100)
-      expect(results.variantStats.control).toBeDefined()
-      expect(results.variantStats.treatment).toBeDefined()
-    })
-
-    it('supports experiment overrides', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'override-exp',
-          name: 'Override Test',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-        })
-      )
-
-      manager.setOverride('override-exp', 'treatment')
-      const assignment = manager.assign('override-exp', 'any-user')
-      expect(assignment.variantId).toBe('treatment')
-    })
-
-    it('pauses and resumes experiments', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'pause-exp',
-          name: 'Pause Test',
-          variants: [
-            { id: 'control', name: 'Control', weight: 50 },
-            { id: 'treatment', name: 'Treatment', weight: 50 },
-          ],
-        })
-      )
-
-      manager.pause('pause-exp')
-      const paused = manager.assign('pause-exp', 'user-1')
-      expect(paused.variantId).toBeNull()
-
-      manager.resume('pause-exp')
-      const resumed = manager.assign('pause-exp', 'user-2')
-      expect(resumed.variantId).not.toBeNull()
-    })
-
-    it('lists active experiments', () => {
-      manager.register(
-        createProductExperiment({
-          id: 'active-1',
-          name: 'Active 1',
-          variants: [
-            { id: 'a', name: 'A', weight: 50 },
-            { id: 'b', name: 'B', weight: 50 },
-          ],
-        })
-      )
-      manager.register(
-        createProductExperiment({
-          id: 'active-2',
-          name: 'Active 2',
-          variants: [
-            { id: 'a', name: 'A', weight: 50 },
-            { id: 'b', name: 'B', weight: 50 },
-          ],
-        })
-      )
-
-      manager.pause('active-2')
-
-      const active = manager.listActive()
-      expect(active).toHaveLength(1)
-      expect(active[0].id).toBe('active-1')
-    })
-  })
-})

package/test/features/define.test.ts

@@ -1,187 +0,0 @@
-/**
- * Tests for Feature definitions
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect } from 'vitest'
-import {
-  Feature,
-  defineFeature,
-  FeatureRegistry,
-  createFeatureRegistry,
-} from '../../src/features/define.js'
-
-describe('Feature Definition', () => {
-  describe('Feature()', () => {
-    it('creates a feature with required properties', () => {
-      const feature = Feature({
-        id: 'dark-mode',
-        name: 'Dark Mode',
-        description: 'Enable dark mode UI',
-      })
-
-      expect(feature.id).toBe('dark-mode')
-      expect(feature.name).toBe('Dark Mode')
-      expect(feature.description).toBe('Enable dark mode UI')
-    })
-
-    it('supports feature categories', () => {
-      const feature = Feature({
-        id: 'analytics',
-        name: 'Analytics Dashboard',
-        description: 'View analytics',
-        category: 'reporting',
-      })
-
-      expect(feature.category).toBe('reporting')
-    })
-
-    it('supports dependencies on other features', () => {
-      const feature = Feature({
-        id: 'advanced-charts',
-        name: 'Advanced Charts',
-        description: 'Premium chart types',
-        dependencies: ['analytics', 'data-export'],
-      })
-
-      expect(feature.dependencies).toEqual(['analytics', 'data-export'])
-    })
-
-    it('supports feature metadata', () => {
-      const feature = Feature({
-        id: 'ai-assistant',
-        name: 'AI Assistant',
-        description: 'AI-powered help',
-        metadata: {
-          releaseDate: '2024-01-15',
-          team: 'ai-core',
-        },
-      })
-
-      expect(feature.metadata?.releaseDate).toBe('2024-01-15')
-      expect(feature.metadata?.team).toBe('ai-core')
-    })
-
-    it('defaults status to active', () => {
-      const feature = Feature({
-        id: 'test',
-        name: 'Test',
-        description: 'Test feature',
-      })
-
-      expect(feature.status).toBe('active')
-    })
-
-    it('supports custom status', () => {
-      const feature = Feature({
-        id: 'beta',
-        name: 'Beta Feature',
-        description: 'In beta',
-        status: 'beta',
-      })
-
-      expect(feature.status).toBe('beta')
-    })
-  })
-
-  describe('defineFeature()', () => {
-    it('creates and validates a feature definition', () => {
-      const feature = defineFeature({
-        id: 'notifications',
-        name: 'Notifications',
-        description: 'Push notifications',
-        version: '1.0.0',
-      })
-
-      expect(feature.id).toBe('notifications')
-      expect(feature.version).toBe('1.0.0')
-    })
-
-    it('throws for invalid feature id', () => {
-      expect(() =>
-        defineFeature({
-          id: '',
-          name: 'Invalid',
-          description: 'No ID',
-        })
-      ).toThrow('Feature ID is required')
-    })
-  })
-
-  describe('FeatureRegistry', () => {
-    it('registers and retrieves features', () => {
-      const registry = createFeatureRegistry()
-
-      const feature = Feature({
-        id: 'storage',
-        name: 'Cloud Storage',
-        description: 'Store files',
-      })
-
-      registry.register(feature)
-      const retrieved = registry.get('storage')
-
-      expect(retrieved).toEqual(feature)
-    })
-
-    it('lists all features', () => {
-      const registry = createFeatureRegistry()
-
-      registry.register(Feature({ id: 'f1', name: 'F1', description: 'D1' }))
-      registry.register(Feature({ id: 'f2', name: 'F2', description: 'D2' }))
-
-      expect(registry.list()).toHaveLength(2)
-    })
-
-    it('filters features by category', () => {
-      const registry = createFeatureRegistry()
-
-      registry.register(
-        Feature({
-          id: 'chart',
-          name: 'Charts',
-          description: 'Charts',
-          category: 'reporting',
-        })
-      )
-      registry.register(
-        Feature({
-          id: 'auth',
-          name: 'Auth',
-          description: 'Auth',
-          category: 'security',
-        })
-      )
-
-      const reporting = registry.listByCategory('reporting')
-      expect(reporting).toHaveLength(1)
-      expect(reporting[0].id).toBe('chart')
-    })
-
-    it('returns feature dependency graph', () => {
-      const registry = createFeatureRegistry()
-
-      registry.register(Feature({ id: 'base', name: 'Base', description: 'Base' }))
-      registry.register(
-        Feature({
-          id: 'advanced',
-          name: 'Advanced',
-          description: 'Advanced',
-          dependencies: ['base'],
-        })
-      )
-      registry.register(
-        Feature({
-          id: 'premium',
-          name: 'Premium',
-          description: 'Premium',
-          dependencies: ['advanced'],
-        })
-      )
-
-      const deps = registry.getDependencyGraph('premium')
-      expect(deps).toContain('base')
-      expect(deps).toContain('advanced')
-    })
-  })
-})