@littlebearapps/platform-admin-sdk 2.0.0 → 2.2.0

package/templates/standard/tests/unit/cloudflare/alerting.test.ts

@@ -0,0 +1,480 @@
+/**
+ * Unit Tests for Alerting Service
+ *
+ * Tests Slack/Email alert generation, severity formatting, and rate limiting logic.
+ *
+ * @module tests/unit/cloudflare/alerting
+ * @created 2026-01-05
+ * @task task-17.25 - Unit tests for alerting service
+ */
+
+import { describe, expect, it } from 'vitest';
+import {
+  getSeverityColour,
+  getSeverityEmoji,
+  formatPercentage,
+  generateAlertKey,
+  buildSlackMessage,
+  buildSummarySlackMessage,
+  evaluateWarning,
+  buildEmailHtml,
+  buildEmailText,
+  type CostSpikeAlert,
+} from '../../../dashboard/src/lib/cloudflare/alerting';
+import type { ThresholdWarning, CostBreakdown } from '../../../dashboard/src/lib/cloudflare/costs';
+
+describe('Alerting Service', () => {
+  describe('getSeverityColour', () => {
+    it('returns red for critical level', () => {
+      expect(getSeverityColour('critical')).toBe('#dc3545');
+    });
+
+    it('returns orange for high level', () => {
+      expect(getSeverityColour('high')).toBe('#fd7e14');
+    });
+
+    it('returns yellow for warning level', () => {
+      expect(getSeverityColour('warning')).toBe('#ffc107');
+    });
+
+    it('returns green for normal level', () => {
+      expect(getSeverityColour('normal')).toBe('#28a745');
+    });
+  });
+
+  describe('getSeverityEmoji', () => {
+    it('returns siren emoji for critical level', () => {
+      expect(getSeverityEmoji('critical')).toBe(':rotating_light:');
+    });
+
+    it('returns warning emoji for high level', () => {
+      expect(getSeverityEmoji('high')).toBe(':warning:');
+    });
+
+    it('returns yellow circle for warning level', () => {
+      expect(getSeverityEmoji('warning')).toBe(':yellow_circle:');
+    });
+
+    it('returns checkmark for normal level', () => {
+      expect(getSeverityEmoji('normal')).toBe(':white_check_mark:');
+    });
+  });
+
+  describe('formatPercentage', () => {
+    it('formats positive percentages with plus sign', () => {
+      expect(formatPercentage(50)).toBe('+50.0%');
+    });
+
+    it('formats negative percentages with minus sign', () => {
+      expect(formatPercentage(-25.5)).toBe('-25.5%');
+    });
+
+    it('formats zero with plus sign', () => {
+      expect(formatPercentage(0)).toBe('+0.0%');
+    });
+
+    it('formats decimal values correctly', () => {
+      expect(formatPercentage(33.333)).toBe('+33.3%');
+    });
+  });
+
+  describe('generateAlertKey', () => {
+    it('generates correct deduplication key', () => {
+      const alert: CostSpikeAlert = {
+        id: 'test-123',
+        serviceType: 'Workers',
+        resourceName: 'platform-api',
+        currentCost: 5.0,
+        previousCost: 2.5,
+        costDeltaPct: 100,
+        thresholdLevel: 'high',
+        absoluteMax: 10.0,
+        timestamp: '2026-01-05T12:00:00Z',
+      };
+
+      expect(generateAlertKey(alert)).toBe('cost-spike:Workers:platform-api');
+    });
+
+    it('handles special characters in resource name', () => {
+      const alert: CostSpikeAlert = {
+        id: 'test-123',
+        serviceType: 'D1',
+        resourceName: 'my-project-db',
+        currentCost: 10.0,
+        previousCost: 5.0,
+        costDeltaPct: 100,
+        thresholdLevel: 'critical',
+        absoluteMax: 15.0,
+        timestamp: '2026-01-05T12:00:00Z',
+      };
+
+      expect(generateAlertKey(alert)).toBe('cost-spike:D1:my-project-db');
+    });
+  });
+
+  describe('buildSlackMessage', () => {
+    const mockAlert: CostSpikeAlert = {
+      id: 'alert-456',
+      serviceType: 'Workers',
+      resourceName: 'requests',
+      currentCost: 7.5,
+      previousCost: 3.0,
+      costDeltaPct: 150,
+      thresholdLevel: 'critical',
+      absoluteMax: 5.0,
+      timestamp: '2026-01-05T14:30:00Z',
+    };
+
+    it('includes fallback text with cost info', () => {
+      const message = buildSlackMessage(mockAlert);
+
+      expect(message.text).toContain('[CRITICAL]');
+      expect(message.text).toContain('Workers');
+      expect(message.text).toContain('$7.50');
+    });
+
+    it('includes header block with severity emoji', () => {
+      const message = buildSlackMessage(mockAlert);
+      const headerBlock = message.blocks.find((b) => b.type === 'header');
+
+      expect(headerBlock).toBeDefined();
+      expect(headerBlock?.text?.text).toContain(':rotating_light:');
+    });
+
+    it('includes section block with service fields', () => {
+      const message = buildSlackMessage(mockAlert);
+      const sectionBlock = message.blocks.find((b) => b.type === 'section');
+
+      expect(sectionBlock).toBeDefined();
+      expect(sectionBlock?.fields).toHaveLength(6);
+
+      const fieldTexts = sectionBlock?.fields?.map((f) => f.text) ?? [];
+      expect(fieldTexts.some((t) => t.includes('Workers'))).toBe(true);
+      expect(fieldTexts.some((t) => t.includes('$7.50'))).toBe(true);
+      expect(fieldTexts.some((t) => t.includes('+150.0%'))).toBe(true);
+    });
+
+    it('includes context block with alert ID', () => {
+      const message = buildSlackMessage(mockAlert);
+      const contextBlock = message.blocks.find((b) => b.type === 'context');
+
+      expect(contextBlock).toBeDefined();
+      expect(contextBlock?.text?.text).toContain('alert-456');
+    });
+
+    it('includes attachment with severity colour', () => {
+      const message = buildSlackMessage(mockAlert);
+
+      expect(message.attachments).toHaveLength(1);
+      expect(message.attachments?.[0].color).toBe('#dc3545'); // Critical = red
+    });
+  });
+
+  describe('buildSummarySlackMessage', () => {
+    const mockAlerts: CostSpikeAlert[] = [
+      {
+        id: 'alert-1',
+        serviceType: 'Workers',
+        resourceName: 'requests',
+        currentCost: 7.5,
+        previousCost: 3.0,
+        costDeltaPct: 150,
+        thresholdLevel: 'critical',
+        absoluteMax: 5.0,
+        timestamp: '2026-01-05T14:30:00Z',
+      },
+      {
+        id: 'alert-2',
+        serviceType: 'D1',
+        resourceName: 'rowsRead',
+        currentCost: 4.0,
+        previousCost: 2.0,
+        costDeltaPct: 100,
+        thresholdLevel: 'high',
+        absoluteMax: 5.0,
+        timestamp: '2026-01-05T14:30:00Z',
+      },
+      {
+        id: 'alert-3',
+        serviceType: 'KV',
+        resourceName: 'reads',
+        currentCost: 2.0,
+        previousCost: 1.5,
+        costDeltaPct: 33.3,
+        thresholdLevel: 'warning',
+        absoluteMax: 5.0,
+        timestamp: '2026-01-05T14:30:00Z',
+      },
+    ];
+
+    it('counts alerts by severity', () => {
+      const message = buildSummarySlackMessage(mockAlerts);
+      const sectionBlock = message.blocks.find((b) => b.type === 'section');
+      const fieldTexts = sectionBlock?.fields?.map((f) => f.text) ?? [];
+
+      expect(fieldTexts.some((t) => t.includes('*Critical:* 1'))).toBe(true);
+      expect(fieldTexts.some((t) => t.includes('*High:* 1'))).toBe(true);
+      expect(fieldTexts.some((t) => t.includes('*Warning:* 1'))).toBe(true);
+    });
+
+    it('calculates total cost across alerts', () => {
+      const message = buildSummarySlackMessage(mockAlerts);
+      const sectionBlock = message.blocks.find((b) => b.type === 'section');
+      const fieldTexts = sectionBlock?.fields?.map((f) => f.text) ?? [];
+
+      // Total: 7.5 + 4.0 + 2.0 = 13.5
+      expect(fieldTexts.some((t) => t.includes('$13.50'))).toBe(true);
+    });
+
+    it('uses critical emoji when critical alerts exist', () => {
+      const message = buildSummarySlackMessage(mockAlerts);
+      const headerBlock = message.blocks.find((b) => b.type === 'header');
+
+      expect(headerBlock?.text?.text).toContain(':rotating_light:');
+    });
+
+    it('lists up to 5 alerts in summary', () => {
+      const message = buildSummarySlackMessage(mockAlerts);
+      const alertBlocks = message.blocks.filter(
+        (b) => b.type === 'section' && b.text?.text?.includes('$')
+      );
+
+      expect(alertBlocks.length).toBeLessThanOrEqual(5);
+    });
+  });
+
+  describe('evaluateWarning', () => {
+    const baseCosts: CostBreakdown = {
+      workers: 5.0,
+      d1: 3.0,
+      kv: 1.0,
+      r2: 2.0,
+      durableObjects: 0.5,
+      vectorize: 0.0,
+      aiGateway: 1.5,
+      workersAI: 0.0,
+      pages: 0.0,
+      queues: 0.0,
+      workflows: 0.0,
+      total: 13.0,
+    };
+
+    const previousCosts: CostBreakdown = {
+      workers: 2.0,
+      d1: 2.5,
+      kv: 0.8,
+      r2: 1.5,
+      durableObjects: 0.4,
+      vectorize: 0.0,
+      aiGateway: 1.0,
+      workersAI: 0.0,
+      pages: 0.0,
+      queues: 0.0,
+      workflows: 0.0,
+      total: 8.2,
+    };
+
+    it('returns alert for critical threshold level', () => {
+      const warning: ThresholdWarning = {
+        resource: 'Workers',
+        metric: 'requests',
+        current: 1000000,
+        limit: 100000,
+        percentage: 1000,
+        level: 'critical',
+      };
+
+      const result = evaluateWarning(warning, baseCosts, previousCosts, 5.0);
+
+      expect(result).not.toBeNull();
+      expect(result?.thresholdLevel).toBe('critical');
+    });
+
+    it('returns alert when cost delta exceeds 50%', () => {
+      const warning: ThresholdWarning = {
+        resource: 'Workers',
+        metric: 'requests',
+        current: 100000,
+        limit: 100000,
+        percentage: 100,
+        level: 'high', // Not critical, but delta > 50%
+      };
+
+      const result = evaluateWarning(warning, baseCosts, previousCosts, 10.0);
+
+      expect(result).not.toBeNull();
+      // Workers: current 5.0, previous 2.0 = 150% delta
+      expect(result?.costDeltaPct).toBeCloseTo(150);
+    });
+
+    it('returns alert when cost exceeds absolute max', () => {
+      const warning: ThresholdWarning = {
+        resource: 'Workers',
+        metric: 'requests',
+        current: 100000,
+        limit: 100000,
+        percentage: 100,
+        level: 'warning', // Low level
+      };
+
+      // Set absolute max below current cost
+      const result = evaluateWarning(warning, baseCosts, previousCosts, 3.0);
+
+      expect(result).not.toBeNull();
+      expect(result?.currentCost).toBe(5.0);
+      expect(result?.absoluteMax).toBe(3.0);
+    });
+
+    it('returns null for warning level below thresholds', () => {
+      const warning: ThresholdWarning = {
+        resource: 'KV',
+        metric: 'reads',
+        current: 10000,
+        limit: 100000,
+        percentage: 10,
+        level: 'warning',
+      };
+
+      // KV: current 1.0, previous 0.8 = 25% delta (below 50%)
+      // Cost 1.0 is below absoluteMax 10.0
+      // Level is not critical
+      const result = evaluateWarning(warning, baseCosts, previousCosts, 10.0);
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null for unknown service type', () => {
+      const warning: ThresholdWarning = {
+        resource: 'UnknownService',
+        metric: 'something',
+        current: 1000,
+        limit: 100,
+        percentage: 1000,
+        level: 'critical',
+      };
+
+      const result = evaluateWarning(warning, baseCosts, previousCosts, 5.0);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles null previous costs', () => {
+      const warning: ThresholdWarning = {
+        resource: 'Workers',
+        metric: 'requests',
+        current: 100000,
+        limit: 100000,
+        percentage: 100,
+        level: 'critical',
+      };
+
+      const result = evaluateWarning(warning, baseCosts, null, 5.0);
+
+      expect(result).not.toBeNull();
+      expect(result?.previousCost).toBe(0);
+      expect(result?.costDeltaPct).toBe(0);
+    });
+  });
+
+  describe('buildEmailHtml', () => {
+    const mockAlert: CostSpikeAlert = {
+      id: 'email-test-123',
+      serviceType: 'D1',
+      resourceName: 'rowsRead',
+      currentCost: 12.0,
+      previousCost: 5.0,
+      costDeltaPct: 140,
+      thresholdLevel: 'high',
+      absoluteMax: 10.0,
+      timestamp: '2026-01-05T16:00:00Z',
+    };
+
+    it('includes HTML doctype and structure', () => {
+      const html = buildEmailHtml(mockAlert);
+
+      expect(html).toContain('<!DOCTYPE html>');
+      expect(html).toContain('<html');
+      expect(html).toContain('</html>');
+    });
+
+    it('includes severity level in header', () => {
+      const html = buildEmailHtml(mockAlert);
+
+      expect(html).toContain('[HIGH]');
+      expect(html).toContain('D1');
+    });
+
+    it('includes cost details table', () => {
+      const html = buildEmailHtml(mockAlert);
+
+      expect(html).toContain('$12.00');
+      expect(html).toContain('$5.00');
+      expect(html).toContain('+140.0%');
+    });
+
+    it('includes severity colour in styling', () => {
+      const html = buildEmailHtml(mockAlert);
+
+      expect(html).toContain('#fd7e14'); // Orange for high
+    });
+
+    it('includes alert ID in footer', () => {
+      const html = buildEmailHtml(mockAlert);
+
+      expect(html).toContain('email-test-123');
+    });
+
+    it('includes recommended action for high level', () => {
+      const html = buildEmailHtml(mockAlert);
+
+      expect(html).toContain('Review usage patterns');
+    });
+  });
+
+  describe('buildEmailText', () => {
+    const mockAlert: CostSpikeAlert = {
+      id: 'text-test-456',
+      serviceType: 'R2',
+      resourceName: 'storageBytes',
+      currentCost: 25.0,
+      previousCost: 10.0,
+      costDeltaPct: 150,
+      thresholdLevel: 'critical',
+      absoluteMax: 20.0,
+      timestamp: '2026-01-05T17:00:00Z',
+    };
+
+    it('includes severity level', () => {
+      const text = buildEmailText(mockAlert);
+
+      expect(text).toContain('[CRITICAL]');
+    });
+
+    it('includes service and resource info', () => {
+      const text = buildEmailText(mockAlert);
+
+      expect(text).toContain('Service: R2');
+      expect(text).toContain('Resource: storageBytes');
+    });
+
+    it('includes cost details', () => {
+      const text = buildEmailText(mockAlert);
+
+      expect(text).toContain('Current Cost: $25.00');
+      expect(text).toContain('Previous Cost: $10.00');
+      expect(text).toContain('Change: +150.0%');
+    });
+
+    it('includes recommended action for critical level', () => {
+      const text = buildEmailText(mockAlert);
+
+      expect(text).toContain('Investigate immediately');
+    });
+
+    it('includes alert ID', () => {
+      const text = buildEmailText(mockAlert);
+
+      expect(text).toContain('Alert ID: text-test-456');
+    });
+  });
+});