@vuer-ai/vuer-rtc-server 0.2.0 → 0.2.2

package/tests/compression/compression.test.ts

@@ -0,0 +1,343 @@
+/**
+ * Unit Tests for CompressionUtils
+ *
+ * Tests verify:
+ * A. Compression reduces data size
+ * B. Decompression roundtrip preserves data integrity
+ * C. Compression ratio is within expected bounds
+ * D. Edge cases (empty, large, nested objects)
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import {
+  compressSnapshot,
+  decompressSnapshot,
+  verifyCompressionRoundtrip,
+  getCompressionStats,
+} from '../../src/compression/CompressionUtils';
+
+describe('CompressionUtils', () => {
+  describe('compressSnapshot', () => {
+    it('should compress a simple snapshot', () => {
+      const snapshot = {
+        graph: {
+          nodes: {
+            root: { key: 'root', tag: 'Group', name: 'Root' },
+          },
+          rootKey: 'root',
+        },
+        vectorClock: { session1: 10 },
+        lamportTime: 10,
+        journalIndex: 10,
+      };
+
+      const result = compressSnapshot(snapshot);
+
+      expect(result.compressed).toBeDefined();
+      expect(result.compressedSize).toBeLessThan(result.originalSize);
+      expect(result.ratio).toBeGreaterThan(0);
+      expect(result.ratio).toBeLessThan(100);
+    });
+
+    it('should compress a complex nested snapshot', () => {
+      const nodeMap: Record<string, any> = {
+        root: { key: 'root', tag: 'Group', name: 'Root Node', children: [] },
+      };
+
+      // Create 50 child nodes
+      for (let i = 0; i < 50; i++) {
+        nodeMap[`child-${i}`] = {
+          key: `child-${i}`,
+          tag: 'Mesh',
+          name: `Child ${i}`,
+          position: [Math.random(), Math.random(), Math.random()],
+          rotation: [Math.random(), Math.random(), Math.random()],
+          scale: [1, 1, 1],
+          children: [],
+        };
+      }
+
+      const snapshot = {
+        graph: {
+          nodes: nodeMap,
+          rootKey: 'root',
+        },
+        vectorClock: {
+          session1: 100,
+          session2: 85,
+          session3: 92,
+        },
+        lamportTime: 100,
+        journalIndex: 100,
+      };
+
+      const result = compressSnapshot(snapshot);
+
+      // Complex nested object should compress well
+      expect(result.compressedSize).toBeLessThan(result.originalSize);
+      // With repetitive structure, expect decent compression (30-60% of original)
+      expect(result.ratio).toBeLessThan(70);
+    });
+
+    it('should return compression metrics', () => {
+      const snapshot = { data: 'test' };
+      const result = compressSnapshot(snapshot);
+
+      expect(result).toHaveProperty('compressed');
+      expect(result).toHaveProperty('original');
+      expect(result).toHaveProperty('ratio');
+      expect(result).toHaveProperty('originalSize');
+      expect(result).toHaveProperty('compressedSize');
+
+      expect(typeof result.originalSize).toBe('number');
+      expect(typeof result.compressedSize).toBe('number');
+      expect(typeof result.ratio).toBe('number');
+    });
+  });
+
+  describe('decompressSnapshot', () => {
+    it('should decompress a compressed snapshot', () => {
+      const original = {
+        graph: {
+          nodes: {
+            root: { key: 'root', tag: 'Group', name: 'Root', children: [] },
+          },
+          rootKey: 'root',
+        },
+        vectorClock: { session1: 5 },
+        lamportTime: 5,
+        journalIndex: 5,
+      };
+
+      const compressed = compressSnapshot(original);
+      const result = decompressSnapshot(compressed.compressed);
+
+      expect(result.decompressed).toBeDefined();
+      expect(result.verified).toBe(true);
+
+      const decompressedObj = JSON.parse(result.decompressed.toString('utf-8'));
+      expect(decompressedObj).toEqual(original);
+    });
+
+    it('should handle decompression of large data', () => {
+      const nodeMap: Record<string, any> = {
+        root: { key: 'root', tag: 'Group', name: 'Root', children: [] },
+      };
+
+      // Create 200 nodes with repetitive data
+      for (let i = 0; i < 200; i++) {
+        nodeMap[`node-${i}`] = {
+          key: `node-${i}`,
+          tag: 'Mesh',
+          position: [Math.random(), Math.random(), Math.random()],
+          data: `Large data field ${i}`.repeat(10),
+          children: [],
+        };
+      }
+
+      const largeSnapshot = {
+        graph: {
+          nodes: nodeMap,
+          rootKey: 'root',
+        },
+        vectorClock: Object.fromEntries(
+          Array.from({ length: 10 }, (_, i) => [`session${i}`, i * 10])
+        ),
+        lamportTime: 100,
+        journalIndex: 100,
+      };
+
+      const compressed = compressSnapshot(largeSnapshot);
+      const result = decompressSnapshot(compressed.compressed);
+
+      expect(result.verified).toBe(true);
+      const decompressed = JSON.parse(result.decompressed.toString('utf-8'));
+      expect(decompressed).toEqual(largeSnapshot);
+    });
+
+    it('should throw on corrupted data', () => {
+      const corruptedBuffer = Buffer.from('not-gzip-data');
+      expect(() => decompressSnapshot(corruptedBuffer)).toThrow();
+    });
+
+    it('should throw on empty buffer', () => {
+      const emptyBuffer = Buffer.alloc(0);
+      expect(() => decompressSnapshot(emptyBuffer)).toThrow();
+    });
+  });
+
+  describe('verifyCompressionRoundtrip', () => {
+    it('should verify roundtrip for simple snapshot', () => {
+      const snapshot = {
+        graph: {
+          nodes: {
+            root: { key: 'root', tag: 'Group', name: 'Root', children: [] },
+          },
+          rootKey: 'root',
+        },
+        vectorClock: {},
+        lamportTime: 0,
+        journalIndex: 0,
+      };
+
+      const verified = verifyCompressionRoundtrip(snapshot);
+      expect(verified).toBe(true);
+    });
+
+    it('should verify roundtrip for complex snapshot', () => {
+      const nodeMap: Record<string, any> = {
+        root: { key: 'root', tag: 'Group', name: 'Root', children: [] },
+      };
+
+      // Create 100 child nodes
+      for (let i = 0; i < 100; i++) {
+        nodeMap[`child-${i}`] = {
+          key: `child-${i}`,
+          tag: 'Mesh',
+          name: `Child ${i}`,
+          position: [1, 2, 3],
+          properties: { a: 1, b: 'test', c: [1, 2, 3] },
+          children: [],
+        };
+      }
+
+      const snapshot = {
+        graph: {
+          nodes: nodeMap,
+          rootKey: 'root',
+        },
+        vectorClock: { s1: 50, s2: 50, s3: 50 },
+        lamportTime: 50,
+        journalIndex: 50,
+      };
+
+      const verified = verifyCompressionRoundtrip(snapshot);
+      expect(verified).toBe(true);
+    });
+
+    it('should handle null and undefined', () => {
+      // null is valid JSON
+      expect(verifyCompressionRoundtrip(null)).toBe(true);
+
+      // undefined becomes null in JSON
+      const result = verifyCompressionRoundtrip(undefined);
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('getCompressionStats', () => {
+    it('should return statistics without storing data', () => {
+      const snapshot = {
+        data: 'test data'.repeat(100),
+        nested: { deep: { structure: { value: 123 } } },
+      };
+
+      const stats = getCompressionStats(snapshot);
+
+      expect(stats).toHaveProperty('originalSize');
+      expect(stats).toHaveProperty('compressedSize');
+      expect(stats).toHaveProperty('ratio');
+      expect(stats).toHaveProperty('savedBytes');
+
+      expect(stats.originalSize).toBeGreaterThan(0);
+      expect(stats.compressedSize).toBeGreaterThan(0);
+      expect(stats.savedBytes).toBe(stats.originalSize - stats.compressedSize);
+      expect(stats.ratio).toBeLessThan(100);
+    });
+
+    it('should show significant savings for repetitive data', () => {
+      const repetitiveSnapshot = {
+        items: Array.from({ length: 1000 }, (_, i) => ({
+          id: i,
+          name: `Item ${i}`,
+          type: 'standard',
+          status: 'active',
+          tags: ['tag1', 'tag2', 'tag3'],
+        })),
+      };
+
+      const stats = getCompressionStats(repetitiveSnapshot);
+
+      // Repetitive data should compress well (expect <50% of original)
+      expect(stats.ratio).toBeLessThan(50);
+      expect(stats.savedBytes).toBeGreaterThan(stats.originalSize * 0.5);
+    });
+  });
+
+  describe('Integration: Real-world snapshots', () => {
+    it('should achieve 75-80% compression on realistic journal snapshot', () => {
+      // Simulate a realistic journal snapshot with multiple rooms/scenes
+      const nodes: Record<string, any> = {
+        root: { key: 'root', tag: 'Group', name: 'World Root', children: [] },
+      };
+
+      // Create 20 rooms with 50 meshes each
+      for (let roomIdx = 0; roomIdx < 20; roomIdx++) {
+        nodes[`room-${roomIdx}`] = {
+          key: `room-${roomIdx}`,
+          tag: 'Group',
+          name: `Room ${roomIdx}`,
+          children: [],
+        };
+
+        for (let nodeIdx = 0; nodeIdx < 50; nodeIdx++) {
+          nodes[`node-${roomIdx}-${nodeIdx}`] = {
+            key: `node-${roomIdx}-${nodeIdx}`,
+            tag: 'Mesh',
+            name: `Mesh ${nodeIdx}`,
+            position: [Math.random() * 100, Math.random() * 100, Math.random() * 100],
+            rotation: [0, 0, 0],
+            scale: [1, 1, 1],
+            material: {
+              color: `#${Math.random().toString(16).slice(2, 8)}`,
+              roughness: 0.5,
+              metallic: 0.5,
+            },
+            children: [],
+          };
+        }
+      }
+
+      const realisticSnapshot = {
+        graph: {
+          nodes,
+          rootKey: 'root',
+        },
+        vectorClock: Object.fromEntries(
+          Array.from({ length: 50 }, (_, i) => [`session-${i}`, 1000 + i * 100])
+        ),
+        lamportTime: 6000,
+        journalIndex: 6000,
+      };
+
+      const stats = getCompressionStats(realisticSnapshot);
+
+      // Should achieve our target compression ratio
+      expect(stats.ratio).toBeLessThan(25); // Less than 25% is 75%+ compression
+      console.log(
+        `✓ Compression: ${stats.originalSize} → ${stats.compressedSize} bytes (${stats.ratio.toFixed(1)}% of original, ${(100 - stats.ratio).toFixed(1)}% saved)`
+      );
+    });
+
+    it('should handle empty snapshot', () => {
+      const emptySnapshot = {
+        graph: {
+          nodes: {
+            root: { key: 'root', tag: 'Group', name: 'Root', children: [] },
+          },
+          rootKey: 'root',
+        },
+        vectorClock: {},
+        lamportTime: 0,
+        journalIndex: 0,
+      };
+
+      const result = compressSnapshot(emptySnapshot);
+      expect(result.compressedSize).toBeGreaterThan(0);
+
+      // Even empty snapshots benefit from compression slightly
+      const decompressed = decompressSnapshot(result.compressed);
+      expect(decompressed.verified).toBe(true);
+    });
+  });
+});

package/tests/integration/repositories.test.ts

@@ -19,6 +19,7 @@ interface ISessionRepository {
   findByDocument(documentId: string): Promise<any[]>;
   updatePresence(id: string, presence: any): Promise<any>;
   disconnect(id: string): Promise<any>;
+  deleteDisconnected(olderThan: Date): Promise<number>;
 }
 
 // Try to import - will fail until implemented
@@ -69,6 +70,9 @@ try {
     disconnect() {
       throw new Error('Not implemented');
     }
+    deleteDisconnected() {
+      throw new Error('Not implemented');
+    }
   } as any;
 }
 
@@ -316,5 +320,90 @@ describe('Database Repositories', () => {
       // Cleanup
       await sessionRepo.disconnect(session1.id);
     });
+
+    it('should delete old disconnected sessions', async () => {
+      // Create and disconnect a session
+      const oldSession = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-old',
+        clientId: 'client-old',
+      });
+      await sessionRepo.disconnect(oldSession.id);
+
+      // Create a recent disconnected session
+      const recentSession = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-recent',
+        clientId: 'client-recent',
+      });
+      await sessionRepo.disconnect(recentSession.id);
+
+      // Create an active session
+      const activeSession = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-active',
+        clientId: 'client-active',
+      });
+
+      // Delete sessions disconnected before now (should catch the old one but not recent)
+      // We'll use a cutoff that's slightly in the past
+      const cutoffDate = new Date(Date.now() - 1000); // 1 second ago
+
+      // Wait a bit to ensure timestamps are different
+      await new Promise(resolve => setTimeout(resolve, 1100));
+
+      const deletedCount = await sessionRepo.deleteDisconnected(cutoffDate);
+
+      // Should delete both disconnected sessions (old and recent)
+      expect(deletedCount).toBeGreaterThanOrEqual(2);
+
+      // Active session should still exist
+      const activeFound = await sessionRepo.findById(activeSession.id);
+      expect(activeFound).toBeDefined();
+      expect(activeFound!.connected).toBe(true);
+
+      // Old session should be gone
+      const oldFound = await sessionRepo.findById(oldSession.id);
+      expect(oldFound).toBeNull();
+
+      // Recent session should be gone
+      const recentFound = await sessionRepo.findById(recentSession.id);
+      expect(recentFound).toBeNull();
+
+      // Cleanup
+      await sessionRepo.disconnect(activeSession.id);
+    });
+
+    it('should not delete active sessions', async () => {
+      // Create active sessions
+      const session1 = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-active-1',
+        clientId: 'client-active-1',
+      });
+
+      const session2 = await sessionRepo.create({
+        documentId: testDocId,
+        userId: 'user-active-2',
+        clientId: 'client-active-2',
+      });
+
+      // Try to delete all sessions (even future ones)
+      const futureDate = new Date(Date.now() + 24 * 60 * 60 * 1000);
+      const deletedCount = await sessionRepo.deleteDisconnected(futureDate);
+
+      // Should not delete any active sessions
+      const session1Found = await sessionRepo.findById(session1.id);
+      const session2Found = await sessionRepo.findById(session2.id);
+
+      expect(session1Found).toBeDefined();
+      expect(session1Found!.connected).toBe(true);
+      expect(session2Found).toBeDefined();
+      expect(session2Found!.connected).toBe(true);
+
+      // Cleanup
+      await sessionRepo.disconnect(session1.id);
+      await sessionRepo.disconnect(session2.id);
+    });
   });
 });