business-as-code 2.1.1 → 2.3.0

package/test/service.test.ts

@@ -0,0 +1,450 @@
+/**
+ * Tests for service.ts - Service definition and management
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  Service,
+  calculateHourlyPrice,
+  calculateMonthlyRetainer,
+  checkSLAUptime,
+  parseDeliveryTimeToDays,
+  estimateCompletionDate,
+  calculateValueBasedPrice,
+  validateService,
+} from '../src/service.js'
+import type { ServiceDefinition } from '../src/types.js'
+
+describe('Service', () => {
+  describe('Service()', () => {
+    it('should create a service with required fields', () => {
+      const service = Service({ name: 'Test Service' })
+
+      expect(service.name).toBe('Test Service')
+      expect(service.pricingModel).toBe('hourly')
+      expect(service.currency).toBe('USD')
+      expect(service.metadata).toEqual({})
+    })
+
+    it('should create a service with all fields', () => {
+      const service = Service({
+        name: 'Consulting Service',
+        description: 'Expert consulting',
+        category: 'Professional Services',
+        targetSegment: 'Enterprise',
+        valueProposition: 'Maximize ROI',
+        pricingModel: 'fixed',
+        price: 5000,
+        currency: 'EUR',
+        deliveryTime: '2 weeks',
+        sla: {
+          uptime: 99.9,
+          responseTime: '< 24 hours',
+          supportHours: '9-5 EST',
+          penalties: '10% refund per day',
+        },
+        metadata: { type: 'premium' },
+      })
+
+      expect(service.name).toBe('Consulting Service')
+      expect(service.description).toBe('Expert consulting')
+      expect(service.pricingModel).toBe('fixed')
+      expect(service.price).toBe(5000)
+      expect(service.currency).toBe('EUR')
+      expect(service.deliveryTime).toBe('2 weeks')
+      expect(service.sla?.uptime).toBe(99.9)
+      expect(service.metadata).toEqual({ type: 'premium' })
+    })
+
+    it('should throw error if name is missing', () => {
+      expect(() => Service({ name: '' })).toThrow('Service name is required')
+    })
+
+    it('should preserve provided values', () => {
+      const service = Service({
+        name: 'Test',
+        pricingModel: 'retainer',
+        currency: 'GBP',
+      })
+
+      expect(service.pricingModel).toBe('retainer')
+      expect(service.currency).toBe('GBP')
+    })
+  })
+
+  describe('calculateHourlyPrice()', () => {
+    it('should calculate price for hours', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'hourly',
+        price: 150,
+      })
+
+      expect(calculateHourlyPrice(service, 10)).toBe(1500)
+    })
+
+    it('should throw error for non-hourly pricing', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'fixed',
+        price: 5000,
+      })
+
+      expect(() => calculateHourlyPrice(service, 10)).toThrow(
+        'Service must use hourly pricing model'
+      )
+    })
+
+    it('should throw error if price is missing', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'hourly',
+      })
+
+      expect(() => calculateHourlyPrice(service, 10)).toThrow(
+        'Service must use hourly pricing model'
+      )
+    })
+
+    it('should handle zero hours', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'hourly',
+        price: 150,
+      })
+
+      expect(calculateHourlyPrice(service, 0)).toBe(0)
+    })
+
+    it('should handle fractional hours', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'hourly',
+        price: 100,
+      })
+
+      expect(calculateHourlyPrice(service, 1.5)).toBe(150)
+    })
+  })
+
+  describe('calculateMonthlyRetainer()', () => {
+    it('should calculate monthly retainer', () => {
+      const service = Service({
+        name: 'Support',
+        pricingModel: 'hourly',
+        price: 100,
+      })
+
+      expect(calculateMonthlyRetainer(service, 40)).toBe(4000)
+    })
+
+    it('should throw error for non-hourly pricing', () => {
+      const service = Service({
+        name: 'Support',
+        pricingModel: 'fixed',
+        price: 5000,
+      })
+
+      expect(() => calculateMonthlyRetainer(service, 40)).toThrow(
+        'Service must use hourly pricing model'
+      )
+    })
+
+    it('should handle zero hours', () => {
+      const service = Service({
+        name: 'Support',
+        pricingModel: 'hourly',
+        price: 100,
+      })
+
+      expect(calculateMonthlyRetainer(service, 0)).toBe(0)
+    })
+  })
+
+  describe('checkSLAUptime()', () => {
+    it('should return true when uptime meets SLA', () => {
+      const service = Service({
+        name: 'API',
+        sla: { uptime: 99.9 },
+      })
+
+      expect(checkSLAUptime(service, 99.95)).toBe(true)
+    })
+
+    it('should return true when uptime equals SLA', () => {
+      const service = Service({
+        name: 'API',
+        sla: { uptime: 99.9 },
+      })
+
+      expect(checkSLAUptime(service, 99.9)).toBe(true)
+    })
+
+    it('should return false when uptime below SLA', () => {
+      const service = Service({
+        name: 'API',
+        sla: { uptime: 99.9 },
+      })
+
+      expect(checkSLAUptime(service, 99.5)).toBe(false)
+    })
+
+    it('should return true when no SLA uptime defined', () => {
+      const service = Service({ name: 'API' })
+      expect(checkSLAUptime(service, 99.5)).toBe(true)
+    })
+
+    it('should return true when no SLA defined', () => {
+      const service = Service({
+        name: 'API',
+        sla: { responseTime: '< 24 hours' },
+      })
+
+      expect(checkSLAUptime(service, 99.5)).toBe(true)
+    })
+  })
+
+  describe('parseDeliveryTimeToDays()', () => {
+    it('should parse days', () => {
+      expect(parseDeliveryTimeToDays('5 days')).toBe(5)
+      expect(parseDeliveryTimeToDays('1 day')).toBe(1)
+    })
+
+    it('should parse weeks', () => {
+      expect(parseDeliveryTimeToDays('2 weeks')).toBe(14)
+      expect(parseDeliveryTimeToDays('1 week')).toBe(7)
+    })
+
+    it('should parse months', () => {
+      expect(parseDeliveryTimeToDays('1 month')).toBe(30)
+      expect(parseDeliveryTimeToDays('3 months')).toBe(90)
+    })
+
+    it('should parse hours', () => {
+      expect(parseDeliveryTimeToDays('24 hours')).toBe(1)
+      expect(parseDeliveryTimeToDays('48 hours')).toBe(2)
+    })
+
+    it('should return 0 for undefined', () => {
+      expect(parseDeliveryTimeToDays(undefined)).toBe(0)
+    })
+
+    it('should return 0 for invalid format', () => {
+      expect(parseDeliveryTimeToDays('invalid')).toBe(0)
+      expect(parseDeliveryTimeToDays('soon')).toBe(0)
+    })
+
+    it('should handle case insensitivity', () => {
+      expect(parseDeliveryTimeToDays('2 WEEKS')).toBe(14)
+      expect(parseDeliveryTimeToDays('1 Day')).toBe(1)
+    })
+  })
+
+  describe('estimateCompletionDate()', () => {
+    it('should estimate completion date', () => {
+      const service = Service({
+        name: 'Project',
+        deliveryTime: '2 weeks',
+      })
+
+      const startDate = new Date('2024-01-01')
+      const completion = estimateCompletionDate(service, startDate)
+
+      expect(completion.getTime()).toBe(new Date('2024-01-15').getTime())
+    })
+
+    it('should use current date if no start date provided', () => {
+      const service = Service({
+        name: 'Project',
+        deliveryTime: '1 day',
+      })
+
+      const now = new Date()
+      const completion = estimateCompletionDate(service)
+
+      // Allow for small timing differences
+      const expectedDate = new Date(now)
+      expectedDate.setDate(now.getDate() + 1)
+      expect(completion.getDate()).toBe(expectedDate.getDate())
+    })
+
+    it('should handle no delivery time', () => {
+      const service = Service({ name: 'Project' })
+
+      const startDate = new Date('2024-01-01')
+      const completion = estimateCompletionDate(service, startDate)
+
+      expect(completion.getTime()).toBe(startDate.getTime())
+    })
+  })
+
+  describe('calculateValueBasedPrice()', () => {
+    it('should calculate value-based price', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'value-based',
+      })
+
+      expect(calculateValueBasedPrice(service, 100000, 20)).toBe(20000)
+    })
+
+    it('should throw error for non-value-based pricing', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'hourly',
+        price: 150,
+      })
+
+      expect(() => calculateValueBasedPrice(service, 100000, 20)).toThrow(
+        'Service must use value-based pricing model'
+      )
+    })
+
+    it('should throw error for invalid percentage (below 0)', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'value-based',
+      })
+
+      expect(() => calculateValueBasedPrice(service, 100000, -10)).toThrow(
+        'Value share percentage must be between 0 and 100'
+      )
+    })
+
+    it('should throw error for invalid percentage (above 100)', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'value-based',
+      })
+
+      expect(() => calculateValueBasedPrice(service, 100000, 150)).toThrow(
+        'Value share percentage must be between 0 and 100'
+      )
+    })
+
+    it('should handle zero value', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'value-based',
+      })
+
+      expect(calculateValueBasedPrice(service, 0, 20)).toBe(0)
+    })
+
+    it('should handle zero percentage', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'value-based',
+      })
+
+      expect(calculateValueBasedPrice(service, 100000, 0)).toBe(0)
+    })
+
+    it('should handle 100% percentage', () => {
+      const service = Service({
+        name: 'Consulting',
+        pricingModel: 'value-based',
+      })
+
+      expect(calculateValueBasedPrice(service, 100000, 100)).toBe(100000)
+    })
+  })
+
+  describe('validateService()', () => {
+    it('should validate valid service', () => {
+      const service: ServiceDefinition = {
+        name: 'Valid Service',
+        pricingModel: 'hourly',
+        price: 100,
+      }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(true)
+      expect(result.errors).toHaveLength(0)
+    })
+
+    it('should fail if name is missing', () => {
+      const service: ServiceDefinition = { name: '' }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Service name is required')
+    })
+
+    it('should fail if price is negative', () => {
+      const service: ServiceDefinition = { name: 'Test', price: -100 }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Service price cannot be negative')
+    })
+
+    it('should fail if SLA uptime is below 0', () => {
+      const service: ServiceDefinition = {
+        name: 'Test',
+        sla: { uptime: -1 },
+      }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('SLA uptime must be between 0 and 100')
+    })
+
+    it('should fail if SLA uptime is above 100', () => {
+      const service: ServiceDefinition = {
+        name: 'Test',
+        sla: { uptime: 101 },
+      }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('SLA uptime must be between 0 and 100')
+    })
+
+    it('should fail for invalid pricing model', () => {
+      const service: ServiceDefinition = {
+        name: 'Test',
+        pricingModel: 'invalid' as ServiceDefinition['pricingModel'],
+      }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(false)
+      expect(result.errors).toContain('Invalid pricing model')
+    })
+
+    it('should allow all valid pricing models', () => {
+      const pricingModels: ServiceDefinition['pricingModel'][] = [
+        'hourly',
+        'fixed',
+        'retainer',
+        'value-based',
+      ]
+
+      for (const model of pricingModels) {
+        const service: ServiceDefinition = { name: 'Test', pricingModel: model }
+        const result = validateService(service)
+        expect(result.valid).toBe(true)
+      }
+    })
+
+    it('should allow zero price', () => {
+      const service: ServiceDefinition = { name: 'Free Service', price: 0 }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(true)
+    })
+
+    it('should return multiple errors', () => {
+      const service: ServiceDefinition = {
+        name: '',
+        price: -100,
+        sla: { uptime: 150 },
+        pricingModel: 'invalid' as ServiceDefinition['pricingModel'],
+      }
+
+      const result = validateService(service)
+      expect(result.valid).toBe(false)
+      expect(result.errors.length).toBeGreaterThan(1)
+    })
+  })
+})