business-as-code 2.1.1 → 2.3.0

package/test/process.test.ts

@@ -0,0 +1,503 @@
+/**
+ * Tests for process.ts - Business process definition and management
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  Process,
+  getStepsInOrder,
+  getStepsByAutomationLevel,
+  calculateTotalDuration,
+  formatDuration,
+  calculateAutomationPercentage,
+  getMetric,
+  meetsTarget,
+  calculateMetricAchievement,
+  updateMetric,
+  addStep,
+  removeStep,
+  validateProcess,
+} from '../src/process.js'
+import type { ProcessDefinition, ProcessStep, ProcessMetric } from '../src/types.js'
+
+describe('Process', () => {
+  describe('Process()', () => {
+    it('should create a process with required fields', () => {
+      const process = Process({ name: 'Test Process' })
+
+      expect(process.name).toBe('Test Process')
+      expect(process.category).toBe('support')
+      expect(process.steps).toEqual([])
+      expect(process.inputs).toEqual([])
+      expect(process.outputs).toEqual([])
+      expect(process.metrics).toEqual([])
+      expect(process.metadata).toEqual({})
+    })
+
+    it('should create a process with all fields', () => {
+      const process = Process({
+        name: 'Customer Onboarding',
+        description: 'Onboard new customers',
+        category: 'core',
+        owner: 'Customer Success',
+        steps: [
+          { order: 1, name: 'Welcome Email', automationLevel: 'automated' },
+          { order: 2, name: 'Setup Call', automationLevel: 'manual' },
+        ],
+        inputs: ['Customer Info', 'Subscription Plan'],
+        outputs: ['Configured Account'],
+        metrics: [{ name: 'Time to Value', target: 24, unit: 'hours' }],
+        metadata: { version: 1 },
+      })
+
+      expect(process.name).toBe('Customer Onboarding')
+      expect(process.category).toBe('core')
+      expect(process.steps).toHaveLength(2)
+      expect(process.inputs).toHaveLength(2)
+      expect(process.outputs).toHaveLength(1)
+      expect(process.metrics).toHaveLength(1)
+    })
+
+    it('should throw error if name is missing', () => {
+      expect(() => Process({ name: '' })).toThrow('Process name is required')
+    })
+  })
+
+  describe('getStepsInOrder()', () => {
+    const process = Process({
+      name: 'Test',
+      steps: [
+        { order: 3, name: 'Third' },
+        { order: 1, name: 'First' },
+        { order: 2, name: 'Second' },
+      ],
+    })
+
+    it('should return steps sorted by order', () => {
+      const sorted = getStepsInOrder(process)
+
+      expect(sorted[0]?.name).toBe('First')
+      expect(sorted[1]?.name).toBe('Second')
+      expect(sorted[2]?.name).toBe('Third')
+    })
+
+    it('should handle empty steps', () => {
+      const emptyProcess = Process({ name: 'Empty' })
+      const sorted = getStepsInOrder(emptyProcess)
+
+      expect(sorted).toEqual([])
+    })
+  })
+
+  describe('getStepsByAutomationLevel()', () => {
+    const process = Process({
+      name: 'Test',
+      steps: [
+        { order: 1, name: 'Step 1', automationLevel: 'automated' },
+        { order: 2, name: 'Step 2', automationLevel: 'manual' },
+        { order: 3, name: 'Step 3', automationLevel: 'automated' },
+        { order: 4, name: 'Step 4', automationLevel: 'semi-automated' },
+      ],
+    })
+
+    it('should filter by automated level', () => {
+      const automated = getStepsByAutomationLevel(process, 'automated')
+
+      expect(automated).toHaveLength(2)
+      expect(automated[0]?.name).toBe('Step 1')
+      expect(automated[1]?.name).toBe('Step 3')
+    })
+
+    it('should filter by manual level', () => {
+      const manual = getStepsByAutomationLevel(process, 'manual')
+
+      expect(manual).toHaveLength(1)
+      expect(manual[0]?.name).toBe('Step 2')
+    })
+
+    it('should return empty for non-existent level', () => {
+      const emptyProcess = Process({ name: 'Empty' })
+      const result = getStepsByAutomationLevel(emptyProcess, 'automated')
+
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('calculateTotalDuration()', () => {
+    it('should calculate total duration in minutes', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1', duration: '5 minutes' },
+          { order: 2, name: 'Step 2', duration: '30 minutes' },
+          { order: 3, name: 'Step 3', duration: '1 hour' },
+        ],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(95)
+    })
+
+    it('should handle hours', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [{ order: 1, name: 'Step 1', duration: '2 hours' }],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(120)
+    })
+
+    it('should handle days', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [{ order: 1, name: 'Step 1', duration: '1 day' }],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(1440)
+    })
+
+    it('should handle weeks', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [{ order: 1, name: 'Step 1', duration: '1 week' }],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(10080)
+    })
+
+    it('should handle missing duration', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1' },
+          { order: 2, name: 'Step 2', duration: '10 minutes' },
+        ],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(10)
+    })
+
+    it('should return 0 for empty steps', () => {
+      const process = Process({ name: 'Test' })
+      expect(calculateTotalDuration(process)).toBe(0)
+    })
+
+    it('should handle singular/plural units', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1', duration: '1 minute' },
+          { order: 2, name: 'Step 2', duration: '1 hour' },
+          { order: 3, name: 'Step 3', duration: '1 day' },
+        ],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(1 + 60 + 1440)
+    })
+
+    it('should handle abbreviations', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1', duration: '5 min' },
+          { order: 2, name: 'Step 2', duration: '1 hr' },
+        ],
+      })
+
+      expect(calculateTotalDuration(process)).toBe(65)
+    })
+  })
+
+  describe('formatDuration()', () => {
+    it('should format minutes', () => {
+      expect(formatDuration(45)).toBe('45 minutes')
+    })
+
+    it('should format hours', () => {
+      expect(formatDuration(120)).toBe('2 hours')
+    })
+
+    it('should format hours and minutes', () => {
+      expect(formatDuration(150)).toBe('2 hours 30 minutes')
+    })
+
+    it('should format days', () => {
+      expect(formatDuration(2880)).toBe('2 days')
+    })
+
+    it('should format days and hours', () => {
+      expect(formatDuration(1560)).toBe('1 days 2 hours')
+    })
+  })
+
+  describe('calculateAutomationPercentage()', () => {
+    it('should calculate percentage of automated steps', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1', automationLevel: 'automated' },
+          { order: 2, name: 'Step 2', automationLevel: 'automated' },
+          { order: 3, name: 'Step 3', automationLevel: 'manual' },
+          { order: 4, name: 'Step 4', automationLevel: 'semi-automated' },
+        ],
+      })
+
+      expect(calculateAutomationPercentage(process)).toBe(75)
+    })
+
+    it('should return 0 for empty steps', () => {
+      const process = Process({ name: 'Test' })
+      expect(calculateAutomationPercentage(process)).toBe(0)
+    })
+
+    it('should return 100 for fully automated process', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1', automationLevel: 'automated' },
+          { order: 2, name: 'Step 2', automationLevel: 'semi-automated' },
+        ],
+      })
+
+      expect(calculateAutomationPercentage(process)).toBe(100)
+    })
+
+    it('should return 0 for fully manual process', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'Step 1', automationLevel: 'manual' },
+          { order: 2, name: 'Step 2', automationLevel: 'manual' },
+        ],
+      })
+
+      expect(calculateAutomationPercentage(process)).toBe(0)
+    })
+  })
+
+  describe('getMetric()', () => {
+    const process = Process({
+      name: 'Test',
+      metrics: [
+        { name: 'Time to Value', target: 24 },
+        { name: 'Completion Rate', target: 90 },
+      ],
+    })
+
+    it('should find metric by name', () => {
+      const metric = getMetric(process, 'Time to Value')
+
+      expect(metric?.name).toBe('Time to Value')
+      expect(metric?.target).toBe(24)
+    })
+
+    it('should return undefined for non-existent metric', () => {
+      const metric = getMetric(process, 'NonExistent')
+      expect(metric).toBeUndefined()
+    })
+  })
+
+  describe('meetsTarget()', () => {
+    it('should return true when current meets target', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 90, current: 95 }
+      expect(meetsTarget(metric)).toBe(true)
+    })
+
+    it('should return true when current equals target', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 90, current: 90 }
+      expect(meetsTarget(metric)).toBe(true)
+    })
+
+    it('should return false when current is below target', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 90, current: 85 }
+      expect(meetsTarget(metric)).toBe(false)
+    })
+
+    it('should return false when target is undefined', () => {
+      const metric: ProcessMetric = { name: 'Test', current: 90 }
+      expect(meetsTarget(metric)).toBe(false)
+    })
+
+    it('should return false when current is undefined', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 90 }
+      expect(meetsTarget(metric)).toBe(false)
+    })
+  })
+
+  describe('calculateMetricAchievement()', () => {
+    it('should calculate achievement percentage', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 100, current: 75 }
+      expect(calculateMetricAchievement(metric)).toBe(75)
+    })
+
+    it('should handle over-achievement', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 100, current: 150 }
+      expect(calculateMetricAchievement(metric)).toBe(150)
+    })
+
+    it('should return 100 when target is 0', () => {
+      const metric: ProcessMetric = { name: 'Test', target: 0, current: 50 }
+      expect(calculateMetricAchievement(metric)).toBe(100)
+    })
+
+    it('should return 0 when values are undefined', () => {
+      const metric: ProcessMetric = { name: 'Test' }
+      expect(calculateMetricAchievement(metric)).toBe(0)
+    })
+  })
+
+  describe('updateMetric()', () => {
+    const process = Process({
+      name: 'Test',
+      metrics: [
+        { name: 'Metric 1', target: 100, current: 50 },
+        { name: 'Metric 2', target: 200, current: 100 },
+      ],
+    })
+
+    it('should update metric current value', () => {
+      const updated = updateMetric(process, 'Metric 1', 75)
+      const metric = updated.metrics?.find((m) => m.name === 'Metric 1')
+
+      expect(metric?.current).toBe(75)
+    })
+
+    it('should not affect other metrics', () => {
+      const updated = updateMetric(process, 'Metric 1', 75)
+      const metric2 = updated.metrics?.find((m) => m.name === 'Metric 2')
+
+      expect(metric2?.current).toBe(100)
+    })
+
+    it('should handle non-existent metric', () => {
+      const updated = updateMetric(process, 'NonExistent', 75)
+      expect(updated.metrics).toHaveLength(2)
+    })
+  })
+
+  describe('addStep()', () => {
+    it('should add step to process', () => {
+      const process = Process({
+        name: 'Test',
+        steps: [{ order: 1, name: 'First' }],
+      })
+
+      const updated = addStep(process, { order: 2, name: 'Second' })
+
+      expect(updated.steps).toHaveLength(2)
+      expect(updated.steps?.[1]?.name).toBe('Second')
+    })
+
+    it('should add step to empty process', () => {
+      const process = Process({ name: 'Test' })
+      const updated = addStep(process, { order: 1, name: 'First' })
+
+      expect(updated.steps).toHaveLength(1)
+    })
+  })
+
+  describe('removeStep()', () => {
+    const process = Process({
+      name: 'Test',
+      steps: [
+        { order: 1, name: 'First' },
+        { order: 2, name: 'Second' },
+        { order: 3, name: 'Third' },
+      ],
+    })
+
+    it('should remove step by order', () => {
+      const updated = removeStep(process, 2)
+
+      expect(updated.steps).toHaveLength(2)
+      expect(updated.steps?.find((s) => s.order === 2)).toBeUndefined()
+    })
+
+    it('should handle removing non-existent step', () => {
+      const updated = removeStep(process, 99)
+      expect(updated.steps).toHaveLength(3)
+    })
+  })
+
+  describe('validateProcess()', () => {
+    it('should validate valid process', () => {
+      const process: ProcessDefinition = {
+        name: 'Valid Process',
+        steps: [
+          { order: 1, name: 'Step 1' },
+          { order: 2, name: 'Step 2' },
+        ],
+        metrics: [{ name: 'Metric 1', target: 100, current: 50 }],
+      }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(true)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('should fail if name is missing', () => {
+      const process: ProcessDefinition = { name: '' }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Process name is required')
+    })
+
+    it('should fail if step has no name', () => {
+      const process: ProcessDefinition = {
+        name: 'Test',
+        steps: [{ order: 1, name: '' }],
+      }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Step at order 1 must have a name')
+    })
+
+    it('should fail for duplicate step orders', () => {
+      const process: ProcessDefinition = {
+        name: 'Test',
+        steps: [
+          { order: 1, name: 'First' },
+          { order: 1, name: 'Duplicate' },
+        ],
+      }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Duplicate step order: 1')
+    })
+
+    it('should fail if metric has no name', () => {
+      const process: ProcessDefinition = {
+        name: 'Test',
+        metrics: [{ name: '', target: 100 }],
+      }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Metric must have a name')
+    })
+
+    it('should fail if metric target is negative', () => {
+      const process: ProcessDefinition = {
+        name: 'Test',
+        metrics: [{ name: 'Test Metric', target: -10 }],
+      }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Metric Test Metric target cannot be negative')
+    })
+
+    it('should fail if metric current is negative', () => {
+      const process: ProcessDefinition = {
+        name: 'Test',
+        metrics: [{ name: 'Test Metric', target: 100, current: -5 }],
+      }
+
+      const result = validateProcess(process)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Metric Test Metric current value cannot be negative')
+    })
+  })
+})