@littlebearapps/platform-admin-sdk 2.0.0 → 2.2.0

package/templates/shared/tests/e2e/usage-export.test.ts

@@ -0,0 +1,784 @@
+/**
+ * E2E Tests for Usage Export Functionality
+ *
+ * Tests the CSV and JSON export features of the Usage Dashboard.
+ * Validates data transformation, filename generation, and content structure.
+ *
+ * @module tests/e2e/usage-export
+ * @created 2026-01-05
+ * @task task-17.26 - E2E tests for export functionality
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { UnifiedResource } from '../../dashboard/src/components/usage/types';
+
+/**
+ * Mock filter state matching the dashboard's FilterState interface
+ */
+interface MockFilterState {
+  period: string;
+  project: string;
+  serviceTypes: string[];
+  searchQuery: string;
+  onlyChanged: boolean;
+  nonZeroCost: boolean;
+  compareMode: string;
+}
+
+/**
+ * Generate export filename matching dashboard logic
+ */
+function getExportFilename(ext: string, filterState: MockFilterState): string {
+  const date = new Date().toISOString().split('T')[0];
+  const period = filterState.period;
+  const project = filterState.project === 'all' ? 'all-projects' : filterState.project;
+  return `cloudflare-usage-${project}-${period}-${date}.${ext}`;
+}
+
+/**
+ * Generate CSV content matching dashboard logic
+ */
+function exportToCsv(resources: UnifiedResource[]): string {
+  const headers = [
+    'Name',
+    'Type',
+    'Project',
+    'Usage',
+    'Unit',
+    'Current Cost ($)',
+    'Prior Cost ($)',
+    'Change (%)',
+    'Status',
+  ];
+  const rows = resources.map((r) => [
+    r.name,
+    r.type,
+    r.project,
+    r.usage.value.toString(),
+    r.usage.unit,
+    r.costCurrent.toFixed(4),
+    r.costPrior.toFixed(4),
+    r.costDeltaPct === 'NEW' ? 'NEW' : (r.costDeltaPct?.toFixed(1) ?? '0'),
+    r.status,
+  ]);
+
+  return [headers, ...rows]
+    .map((row) => row.map((cell) => `"${cell.toString().replace(/"/g, '""')}"`).join(','))
+    .join('\n');
+}
+
+/**
+ * Generate JSON export content matching dashboard logic
+ */
+function exportToJson(
+  resources: UnifiedResource[],
+  filterState: MockFilterState
+): {
+  exportedAt: string;
+  filters: MockFilterState;
+  summary: {
+    totalResources: number;
+    totalCurrentCost: number;
+    totalPriorCost: number;
+    resourcesByType: Record<string, number>;
+  };
+  resources: Partial<UnifiedResource>[];
+} {
+  return {
+    exportedAt: new Date().toISOString(),
+    filters: {
+      period: filterState.period,
+      project: filterState.project,
+      serviceTypes: filterState.serviceTypes,
+      searchQuery: filterState.searchQuery,
+      onlyChanged: filterState.onlyChanged,
+      nonZeroCost: filterState.nonZeroCost,
+      compareMode: filterState.compareMode,
+    },
+    summary: {
+      totalResources: resources.length,
+      totalCurrentCost: resources.reduce((sum, r) => sum + r.costCurrent, 0),
+      totalPriorCost: resources.reduce((sum, r) => sum + r.costPrior, 0),
+      resourcesByType: resources.reduce(
+        (acc, r) => {
+          acc[r.type] = (acc[r.type] || 0) + 1;
+          return acc;
+        },
+        {} as Record<string, number>
+      ),
+    },
+    resources: resources.map((r) => ({
+      id: r.id,
+      name: r.name,
+      type: r.type,
+      project: r.project,
+      usage: r.usage,
+      costCurrent: r.costCurrent,
+      costPrior: r.costPrior,
+      costDelta: r.costDelta,
+      costDeltaPct: r.costDeltaPct,
+      status: r.status,
+    })),
+  };
+}
+
+describe('Usage Export - Filename Generation', () => {
+  it('generates correct CSV filename for all projects', () => {
+    const filterState: MockFilterState = {
+      period: '30d',
+      project: 'all',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    const filename = getExportFilename('csv', filterState);
+    const today = new Date().toISOString().split('T')[0];
+
+    expect(filename).toBe(`cloudflare-usage-all-projects-30d-${today}.csv`);
+  });
+
+  it('generates correct JSON filename for specific project', () => {
+    const filterState: MockFilterState = {
+      period: '7d',
+      project: 'brand-copilot',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    const filename = getExportFilename('json', filterState);
+    const today = new Date().toISOString().split('T')[0];
+
+    expect(filename).toBe(`cloudflare-usage-brand-copilot-7d-${today}.json`);
+  });
+
+  it('includes period in filename', () => {
+    const periods = ['24h', '7d', '30d'];
+    const filterState: MockFilterState = {
+      period: '',
+      project: 'all',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    for (const period of periods) {
+      filterState.period = period;
+      const filename = getExportFilename('csv', filterState);
+      expect(filename).toContain(period);
+    }
+  });
+
+  it('includes correct date format (YYYY-MM-DD)', () => {
+    const filterState: MockFilterState = {
+      period: '30d',
+      project: 'all',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    const filename = getExportFilename('csv', filterState);
+    const datePattern = /\d{4}-\d{2}-\d{2}/;
+
+    expect(filename).toMatch(datePattern);
+  });
+});
+
+describe('Usage Export - CSV Content', () => {
+  const mockResources: UnifiedResource[] = [
+    {
+      id: 'worker-api',
+      name: 'brand-copilot-api',
+      type: 'worker',
+      project: 'brand-copilot',
+      usage: { value: 100000, unit: 'requests', formatted: '100K' },
+      costCurrent: 5.5,
+      costPrior: 4.0,
+      costDelta: 1.5,
+      costDeltaPct: 37.5,
+      status: 'healthy',
+    },
+    {
+      id: 'd1-main',
+      name: 'platform-db',
+      type: 'd1',
+      project: 'platform',
+      usage: { value: 50000, unit: 'rows read', formatted: '50K' },
+      costCurrent: 2.0,
+      costPrior: 0,
+      costDelta: 2.0,
+      costDeltaPct: 'NEW',
+      status: 'warning',
+    },
+  ];
+
+  it('includes correct CSV headers', () => {
+    const csv = exportToCsv(mockResources);
+    const headerLine = csv.split('\n')[0];
+
+    expect(headerLine).toContain('"Name"');
+    expect(headerLine).toContain('"Type"');
+    expect(headerLine).toContain('"Project"');
+    expect(headerLine).toContain('"Usage"');
+    expect(headerLine).toContain('"Unit"');
+    expect(headerLine).toContain('"Current Cost ($)"');
+    expect(headerLine).toContain('"Prior Cost ($)"');
+    expect(headerLine).toContain('"Change (%)"');
+    expect(headerLine).toContain('"Status"');
+  });
+
+  it('includes all resources in CSV', () => {
+    const csv = exportToCsv(mockResources);
+    const lines = csv.split('\n');
+
+    // Header + 2 data rows
+    expect(lines).toHaveLength(3);
+  });
+
+  it('formats costs with 4 decimal places', () => {
+    const csv = exportToCsv(mockResources);
+
+    expect(csv).toContain('"5.5000"');
+    expect(csv).toContain('"4.0000"');
+    expect(csv).toContain('"2.0000"');
+  });
+
+  it('handles NEW delta percentage', () => {
+    const csv = exportToCsv(mockResources);
+
+    expect(csv).toContain('"NEW"');
+  });
+
+  it('formats numeric delta as percentage', () => {
+    const csv = exportToCsv(mockResources);
+
+    // 37.5% formatted as 37.5
+    expect(csv).toContain('"37.5"');
+  });
+
+  it('escapes double quotes in values', () => {
+    const resourceWithQuotes: UnifiedResource[] = [
+      {
+        id: 'worker-test',
+        name: 'Test "Worker"',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 1000, unit: 'requests', formatted: '1K' },
+        costCurrent: 1.0,
+        costPrior: 0,
+        costDelta: 1.0,
+        costDeltaPct: 100,
+        status: 'healthy',
+      },
+    ];
+
+    const csv = exportToCsv(resourceWithQuotes);
+
+    // Double quotes should be escaped as ""
+    expect(csv).toContain('Test ""Worker""');
+  });
+
+  it('returns empty CSV for empty resources', () => {
+    const csv = exportToCsv([]);
+    const lines = csv.split('\n');
+
+    // Only header row
+    expect(lines).toHaveLength(1);
+  });
+
+  it('preserves resource order in CSV', () => {
+    const csv = exportToCsv(mockResources);
+    const lines = csv.split('\n');
+
+    expect(lines[1]).toContain('brand-copilot-api');
+    expect(lines[2]).toContain('platform-db');
+  });
+});
+
+describe('Usage Export - JSON Content', () => {
+  const mockResources: UnifiedResource[] = [
+    {
+      id: 'worker-api',
+      name: 'brand-copilot-api',
+      type: 'worker',
+      project: 'brand-copilot',
+      usage: { value: 100000, unit: 'requests', formatted: '100K' },
+      costCurrent: 5.5,
+      costPrior: 4.0,
+      costDelta: 1.5,
+      costDeltaPct: 37.5,
+      status: 'healthy',
+    },
+    {
+      id: 'kv-cache',
+      name: 'platform-cache',
+      type: 'kv',
+      project: 'platform',
+      usage: { value: 10000, unit: 'operations', formatted: '10K' },
+      costCurrent: 1.0,
+      costPrior: 0.5,
+      costDelta: 0.5,
+      costDeltaPct: 100,
+      status: 'healthy',
+    },
+  ];
+
+  const mockFilterState: MockFilterState = {
+    period: '30d',
+    project: 'all',
+    serviceTypes: ['worker', 'kv'],
+    searchQuery: 'api',
+    onlyChanged: true,
+    nonZeroCost: true,
+    compareMode: 'lastMonth',
+  };
+
+  it('includes exportedAt timestamp', () => {
+    const json = exportToJson(mockResources, mockFilterState);
+
+    expect(json.exportedAt).toBeDefined();
+    expect(new Date(json.exportedAt).toISOString()).toBe(json.exportedAt);
+  });
+
+  it('includes all filter state', () => {
+    const json = exportToJson(mockResources, mockFilterState);
+
+    expect(json.filters.period).toBe('30d');
+    expect(json.filters.project).toBe('all');
+    expect(json.filters.serviceTypes).toEqual(['worker', 'kv']);
+    expect(json.filters.searchQuery).toBe('api');
+    expect(json.filters.onlyChanged).toBe(true);
+    expect(json.filters.nonZeroCost).toBe(true);
+    expect(json.filters.compareMode).toBe('lastMonth');
+  });
+
+  it('calculates correct summary totals', () => {
+    const json = exportToJson(mockResources, mockFilterState);
+
+    expect(json.summary.totalResources).toBe(2);
+    expect(json.summary.totalCurrentCost).toBe(6.5); // 5.5 + 1.0
+    expect(json.summary.totalPriorCost).toBe(4.5); // 4.0 + 0.5
+  });
+
+  it('counts resources by type', () => {
+    const json = exportToJson(mockResources, mockFilterState);
+
+    expect(json.summary.resourcesByType.worker).toBe(1);
+    expect(json.summary.resourcesByType.kv).toBe(1);
+  });
+
+  it('includes all resource fields', () => {
+    const json = exportToJson(mockResources, mockFilterState);
+
+    const resource = json.resources[0];
+    expect(resource.id).toBe('worker-api');
+    expect(resource.name).toBe('brand-copilot-api');
+    expect(resource.type).toBe('worker');
+    expect(resource.project).toBe('brand-copilot');
+    expect(resource.usage).toEqual({ value: 100000, unit: 'requests', formatted: '100K' });
+    expect(resource.costCurrent).toBe(5.5);
+    expect(resource.costPrior).toBe(4.0);
+    expect(resource.costDelta).toBe(1.5);
+    expect(resource.costDeltaPct).toBe(37.5);
+    expect(resource.status).toBe('healthy');
+  });
+
+  it('handles empty resources', () => {
+    const json = exportToJson([], mockFilterState);
+
+    expect(json.summary.totalResources).toBe(0);
+    expect(json.summary.totalCurrentCost).toBe(0);
+    expect(json.summary.totalPriorCost).toBe(0);
+    expect(json.resources).toHaveLength(0);
+  });
+
+  it('preserves NEW delta percentage in JSON', () => {
+    const resourceWithNew: UnifiedResource[] = [
+      {
+        id: 'd1-new',
+        name: 'new-database',
+        type: 'd1',
+        project: 'platform',
+        usage: { value: 1000, unit: 'rows', formatted: '1K' },
+        costCurrent: 1.0,
+        costPrior: 0,
+        costDelta: 1.0,
+        costDeltaPct: 'NEW',
+        status: 'healthy',
+      },
+    ];
+
+    const json = exportToJson(resourceWithNew, mockFilterState);
+
+    expect(json.resources[0].costDeltaPct).toBe('NEW');
+  });
+});
+
+describe('Usage Export - Filter Application', () => {
+  const allResources: UnifiedResource[] = [
+    {
+      id: 'worker-1',
+      name: 'worker-active',
+      type: 'worker',
+      project: 'brand-copilot',
+      usage: { value: 1000, unit: 'requests', formatted: '1K' },
+      costCurrent: 5.0,
+      costPrior: 4.0,
+      costDelta: 1.0,
+      costDeltaPct: 25,
+      status: 'healthy',
+    },
+    {
+      id: 'd1-1',
+      name: 'd1-active',
+      type: 'd1',
+      project: 'platform',
+      usage: { value: 500, unit: 'rows', formatted: '500' },
+      costCurrent: 0,
+      costPrior: 0,
+      costDelta: 0,
+      costDeltaPct: 0,
+      status: 'healthy',
+    },
+    {
+      id: 'kv-1',
+      name: 'kv-changed',
+      type: 'kv',
+      project: 'brand-copilot',
+      usage: { value: 200, unit: 'ops', formatted: '200' },
+      costCurrent: 2.0,
+      costPrior: 0,
+      costDelta: 2.0,
+      costDeltaPct: 'NEW',
+      status: 'warning',
+    },
+  ];
+
+  it('exports respects project filter', () => {
+    // Simulate filtering
+    const filtered = allResources.filter((r) => r.project === 'brand-copilot');
+
+    expect(filtered).toHaveLength(2);
+    expect(filtered.every((r) => r.project === 'brand-copilot')).toBe(true);
+  });
+
+  it('exports respects nonZeroCost filter', () => {
+    // Simulate filtering
+    const filtered = allResources.filter((r) => r.costCurrent > 0);
+
+    expect(filtered).toHaveLength(2);
+    expect(filtered.every((r) => r.costCurrent > 0)).toBe(true);
+  });
+
+  it('exports respects onlyChanged filter', () => {
+    // Simulate filtering (>5% change or NEW)
+    const filtered = allResources.filter((r) => {
+      if (r.costDeltaPct === 'NEW') return true;
+      if (typeof r.costDeltaPct === 'number') return Math.abs(r.costDeltaPct) > 5;
+      return false;
+    });
+
+    expect(filtered).toHaveLength(2); // 25% change and NEW
+  });
+
+  it('exports respects serviceType filter', () => {
+    // Simulate filtering
+    const filtered = allResources.filter((r) => ['worker', 'd1'].includes(r.type));
+
+    expect(filtered).toHaveLength(2);
+    expect(filtered.some((r) => r.type === 'kv')).toBe(false);
+  });
+
+  it('exports respects searchQuery filter', () => {
+    // Simulate filtering (case insensitive)
+    const filtered = allResources.filter((r) => r.name.toLowerCase().includes('active'));
+
+    expect(filtered).toHaveLength(2);
+  });
+
+  it('exports combined filters correctly', () => {
+    // Simulate: brand-copilot project + non-zero cost
+    const filtered = allResources.filter((r) => r.project === 'brand-copilot' && r.costCurrent > 0);
+
+    expect(filtered).toHaveLength(2);
+    expect(filtered.every((r) => r.project === 'brand-copilot' && r.costCurrent > 0)).toBe(true);
+  });
+});
+
+describe('Usage Export - Edge Cases', () => {
+  it('handles special characters in resource names', () => {
+    const specialResources: UnifiedResource[] = [
+      {
+        id: 'worker-special',
+        name: 'worker-with-comma, quote" and newline\n',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 100, unit: 'requests', formatted: '100' },
+        costCurrent: 1.0,
+        costPrior: 0,
+        costDelta: 1.0,
+        costDeltaPct: 100,
+        status: 'healthy',
+      },
+    ];
+
+    const csv = exportToCsv(specialResources);
+
+    // CSV should properly escape the content
+    expect(csv).toContain('""'); // Escaped quote
+  });
+
+  it('handles null/undefined delta percentage', () => {
+    const nullDeltaResources: UnifiedResource[] = [
+      {
+        id: 'worker-null',
+        name: 'null-delta',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 100, unit: 'requests', formatted: '100' },
+        costCurrent: 1.0,
+        costPrior: 0,
+        costDelta: 0,
+        costDeltaPct: null,
+        status: 'healthy',
+      },
+    ];
+
+    const csv = exportToCsv(nullDeltaResources);
+
+    // Should show 0 for null delta
+    expect(csv).toContain('"0"');
+  });
+
+  it('handles very large usage values', () => {
+    const largeResources: UnifiedResource[] = [
+      {
+        id: 'worker-large',
+        name: 'high-traffic',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 999999999, unit: 'requests', formatted: '999.9M' },
+        costCurrent: 100.0,
+        costPrior: 50.0,
+        costDelta: 50.0,
+        costDeltaPct: 100,
+        status: 'critical',
+      },
+    ];
+
+    const csv = exportToCsv(largeResources);
+
+    expect(csv).toContain('999999999');
+    expect(csv).toContain('"100.0000"');
+  });
+
+  it('handles very small cost values', () => {
+    const smallResources: UnifiedResource[] = [
+      {
+        id: 'worker-small',
+        name: 'low-usage',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 10, unit: 'requests', formatted: '10' },
+        costCurrent: 0.0001,
+        costPrior: 0.00005,
+        costDelta: 0.00005,
+        costDeltaPct: 100,
+        status: 'healthy',
+      },
+    ];
+
+    const csv = exportToCsv(smallResources);
+
+    expect(csv).toContain('"0.0001"');
+    expect(csv).toContain('"0.0001"'); // Prior rounded
+  });
+
+  it('handles negative delta percentage', () => {
+    const negativeResources: UnifiedResource[] = [
+      {
+        id: 'worker-negative',
+        name: 'reduced-usage',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 100, unit: 'requests', formatted: '100' },
+        costCurrent: 2.0,
+        costPrior: 5.0,
+        costDelta: -3.0,
+        costDeltaPct: -60,
+        status: 'healthy',
+      },
+    ];
+
+    const csv = exportToCsv(negativeResources);
+
+    expect(csv).toContain('"-60.0"');
+  });
+
+  it('handles all resource types', () => {
+    const allTypes: UnifiedResource[] = [
+      'worker',
+      'd1',
+      'kv',
+      'r2',
+      'vectorize',
+      'ai-gateway',
+      'pages',
+      'queues',
+      'workflows',
+      'durable-objects',
+    ].map((type, i) => ({
+      id: `${type}-1`,
+      name: `${type}-resource`,
+      type: type as UnifiedResource['type'],
+      project: 'test',
+      usage: { value: 100 * (i + 1), unit: 'units', formatted: `${100 * (i + 1)}` },
+      costCurrent: 1.0 * (i + 1),
+      costPrior: 0.5 * (i + 1),
+      costDelta: 0.5 * (i + 1),
+      costDeltaPct: 100,
+      status: 'healthy' as const,
+    }));
+
+    const csv = exportToCsv(allTypes);
+    const lines = csv.split('\n');
+
+    // Header + 10 resource types
+    expect(lines).toHaveLength(11);
+  });
+
+  it('handles all status types', () => {
+    const allStatuses: UnifiedResource[] = ['healthy', 'warning', 'high', 'critical'].map(
+      (status, _i) => ({
+        id: `status-${status}`,
+        name: `${status}-resource`,
+        type: 'worker' as const,
+        project: 'test',
+        usage: { value: 100, unit: 'requests', formatted: '100' },
+        costCurrent: 1.0,
+        costPrior: 0.5,
+        costDelta: 0.5,
+        costDeltaPct: 100,
+        status: status as UnifiedResource['status'],
+      })
+    );
+
+    const csv = exportToCsv(allStatuses);
+
+    expect(csv).toContain('"healthy"');
+    expect(csv).toContain('"warning"');
+    expect(csv).toContain('"high"');
+    expect(csv).toContain('"critical"');
+  });
+});
+
+describe('Usage Export - JSON Serialisation', () => {
+  it('produces valid JSON', () => {
+    const resources: UnifiedResource[] = [
+      {
+        id: 'worker-1',
+        name: 'test-worker',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 1000, unit: 'requests', formatted: '1K' },
+        costCurrent: 5.0,
+        costPrior: 4.0,
+        costDelta: 1.0,
+        costDeltaPct: 25,
+        status: 'healthy',
+      },
+    ];
+
+    const filterState: MockFilterState = {
+      period: '30d',
+      project: 'all',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    const json = exportToJson(resources, filterState);
+    const serialised = JSON.stringify(json);
+
+    expect(() => JSON.parse(serialised)).not.toThrow();
+  });
+
+  it('preserves numeric precision', () => {
+    const resources: UnifiedResource[] = [
+      {
+        id: 'worker-1',
+        name: 'test',
+        type: 'worker',
+        project: 'test',
+        usage: { value: 1000, unit: 'requests', formatted: '1K' },
+        costCurrent: 5.123456789,
+        costPrior: 4.987654321,
+        costDelta: 0.135802468,
+        costDeltaPct: 2.72,
+        status: 'healthy',
+      },
+    ];
+
+    const filterState: MockFilterState = {
+      period: '30d',
+      project: 'all',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    const json = exportToJson(resources, filterState);
+
+    // JSON preserves full precision
+    expect(json.resources[0].costCurrent).toBe(5.123456789);
+    expect(json.resources[0].costPrior).toBe(4.987654321);
+  });
+
+  it('handles Unicode characters in project names', () => {
+    const resources: UnifiedResource[] = [
+      {
+        id: 'worker-unicode',
+        name: 'worker-\u65e5\u672c\u8a9e',
+        type: 'worker',
+        project: '\u30d7\u30ed\u30b8\u30a7\u30af\u30c8',
+        usage: { value: 1000, unit: 'requests', formatted: '1K' },
+        costCurrent: 5.0,
+        costPrior: 4.0,
+        costDelta: 1.0,
+        costDeltaPct: 25,
+        status: 'healthy',
+      },
+    ];
+
+    const filterState: MockFilterState = {
+      period: '30d',
+      project: 'all',
+      serviceTypes: [],
+      searchQuery: '',
+      onlyChanged: false,
+      nonZeroCost: false,
+      compareMode: 'none',
+    };
+
+    const json = exportToJson(resources, filterState);
+    const serialised = JSON.stringify(json);
+    const parsed = JSON.parse(serialised);
+
+    expect(parsed.resources[0].name).toBe('worker-\u65e5\u672c\u8a9e');
+    expect(parsed.resources[0].project).toBe('\u30d7\u30ed\u30b8\u30a7\u30af\u30c8');
+  });
+});