test(chrome-extension): stabilize memory stress comparison

Author: quanru

apps/chrome-extension/tests/event-memory-stress.test.ts

@@ -202,31 +202,32 @@ describe('Chrome Extension Event Recording - Crash Reproduction', () => {
   );
 
   /**
-   * Direct comparison: measure the ratio of peak heap between old and new.
+   * Direct comparison: measure deterministic structured-clone payload volume.
    */
   it(
-    'NEW approach uses significantly less peak memory than OLD',
+    'NEW approach sends significantly less cumulative message data than OLD',
     () => {
       // --- Old approach ---
-      if (global.gc) global.gc();
-      const oldBaseline = getHeapUsedMB();
       const oldEvents: MockEvent[] = [];
+      let oldTotalMessageBytes = 0;
+      let oldMaxMessageBytes = 0;
 
       for (let i = 0; i < 40; i++) {
         oldEvents.push(createMockEvent(i));
         const s = JSON.stringify({ action: 'events', data: oldEvents });
+        oldTotalMessageBytes += s.length;
+        oldMaxMessageBytes = Math.max(oldMaxMessageBytes, s.length);
         JSON.parse(s);
       }
-      const oldPeak = getHeapUsedMB();
-      const oldGrowth = oldPeak - oldBaseline;
 
       // Force cleanup
       oldEvents.length = 0;
       if (global.gc) global.gc();
 
       // --- New approach ---
-      const newBaseline = getHeapUsedMB();
       const newEvents: MockEvent[] = [];
+      let newTotalMessageBytes = 0;
+      let newMaxMessageBytes = 0;
 
       for (let i = 0; i < 40; i++) {
         const event = createMockEvent(i);
@@ -236,20 +237,32 @@ describe('Chrome Extension Event Recording - Crash Reproduction', () => {
           data: event,
           eventIndex: i,
         });
+        newTotalMessageBytes += s.length;
+        newMaxMessageBytes = Math.max(newMaxMessageBytes, s.length);
         JSON.parse(s);
       }
-      const newPeak = getHeapUsedMB();
-      const newGrowth = newPeak - newBaseline;
 
       console.log('\n=== COMPARISON (40 events) ===');
-      console.log(`Old heap growth: ${oldGrowth.toFixed(0)} MB`);
-      console.log(`New heap growth: ${newGrowth.toFixed(0)} MB`);
       console.log(
-        `Ratio: old is ${(oldGrowth / Math.max(newGrowth, 1)).toFixed(1)}x more memory`,
+        `Old cumulative message data: ${(oldTotalMessageBytes / 1024 / 1024).toFixed(0)} MB`,
+      );
+      console.log(
+        `New cumulative message data: ${(newTotalMessageBytes / 1024 / 1024).toFixed(0)} MB`,
+      );
+      console.log(
+        `Old max message size: ${(oldMaxMessageBytes / 1024 / 1024).toFixed(0)} MB`,
+      );
+      console.log(
+        `New max message size: ${(newMaxMessageBytes / 1024 / 1024).toFixed(2)} MB`,
+      );
+      console.log(
+        `Ratio: old sends ${(oldTotalMessageBytes / newTotalMessageBytes).toFixed(1)}x more data`,
       );
 
-      // The old approach must use significantly more memory
-      expect(oldGrowth).toBeGreaterThan(newGrowth);
+      // Heap snapshots are noisy under CI GC and coverage. The serialized
+      // payload size is the stable part of the structured-clone cost.
+      expect(oldTotalMessageBytes).toBeGreaterThan(newTotalMessageBytes * 10);
+      expect(oldMaxMessageBytes).toBeGreaterThan(newMaxMessageBytes * 10);
     },
     STRESS_TEST_TIMEOUT_MS,
   );