digital-products 2.1.3 → 2.3.0

package/test/lifecycle/transitions.test.ts

@@ -1,207 +0,0 @@
-/**
- * Tests for Lifecycle Transitions
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  TransitionRule,
-  createTransitionRule,
-  TransitionChecker,
-  createTransitionChecker,
-  TransitionResult,
-} from '../../src/lifecycle/transitions.js'
-
-describe('Lifecycle Transitions', () => {
-  describe('TransitionRule', () => {
-    it('creates a basic rule', () => {
-      const rule = createTransitionRule({
-        from: 'beta',
-        to: 'ga',
-        name: 'Beta to GA',
-      })
-
-      expect(rule.from).toBe('beta')
-      expect(rule.to).toBe('ga')
-    })
-
-    it('supports preconditions', () => {
-      const rule = createTransitionRule({
-        from: 'beta',
-        to: 'ga',
-        name: 'GA Readiness',
-        preconditions: [
-          { name: 'tests-pass', check: () => true },
-          { name: 'docs-complete', check: () => true },
-        ],
-      })
-
-      expect(rule.preconditions).toHaveLength(2)
-    })
-
-    it('supports required approvals', () => {
-      const rule = createTransitionRule({
-        from: 'ga',
-        to: 'deprecated',
-        name: 'Deprecation',
-        requiredApprovals: ['product-lead', 'eng-lead'],
-      })
-
-      expect(rule.requiredApprovals).toContain('product-lead')
-    })
-
-    it('supports notifications', () => {
-      const rule = createTransitionRule({
-        from: 'deprecated',
-        to: 'sunset',
-        name: 'Sunset',
-        notifications: [
-          { channel: 'email', recipients: ['users'] },
-          { channel: 'slack', recipients: ['#product'] },
-        ],
-      })
-
-      expect(rule.notifications).toHaveLength(2)
-    })
-  })
-
-  describe('TransitionChecker', () => {
-    let checker: TransitionChecker
-
-    beforeEach(() => {
-      checker = createTransitionChecker()
-    })
-
-    it('validates allowed transition', () => {
-      checker.addRule(
-        createTransitionRule({
-          from: 'beta',
-          to: 'ga',
-          name: 'Beta to GA',
-        })
-      )
-
-      const result = checker.check('beta', 'ga')
-      expect(result.allowed).toBe(true)
-    })
-
-    it('rejects disallowed transition', () => {
-      checker.addRule(
-        createTransitionRule({
-          from: 'beta',
-          to: 'ga',
-          name: 'Beta to GA',
-        })
-      )
-
-      const result = checker.check('ga', 'beta')
-      expect(result.allowed).toBe(false)
-      expect(result.reason).toContain('No rule defined')
-    })
-
-    it('checks preconditions', async () => {
-      let testsPass = false
-
-      checker.addRule(
-        createTransitionRule({
-          from: 'beta',
-          to: 'ga',
-          name: 'Beta to GA',
-          preconditions: [{ name: 'tests-pass', check: () => testsPass }],
-        })
-      )
-
-      let result = await checker.checkWithPreconditions('beta', 'ga')
-      expect(result.allowed).toBe(false)
-      expect(result.failedPreconditions).toContain('tests-pass')
-
-      testsPass = true
-      result = await checker.checkWithPreconditions('beta', 'ga')
-      expect(result.allowed).toBe(true)
-    })
-
-    it('checks async preconditions', async () => {
-      checker.addRule(
-        createTransitionRule({
-          from: 'beta',
-          to: 'ga',
-          name: 'Beta to GA',
-          preconditions: [
-            {
-              name: 'api-check',
-              check: async () => {
-                // Simulate API check
-                return true
-              },
-            },
-          ],
-        })
-      )
-
-      const result = await checker.checkWithPreconditions('beta', 'ga')
-      expect(result.allowed).toBe(true)
-    })
-
-    it('checks required approvals', () => {
-      checker.addRule(
-        createTransitionRule({
-          from: 'ga',
-          to: 'deprecated',
-          name: 'Deprecation',
-          requiredApprovals: ['product-lead', 'eng-lead'],
-        })
-      )
-
-      const result = checker.checkApprovals('ga', 'deprecated', {
-        approvals: ['product-lead'],
-      })
-
-      expect(result.allowed).toBe(false)
-      expect(result.missingApprovals).toContain('eng-lead')
-    })
-
-    it('passes with all approvals', () => {
-      checker.addRule(
-        createTransitionRule({
-          from: 'ga',
-          to: 'deprecated',
-          name: 'Deprecation',
-          requiredApprovals: ['product-lead', 'eng-lead'],
-        })
-      )
-
-      const result = checker.checkApprovals('ga', 'deprecated', {
-        approvals: ['product-lead', 'eng-lead'],
-      })
-
-      expect(result.allowed).toBe(true)
-    })
-
-    it('lists available transitions', () => {
-      checker.addRule(createTransitionRule({ from: 'alpha', to: 'beta', name: 'To Beta' }))
-      checker.addRule(createTransitionRule({ from: 'beta', to: 'ga', name: 'To GA' }))
-      checker.addRule(createTransitionRule({ from: 'beta', to: 'alpha', name: 'Rollback' }))
-
-      const available = checker.getAvailableTransitions('beta')
-      expect(available).toContain('ga')
-      expect(available).toContain('alpha')
-    })
-
-    it('validates transition path', () => {
-      checker.addRule(createTransitionRule({ from: 'alpha', to: 'beta', name: 'To Beta' }))
-      checker.addRule(createTransitionRule({ from: 'beta', to: 'ga', name: 'To GA' }))
-
-      const path = checker.validatePath(['alpha', 'beta', 'ga'])
-      expect(path.valid).toBe(true)
-    })
-
-    it('rejects invalid transition path', () => {
-      checker.addRule(createTransitionRule({ from: 'alpha', to: 'beta', name: 'To Beta' }))
-      checker.addRule(createTransitionRule({ from: 'beta', to: 'ga', name: 'To GA' }))
-
-      const path = checker.validatePath(['alpha', 'ga']) // Missing beta
-      expect(path.valid).toBe(false)
-      expect(path.invalidAt).toBe(1)
-    })
-  })
-})

package/test/onboarding/flows.test.ts

@@ -1,307 +0,0 @@
-/**
- * Tests for Onboarding Flows
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  OnboardingFlow,
-  createOnboardingFlow,
-  OnboardingStep,
-  OnboardingManager,
-  createOnboardingManager,
-  UserOnboardingState,
-} from '../../src/onboarding/flows.js'
-
-describe('Onboarding Flows', () => {
-  describe('OnboardingStep', () => {
-    it('defines a step with required fields', () => {
-      const step: OnboardingStep = {
-        id: 'welcome',
-        name: 'Welcome',
-        description: 'Welcome to the product',
-        order: 0,
-      }
-
-      expect(step.id).toBe('welcome')
-      expect(step.order).toBe(0)
-    })
-
-    it('supports completion criteria', () => {
-      const step: OnboardingStep = {
-        id: 'profile-setup',
-        name: 'Set Up Profile',
-        order: 1,
-        completionCriteria: {
-          event: 'profile.completed',
-          requiredFields: ['name', 'avatar'],
-        },
-      }
-
-      expect(step.completionCriteria?.event).toBe('profile.completed')
-    })
-
-    it('supports skip conditions', () => {
-      const step: OnboardingStep = {
-        id: 'connect-integration',
-        name: 'Connect Integration',
-        order: 2,
-        skippable: true,
-        skipCondition: {
-          attribute: 'hasIntegrations',
-          value: true,
-        },
-      }
-
-      expect(step.skippable).toBe(true)
-    })
-
-    it('supports custom content', () => {
-      const step: OnboardingStep = {
-        id: 'tutorial',
-        name: 'Tutorial',
-        order: 3,
-        content: {
-          type: 'video',
-          url: 'https://example.com/tutorial.mp4',
-          duration: 120,
-        },
-      }
-
-      expect(step.content?.type).toBe('video')
-    })
-  })
-
-  describe('OnboardingFlow', () => {
-    it('creates a flow with steps', () => {
-      const flow = createOnboardingFlow({
-        id: 'new-user',
-        name: 'New User Onboarding',
-        steps: [
-          { id: 'welcome', name: 'Welcome', order: 0 },
-          { id: 'setup', name: 'Setup', order: 1 },
-          { id: 'first-task', name: 'First Task', order: 2 },
-        ],
-      })
-
-      expect(flow.id).toBe('new-user')
-      expect(flow.steps).toHaveLength(3)
-    })
-
-    it('orders steps correctly', () => {
-      const flow = createOnboardingFlow({
-        id: 'ordered',
-        name: 'Ordered Flow',
-        steps: [
-          { id: 'c', name: 'C', order: 2 },
-          { id: 'a', name: 'A', order: 0 },
-          { id: 'b', name: 'B', order: 1 },
-        ],
-      })
-
-      expect(flow.steps[0].id).toBe('a')
-      expect(flow.steps[1].id).toBe('b')
-      expect(flow.steps[2].id).toBe('c')
-    })
-
-    it('supports conditional steps', () => {
-      const flow = createOnboardingFlow({
-        id: 'conditional',
-        name: 'Conditional Flow',
-        steps: [
-          { id: 'base', name: 'Base', order: 0 },
-          {
-            id: 'enterprise-only',
-            name: 'Enterprise Setup',
-            order: 1,
-            condition: { attribute: 'tier', operator: 'equals', value: 'enterprise' },
-          },
-        ],
-      })
-
-      expect(flow.steps[1].condition).toBeDefined()
-    })
-
-    it('supports tier-specific flows', () => {
-      const flow = createOnboardingFlow({
-        id: 'pro-onboarding',
-        name: 'Pro User Onboarding',
-        targetTiers: ['pro', 'enterprise'],
-        steps: [
-          { id: 'advanced-features', name: 'Advanced Features', order: 0 },
-        ],
-      })
-
-      expect(flow.targetTiers).toContain('pro')
-    })
-
-    it('calculates estimated duration', () => {
-      const flow = createOnboardingFlow({
-        id: 'timed',
-        name: 'Timed Flow',
-        steps: [
-          { id: 's1', name: 'S1', order: 0, estimatedMinutes: 5 },
-          { id: 's2', name: 'S2', order: 1, estimatedMinutes: 10 },
-          { id: 's3', name: 'S3', order: 2, estimatedMinutes: 3 },
-        ],
-      })
-
-      expect(flow.totalEstimatedMinutes).toBe(18)
-    })
-  })
-
-  describe('OnboardingManager', () => {
-    let manager: OnboardingManager
-
-    beforeEach(() => {
-      manager = createOnboardingManager()
-
-      manager.registerFlow(
-        createOnboardingFlow({
-          id: 'default',
-          name: 'Default Onboarding',
-          steps: [
-            { id: 'welcome', name: 'Welcome', order: 0 },
-            { id: 'setup', name: 'Setup', order: 1 },
-            { id: 'complete', name: 'Complete', order: 2 },
-          ],
-        })
-      )
-    })
-
-    it('starts onboarding for user', () => {
-      const state = manager.startOnboarding('user-123', 'default')
-
-      expect(state.userId).toBe('user-123')
-      expect(state.flowId).toBe('default')
-      expect(state.currentStepId).toBe('welcome')
-      expect(state.completedSteps).toHaveLength(0)
-    })
-
-    it('advances to next step', () => {
-      manager.startOnboarding('user-456', 'default')
-      const state = manager.completeStep('user-456', 'welcome')
-
-      expect(state.currentStepId).toBe('setup')
-      expect(state.completedSteps).toContain('welcome')
-    })
-
-    it('completes onboarding', () => {
-      manager.startOnboarding('user-789', 'default')
-      manager.completeStep('user-789', 'welcome')
-      manager.completeStep('user-789', 'setup')
-      const state = manager.completeStep('user-789', 'complete')
-
-      expect(state.status).toBe('completed')
-      expect(state.completedAt).toBeDefined()
-    })
-
-    it('calculates progress', () => {
-      manager.startOnboarding('user-progress', 'default')
-      expect(manager.getProgress('user-progress')).toBe(0)
-
-      manager.completeStep('user-progress', 'welcome')
-      expect(manager.getProgress('user-progress')).toBeCloseTo(33, 0)
-
-      manager.completeStep('user-progress', 'setup')
-      expect(manager.getProgress('user-progress')).toBeCloseTo(67, 0)
-    })
-
-    it('skips steps', () => {
-      manager.registerFlow(
-        createOnboardingFlow({
-          id: 'skippable',
-          name: 'Skippable Flow',
-          steps: [
-            { id: 's1', name: 'S1', order: 0 },
-            { id: 's2', name: 'S2', order: 1, skippable: true },
-            { id: 's3', name: 'S3', order: 2 },
-          ],
-        })
-      )
-
-      manager.startOnboarding('skip-user', 'skippable')
-      manager.completeStep('skip-user', 's1')
-      const state = manager.skipStep('skip-user', 's2')
-
-      expect(state.currentStepId).toBe('s3')
-      expect(state.skippedSteps).toContain('s2')
-    })
-
-    it('prevents skipping non-skippable steps', () => {
-      manager.startOnboarding('no-skip-user', 'default')
-
-      expect(() => manager.skipStep('no-skip-user', 'welcome')).toThrow(
-        'Step is not skippable'
-      )
-    })
-
-    it('resumes onboarding', () => {
-      manager.startOnboarding('resume-user', 'default')
-      manager.completeStep('resume-user', 'welcome')
-
-      // Simulate session end and resume
-      const state = manager.getState('resume-user')
-      expect(state?.currentStepId).toBe('setup')
-    })
-
-    it('tracks time spent per step', () => {
-      manager.startOnboarding('time-user', 'default')
-
-      // Simulate spending time on step
-      manager.startStep('time-user', 'welcome')
-      // ... time passes ...
-      manager.completeStep('time-user', 'welcome')
-
-      const state = manager.getState('time-user')
-      expect(state?.stepTimes?.welcome).toBeDefined()
-    })
-
-    it('supports multiple flows per user', () => {
-      manager.registerFlow(
-        createOnboardingFlow({
-          id: 'advanced',
-          name: 'Advanced Features',
-          steps: [{ id: 'advanced-1', name: 'Advanced 1', order: 0 }],
-        })
-      )
-
-      manager.startOnboarding('multi-flow-user', 'default')
-      manager.startOnboarding('multi-flow-user', 'advanced')
-
-      const flows = manager.getActiveFlows('multi-flow-user')
-      expect(flows).toHaveLength(2)
-    })
-
-    it('emits events on step completion', () => {
-      const events: Array<{ event: string; stepId: string }> = []
-      manager.on('step.completed', (e) => events.push(e))
-
-      manager.startOnboarding('event-user', 'default')
-      manager.completeStep('event-user', 'welcome')
-
-      expect(events).toHaveLength(1)
-      expect(events[0].stepId).toBe('welcome')
-    })
-
-    it('gets onboarding analytics', () => {
-      // Complete flow for some users
-      for (let i = 0; i < 5; i++) {
-        manager.startOnboarding(`user-${i}`, 'default')
-        manager.completeStep(`user-${i}`, 'welcome')
-        if (i < 3) {
-          manager.completeStep(`user-${i}`, 'setup')
-        }
-        if (i < 2) {
-          manager.completeStep(`user-${i}`, 'complete')
-        }
-      }
-
-      const analytics = manager.getAnalytics('default')
-      expect(analytics.started).toBe(5)
-      expect(analytics.completed).toBe(2)
-      expect(analytics.dropoffByStep.welcome).toBe(0)
-      expect(analytics.dropoffByStep.setup).toBe(1)
-    })
-  })
-})