services-as-software 2.1.1 → 2.1.3

package/tests/sla.test.ts

@@ -0,0 +1,414 @@
+/**
+ * SLA (Service Level Agreement) Tests
+ *
+ * Tests for defining and monitoring service level agreements.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  defineSLA,
+  createSLO,
+  monitorSLA,
+  checkSLACompliance,
+  calculateErrorBudget,
+  createSLAAlert,
+  recordSLABreach,
+  getSLAReport,
+} from '../src/sla/index.js'
+
+describe('Service Level Agreements', () => {
+  describe('defineSLA', () => {
+    it('should define a basic SLA', () => {
+      const sla = defineSLA({
+        name: 'Standard SLA',
+        version: '1.0',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+        responseTimeTarget: 200, // ms
+      })
+
+      expect(sla.name).toBe('Standard SLA')
+      expect(sla.tier).toBe('standard')
+      expect(sla.uptimeTarget).toBe(99.9)
+      expect(sla.responseTimeTarget).toBe(200)
+    })
+
+    it('should define SLA with support levels', () => {
+      const sla = defineSLA({
+        name: 'Premium SLA',
+        tier: 'premium',
+        support: {
+          hours: '24/7',
+          channels: ['email', 'chat', 'phone'],
+          responseTime: {
+            critical: '15 minutes',
+            high: '1 hour',
+            medium: '4 hours',
+            low: '24 hours',
+          },
+        },
+      })
+
+      expect(sla.support.hours).toBe('24/7')
+      expect(sla.support.channels).toContain('phone')
+      expect(sla.support.responseTime.critical).toBe('15 minutes')
+    })
+
+    it('should define SLA with credit policy', () => {
+      const sla = defineSLA({
+        name: 'Enterprise SLA',
+        tier: 'enterprise',
+        uptimeTarget: 99.99,
+        creditPolicy: {
+          '99.99-99.9': 10, // 10% credit for 99.9-99.99% uptime
+          '99.9-99.0': 25, // 25% credit
+          'below-99.0': 50, // 50% credit
+        },
+        maxCredit: 100,
+      })
+
+      expect(sla.creditPolicy['99.99-99.9']).toBe(10)
+      expect(sla.maxCredit).toBe(100)
+    })
+
+    it('should define SLA with exclusions', () => {
+      const sla = defineSLA({
+        name: 'Standard SLA',
+        tier: 'standard',
+        exclusions: [
+          'Scheduled maintenance',
+          'Force majeure',
+          'Customer-caused issues',
+        ],
+        maintenanceWindows: [
+          { day: 'Sunday', time: '02:00-06:00', timezone: 'UTC' },
+        ],
+      })
+
+      expect(sla.exclusions).toContain('Scheduled maintenance')
+      expect(sla.maintenanceWindows).toHaveLength(1)
+    })
+
+    it('should define SLA with effective dates', () => {
+      const sla = defineSLA({
+        name: 'Q1 SLA',
+        tier: 'standard',
+        effectiveFrom: new Date('2024-01-01'),
+        effectiveUntil: new Date('2024-03-31'),
+      })
+
+      expect(sla.effectiveFrom).toEqual(new Date('2024-01-01'))
+      expect(sla.effectiveUntil).toEqual(new Date('2024-03-31'))
+    })
+  })
+
+  describe('createSLO', () => {
+    it('should create an SLO (Service Level Objective)', () => {
+      const slo = createSLO({
+        name: 'API Availability',
+        metric: 'availability',
+        target: 99.9,
+        comparison: '>=',
+        windowType: 'rolling',
+        windowDuration: '30d',
+      })
+
+      expect(slo.name).toBe('API Availability')
+      expect(slo.metric).toBe('availability')
+      expect(slo.target).toBe(99.9)
+      expect(slo.windowDuration).toBe('30d')
+    })
+
+    it('should create SLO with error budget', () => {
+      const slo = createSLO({
+        name: 'Latency P99',
+        metric: 'latency',
+        target: 200, // 200ms
+        unit: 'ms',
+        errorBudget: 0.1, // 0.1% error budget
+      })
+
+      expect(slo.errorBudget).toBe(0.1)
+    })
+
+    it('should create SLO with alerting config', () => {
+      const slo = createSLO({
+        name: 'Error Rate',
+        metric: 'error-rate',
+        target: 0.1, // 0.1%
+        comparison: '<=',
+        alertThreshold: 0.08, // Alert at 0.08%
+        alertOnBreach: true,
+      })
+
+      expect(slo.alertThreshold).toBe(0.08)
+      expect(slo.alertOnBreach).toBe(true)
+    })
+  })
+
+  describe('monitorSLA', () => {
+    it('should start monitoring an SLA', async () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+      })
+
+      const monitor = await monitorSLA(sla, {
+        checkInterval: 60000, // every minute
+        metricsSource: async () => ({
+          uptime: 99.95,
+          responseTime: 150,
+        }),
+      })
+
+      expect(monitor.status).toBe('monitoring')
+      expect(monitor.slaId).toBe(sla.id)
+    })
+
+    it('should emit events on SLA status change', async () => {
+      const onBreach = vi.fn()
+
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+      })
+
+      const monitor = await monitorSLA(sla, {
+        metricsSource: async () => ({ uptime: 99.0 }), // below target
+        onBreach,
+      })
+
+      await monitor.check()
+
+      expect(onBreach).toHaveBeenCalled()
+    })
+
+    it('should track SLA burn rate', async () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+      })
+
+      const monitor = await monitorSLA(sla, {
+        metricsSource: async () => ({ uptime: 99.5 }),
+      })
+
+      const stats = await monitor.getStats()
+
+      expect(stats.burnRate).toBeDefined()
+      expect(stats.errorBudgetRemaining).toBeDefined()
+    })
+  })
+
+  describe('checkSLACompliance', () => {
+    it('should check if metrics are within SLA', () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+        responseTimeTarget: 200,
+      })
+
+      const result = checkSLACompliance(sla, {
+        uptime: 99.95,
+        responseTime: 150,
+      })
+
+      expect(result.compliant).toBe(true)
+      expect(result.metrics.uptime.passed).toBe(true)
+      expect(result.metrics.responseTime.passed).toBe(true)
+    })
+
+    it('should detect SLA breach', () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+      })
+
+      const result = checkSLACompliance(sla, {
+        uptime: 99.5, // below target
+      })
+
+      expect(result.compliant).toBe(false)
+      expect(result.metrics.uptime.passed).toBe(false)
+      expect(result.metrics.uptime.deviation).toBe(-0.4)
+    })
+
+    it('should exclude maintenance windows from compliance check', () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+        maintenanceWindows: [
+          { day: 'Sunday', time: '02:00-06:00', timezone: 'UTC' },
+        ],
+      })
+
+      const result = checkSLACompliance(sla, {
+        uptime: 99.5,
+        maintenanceHours: 4, // 4 hours of maintenance
+      })
+
+      // Should adjust uptime calculation to exclude maintenance
+      expect(result.adjustedUptime).toBeGreaterThan(99.5)
+    })
+  })
+
+  describe('calculateErrorBudget', () => {
+    it('should calculate remaining error budget', () => {
+      const budget = calculateErrorBudget({
+        target: 99.9, // 99.9% uptime
+        windowDays: 30,
+        currentUptime: 99.95,
+      })
+
+      expect(budget.totalBudget).toBe(43.2) // 0.1% of 30 days in minutes
+      expect(budget.consumed).toBeLessThan(budget.totalBudget)
+      expect(budget.remaining).toBeGreaterThan(0)
+      expect(budget.remainingPercentage).toBeGreaterThan(0)
+    })
+
+    it('should indicate when error budget is exhausted', () => {
+      const budget = calculateErrorBudget({
+        target: 99.9,
+        windowDays: 30,
+        currentUptime: 99.0, // significantly below target
+      })
+
+      expect(budget.remaining).toBeLessThanOrEqual(0)
+      expect(budget.exhausted).toBe(true)
+    })
+
+    it('should calculate burn rate', () => {
+      const budget = calculateErrorBudget({
+        target: 99.9,
+        windowDays: 30,
+        currentUptime: 99.85,
+        daysPassed: 15,
+      })
+
+      // Burn rate > 1 means consuming budget faster than allowed
+      expect(budget.burnRate).toBeDefined()
+    })
+  })
+
+  describe('createSLAAlert', () => {
+    it('should create alert configuration', () => {
+      const alert = createSLAAlert({
+        name: 'High Error Rate Alert',
+        condition: 'error_rate > 0.1',
+        severity: 'critical',
+        channels: ['email', 'slack', 'pagerduty'],
+        cooldown: 300, // 5 minutes
+      })
+
+      expect(alert.name).toBe('High Error Rate Alert')
+      expect(alert.severity).toBe('critical')
+      expect(alert.channels).toContain('pagerduty')
+    })
+
+    it('should support escalation paths', () => {
+      const alert = createSLAAlert({
+        name: 'SLA Breach Alert',
+        condition: 'uptime < 99.9',
+        escalation: [
+          { after: '0m', notify: 'on-call-engineer' },
+          { after: '15m', notify: 'engineering-manager' },
+          { after: '30m', notify: 'vp-engineering' },
+        ],
+      })
+
+      expect(alert.escalation).toHaveLength(3)
+      expect(alert.escalation[1].after).toBe('15m')
+    })
+  })
+
+  describe('recordSLABreach', () => {
+    it('should record an SLA breach incident', async () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+      })
+
+      const breach = await recordSLABreach({
+        slaId: sla.id,
+        metric: 'uptime',
+        expected: 99.9,
+        actual: 99.5,
+        startedAt: new Date('2024-01-15T10:00:00Z'),
+        endedAt: new Date('2024-01-15T12:00:00Z'),
+        impact: 'partial',
+        affectedCustomers: 150,
+      })
+
+      expect(breach.id).toBeDefined()
+      expect(breach.duration).toBe(7200000) // 2 hours in ms
+      expect(breach.affectedCustomers).toBe(150)
+    })
+
+    it('should calculate credit owed', async () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'enterprise',
+        uptimeTarget: 99.99,
+        creditPolicy: {
+          '99.99-99.9': 10,
+          '99.9-99.0': 25,
+        },
+      })
+
+      const breach = await recordSLABreach({
+        slaId: sla.id,
+        metric: 'uptime',
+        actual: 99.5,
+        monthlyBillingAmount: 10000,
+      })
+
+      expect(breach.creditOwed).toBe(2500) // 25% of $10,000
+    })
+  })
+
+  describe('getSLAReport', () => {
+    it('should generate SLA compliance report', async () => {
+      const sla = defineSLA({
+        name: 'Test SLA',
+        tier: 'standard',
+        uptimeTarget: 99.9,
+      })
+
+      const report = await getSLAReport({
+        slaId: sla.id,
+        period: {
+          start: new Date('2024-01-01'),
+          end: new Date('2024-01-31'),
+        },
+      })
+
+      expect(report.slaId).toBe(sla.id)
+      expect(report.period).toBeDefined()
+      expect(report.metrics).toBeDefined()
+      expect(report.breaches).toBeDefined()
+      expect(report.compliancePercentage).toBeDefined()
+    })
+
+    it('should include historical trends', async () => {
+      const report = await getSLAReport({
+        slaId: 'test-sla',
+        period: {
+          start: new Date('2024-01-01'),
+          end: new Date('2024-03-31'),
+        },
+        includeHistory: true,
+        groupBy: 'month',
+      })
+
+      expect(report.history).toHaveLength(3) // 3 months
+      expect(report.history[0].month).toBe('2024-01')
+    })
+  })
+})