test: add afterEach cleanup + timer tracking in error_recovery test (anti-flake)

Author: oorabona

test/integration/error_recovery_and_state_transitions.test.ts

@@ -1,7 +1,41 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import * as lzma from '../../src/lzma.js';
 
 describe('Error Recovery and State Transitions', () => {
+  // Track every stream + timer created so we can guarantee cleanup, even if a
+  // test rejects mid-flight or a native callback is queued after the test ends.
+  // Without this, late callbacks (xz.emit('onerror', ...) firing after close())
+  // can crash the vitest worker — historical Windows+Node20 / Ubuntu+Node24 flakes.
+  let streams: lzma.Xz[] = [];
+  let timers: NodeJS.Timeout[] = [];
+
+  const track = <T extends lzma.Xz>(s: T): T => {
+    streams.push(s);
+    return s;
+  };
+
+  const trackTimer = (t: NodeJS.Timeout): NodeJS.Timeout => {
+    timers.push(t);
+    return t;
+  };
+
+  beforeEach(() => {
+    streams = [];
+    timers = [];
+  });
+
+  afterEach(() => {
+    for (const t of timers) clearTimeout(t);
+    for (const s of streams) {
+      try {
+        if (typeof s.destroy === 'function') s.destroy();
+        else if (typeof s.close === 'function' && !s._closed) s.close();
+      } catch {
+        // best-effort: ignore double-destroy errors
+      }
+    }
+  });
+
   it('should cover filter validation catch block', () => {
     // Force the try-catch path in filter validation
     expect(() => {
@@ -14,12 +48,13 @@ describe('Error Recovery and State Transitions', () => {
       };
 
       const xz = new lzma.Xz({ filters: malformedFilters });
+      track(xz);
       xz.close();
     }).toThrow('Filters need to be in an array!');
   });
 
   it('should cover callback when stream is ending', async () => {
-    const xz = new lzma.Xz();
+    const xz = track(new lzma.Xz());
 
     return new Promise<void>((resolve) => {
       let callbackExecuted = false;
@@ -29,27 +64,27 @@ describe('Error Recovery and State Transitions', () => {
       xz.end(); // This puts stream in 'ending' state
 
       // Immediately try to flush while ending - should trigger the appropriate behavior
-      setTimeout(() => {
-        xz.flush(() => {
-          callbackExecuted = true;
-          expect(callbackExecuted).toBe(true);
-          xz.close();
-          resolve();
-        });
-      }, 1); // Very small delay to ensure ending state
+      trackTimer(
+        setTimeout(() => {
+          xz.flush(() => {
+            callbackExecuted = true;
+            expect(callbackExecuted).toBe(true);
+            resolve();
+          });
+        }, 1) // Very small delay to ensure ending state
+      );
 
       // Fallback timeout
-      setTimeout(() => {
-        if (!callbackExecuted) {
-          xz.close();
-          resolve();
-        }
-      }, 50);
+      trackTimer(
+        setTimeout(() => {
+          if (!callbackExecuted) resolve();
+        }, 50)
+      );
     });
   });
 
   it('should cover lines 457-458 - async LZMA error handling', async () => {
-    const xz = new lzma.Xz();
+    const xz = track(new lzma.Xz());
 
     return new Promise<void>((resolve) => {
       let errorCount = 0;
@@ -59,16 +94,13 @@ describe('Error Recovery and State Transitions', () => {
         expect(error).toBeInstanceOf(Error);
         // Accept any LZMA error code (native + manual emit may both fire)
         expect(error.errno).toBeGreaterThan(0);
-
-        if (errorCount === 1) {
-          xz.close();
-        }
+        if (errorCount === 1) xz.close();
       });
 
       // Absorb any errors after stream is destroyed (e.g. LZMA_PROG_ERROR
       // from native callback firing after close)
       xz.on('close', () => {
-        setTimeout(resolve, 50);
+        trackTimer(setTimeout(resolve, 50));
       });
 
       // Emit onerror directly — this triggers the onerror→error conversion (line 357-360)
@@ -86,7 +118,7 @@ describe('Error Recovery and State Transitions', () => {
     ];
 
     for (const errorCode of testCases) {
-      const xz = new lzma.Xz();
+      const xz = track(new lzma.Xz());
 
       await new Promise<void>((resolve) => {
         xz.on('error', (error) => {
@@ -102,18 +134,15 @@ describe('Error Recovery and State Transitions', () => {
   });
 
   it('should handle stream state transitions correctly', async () => {
-    const xz = new lzma.Xz();
+    const xz = track(new lzma.Xz());
 
     return new Promise<void>((resolve) => {
       let statesTracked = 0;
       const expectedStates = 3;
 
       const checkComplete = () => {
         statesTracked++;
-        if (statesTracked >= expectedStates) {
-          xz.close();
-          resolve();
-        }
+        if (statesTracked >= expectedStates) resolve();
       };
 
       // Test ended state flush
@@ -126,9 +155,11 @@ describe('Error Recovery and State Transitions', () => {
       xz.end();
 
       // Test normal flush
-      setTimeout(() => {
-        xz.flush(() => checkComplete());
-      }, 5);
+      trackTimer(
+        setTimeout(() => {
+          xz.flush(() => checkComplete());
+        }, 5)
+      );
 
       checkComplete(); // Initial count
     });