@liquidmetal-ai/precip 1.0.0

package/src/sandbox/bridges/bridge-fixes.test.ts

@@ -0,0 +1,614 @@
+/**
+ * Tests for bridge fixes: leaks, edge cases, and error handling
+ *
+ * These tests verify the fixes for issues identified in code review:
+ * 1. TextDecoder memory leak (cleanup handler)
+ * 2. Bridge installer error handling (try-catch)
+ * 3. Promise state check error handling
+ * 4. ReadableStream locked property (dynamic getter)
+ * 5. Error formatting with circular references (safe stringify)
+ * 6. TextDecoder silent fallback (explicit error)
+ * 7. CoalescingReader state reset on error
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+import type { BridgeInstaller } from './types.js';
+import { sandboxAsync, sandboxSync } from '../../types.js';
+import { createHttpbinMocks } from '../test-mocks.js';
+
+let mockFetch: any;
+
+function setupMockFetch() {
+  const mocks = createHttpbinMocks();
+  mockFetch = vi.fn(async (url: string, _init?: RequestInit) => {
+    const urlKey = url.split('?')[0];
+    const mock = mocks.get(urlKey);
+    if (!mock) {
+      throw new Error(`No mock for: ${urlKey}`);
+    }
+    if (mock.delay) {
+      await new Promise(resolve => setTimeout(resolve, mock.delay));
+    }
+    return new Response(mock.body, {
+      status: mock.status ?? 200,
+      statusText: mock.statusText ?? 'OK',
+      headers: new Headers(mock.headers)
+    });
+  });
+  globalThis.fetch = mockFetch;
+}
+
+function restoreFetch() {
+  vi.restoreAllMocks();
+}
+
+describe('TextDecoder Cleanup', () => {
+  it('should not leak decoder instances across multiple executions', async () => {
+    // Run many iterations using TextDecoder with streaming mode
+    // If cleanup isn't working, memory would grow
+    for (let i = 0; i < 20; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				const decoder = new TextDecoder();
+				// Use streaming mode which creates stateful decoder
+				const chunk1 = new Uint8Array([104, 101]);  // "he"
+				const chunk2 = new Uint8Array([108, 108, 111]);  // "llo"
+				
+				const text1 = decoder.decode(chunk1, { stream: true });
+				const text2 = decoder.decode(chunk2, { stream: true });
+				const text3 = decoder.decode();  // flush
+				
+				return text1 + text2 + text3
+			`,
+        {}
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe('hello');
+    }
+    // If we get here without memory issues, cleanup is working
+  });
+
+  it('should handle multiple TextDecoder instances in single execution', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const decoders = [];
+			for (let i = 0; i < 10; i++) {
+				decoders.push(new TextDecoder());
+			}
+			
+			// Use all decoders
+			const results = decoders.map((d, i) => {
+				const bytes = new Uint8Array([48 + i]);  // '0' to '9'
+				return d.decode(bytes);
+			});
+			
+			return results.join('')
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('0123456789');
+  });
+});
+
+describe('Bridge Installer Error Handling', () => {
+  it('should handle throwing bridge installer gracefully', async () => {
+    const throwingInstaller: BridgeInstaller = () => {
+      throw new Error('Bridge installer failed');
+    };
+
+    const result = await executeWithAsyncHost(
+      'return 42',
+      {},
+      { bridgeInstallers: [throwingInstaller] }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Bridge installer failed');
+  });
+
+  it('should execute installers in order and stop on first error', async () => {
+    const installOrder: number[] = [];
+
+    const installer1: BridgeInstaller = () => {
+      installOrder.push(1);
+    };
+
+    const installer2: BridgeInstaller = () => {
+      installOrder.push(2);
+      throw new Error('Installer 2 failed');
+    };
+
+    const installer3: BridgeInstaller = () => {
+      installOrder.push(3); // Should never be called
+    };
+
+    const result = await executeWithAsyncHost(
+      'return 42',
+      {},
+      { bridgeInstallers: [installer1, installer2, installer3] }
+    );
+
+    expect(result.success).toBe(false);
+    expect(installOrder).toEqual([1, 2]); // installer3 should not run
+  });
+
+  it('should cleanup properly after installer error', async () => {
+    // Run multiple times to ensure no resource leaks
+    for (let i = 0; i < 5; i++) {
+      const throwingInstaller: BridgeInstaller = () => {
+        throw new Error('Intentional failure');
+      };
+
+      const result = await executeWithAsyncHost(
+        'return 42',
+        {},
+        { bridgeInstallers: [throwingInstaller] }
+      );
+
+      expect(result.success).toBe(false);
+    }
+  });
+});
+
+describe('Promise State Error Handling', () => {
+  it('should handle promise rejection with string error', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			throw new Error('Simple error message')
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Simple error message');
+  });
+
+  it('should handle promise rejection with object error', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const err = { code: 'ERR_001', message: 'Complex error' };
+			throw err
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('should handle async function throwing error', async () => {
+    const globals = {
+      asyncThrow: sandboxAsync(async () => {
+        throw new Error('Async error');
+      })
+    };
+
+    const result = await executeWithAsyncHost(
+      `
+			return await asyncThrow()
+		`,
+      globals
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Async error');
+  });
+});
+
+describe('Safe Stringify for Error Formatting', () => {
+  it('should handle circular references in errors', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const obj = { a: 1 };
+			obj.self = obj;  // Create circular reference
+			throw obj
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    // Should not crash - error should be stringified safely
+    expect(result.error).toBeDefined();
+  });
+
+  it('should handle undefined error', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			throw undefined
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it('should handle null error', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			throw null
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+});
+
+describe('TextDecoder Error Handling', () => {
+  it('should handle invalid input to decode()', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const decoder = new TextDecoder();
+			try {
+				// Try to decode a non-buffer value
+				decoder.decode("not a buffer");
+				return "no error"
+			} catch (e) {
+				return "error caught: " + e.message
+			}
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toContain('error caught');
+  });
+
+  it('should properly decode valid ArrayBuffer', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const decoder = new TextDecoder();
+			const buffer = new ArrayBuffer(5);
+			const view = new Uint8Array(buffer);
+			view[0] = 104;  // 'h'
+			view[1] = 101;  // 'e'
+			view[2] = 108;  // 'l'
+			view[3] = 108;  // 'l'
+			view[4] = 111;  // 'o'
+			return decoder.decode(buffer)
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('hello');
+  });
+});
+
+describe('ReadableStream Locked Property', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+
+  it('should reflect locked state dynamically after getReader()', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const response = await fetch('https://httpbin.org/stream-bytes/10');
+			const body = response.body;
+			
+			// Check initial state
+			const initialLocked = body.locked;
+			
+			// Get reader - should lock the stream
+			const reader = body.getReader();
+			
+			// Check locked state after getting reader
+			const afterLocked = body.locked;
+			
+			// Read and release
+			const { done, value } = await reader.read();
+			reader.releaseLock();
+			
+			// Check state after release
+			const afterRelease = body.locked;
+			
+			return { initialLocked, afterLocked, afterRelease }
+		`,
+      {},
+      { timeoutMs: 10000 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result.initialLocked).toBe(false);
+    expect(result.result.afterLocked).toBe(true);
+    // Note: afterRelease might still be true if stream is consumed
+  });
+
+  it('should report locked=true when reader is active', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const response = await fetch('https://httpbin.org/stream-bytes/50');
+			const body = response.body;
+			
+			const reader = body.getReader();
+			const isLocked = body.locked;
+			
+			// Clean up
+			reader.releaseLock();
+			
+			return isLocked
+		`,
+      {},
+      { timeoutMs: 10000 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe(true);
+  });
+});
+
+describe('Stream Error Handling', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+  it('should handle stream read errors gracefully', async () => {
+    // Create a scenario where stream reading might fail
+    const globals = {
+      createFailingStream: sandboxSync(() => {
+        // Return a stream-like object that will fail
+        return {
+          getReader: () => ({
+            read: async () => {
+              throw new Error('Stream read failed');
+            },
+            releaseLock: () => {}
+          })
+        };
+      })
+    };
+
+    const result = await executeWithAsyncHost(
+      `
+			try {
+				const stream = createFailingStream();
+				const reader = stream.getReader();
+				await reader.read();
+				return "no error"
+			} catch (e) {
+				return "error: " + e.message
+			}
+		`,
+      globals
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toContain('error');
+  });
+});
+
+describe('Cleanup After Errors', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+
+  it('should cleanup all resources after timeout', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			// Start a long operation
+			while (true) {
+				// Infinite loop
+			}
+		`,
+      {},
+      { timeoutMs: 100 }
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/timeout|interrupted/i);
+  });
+
+  it('should cleanup TextEncoder/TextDecoder after error', async () => {
+    // Run an execution that creates encoders but fails
+    const result = await executeWithAsyncHost(
+      `
+			const encoder = new TextEncoder();
+			const decoder = new TextDecoder();
+			const bytes = encoder.encode("test");
+			decoder.decode(bytes);
+			
+			// Now fail
+			throw new Error('Intentional failure');
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(false);
+
+    // Should be able to run another execution without issues
+    const result2 = await executeWithAsyncHost(
+      `
+			const encoder = new TextEncoder();
+			return encoder.encode("ok").length
+		`,
+      {}
+    );
+
+    expect(result2.success).toBe(true);
+    expect(result2.result).toBe(2);
+  });
+
+  it('should cleanup with active fetch when error occurs', async () => {
+    // This test verifies that starting a fetch and immediately throwing
+    // doesn't crash the process. The cleanup now detects lingering promise
+    // objects and skips runtime disposal to avoid the GC assertion.
+    for (let i = 0; i < 3; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				// Start a fetch but throw before it completes
+				const p = fetch('https://httpbin.org/delay/5');
+				throw new Error('Interrupting');
+			`,
+        {},
+        { timeoutMs: 1000 }
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Interrupting');
+    }
+
+    // Verify the process still works after the edge case
+    const normalResult = await executeWithAsyncHost(`return 42`, {});
+    expect(normalResult.success).toBe(true);
+    expect(normalResult.result).toBe(42);
+  });
+});
+
+describe('Multiple Concurrent Async Operations', () => {
+  it('should handle rapid promise additions', async () => {
+    const code = `
+			const promises = [];
+			for (let i = 0; i < 50; i++) {
+				promises.push(asyncOp(i));
+			}
+			const results = await Promise.all(promises);
+			return results.reduce((a, b) => a + b, 0)
+		`;
+
+    const globals = {
+      asyncOp: sandboxAsync(async (n: number) => {
+        // Variable delays to create interleaving
+        await new Promise(r => setTimeout(r, Math.random() * 5));
+        return n;
+      })
+    };
+
+    const result = await executeWithAsyncHost(code, globals, { timeoutMs: 5000 });
+
+    expect(result.success).toBe(true);
+    // Sum of 0 to 49 = 1225
+    expect(result.result).toBe(1225);
+  });
+
+  it('should handle promise race conditions', async () => {
+    const code = `
+			const results = [];
+			
+			// Fire off operations that resolve in different orders
+			// Using async host functions instead of setTimeout
+			const a = Promise.resolve('a');
+			const b = delay(10).then(() => 'b');
+			const c = Promise.resolve('c');
+			
+			results.push(await a);
+			results.push(await c);
+			results.push(await b);
+			
+			return results.join('')
+		`;
+
+    const globals = {
+      delay: sandboxAsync((ms: number) => new Promise(r => setTimeout(r, ms)))
+    };
+
+    const result = await executeWithAsyncHost(code, globals);
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('acb');
+  });
+});
+
+describe('Resource Leak Prevention', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+
+  it('should not leak handles with repeated JSON operations', async () => {
+    for (let i = 0; i < 30; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				const data = { i: ${i}, nested: { arr: [1, 2, 3] } };
+				const json = JSON.stringify(data);
+				const parsed = JSON.parse(json);
+				return parsed.i + parsed.nested.arr.length
+			`,
+        {}
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(i + 3);
+    }
+  });
+
+  it('should not leak with repeated fetch operations', async () => {
+    for (let i = 0; i < 5; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				const response = await fetch('https://httpbin.org/uuid');
+				const data = await response.json();
+				return typeof data.uuid
+			`,
+        {},
+        { timeoutMs: 10000 }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe('string');
+    }
+  });
+});
+
+describe('Edge Cases', () => {
+  it('should handle zero timeout gracefully', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			return 42
+		`,
+      {},
+      { timeoutMs: 0 }
+    );
+
+    // With 0 timeout, synchronous code may still succeed since the timeout
+    // is checked between async operations, not during sync execution.
+    // The important thing is it doesn't crash or hang.
+    expect(result.success !== undefined).toBe(true);
+  });
+
+  it('should handle very small memory limit', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const arr = [];
+			for (let i = 0; i < 10000; i++) {
+				arr.push({ x: i, y: i * 2, z: "string".repeat(100) });
+			}
+			return arr.length
+		`,
+      {},
+      { memoryLimitBytes: 1024 * 1024 }
+    ); // 1MB
+
+    // Should either succeed with a smaller allocation or fail gracefully
+    expect(result.success !== undefined).toBe(true);
+  });
+
+  it('should handle empty code', async () => {
+    const result = await executeWithAsyncHost('', {});
+    expect(result.success).toBe(true);
+    expect(result.result).toBeUndefined();
+  });
+
+  it('should handle code with only comments', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			// This is a comment
+			/* Multi-line
+			   comment */
+		`,
+      {}
+    );
+    expect(result.success).toBe(true);
+  });
+
+  it('should handle code returning undefined', async () => {
+    const result = await executeWithAsyncHost('return undefined', {});
+    expect(result.success).toBe(true);
+    expect(result.result).toBeUndefined();
+  });
+
+  it('should handle code returning null', async () => {
+    const result = await executeWithAsyncHost('return null', {});
+    expect(result.success).toBe(true);
+    expect(result.result).toBeNull();
+  });
+});