/**
* Unit tests for Code Mode Sandbox
*
* Tests sandbox creation, code execution, timeout handling,
* and resource cleanup.
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { CodeModeSandbox, SandboxPool } from '../sandbox.js';
describe('CodeModeSandbox', () => {
let sandbox: CodeModeSandbox;
beforeEach(() => {
sandbox = CodeModeSandbox.create();
});
afterEach(() => {
sandbox.dispose();
});
describe('create()', () => {
it('should create a sandbox instance', () => {
expect(sandbox).toBeDefined();
expect(sandbox.isHealthy()).toBe(true);
});
it('should accept custom options', () => {
const customSandbox = CodeModeSandbox.create({
timeoutMs: 5000,
memoryLimitMb: 64
});
expect(customSandbox).toBeDefined();
expect(customSandbox.isHealthy()).toBe(true);
customSandbox.dispose();
});
});
describe('execute()', () => {
it('should execute simple code and return result', async () => {
const result = await sandbox.execute(
'return 1 + 2;',
{}
);
expect(result.success).toBe(true);
expect(result.result).toBe(3);
expect(result.metrics.wallTimeMs).toBeGreaterThanOrEqual(0);
});
it('should execute async code', async () => {
const result = await sandbox.execute(
'return await Promise.resolve(42);',
{}
);
expect(result.success).toBe(true);
expect(result.result).toBe(42);
});
it('should provide access to pg bindings', async () => {
const mockBindings = {
core: {
listTables: async () => [{ name: 'users' }, { name: 'products' }]
}
};
const result = await sandbox.execute(
'const tables = await pg.core.listTables(); return tables.length;',
mockBindings
);
expect(result.success).toBe(true);
expect(result.result).toBe(2);
});
it('should handle execution errors', async () => {
const result = await sandbox.execute(
'throw new Error("test error");',
{}
);
expect(result.success).toBe(false);
expect(result.error).toContain('test error');
});
it('should block access to require', async () => {
const result = await sandbox.execute(
'const fs = require("fs"); return fs;',
{}
);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
it('should block access to process', async () => {
const result = await sandbox.execute(
'return process.env;',
{}
);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
it('should return error after disposed', async () => {
sandbox.dispose();
const result = await sandbox.execute('return 1;', {});
expect(result.success).toBe(false);
expect(result.error).toContain('disposed');
});
it('should provide execution metrics', async () => {
const result = await sandbox.execute('return "test";', {});
expect(result.metrics).toBeDefined();
expect(result.metrics.wallTimeMs).toBeGreaterThanOrEqual(0);
expect(result.metrics.cpuTimeMs).toBeGreaterThanOrEqual(0);
expect(typeof result.metrics.memoryUsedMb).toBe('number');
});
});
describe('dispose()', () => {
it('should mark sandbox as unhealthy', () => {
expect(sandbox.isHealthy()).toBe(true);
sandbox.dispose();
expect(sandbox.isHealthy()).toBe(false);
});
it('should be idempotent', () => {
sandbox.dispose();
sandbox.dispose(); // Should not throw
expect(sandbox.isHealthy()).toBe(false);
});
});
});
describe('SandboxPool', () => {
let pool: SandboxPool;
beforeEach(() => {
pool = new SandboxPool({ minInstances: 2, maxInstances: 5 });
pool.initialize();
});
afterEach(() => {
pool.dispose();
});
describe('initialize()', () => {
it('should create minimum instances', () => {
const stats = pool.getStats();
expect(stats.available).toBe(2);
expect(stats.inUse).toBe(0);
});
});
describe('acquire()', () => {
it('should return a sandbox from the pool', () => {
const sandbox = pool.acquire();
expect(sandbox).toBeDefined();
expect(sandbox.isHealthy()).toBe(true);
const stats = pool.getStats();
expect(stats.inUse).toBe(1);
});
it('should create new sandboxes if pool is empty', () => {
// Acquire more than minInstances
const s1 = pool.acquire();
const s2 = pool.acquire();
const s3 = pool.acquire();
expect(pool.getStats().inUse).toBe(3);
pool.release(s1);
pool.release(s2);
pool.release(s3);
});
it('should throw when pool is exhausted', () => {
const sandboxes: CodeModeSandbox[] = [];
for (let i = 0; i < 5; i++) {
sandboxes.push(pool.acquire());
}
expect(() => pool.acquire()).toThrowError(/exhausted/);
sandboxes.forEach(s => pool.release(s));
});
it('should throw after disposed', () => {
pool.dispose();
expect(() => pool.acquire()).toThrowError(/disposed/);
});
});
describe('release()', () => {
it('should return sandbox to pool', () => {
const sandbox = pool.acquire();
expect(pool.getStats().inUse).toBe(1);
pool.release(sandbox);
expect(pool.getStats().inUse).toBe(0);
expect(pool.getStats().available).toBeGreaterThan(0);
});
it('should ignore sandboxes not from pool', () => {
const external = CodeModeSandbox.create();
pool.release(external); // Should not throw
external.dispose();
});
});
describe('execute()', () => {
it('should execute code and return result', async () => {
const result = await pool.execute('return 5 * 5;', {});
expect(result.success).toBe(true);
expect(result.result).toBe(25);
});
it('should return sandbox to pool after execution', async () => {
await pool.execute('return 1;', {});
const stats = pool.getStats();
expect(stats.inUse).toBe(0);
});
it('should return sandbox to pool even on error', async () => {
await pool.execute('throw new Error("fail");', {});
const stats = pool.getStats();
expect(stats.inUse).toBe(0);
});
});
describe('dispose()', () => {
it('should clear all sandboxes', () => {
pool.dispose();
const stats = pool.getStats();
expect(stats.available).toBe(0);
expect(stats.inUse).toBe(0);
});
it('should be idempotent', () => {
pool.dispose();
pool.dispose(); // Should not throw
});
});
describe('cleanup edge cases', () => {
it('should dispose sandbox on release when pool is disposed', async () => {
const sandbox = pool.acquire();
expect(sandbox.isHealthy()).toBe(true);
pool.dispose();
// Pool dispose also disposes all sandboxes including in-use ones
expect(sandbox.isHealthy()).toBe(false);
});
it('should dispose unhealthy sandbox on release', () => {
const sandbox = pool.acquire();
sandbox.dispose(); // Make it unhealthy
pool.release(sandbox); // Should not throw
});
});
describe('getStats()', () => {
it('should return correct pool statistics', () => {
const stats = pool.getStats();
expect(stats).toHaveProperty('available');
expect(stats).toHaveProperty('inUse');
expect(stats).toHaveProperty('max');
expect(stats.max).toBe(5);
});
it('should track in-use count correctly', () => {
const s1 = pool.acquire();
expect(pool.getStats().inUse).toBe(1);
const s2 = pool.acquire();
expect(pool.getStats().inUse).toBe(2);
pool.release(s1);
expect(pool.getStats().inUse).toBe(1);
pool.release(s2);
expect(pool.getStats().inUse).toBe(0);
});
});
});
describe('CodeModeSandbox Console', () => {
let sandbox: CodeModeSandbox;
beforeEach(() => {
sandbox = CodeModeSandbox.create();
});
afterEach(() => {
sandbox.dispose();
});
describe('console output capture', () => {
it('should capture console.log output', async () => {
await sandbox.execute('console.log("test message");', {});
const output = sandbox.getConsoleOutput();
expect(output).toContain('test message');
});
it('should capture console.warn output with prefix', async () => {
await sandbox.execute('console.warn("warning");', {});
const output = sandbox.getConsoleOutput();
expect(output.some(line => line.includes('[WARN]') && line.includes('warning'))).toBe(true);
});
it('should capture console.error output with prefix', async () => {
await sandbox.execute('console.error("error message");', {});
const output = sandbox.getConsoleOutput();
expect(output.some(line => line.includes('[ERROR]') && line.includes('error message'))).toBe(true);
});
it('should capture console.info output with prefix', async () => {
await sandbox.execute('console.info("info message");', {});
const output = sandbox.getConsoleOutput();
expect(output.some(line => line.includes('[INFO]') && line.includes('info message'))).toBe(true);
});
it('should serialize objects in console output', async () => {
await sandbox.execute('console.log({ key: "value" });', {});
const output = sandbox.getConsoleOutput();
expect(output.some(line => line.includes('"key"') && line.includes('"value"'))).toBe(true);
});
it('should handle multiple console arguments', async () => {
await sandbox.execute('console.log("a", "b", "c");', {});
const output = sandbox.getConsoleOutput();
expect(output.some(line => line.includes('a b c'))).toBe(true);
});
it('should clear console output', async () => {
await sandbox.execute('console.log("first");', {});
expect(sandbox.getConsoleOutput().length).toBeGreaterThan(0);
sandbox.clearConsoleOutput();
expect(sandbox.getConsoleOutput()).toEqual([]);
});
});
});
describe('CodeModeSandbox Timeout Handling', () => {
it('should detect timeout errors', async () => {
const sandbox = CodeModeSandbox.create({ timeoutMs: 50 });
// Execute code that will timeout
const result = await sandbox.execute(`
let i = 0;
while(true) { i++; }
return i;
`, {});
expect(result.success).toBe(false);
expect(result.error).toContain('timeout');
sandbox.dispose();
});
});
describe('SandboxPool Cleanup', () => {
it('should skip unhealthy sandboxes during acquire', () => {
const pool = new SandboxPool({ minInstances: 2, maxInstances: 5 });
pool.initialize();
// Acquire and dispose to make unhealthy
const s1 = pool.acquire();
s1.dispose();
pool.release(s1);
// Next acquire should skip the unhealthy one
const s2 = pool.acquire();
expect(s2.isHealthy()).toBe(true);
pool.release(s2);
pool.dispose();
});
it('should not return excess sandboxes to pool', () => {
const pool = new SandboxPool({ minInstances: 1, maxInstances: 3 });
pool.initialize();
// Acquire all 3
const sandboxes = [pool.acquire(), pool.acquire(), pool.acquire()];
// Release all - pool should only keep up to max
for (const s of sandboxes) {
pool.release(s);
}
// Available should not exceed max
expect(pool.getStats().available).toBeLessThanOrEqual(3);
pool.dispose();
});
it('should dispose sandbox when released after pool is disposed (line 302-303)', () => {
const pool = new SandboxPool({ minInstances: 1, maxInstances: 3 });
pool.initialize();
// Acquire a sandbox
const sandbox = pool.acquire();
expect(sandbox.isHealthy()).toBe(true);
// Dispose pool while sandbox is in use
pool.dispose();
// The sandbox should now be disposed (pool.dispose disposes all in-use)
// but let's also verify the release path explicitly
expect(sandbox.isHealthy()).toBe(false);
});
it('should dispose unhealthy sandbox found during acquire loop (line 276)', () => {
const pool = new SandboxPool({ minInstances: 3, maxInstances: 5 });
pool.initialize();
// Acquire all available sandboxes and make them unhealthy
const s1 = pool.acquire();
const s2 = pool.acquire();
const s3 = pool.acquire();
// Dispose them to make unhealthy
s1.dispose();
s2.dispose();
s3.dispose();
// Release them back to pool (they go back as unhealthy)
pool.release(s1);
pool.release(s2);
pool.release(s3);
// Now acquire should find unhealthy sandboxes and dispose them,
// then create a new one
const newSandbox = pool.acquire();
expect(newSandbox.isHealthy()).toBe(true);
pool.release(newSandbox);
pool.dispose();
});
});
describe('SandboxPool Cleanup Interval', () => {
it('should trigger cleanup on interval and remove unhealthy sandboxes (lines 333-344)', async () => {
// Create pool with very short idle timeout for testing
const pool = new SandboxPool(
{ minInstances: 1, maxInstances: 5, idleTimeoutMs: 50 },
{ timeoutMs: 10000 }
);
pool.initialize();
// Pool should start with minInstances
expect(pool.getStats().available).toBe(1);
// Acquire and release to add more to pool
const s1 = pool.acquire();
const s2 = pool.acquire();
pool.release(s1);
pool.release(s2);
expect(pool.getStats().available).toBe(2);
// Wait for cleanup interval to trigger (which trims to minInstances)
await new Promise(resolve => setTimeout(resolve, 100));
// After cleanup, should be trimmed back to minInstances
expect(pool.getStats().available).toBe(1);
pool.dispose();
});
it('should trim excess sandboxes during cleanup to minInstances (lines 347-349)', async () => {
const pool = new SandboxPool(
{ minInstances: 1, maxInstances: 10, idleTimeoutMs: 30 }
);
pool.initialize();
// Create many sandboxes
const sandboxes = [];
for (let i = 0; i < 5; i++) {
sandboxes.push(pool.acquire());
}
// Release them all back
for (const s of sandboxes) {
pool.release(s);
}
// Should have 5 available now
expect(pool.getStats().available).toBe(5);
// Wait for cleanup to trim
await new Promise(resolve => setTimeout(resolve, 80));
// Should be trimmed to minInstances (1)
expect(pool.getStats().available).toBe(1);
pool.dispose();
});
it('should remove unhealthy sandboxes during cleanup (lines 335-341)', async () => {
const pool = new SandboxPool(
{ minInstances: 2, maxInstances: 5, idleTimeoutMs: 30 }
);
pool.initialize();
// Make one of the initial sandboxes unhealthy by acquiring and disposing it
const s1 = pool.acquire();
const s2 = pool.acquire();
s1.dispose(); // Make unhealthy
pool.release(s1);
pool.release(s2);
// Wait for cleanup
await new Promise(resolve => setTimeout(resolve, 80));
// After cleanup, unhealthy should be removed, then trimmed to min
// Only healthy ones should remain
const remaining = pool.getStats().available;
expect(remaining).toBeLessThanOrEqual(2);
pool.dispose();
});
});
