@liquidmetal-ai/precip 1.0.0

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

@@ -0,0 +1,331 @@
+/**
+ * Tests for code review fixes:
+ * 1. search.ts - use-after-dispose of iterator factory and resultHandle
+ * 2. storage.ts - dangling handle in KV json() error path, uses parseJsonInContext
+ * 3. headers.ts - callFunction return value leak in forEach
+ * 4. sandbox.ts - allHostPromises unbounded growth removed
+ * 5. utils.ts - dead code branch in defineClass
+ * 6. response-object.ts - bodyUsed property exposed
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+import { sandboxAsync, sandboxSync, sandboxObject } 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('Fix #1-2: Headers forEach handle leak', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+  it('should not leak handles when using headers.forEach repeatedly', async () => {
+    // Run many iterations to stress-test handle cleanup in forEach
+    for (let i = 0; i < 10; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				const response = await fetch('https://httpbin.org/get');
+				const headerNames = [];
+				response.headers.forEach((value, name) => {
+					headerNames.push(name);
+				});
+				return headerNames.length > 0
+			`,
+        {},
+        { timeoutMs: 10000 }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(true);
+    }
+  });
+
+  it('should handle forEach callback that returns values', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const response = await fetch('https://httpbin.org/get');
+			const entries = [];
+			response.headers.forEach((value, name) => {
+				entries.push(name + ': ' + value);
+				return 'ignored return value'; // This return value was leaking
+			});
+			return entries.length > 0
+		`,
+      {},
+      { timeoutMs: 10000 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe(true);
+  });
+});
+
+describe('Fix #3: allHostPromises removed - cleanup still works', () => {
+  it('should properly clean up with many async globals', async () => {
+    const globals: Record<string, any> = {};
+    // Create many async functions to stress the promise tracking
+    for (let i = 0; i < 20; i++) {
+      globals[`fn${i}`] = sandboxAsync(async (n: number) => n * 2);
+    }
+
+    const calls = Array.from({ length: 20 }, (_, i) => `fn${i}(${i})`).join(', ');
+    const code = `
+			const results = await Promise.all([${calls}]);
+			return results.reduce((a, b) => a + b, 0)
+		`;
+
+    const result = await executeWithAsyncHost(code, globals, { timeoutMs: 5000 });
+    expect(result.success).toBe(true);
+    // Sum of i*2 for i=0..19 = 2*(0+1+...+19) = 2*190 = 380
+    expect(result.result).toBe(380);
+  });
+
+  it('should clean up properly when mixing sync and async globals', async () => {
+    for (let i = 0; i < 5; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				const a = syncFn(5);
+				const b = await asyncFn(10);
+				const c = await obj.method(3);
+				return a + b + c
+			`,
+        {
+          syncFn: sandboxSync((n: number) => n * 2),
+          asyncFn: sandboxAsync(async (n: number) => n * 3),
+          obj: sandboxObject({
+            method: sandboxAsync(async (n: number) => n * 4)
+          })
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(10 + 30 + 12); // 52
+    }
+  });
+});
+
+describe('Fix #4: bodyUsed property exposed on Response', () => {
+  beforeEach(() => setupMockFetch());
+  afterEach(() => restoreFetch());
+
+  it('should report bodyUsed=false before consuming body', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const response = await fetch('https://httpbin.org/get');
+			return response.bodyUsed
+		`,
+      {},
+      { timeoutMs: 10000 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe(false);
+  });
+
+  it('should report bodyUsed=true after consuming body with text()', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const response = await fetch('https://httpbin.org/get');
+			const before = response.bodyUsed;
+			await response.text();
+			const after = response.bodyUsed;
+			return { before, after }
+		`,
+      {},
+      { timeoutMs: 10000 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result.before).toBe(false);
+    expect(result.result.after).toBe(true);
+  });
+
+  it('should report bodyUsed=true after consuming body with json()', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const response = await fetch('https://httpbin.org/json');
+			const before = response.bodyUsed;
+			await response.json();
+			const after = response.bodyUsed;
+			return { before, after }
+		`,
+      {},
+      { timeoutMs: 10000 }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result.before).toBe(false);
+    expect(result.result.after).toBe(true);
+  });
+});
+
+describe('Fix #5: defineClass dead code removed', () => {
+  it('should still define TextEncoder class correctly', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const enc = new TextEncoder();
+			return enc.encoding
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('utf-8');
+  });
+
+  it('should still define TextDecoder class correctly', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const dec = new TextDecoder();
+			return dec.encoding
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('utf-8');
+  });
+});
+
+describe('Fix #6: storage KV json() uses parseJsonInContext', () => {
+  it('should handle JSON operations correctly in sandbox', async () => {
+    // Test that JSON parsing through the shared utility works
+    // This tests the general path since storage KV needs a real KV mount
+    const result = await executeWithAsyncHost(
+      `
+			const obj = { nested: { arr: [1, 2, 3], str: "hello" } };
+			const json = JSON.stringify(obj);
+			const parsed = JSON.parse(json);
+			return parsed.nested.arr.length + parsed.nested.str.length
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe(8); // 3 + 5
+  });
+
+  it('should handle many JSON parse operations without leaks', async () => {
+    // Stress test to verify parseJsonInContext caching works
+    for (let i = 0; i < 20; i++) {
+      const result = await executeWithAsyncHost(
+        `
+				const objects = [];
+				for (let j = 0; j < 50; j++) {
+					const obj = { i: ${i}, j, data: "value" };
+					const str = JSON.stringify(obj);
+					objects.push(JSON.parse(str));
+				}
+				return objects.length
+			`,
+        {}
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(50);
+    }
+  });
+});
+
+describe('Regression: all existing functionality still works', () => {
+  it('should handle async globals with Promise.all', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const results = await Promise.all([
+				asyncAdd(1, 2),
+				asyncAdd(3, 4),
+				asyncAdd(5, 6)
+			]);
+			return results
+		`,
+      {
+        asyncAdd: sandboxAsync(async (a: number, b: number) => a + b)
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toEqual([3, 7, 11]);
+  });
+
+  it('should handle object methods with async operations', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			const a = await api.getData();
+			const b = await api.processData(a);
+			return b
+		`,
+      {
+        api: sandboxObject({
+          getData: sandboxAsync(async () => ({ value: 42 })),
+          processData: sandboxAsync(async (data: any) => data.value * 2)
+        })
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe(84);
+  });
+
+  it('should properly capture console output', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			console.log("hello");
+			console.error("oops");
+			console.warn("careful");
+			return "done"
+		`,
+      {}
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('done');
+    expect(result.consoleOutput).toContain('hello');
+    expect(result.consoleOutput).toContain('[ERROR] oops');
+    expect(result.consoleOutput).toContain('[WARN] careful');
+  });
+
+  it('should handle errors in async globals cleanly', async () => {
+    const result = await executeWithAsyncHost(
+      `
+			try {
+				await failingFn();
+				return "no error"
+			} catch (e) {
+				return "caught: " + e
+			}
+		`,
+      {
+        failingFn: sandboxAsync(async () => {
+          throw new Error('test failure');
+        })
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result).toContain('caught');
+    expect(result.result).toContain('test failure');
+  });
+});