@zoebuildsai/trace 1.5.0

package/tests/v1.2/chunked-upload.test.ts

@@ -0,0 +1,301 @@
+/**
+ * Chunked Upload Tests
+ * Large file handling with resumable transfers
+ */
+
+import { ChunkedUploadEngine, ChunkedFile } from '../../src/chunked-upload';
+
+describe('ChunkedUploadEngine', () => {
+  let engine: ChunkedUploadEngine;
+
+  beforeEach(() => {
+    engine = new ChunkedUploadEngine();
+  });
+
+  describe('Upload Initialization', () => {
+    test('initializes upload for file', () => {
+      const file = engine.initUpload('file-1', 'document.pdf', 50 * 1024 * 1024);
+      expect(file.fileId).toBe('file-1');
+      expect(file.fileName).toBe('document.pdf');
+      expect(file.totalSize).toBe(50 * 1024 * 1024);
+    });
+
+    test('calculates correct chunk count', () => {
+      const file = engine.initUpload('f1', 'test.bin', 15 * 1024 * 1024);
+      // Default chunk size 5MB, so 15MB = 3 chunks
+      expect(file.totalChunks).toBe(3);
+    });
+
+    test('supports custom chunk size', () => {
+      const file = engine.initUpload('f1', 'test.bin', 10 * 1024 * 1024, 2 * 1024 * 1024);
+      expect(file.chunkSize).toBe(2 * 1024 * 1024);
+      expect(file.totalChunks).toBe(5);
+    });
+
+    test('starts with uploading status', () => {
+      const file = engine.initUpload('f1', 'test', 1000);
+      expect(file.status).toBe('uploading');
+    });
+
+    test('initializes progress to 0', () => {
+      const file = engine.initUpload('f1', 'test', 1000);
+      expect(file.progress).toBe(0);
+    });
+  });
+
+  describe('Chunk Upload', () => {
+    test('uploads single chunk', () => {
+      engine.initUpload('f1', 'test.bin', 10 * 1024 * 1024);
+      const chunk = engine.uploadChunk('f1', 0, Buffer.from('chunk data'), 'hash1');
+      expect(chunk.index).toBe(0);
+      expect(chunk.size).toBe('chunk data'.length);
+    });
+
+    test('tracks multiple chunks', () => {
+      engine.initUpload('f1', 'test.bin', 15 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('chunk0'), 'h0');
+      engine.uploadChunk('f1', 1, Buffer.from('chunk1'), 'h1');
+      engine.uploadChunk('f1', 2, Buffer.from('chunk2'), 'h2');
+      const file = engine.getUploadStatus('f1');
+      expect(file?.chunks).toHaveLength(3);
+    });
+
+    test('updates progress as chunks upload', () => {
+      engine.initUpload('f1', 'test.bin', 15 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      let file = engine.getUploadStatus('f1');
+      expect(file?.progress).toBe(Math.round((1 / 3) * 100));
+      
+      engine.uploadChunk('f1', 1, Buffer.from('c1'), 'h1');
+      file = engine.getUploadStatus('f1');
+      expect(file?.progress).toBe(Math.round((2 / 3) * 100));
+    });
+
+    test('marks complete when all chunks received', () => {
+      engine.initUpload('f1', 'test.bin', 10 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      engine.uploadChunk('f1', 1, Buffer.from('c1'), 'h1');
+      const file = engine.getUploadStatus('f1');
+      expect(file?.status).toBe('completed');
+      expect(file?.progress).toBe(100);
+    });
+
+    test('throws error for unknown upload', () => {
+      expect(() => {
+        engine.uploadChunk('unknown', 0, Buffer.from('data'), 'hash');
+      }).toThrow();
+    });
+  });
+
+  describe('Chunk Verification', () => {
+    test('verifies chunk hash', () => {
+      engine.initUpload('f1', 'test', 1000);
+      const data = Buffer.from('test data');
+      const chunk = engine.uploadChunk('f1', 0, data, 'hash123');
+      const valid = engine.verifyChunk(chunk.id, 'hash123');
+      expect(valid).toBe(true);
+    });
+
+    test('rejects mismatched hash', () => {
+      engine.initUpload('f1', 'test', 1000);
+      const chunk = engine.uploadChunk('f1', 0, Buffer.from('test'), 'hash1');
+      const valid = engine.verifyChunk(chunk.id, 'wrong-hash');
+      expect(valid).toBe(false);
+    });
+
+    test('returns false for missing chunk', () => {
+      const valid = engine.verifyChunk('unknown', 'hash');
+      expect(valid).toBe(false);
+    });
+  });
+
+  describe('File Reconstruction', () => {
+    test('reconstructs complete file', () => {
+      engine.initUpload('f1', 'test.bin', 100);
+      engine.uploadChunk('f1', 0, Buffer.from('part1'), 'h1');
+      engine.uploadChunk('f1', 1, Buffer.from('part2'), 'h2');
+      
+      const reconstructed = engine.reconstructFile('f1');
+      expect(reconstructed.toString()).toBe('part1part2');
+    });
+
+    test('maintains chunk order', () => {
+      engine.initUpload('f1', 'test', 100);
+      engine.uploadChunk('f1', 2, Buffer.from('3'), 'h3');
+      engine.uploadChunk('f1', 0, Buffer.from('1'), 'h1');
+      engine.uploadChunk('f1', 1, Buffer.from('2'), 'h2');
+      
+      const file = engine.reconstructFile('f1');
+      expect(file.toString()).toBe('123');
+    });
+
+    test('throws error if incomplete', () => {
+      engine.initUpload('f1', 'test.bin', 100);
+      engine.uploadChunk('f1', 0, Buffer.from('part1'), 'h1');
+      
+      expect(() => {
+        engine.reconstructFile('f1');
+      }).toThrow();
+    });
+  });
+
+  describe('Resume Upload', () => {
+    test('identifies missing chunks', () => {
+      engine.initUpload('f1', 'test.bin', 20 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      engine.uploadChunk('f1', 2, Buffer.from('c2'), 'h2');
+      
+      const missing = engine.getMissingChunks('f1');
+      expect(missing).toContain(1);
+      expect(missing).toContain(3);
+      expect(missing).not.toContain(0);
+      expect(missing).not.toContain(2);
+    });
+
+    test('returns empty for complete upload', () => {
+      engine.initUpload('f1', 'test.bin', 10 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      engine.uploadChunk('f1', 1, Buffer.from('c1'), 'h1');
+      
+      const missing = engine.getMissingChunks('f1');
+      expect(missing).toHaveLength(0);
+    });
+  });
+
+  describe('Cancel Upload', () => {
+    test('cancels active upload', () => {
+      engine.initUpload('f1', 'test.bin', 100);
+      const result = engine.cancelUpload('f1');
+      expect(result).toBe(true);
+      expect(engine.getUploadStatus('f1')).toBeUndefined();
+    });
+
+    test('returns false for unknown upload', () => {
+      const result = engine.cancelUpload('unknown');
+      expect(result).toBe(false);
+    });
+
+    test('cleans up chunks on cancel', () => {
+      engine.initUpload('f1', 'test.bin', 100);
+      engine.uploadChunk('f1', 0, Buffer.from('data'), 'hash');
+      engine.cancelUpload('f1');
+      
+      expect(() => {
+        engine.reconstructFile('f1');
+      }).toThrow();
+    });
+  });
+
+  describe('Progress Tracking', () => {
+    test('reports upload progress', () => {
+      engine.initUpload('f1', 'test.bin', 20 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      
+      const progress = engine.getProgress('f1');
+      expect(progress).toBeGreaterThan(0);
+      expect(progress).toBeLessThan(100);
+    });
+
+    test('returns 0 for unknown upload', () => {
+      const progress = engine.getProgress('unknown');
+      expect(progress).toBe(0);
+    });
+  });
+
+  describe('Time Estimation', () => {
+    test('estimates upload time', () => {
+      const estimate = engine.estimateUploadTime(50 * 1024 * 1024, 5);
+      expect(estimate.chunks).toBe(10); // 50MB / 5MB chunks
+      expect(estimate.timeSeconds).toBeGreaterThan(0);
+    });
+
+    test('accounts for network speed', () => {
+      const fast = engine.estimateUploadTime(100 * 1024 * 1024, 50);
+      const slow = engine.estimateUploadTime(100 * 1024 * 1024, 5);
+      expect(slow.timeSeconds).toBeGreaterThan(fast.timeSeconds);
+    });
+  });
+
+  describe('Active Uploads', () => {
+    test('lists active uploads', () => {
+      engine.initUpload('f1', 'test1.bin', 100);
+      engine.initUpload('f2', 'test2.bin', 100);
+      
+      const active = engine.getActiveUploads();
+      expect(active).toHaveLength(2);
+    });
+
+    test('excludes completed uploads', () => {
+      engine.initUpload('f1', 'test1.bin', 10 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      engine.uploadChunk('f1', 1, Buffer.from('c1'), 'h1');
+      
+      const active = engine.getActiveUploads();
+      expect(active).toHaveLength(0);
+    });
+  });
+
+  describe('Cleanup', () => {
+    test('cleans up specific upload', () => {
+      engine.initUpload('f1', 'test1', 100);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      
+      engine.cleanup('f1');
+      expect(engine.getUploadStatus('f1')).toBeUndefined();
+    });
+
+    test('cleans up all completed uploads', () => {
+      engine.initUpload('f1', 'test1.bin', 10 * 1024 * 1024);
+      engine.uploadChunk('f1', 0, Buffer.from('c0'), 'h0');
+      engine.uploadChunk('f1', 1, Buffer.from('c1'), 'h1');
+      
+      engine.cleanup();
+      expect(engine.getActiveUploads()).toHaveLength(0);
+    });
+  });
+
+  describe('Performance', () => {
+    test('handles 100 concurrent uploads', () => {
+      const start = Date.now();
+      for (let i = 0; i < 100; i++) {
+        engine.initUpload(`f${i}`, `file${i}.bin`, 10 * 1024 * 1024);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100);
+    });
+
+    test('uploads 1000 chunks quickly', () => {
+      engine.initUpload('f1', 'test.bin', 5 * 1024 * 1024 * 1000);
+      const start = Date.now();
+      for (let i = 0; i < 1000; i++) {
+        engine.uploadChunk('f1', i, Buffer.from(`c${i}`), `h${i}`);
+      }
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(500);
+    });
+  });
+
+  describe('Large File Scenarios', () => {
+    test('handles 100MB file', () => {
+      const file = engine.initUpload('f1', 'large.bin', 100 * 1024 * 1024);
+      expect(file.totalChunks).toBe(20); // 100MB / 5MB
+    });
+
+    test('handles 1GB file', () => {
+      const file = engine.initUpload('f1', 'huge.bin', 1024 * 1024 * 1024);
+      expect(file.totalChunks).toBe(205); // ~1GB / 5MB
+    });
+
+    test('resumes partial 100MB upload', () => {
+      engine.initUpload('f1', 'large.bin', 100 * 1024 * 1024);
+      
+      // Upload first 10 chunks
+      for (let i = 0; i < 10; i++) {
+        engine.uploadChunk('f1', i, Buffer.from(`chunk${i}`), `hash${i}`);
+      }
+      
+      const missing = engine.getMissingChunks('f1');
+      expect(missing).toHaveLength(10); // 20 total - 10 uploaded
+    });
+  });
+});

package/tests/v1.2/cliff-detection.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Cliff Detection Tests
+ * Breaking change detection before checkout/merge
+ */
+
+import { CliffDetection, CliffAnalysis } from '../../src/cliff-detection';
+
+describe('CliffDetection', () => {
+  describe('Basic Cliff Analysis', () => {
+    test('detects file removal', () => {
+      const old = new Map([['src/core.ts', 'export class Core {}']]);
+      const newFiles = new Map();
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.hasCliffs).toBe(true);
+      expect(analysis.warnings.some(w => w.type === 'breaking-change')).toBe(true);
+    });
+
+    test('detects multiple file removals', () => {
+      const old = new Map([
+        ['src/core.ts', 'content'],
+        ['src/api.ts', 'content'],
+        ['src/utils.ts', 'content'],
+      ]);
+      const newFiles = new Map();
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.filter(w => w.type === 'breaking-change')).toHaveLength(3);
+    });
+
+    test('ignores new files', () => {
+      const old = new Map();
+      const newFiles = new Map([
+        ['src/new.ts', 'export class New {}'],
+        ['src/another.ts', 'export class Another {}'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.length).toBe(0);
+    });
+
+    test('calculates risk score', () => {
+      const old = new Map([['src/core.ts', 'content']]);
+      const newFiles = new Map();
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.riskScore).toBeGreaterThan(0);
+      expect(analysis.riskScore).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe('API Removal Detection', () => {
+    test('detects removed export', () => {
+      const old = new Map([
+        ['src/api.ts', 'export class UserAPI {}'],
+      ]);
+      const newFiles = new Map([
+        ['src/api.ts', '// API removed'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.length).toBeGreaterThan(0);
+    });
+
+    test('detects removed class definition', () => {
+      const old = new Map([
+        ['src/models.ts', 'export class User {}'],
+      ]);
+      const newFiles = new Map([
+        ['src/models.ts', '// Use new UserV2'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.hasCliffs).toBe(true);
+    });
+  });
+
+  describe('Security Issue Detection', () => {
+    test('detects security TODOs', () => {
+      const old = new Map();
+      const newFiles = new Map([
+        ['src/auth.ts', 'TODO: Fix security vulnerability'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.some(w => w.type === 'security-issue')).toBe(true);
+      expect(analysis.warnings.some(w => w.severity === 'critical')).toBe(true);
+    });
+
+    test('detects auth issues', () => {
+      const old = new Map();
+      const newFiles = new Map([
+        ['src/auth.ts', 'FIXME: Auth bypass vulnerability found'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.some(w => w.type === 'security-issue')).toBe(true);
+    });
+
+    test('detects vulnerability mentions', () => {
+      const old = new Map();
+      const newFiles = new Map([
+        ['src/crypto.ts', 'this is vulnerable to timing attacks'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.some(w => w.type === 'security-issue')).toBe(true);
+    });
+  });
+
+  describe('Performance Regression Detection', () => {
+    test('detects increased loops', () => {
+      const old = new Map([
+        ['src/process.ts', 'for (let i = 0; i < 10; i++) {}'],
+      ]);
+      const newFiles = new Map([
+        ['src/process.ts', 'for (let i = 0; i < 10; i++) { for (let j = 0; j < 10; j++) { for (let k = 0; k < 10; k++) {} } }'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.some(w => w.type === 'performance-regression')).toBe(true);
+    });
+
+    test('detects sync operations', () => {
+      const old = new Map([
+        ['src/io.ts', 'await readFile(path)'],
+      ]);
+      const newFiles = new Map([
+        ['src/io.ts', 'readFileSync(path)'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.some(w => w.type === 'performance-regression')).toBe(true);
+    });
+  });
+
+  describe('Risk Level Classification', () => {
+    test('classifies safe risk level', () => {
+      const level = CliffDetection.getRiskLevel(10);
+      expect(level).toBe('safe');
+    });
+
+    test('classifies caution risk level', () => {
+      const level = CliffDetection.getRiskLevel(35);
+      expect(level).toBe('caution');
+    });
+
+    test('classifies warning risk level', () => {
+      const level = CliffDetection.getRiskLevel(65);
+      expect(level).toBe('warning');
+    });
+
+    test('classifies dangerous risk level', () => {
+      const level = CliffDetection.getRiskLevel(85);
+      expect(level).toBe('dangerous');
+    });
+  });
+
+  describe('Pre-Checkout Warnings', () => {
+    test('warns before unsafe checkout', () => {
+      const current = new Map([
+        ['src/core.ts', 'current content'],
+      ]);
+      const target = new Map(); // File removed
+
+      const analysis = CliffDetection.checkBeforeCheckout(current, target);
+      expect(analysis.safeToUpdate).toBe(true); // No critical issues
+      expect(analysis.hasCliffs).toBe(true);
+    });
+
+    test('allows safe checkout', () => {
+      const current = new Map([
+        ['src/core.ts', 'v1 content'],
+      ]);
+      const target = new Map([
+        ['src/core.ts', 'v1.1 content (minor update)'],
+      ]);
+
+      const analysis = CliffDetection.checkBeforeCheckout(current, target);
+      expect(analysis.hasCliffs).toBe(false);
+    });
+  });
+
+  describe('Pre-Merge Warnings', () => {
+    test('warns before unsafe merge', () => {
+      const base = new Map([
+        ['src/core.ts', 'original'],
+      ]);
+      const merge = new Map(); // File removed
+
+      const analysis = CliffDetection.checkBeforeMerge(base, merge);
+      expect(analysis.hasCliffs).toBe(true);
+    });
+  });
+
+  describe('Report Formatting', () => {
+    test('formats clean report', () => {
+      const report = {
+        timestamp: Date.now(),
+        totalOperations: 100,
+        averageLatency: 45,
+        bottlenecks: [],
+        recommendations: [],
+      };
+
+      const formatted = CliffDetection.formatWarnings({
+        hasCliffs: false,
+        warnings: [],
+        safeToUpdate: true,
+        riskScore: 0,
+      });
+
+      expect(formatted).toContain('No breaking changes');
+      expect(formatted).toContain('Safe to update');
+    });
+
+    test('formats risk warning', () => {
+      const formatted = CliffDetection.formatWarnings({
+        hasCliffs: true,
+        warnings: [
+          {
+            type: 'breaking-change',
+            severity: 'high',
+            description: 'Major API change',
+            affectedFiles: ['src/api.ts'],
+            suggestion: 'Update consumers of this API',
+          },
+        ],
+        safeToUpdate: false,
+        riskScore: 75,
+      });
+
+      expect(formatted).toContain('HIGH');
+      expect(formatted).toContain('breaking-change');
+      expect(formatted).toContain('Major API change');
+    });
+  });
+
+  describe('Complex Scenarios', () => {
+    test('handles multiple simultaneous issues', () => {
+      const old = new Map([
+        ['src/api.ts', 'export class API { userGet() {} }'],
+        ['src/auth.ts', 'export const authenticate = () => {}'],
+        ['src/utils.ts', 'export const helper = () => {}'],
+      ]);
+
+      const newFiles = new Map([
+        ['src/api.ts', 'TODO: Fix security vulnerability'],
+        ['src/auth.ts', '// Removed (use OAuth instead)'],
+        ['src/utils.ts', 'FIXME: Auth bypass'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      expect(analysis.warnings.length).toBeGreaterThan(1);
+      expect(analysis.riskScore).toBeGreaterThan(50);
+    });
+
+    test('prioritizes critical issues', () => {
+      const old = new Map([
+        ['src/core.ts', 'original'],
+      ]);
+
+      const newFiles = new Map([
+        ['src/core.ts', 'TODO: Security TODO, performance issue, and removed API'],
+      ]);
+
+      const analysis = CliffDetection.analyzeCliff(old, newFiles);
+      const criticalWarnings = analysis.warnings.filter(w => w.severity === 'critical');
+      expect(criticalWarnings.length).toBeGreaterThan(0);
+    });
+  });
+});