/**
* Unit tests for Sandbox Factory
*
* Tests the factory functions for creating sandbox instances
* with configurable isolation modes.
*/
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import {
setDefaultSandboxMode,
getDefaultSandboxMode,
getAvailableSandboxModes,
createSandbox,
createSandboxPool,
getSandboxModeInfo,
type SandboxMode,
} from "../sandbox-factory.js";
import { CodeModeSandbox, SandboxPool } from "../sandbox.js";
import { WorkerSandbox, WorkerSandboxPool } from "../worker-sandbox.js";
// Mock the logger
vi.mock("../../utils/logger.js", () => ({
logger: {
debug: vi.fn(),
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
},
}));
describe("Sandbox Factory", () => {
// Store original default mode to restore after tests
let originalMode: SandboxMode;
beforeEach(() => {
originalMode = getDefaultSandboxMode();
});
afterEach(() => {
// Restore original mode
setDefaultSandboxMode(originalMode);
});
describe("setDefaultSandboxMode / getDefaultSandboxMode", () => {
it("should default to vm mode", () => {
setDefaultSandboxMode("vm");
expect(getDefaultSandboxMode()).toBe("vm");
});
it("should switch to worker mode", () => {
setDefaultSandboxMode("worker");
expect(getDefaultSandboxMode()).toBe("worker");
});
it("should switch back to vm mode", () => {
setDefaultSandboxMode("worker");
setDefaultSandboxMode("vm");
expect(getDefaultSandboxMode()).toBe("vm");
});
});
describe("getAvailableSandboxModes", () => {
it("should return array with vm and worker modes", () => {
const modes = getAvailableSandboxModes();
expect(modes).toContain("vm");
expect(modes).toContain("worker");
});
it("should return exactly two modes", () => {
const modes = getAvailableSandboxModes();
expect(modes.length).toBe(2);
});
});
describe("createSandbox", () => {
it("should create CodeModeSandbox when mode is vm", () => {
const sandbox = createSandbox("vm");
expect(sandbox).toBeInstanceOf(CodeModeSandbox);
});
it("should create WorkerSandbox when mode is worker", () => {
const sandbox = createSandbox("worker");
expect(sandbox).toBeInstanceOf(WorkerSandbox);
});
it("should use default mode when not specified", () => {
setDefaultSandboxMode("vm");
const sandbox = createSandbox();
expect(sandbox).toBeInstanceOf(CodeModeSandbox);
});
it("should use worker as default when set", () => {
setDefaultSandboxMode("worker");
const sandbox = createSandbox();
expect(sandbox).toBeInstanceOf(WorkerSandbox);
});
it("should pass options to vm sandbox", () => {
const sandbox = createSandbox("vm", { timeoutMs: 5000 });
expect(sandbox).toBeInstanceOf(CodeModeSandbox);
// Sandbox should be functional
expect(sandbox.isHealthy()).toBe(true);
});
it("should pass options to worker sandbox", () => {
const sandbox = createSandbox("worker", { timeoutMs: 5000 });
expect(sandbox).toBeInstanceOf(WorkerSandbox);
expect(sandbox.isHealthy()).toBe(true);
});
});
describe("createSandboxPool", () => {
it("should create SandboxPool when mode is vm", () => {
const pool = createSandboxPool("vm");
expect(pool).toBeInstanceOf(SandboxPool);
pool.dispose();
});
it("should create WorkerSandboxPool when mode is worker", () => {
const pool = createSandboxPool("worker");
expect(pool).toBeInstanceOf(WorkerSandboxPool);
pool.dispose();
});
it("should use default mode when not specified", () => {
setDefaultSandboxMode("vm");
const pool = createSandboxPool();
expect(pool).toBeInstanceOf(SandboxPool);
pool.dispose();
});
it("should pass pool options to vm pool", () => {
const pool = createSandboxPool("vm", { maxInstances: 5 });
expect(pool).toBeInstanceOf(SandboxPool);
pool.initialize();
const stats = pool.getStats();
expect(stats.max).toBe(5);
pool.dispose();
});
it("should pass pool options to worker pool", () => {
const pool = createSandboxPool("worker", { maxInstances: 3 });
expect(pool).toBeInstanceOf(WorkerSandboxPool);
pool.initialize();
const stats = pool.getStats();
expect(stats.max).toBe(3);
pool.dispose();
});
it("should pass sandbox options to pool", () => {
const pool = createSandboxPool("vm", undefined, { timeoutMs: 10000 });
expect(pool).toBeInstanceOf(SandboxPool);
pool.dispose();
});
});
describe("getSandboxModeInfo", () => {
describe("vm mode info", () => {
it("should return correct name for vm mode", () => {
const info = getSandboxModeInfo("vm");
expect(info.name).toBe("VM Context");
});
it("should describe vm isolation", () => {
const info = getSandboxModeInfo("vm");
expect(info.isolation).toContain("Script isolation");
});
it("should describe vm performance", () => {
const info = getSandboxModeInfo("vm");
expect(info.performance).toContain("Low overhead");
});
it("should describe vm security", () => {
const info = getSandboxModeInfo("vm");
expect(info.security).toContain("Standard");
});
it("should describe vm requirements", () => {
const info = getSandboxModeInfo("vm");
expect(info.requirements).toContain("vm module");
});
});
describe("worker mode info", () => {
it("should return correct name for worker mode", () => {
const info = getSandboxModeInfo("worker");
expect(info.name).toBe("Worker Thread");
});
it("should describe worker isolation", () => {
const info = getSandboxModeInfo("worker");
expect(info.isolation).toContain("Separate V8 instance");
});
it("should describe worker performance", () => {
const info = getSandboxModeInfo("worker");
expect(info.performance).toContain("Higher overhead");
});
it("should describe worker security", () => {
const info = getSandboxModeInfo("worker");
expect(info.security).toContain("Enhanced");
});
it("should describe worker requirements", () => {
const info = getSandboxModeInfo("worker");
expect(info.requirements).toContain("worker_threads");
});
});
});
});
