@btc-vision/bitcoin 7.0.0-alpha.1 → 7.0.0-alpha.10

package/test/workers-pool.spec.ts

@@ -1,13 +1,10 @@
-import { describe, it, expect, beforeEach, afterEach, vi, type Mock } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
-    SignatureType,
-    WorkerState,
     type BatchSigningTaskResult,
-    type SigningTask,
     type ParallelSignerKeyPair,
+    SignatureType,
+    type SigningTask,
     type WorkerResponse,
-    type SigningResultMessage,
-    type WorkerPoolConfig,
 } from '../src/workers/types.js';
 
 // Mock Worker class for browser pool testing
@@ -60,14 +57,16 @@ class MockWorker {
                 }
 
                 // Generate results for all tasks
-                const results = batchMsg.tasks.map((task): BatchSigningTaskResult => ({
-                    taskId: task.taskId,
-                    signature: new Uint8Array(64).fill(0xab),
-                    inputIndex: task.inputIndex,
-                    publicKey: task.publicKey,
-                    signatureType: task.signatureType,
-                    ...(task.leafHash ? { leafHash: task.leafHash } : {}),
-                }));
+                const results = batchMsg.tasks.map(
+                    (task): BatchSigningTaskResult => ({
+                        taskId: task.taskId,
+                        signature: new Uint8Array(64).fill(0xab),
+                        inputIndex: task.inputIndex,
+                        publicKey: task.publicKey,
+                        signatureType: task.signatureType,
+                        ...(task.leafHash ? { leafHash: task.leafHash } : {}),
+                    }),
+                );
 
                 this.simulateMessage({
                     type: 'batchResult',
@@ -104,6 +103,15 @@ class MockWorker {
         this.errorHandlers = [];
     }
 
+    simulateError(error: Error): void {
+        if (this.onerror) {
+            this.onerror(error);
+        }
+        for (const handler of this.errorHandlers) {
+            handler(error);
+        }
+    }
+
     private simulateMessage(data: WorkerResponse): void {
         const event = { data };
         if (this.onmessage) {
@@ -113,15 +121,6 @@ class MockWorker {
             handler(event);
         }
     }
-
-    simulateError(error: Error): void {
-        if (this.onerror) {
-            this.onerror(error);
-        }
-        for (const handler of this.errorHandlers) {
-            handler(error);
-        }
-    }
 }
 
 // Mock Worker that fails signing
@@ -607,6 +606,49 @@ describe('WorkerSigningPool', () => {
         });
     });
 
+    describe('Symbol.asyncDispose', () => {
+        it('should have Symbol.asyncDispose method', () => {
+            const pool = WorkerSigningPool.getInstance({ workerCount: 1 });
+            expect(typeof pool[Symbol.asyncDispose]).toBe('function');
+        });
+
+        it('should terminate workers when disposed', async () => {
+            const pool = WorkerSigningPool.getInstance({ workerCount: 2 });
+            await pool.initialize();
+            expect(pool.workerCount).toBe(2);
+
+            await pool[Symbol.asyncDispose]();
+            expect(pool.workerCount).toBe(0);
+        });
+
+        it('should be safe to call after shutdown', async () => {
+            const pool = WorkerSigningPool.getInstance({ workerCount: 2 });
+            await pool.initialize();
+
+            await pool.shutdown();
+            await pool[Symbol.asyncDispose](); // Should not throw
+
+            expect(pool.workerCount).toBe(0);
+        });
+
+        it('should clean up with await using', async () => {
+            WorkerSigningPool.resetInstance();
+
+            let poolRef: InstanceType<typeof WorkerSigningPool> | undefined;
+
+            // Scoped block — pool is disposed when the block exits
+            {
+                await using pool = WorkerSigningPool.getInstance({ workerCount: 2 });
+                await pool.initialize();
+                expect(pool.workerCount).toBe(2);
+                poolRef = pool;
+            }
+
+            // After scope exit, dispose has been called
+            expect(poolRef!.workerCount).toBe(0);
+        });
+    });
+
     describe('Worker Pool Without Preservation', () => {
         it('should terminate workers after batch when not preserving', async () => {
             const pool = WorkerSigningPool.getInstance({ workerCount: 2 });