repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by bugabinga
opencode/tests/d2.test.ts
Rawimport { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
import path from "node:path";
import {
existsSync,
mkdirSync,
rmSync,
statSync,
unlinkSync,
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
// ============================================================================
// Mock child_process.spawn
// ============================================================================
// Track spawn calls for assertions
const spawnCalls: { command: string; args: string[] }[] = [];
// Mock configuration to control behavior
const mockConfig = {
d2Available: true,
d2Version: "0.6.0",
d2ShouldFail: false,
d2SyntaxError: null as string | null,
d2SpawnError: null as string | null,
d2SpawnErrorCode: null as string | null,
skipOutputFileCreation: false,
oversizedOutput: false,
};
// Mock child_process.spawn
mock.module("node:child_process", () => ({
spawn: (command: string, args: string[]) => {
// Track calls for assertions
spawnCalls.push({ command, args });
const proc = {
stdout: {
on: (event: string, cb: (data: Buffer) => void) => {
if (
event === "data" && args.includes("--version") &&
mockConfig.d2Available
) {
cb(Buffer.from(mockConfig.d2Version));
}
},
},
stderr: {
on: (event: string, cb: (data: Buffer) => void) => {
if (event === "data") {
if (!mockConfig.d2Available && args.includes("--version")) {
cb(Buffer.from("command not found"));
}
if (mockConfig.d2SyntaxError) {
cb(Buffer.from(mockConfig.d2SyntaxError));
}
if (mockConfig.d2ShouldFail && !args.includes("--version")) {
cb(Buffer.from("D2 render failed"));
}
}
},
},
on: (event: string, cb: (code: number | Error) => void) => {
// Handle error for version check when d2 not available
if (
event === "error" && !mockConfig.d2Available &&
args.includes("--version")
) {
const err = new Error("spawn d2 ENOENT") as NodeJS.ErrnoException;
err.code = mockConfig.d2SpawnErrorCode || "ENOENT";
setTimeout(() => cb(err), 0);
return;
}
// Handle spawn error during render
if (
event === "error" && mockConfig.d2SpawnError &&
!args.includes("--version")
) {
const err = new Error(
mockConfig.d2SpawnError,
) as NodeJS.ErrnoException;
err.code = mockConfig.d2SpawnErrorCode || "ENOENT";
setTimeout(() => cb(err), 0);
return;
}
if (event === "close") {
setTimeout(() => {
if (args.includes("--version")) {
cb(mockConfig.d2Available ? 0 : 1);
} else if (mockConfig.d2ShouldFail || mockConfig.d2SyntaxError) {
cb(1);
} else if (mockConfig.d2SpawnError) {
// Error event was already emitted, don't call close with success
cb(1);
} else {
// Create output file (unless skipped for testing)
if (!mockConfig.skipOutputFileCreation) {
const outputArg = args[args.length - 1];
if (outputArg) {
let content =
`<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"><rect/></svg>`;
if (outputArg.endsWith(".png")) content = "PNG";
if (outputArg.endsWith(".pdf")) content = "PDF";
// Create oversized file for testing
if (mockConfig.oversizedOutput) {
content = "x".repeat(51 * 1024 * 1024); // 51MB
}
writeFileSync(outputArg, content);
}
}
cb(0);
}
}, 0);
}
},
};
return proc;
},
}));
// Import the tools and helper functions directly
import {
assertWithinDirectory,
check,
formatFileSize,
getErrorMessage,
getMimeType,
isPathTraversalAttempt,
jsonResponse,
layouts,
parseD2Error,
render,
resolveFilePath,
themes,
tryExtractSvgDimensions,
validateD2Code,
} from "../tools/d2.ts";
// Test directory setup
const testDir = path.join(tmpdir(), `d2-test-${Date.now()}`);
// Mock context (cast to any to satisfy ToolContext type)
const mockContext = {
directory: testDir,
sessionID: "test-session",
messageID: "test-message",
agent: "test-agent",
worktree: testDir,
abort: new AbortController().signal,
metadata: () => {},
ask: async () => {},
} as any;
// Helper to parse JSON response
function parseResponse(response: string): Record<string, unknown> {
return JSON.parse(response);
}
// Setup and cleanup
beforeEach(() => {
// Reset mock state
spawnCalls.length = 0;
mockConfig.d2Available = true;
mockConfig.d2Version = "0.6.0";
mockConfig.d2ShouldFail = false;
mockConfig.d2SyntaxError = null;
mockConfig.d2SpawnError = null;
mockConfig.d2SpawnErrorCode = null;
mockConfig.skipOutputFileCreation = false;
mockConfig.oversizedOutput = false;
// Create test directory
if (!existsSync(testDir)) {
mkdirSync(testDir, { recursive: true });
}
});
afterEach(() => {
if (existsSync(testDir)) {
rmSync(testDir, { recursive: true, force: true });
}
});
// ============================================================================
// Unit Tests for Exported Helper Functions
// ============================================================================
describe("jsonResponse", () => {
test("creates formatted JSON string with 2-space indent", () => {
const result = jsonResponse({ success: true, message: "test" });
expect(result).toBe('{\n "success": true,\n "message": "test"\n}');
});
test("handles nested objects", () => {
const result = jsonResponse({ data: { nested: { value: 1 } } });
expect(result).toContain('"nested"');
expect(result).toContain('"value": 1');
});
test("handles arrays", () => {
const result = jsonResponse({ items: [1, 2, 3] });
expect(result).toContain('"items"');
expect(result).toContain("[\n 1,\n 2,\n 3\n ]");
});
});
describe("assertWithinDirectory", () => {
test("does not throw for path within directory", () => {
const dir = "/home/user/project";
const target = "/home/user/project/file.txt";
expect(() => assertWithinDirectory(target, dir, "test")).not.toThrow();
});
test("does not throw for nested path within directory", () => {
const dir = "/home/user/project";
const target = "/home/user/project/subdir/file.txt";
expect(() => assertWithinDirectory(target, dir, "test")).not.toThrow();
});
test("does not throw when target equals directory", () => {
const dir = "/home/user/project";
expect(() => assertWithinDirectory(dir, dir, "test")).not.toThrow();
});
test("throws for path traversal with ..", () => {
const dir = "/home/user/project";
const target = "/home/user/project/../outside.txt";
expect(() => assertWithinDirectory(target, dir, "test")).toThrow(
"Path security error",
);
});
test("throws for absolute path outside directory", () => {
const dir = "/home/user/project";
const target = "/etc/passwd";
expect(() => assertWithinDirectory(target, dir, "test")).toThrow(
"Path security error",
);
});
test("includes operation name in error message", () => {
const dir = "/home/user/project";
const target = "/etc/passwd";
expect(() => assertWithinDirectory(target, dir, "readFile")).toThrow(
"readFile",
);
});
});
describe("isPathTraversalAttempt", () => {
test("returns false for safe relative path", () => {
const dir = "/home/user/project";
expect(isPathTraversalAttempt("file.txt", dir)).toBe(false);
});
test("returns false for safe nested path", () => {
const dir = "/home/user/project";
expect(isPathTraversalAttempt("subdir/file.txt", dir)).toBe(false);
});
test("returns true for path traversal with ..", () => {
const dir = "/home/user/project";
expect(isPathTraversalAttempt("../outside.txt", dir)).toBe(true);
});
test("returns true for absolute path outside directory", () => {
const dir = "/home/user/project";
expect(isPathTraversalAttempt("/etc/passwd", dir)).toBe(true);
});
test("returns true for path that causes resolve to throw (null byte)", () => {
// Note: path.resolve behavior with null bytes varies by system
// On some systems it throws, on others it handles it gracefully
// The catch block in isPathTraversalAttempt handles the throwing case
// For systems where it doesn't throw, we test with a path that definitely traverses
const dir = "/home/user/project";
// Test that the function handles the path (whether it throws or not)
const result = isPathTraversalAttempt("test\x00.d2", dir);
// The result depends on the system - either it throws (returns true) or
// it resolves to a valid path (returns false)
expect(typeof result).toBe("boolean");
});
test("catch block handles errors from path.resolve", () => {
// To trigger the catch block, we need path.resolve to throw
// Using Symbol which path.resolve cannot handle
const dir = "/home/user/project";
// @ts-ignore - intentionally pass invalid type to trigger catch
const result = isPathTraversalAttempt(Symbol("test"), dir);
// Should return true (safe default) when error occurs
expect(result).toBe(true);
});
});
describe("formatFileSize", () => {
test("formats bytes", () => {
expect(formatFileSize(500)).toBe("500.00 B");
});
test("formats kilobytes", () => {
expect(formatFileSize(1024)).toBe("1.00 KB");
expect(formatFileSize(2048)).toBe("2.00 KB");
});
test("formats megabytes", () => {
expect(formatFileSize(1024 * 1024)).toBe("1.00 MB");
expect(formatFileSize(2.5 * 1024 * 1024)).toBe("2.50 MB");
});
test("formats gigabytes", () => {
expect(formatFileSize(1024 * 1024 * 1024)).toBe("1.00 GB");
});
test("stops at GB even for larger values", () => {
const largeValue = 5 * 1024 * 1024 * 1024; // 5GB
expect(formatFileSize(largeValue)).toBe("5.00 GB");
});
test("handles zero", () => {
expect(formatFileSize(0)).toBe("0.00 B");
});
test("handles fractional values", () => {
expect(formatFileSize(512)).toBe("512.00 B");
expect(formatFileSize(1536)).toBe("1.50 KB");
});
});
describe("getErrorMessage", () => {
test("extracts message from Error instance", () => {
const err = new Error("test error message");
expect(getErrorMessage(err)).toBe("test error message");
});
test("handles TypeError", () => {
const err = new TypeError("type error");
expect(getErrorMessage(err)).toBe("type error");
});
test("handles string", () => {
expect(getErrorMessage("string error")).toBe("string error");
});
test("handles number", () => {
expect(getErrorMessage(42)).toBe("42");
});
test("handles null", () => {
expect(getErrorMessage(null)).toBe("null");
});
test("handles undefined", () => {
expect(getErrorMessage(undefined)).toBe("undefined");
});
test("handles object", () => {
expect(getErrorMessage({ code: "ERR" })).toBe("[object Object]");
});
test("handles array", () => {
expect(getErrorMessage([1, 2, 3])).toBe("1,2,3");
});
});
describe("parseD2Error", () => {
test("extracts line number", () => {
const result = parseD2Error("error at line 42");
expect(result.line).toBe(42);
});
test("extracts column number", () => {
const result = parseD2Error("error at column 10");
expect(result.column).toBe(10);
});
test("extracts both line and column", () => {
const result = parseD2Error("error at line 5, column 10");
expect(result.line).toBe(5);
expect(result.column).toBe(10);
});
test("extracts error message from 'error:' prefix", () => {
const result = parseD2Error("error: something went wrong");
expect(result.message).toBe("something went wrong");
});
test("extracts error message from 'd2:' prefix", () => {
const result = parseD2Error("d2: something went wrong");
expect(result.message).toBe("something went wrong");
});
test("replaces temp file paths with placeholder", () => {
// The temp file replacement only happens when there's no "error:" or "d2:" prefix
// Note: the regex matches "d2:" even in ".d2:" so we need to avoid that pattern
const result = parseD2Error("/tmp/d2-input-123.txt: problem here");
expect(result.message).toContain("<temp-file>");
});
test("generates hint for unexpected token", () => {
const result = parseD2Error("error: unexpected token at line 5");
expect(result.hint).toContain("syntax errors");
});
test("generates hint for undefined shape", () => {
const result = parseD2Error("error: undefined shape 'foo'");
expect(result.hint).toContain("referenced shapes");
});
test("generates hint for 'not found'", () => {
const result = parseD2Error("error: shape 'bar' not found");
expect(result.hint).toContain("referenced shapes");
});
test("generates hint for invalid key", () => {
const result = parseD2Error("error: invalid key 'badkey'");
expect(result.hint).toContain("valid D2 keywords");
});
test("generates hint for 'invalid' without 'invalid key'", () => {
const result = parseD2Error("error: invalid value");
expect(result.hint).toContain("valid D2 keywords");
});
test("generates hint for connection errors", () => {
const result = parseD2Error("error: connection problem");
expect(result.hint).toContain("Connection syntax");
});
test("generates hint for style errors", () => {
const result = parseD2Error("error: unknown style property");
expect(result.hint).toContain("CSS colors");
});
test("generates hint for fill errors", () => {
const result = parseD2Error("error: fill color not recognized");
expect(result.hint).toContain("CSS colors");
});
test("returns no hint for unknown errors", () => {
const result = parseD2Error("error: something else");
expect(result.hint).toBeUndefined();
});
test("handles empty stderr", () => {
const result = parseD2Error("");
expect(result.message).toBe("");
});
});
describe("validateD2Code", () => {
test("returns valid for normal code", () => {
const result = validateD2Code("x -> y");
expect(result.valid).toBe(true);
});
test("returns invalid for empty string", () => {
const result = validateD2Code("");
expect(result.valid).toBe(false);
expect(result.error).toContain("empty");
expect(result.hint).toBeDefined();
});
test("returns invalid for whitespace-only string", () => {
const result = validateD2Code(" \n\t ");
expect(result.valid).toBe(false);
expect(result.error).toContain("whitespace");
expect(result.hint).toBeDefined();
});
test("returns valid for code with leading/trailing whitespace", () => {
const result = validateD2Code(" x -> y ");
expect(result.valid).toBe(true);
});
test("returns valid for single character", () => {
const result = validateD2Code("x");
expect(result.valid).toBe(true);
});
});
describe("getMimeType", () => {
test("returns correct MIME type for svg", () => {
expect(getMimeType("svg")).toBe("image/svg+xml");
});
test("returns correct MIME type for png", () => {
expect(getMimeType("png")).toBe("image/png");
});
test("returns correct MIME type for pdf", () => {
expect(getMimeType("pdf")).toBe("application/pdf");
});
// Note: The default case is technically unreachable with TypeScript's
// type system, but we test it anyway for runtime safety
test("returns default MIME type for unknown format", () => {
// Cast to bypass TypeScript check
expect(getMimeType("unknown" as any)).toBe("application/octet-stream");
});
});
describe("tryExtractSvgDimensions", () => {
test("extracts dimensions from width/height attributes", () => {
const svg = '<svg width="100" height="200"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toEqual({ width: 100, height: 200 });
});
test("extracts dimensions with decimal values", () => {
const svg = '<svg width="100.5" height="200.75"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toEqual({ width: 100.5, height: 200.75 });
});
test("extracts dimensions from viewBox when no width/height", () => {
const svg = '<svg viewBox="0 0 300 400"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toEqual({ width: 300, height: 400 });
});
test("extracts dimensions from viewBox with decimal values", () => {
const svg = '<svg viewBox="10.5 20.3 150.75 200.5"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toEqual({ width: 150.75, height: 200.5 });
});
test("prefers width/height over viewBox", () => {
const svg =
'<svg width="100" height="200" viewBox="0 0 300 400"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toEqual({ width: 100, height: 200 });
});
test("returns null for SVG without dimensions", () => {
const svg = "<svg><rect/></svg>";
const result = tryExtractSvgDimensions(svg);
expect(result).toBeNull();
});
test("returns null for viewBox with insufficient parts", () => {
const svg = '<svg viewBox="0 0 100"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toBeNull();
});
test("handles viewBox with extra whitespace", () => {
const svg = '<svg viewBox=" 0 0 300 400 "><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
expect(result).toEqual({ width: 300, height: 400 });
});
test("catch block handles invalid viewBox gracefully", () => {
// This shouldn't throw even with weird input
const svg = '<svg viewBox="invalid"><rect/></svg>';
const result = tryExtractSvgDimensions(svg);
// parseFloat("invalid") returns NaN, which is still a number
// The function should handle this gracefully
expect(result).toBeDefined();
});
});
describe("resolveFilePath", () => {
test("resolves relative path", () => {
const dir = "/home/user/project";
const result = resolveFilePath("file.txt", dir);
expect(result).toBe(path.resolve(dir, "file.txt"));
});
test("resolves nested relative path", () => {
const dir = "/home/user/project";
const result = resolveFilePath("subdir/file.txt", dir);
expect(result).toBe(path.resolve(dir, "subdir/file.txt"));
});
test("trims whitespace from path", () => {
const dir = "/home/user/project";
const result = resolveFilePath(" file.txt ", dir);
expect(result).toBe(path.resolve(dir, "file.txt"));
});
test("throws for path traversal", () => {
const dir = "/home/user/project";
expect(() => resolveFilePath("../outside.txt", dir)).toThrow(
"Path security error",
);
});
test("throws for absolute path outside directory", () => {
const dir = "/home/user/project";
expect(() => resolveFilePath("/etc/passwd", dir)).toThrow(
"Path security error",
);
});
});
// ============================================================================
// Integration Tests for Tools
// ============================================================================
describe("render tool - input validation", () => {
test("requires either code or file", async () => {
const result = await render.execute(
{ code: undefined, file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("Either 'code' or 'file'");
});
test("rejects both code and file", async () => {
const testFile = path.join(testDir, "test.d2");
writeFileSync(testFile, "x -> y");
const result = await render.execute(
{ code: "a -> b", file: "test.d2", format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("Provide either 'code' or 'file'");
});
test("rejects code exceeding MAX_CODE_SIZE (1MB)", async () => {
const largeCode = "x -> y\n" + "a".repeat(1024 * 1024 + 100);
const result = await render.execute(
{ code: largeCode, file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("exceeds maximum size");
expect(parsed.error).toContain("1MB");
});
test("rejects file exceeding MAX_CODE_SIZE (1MB)", async () => {
const testFile = path.join(testDir, "large.d2");
const largeContent = "x -> y\n" + "a".repeat(1024 * 1024 + 100);
writeFileSync(testFile, largeContent);
const result = await render.execute(
{ code: undefined, file: "large.d2", format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("exceeds maximum size");
expect(parsed.error).toContain("1MB");
});
test("rejects file without .d2 extension", async () => {
const testFile = path.join(testDir, "test.txt");
writeFileSync(testFile, "x -> y");
const result = await render.execute(
{ code: undefined, file: "test.txt", format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain(".d2 extension");
});
test("rejects non-existent file", async () => {
const result = await render.execute(
{
code: undefined,
file: "nonexistent.d2",
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("not found");
});
test("rejects path traversal attempt", async () => {
const result = await render.execute(
{
code: undefined,
file: "../../../etc/passwd",
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("security error");
});
test("rejects absolute path outside directory", async () => {
const result = await render.execute(
{
code: undefined,
file: "/etc/passwd",
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("security error");
});
test("handles path with null byte", async () => {
const result = await render.execute(
{
code: undefined,
file: "test\x00.d2",
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(false);
expect(parsed.error).toBeDefined();
});
});
describe("themes tool", () => {
test("returns list of available themes", async () => {
const result = await themes.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
themes: unknown[];
example: unknown;
};
expect(parsed.success).toBe(true);
expect(Array.isArray(parsed.themes)).toBe(true);
expect(parsed.themes.length).toBe(8); // 8 themes defined
expect(parsed.example).toBeDefined();
});
});
describe("layouts tool", () => {
test("returns list of available layouts", async () => {
const result = await layouts.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
layouts: unknown[];
example: unknown;
};
expect(parsed.success).toBe(true);
expect(Array.isArray(parsed.layouts)).toBe(true);
expect(parsed.layouts.length).toBe(3); // dagre, elk, tala
expect(parsed.example).toBeDefined();
});
});
// ============================================================================
// Integration Tests with Mocked child_process
// ============================================================================
describe("check tool", () => {
test("returns available when d2 is installed", async () => {
const result = await check.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
available: boolean;
version: string;
};
expect(parsed.success).toBe(true);
expect(parsed.available).toBe(true);
expect(parsed.version).toBe("0.6.0");
expect(spawnCalls.length).toBe(1);
expect(spawnCalls[0]?.command).toBe("d2");
expect(spawnCalls[0]?.args).toContain("--version");
});
test("returns unavailable when d2 is not installed (ENOENT)", async () => {
mockConfig.d2Available = false;
const result = await check.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
available: boolean;
error: string;
hint: string;
};
expect(parsed.success).toBe(false);
expect(parsed.available).toBe(false);
expect(parsed.error).toContain("not found");
expect(parsed.hint).toContain("Install");
});
test("returns unavailable when d2 version check fails", async () => {
mockConfig.d2Available = false;
const result = await check.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
available: boolean;
};
expect(parsed.available).toBe(false);
});
test("returns unavailable with different error code (not ENOENT)", async () => {
mockConfig.d2Available = false;
mockConfig.d2SpawnErrorCode = "EPERM";
const result = await check.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
available: boolean;
error: string;
hint: string;
};
expect(parsed.success).toBe(false);
expect(parsed.available).toBe(false);
expect(parsed.error).toContain("not found");
expect(parsed.hint).toContain("Check your installation");
});
});
describe("render tool - successful execution", () => {
test("renders inline code to SVG file", async () => {
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
output: string;
format: string;
d2_version: string;
};
expect(parsed.success).toBe(true);
expect(parsed.format).toBe("svg");
expect(parsed.d2_version).toBe("0.6.0");
// Check that spawn was called twice: once for version check, once for render
expect(spawnCalls.length).toBe(2);
expect(spawnCalls[0]?.args).toContain("--version");
// Second call should be the render with input/output args
expect(spawnCalls[1]?.command).toBe("d2");
expect(spawnCalls[1]?.args?.length).toBeGreaterThanOrEqual(2);
});
test("renders inline code to PNG file", async () => {
const result = await render.execute(
{ code: "a -> b", file: undefined, format: "png", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
format: string;
};
expect(parsed.success).toBe(true);
expect(parsed.format).toBe("png");
// Verify PNG output file was created (mock writes "PNG" content)
const outputArg = spawnCalls[1]?.args[spawnCalls[1]!.args.length - 1];
expect(outputArg).toBeDefined();
expect(outputArg?.endsWith(".png")).toBe(true);
});
test("renders inline code to PDF file", async () => {
const result = await render.execute(
{ code: "a -> b", file: undefined, format: "pdf", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
format: string;
};
expect(parsed.success).toBe(true);
expect(parsed.format).toBe("pdf");
// Verify PDF output file was created
const outputArg = spawnCalls[1]?.args[spawnCalls[1]!.args.length - 1];
expect(outputArg).toBeDefined();
expect(outputArg?.endsWith(".pdf")).toBe(true);
});
test("renders from file", async () => {
const testFile = path.join(testDir, "diagram.d2");
writeFileSync(testFile, "x -> y");
const result = await render.execute(
{
code: undefined,
file: "diagram.d2",
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
input: string;
};
expect(parsed.success).toBe(true);
expect(parsed.input).toBe("diagram.d2");
});
test("renders with theme option", async () => {
const result = await render.execute(
{
code: "x -> y",
file: undefined,
format: "svg",
theme: "dark",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
theme: string;
};
expect(parsed.success).toBe(true);
expect(parsed.theme).toBe("dark");
expect(spawnCalls[1]?.args).toContain("--theme");
expect(spawnCalls[1]?.args).toContain("dark");
});
test("renders with layout option", async () => {
const result = await render.execute(
{
code: "x -> y",
file: undefined,
format: "svg",
layout: "elk",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
layout: string;
};
expect(parsed.success).toBe(true);
expect(parsed.layout).toBe("elk");
expect(spawnCalls[1]?.args).toContain("--layout");
expect(spawnCalls[1]?.args).toContain("elk");
});
test("renders with pad option", async () => {
const result = await render.execute(
{
code: "x -> y",
file: undefined,
format: "svg",
pad: 100,
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result);
expect(parsed.success).toBe(true);
expect(spawnCalls[1]?.args).toContain("--pad");
expect(spawnCalls[1]?.args).toContain("100");
});
test("returns base64 encoded output", async () => {
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: true },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
data: string;
format: string;
};
expect(parsed.success).toBe(true);
expect(parsed.data).toMatch(/^data:image\/svg\+xml;base64,/);
expect(parsed.format).toBe("svg");
});
test("extracts dimensions from SVG output", async () => {
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: true },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
dimensions?: { width?: number; height?: number };
};
expect(parsed.success).toBe(true);
expect(parsed.dimensions).toEqual({ width: 100, height: 100 });
});
});
describe("render tool - error handling", () => {
test("returns error when d2 is not available", async () => {
mockConfig.d2Available = false;
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("not found");
expect(parsed.hint).toContain("Install");
});
test("returns error when d2 render fails", async () => {
mockConfig.d2ShouldFail = true;
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("D2 render failed");
});
test("handles syntax error from d2", async () => {
mockConfig.d2SyntaxError = "error: unexpected token at line 5";
const result = await render.execute(
{ code: "x ->", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("unexpected token");
expect(parsed.hint).toContain("syntax errors");
});
test("handles undefined shape error", async () => {
mockConfig.d2SyntaxError = "error: undefined shape 'foo'";
const result = await render.execute(
{ code: "x -> foo", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("referenced shapes");
});
test("handles connection error", async () => {
mockConfig.d2SyntaxError = "error: connection problem";
const result = await render.execute(
{ code: "x y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("Connection syntax");
});
});
describe("render tool - spawn call verification", () => {
test("passes correct arguments to spawn for render", async () => {
await render.execute(
{
code: "x -> y",
file: undefined,
format: "svg",
theme: "dark",
layout: "elk",
pad: 50,
returnBase64: false,
},
mockContext,
);
// First call is version check
expect(spawnCalls[0]?.command).toBe("d2");
expect(spawnCalls[0]?.args).toEqual(["--version"]);
// Second call is render
expect(spawnCalls[1]?.command).toBe("d2");
const renderArgs = spawnCalls[1]?.args!;
expect(renderArgs).toContain("--layout");
expect(renderArgs).toContain("elk");
expect(renderArgs).toContain("--theme");
expect(renderArgs).toContain("dark");
expect(renderArgs).toContain("--pad");
expect(renderArgs).toContain("50");
// Last arg should be output path
expect(renderArgs[renderArgs.length - 1]).toMatch(/\.svg$/);
});
test("does not pass theme when default", async () => {
await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const renderArgs = spawnCalls[1]?.args!;
expect(renderArgs).not.toContain("--theme");
});
test("does not pass layout when not specified", async () => {
await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const renderArgs = spawnCalls[1]?.args!;
expect(renderArgs).not.toContain("--layout");
});
});
describe("render tool - edge cases", () => {
test("handles spawn error during render", async () => {
mockConfig.d2SpawnError = "spawn d2 ENOENT";
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("Failed to execute d2");
expect(parsed.hint).toContain("properly installed");
});
test("handles output file not created", async () => {
mockConfig.skipOutputFileCreation = true;
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("output file was not created");
});
test("handles style error", async () => {
mockConfig.d2SyntaxError = "error: unknown style property";
const result = await render.execute(
{
code: "x.style.foo: bar",
file: undefined,
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("CSS colors");
});
test("handles fill error", async () => {
mockConfig.d2SyntaxError = "error: fill color not recognized";
const result = await render.execute(
{
code: "x.style.fill: invalidcolor",
file: undefined,
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("CSS colors");
});
test("handles invalid key error", async () => {
mockConfig.d2SyntaxError = "error: invalid key 'badkey'";
const result = await render.execute(
{
code: "x.badkey: value",
file: undefined,
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("valid D2 keywords");
});
test("handles 'invalid' error without 'invalid key'", async () => {
mockConfig.d2SyntaxError = "error: invalid value";
const result = await render.execute(
{
code: "x: invalid",
file: undefined,
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("valid D2 keywords");
});
test("handles 'not found' error", async () => {
mockConfig.d2SyntaxError = "error: shape 'bar' not found";
const result = await render.execute(
{ code: "x -> bar", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.hint).toContain("referenced shapes");
});
test("handles error without specific hint", async () => {
mockConfig.d2SyntaxError = "error: something completely unknown";
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("something completely unknown");
expect(parsed.hint).toBeUndefined();
});
test("includes raw_error when stderr is available", async () => {
mockConfig.d2SyntaxError = "error: detailed error with path /tmp/file.d2";
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
raw_error?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.raw_error).toBeDefined();
expect(parsed.raw_error).toContain("detailed error");
});
test("renders from file with correct input path", async () => {
const testFile = path.join(testDir, "test.d2");
writeFileSync(testFile, "x -> y");
await render.execute(
{ code: undefined, file: "test.d2", format: "svg", returnBase64: false },
mockContext,
);
// The second spawn call should have the full path as first input arg
const renderArgs = spawnCalls[1]?.args!;
expect(renderArgs).toContain(testFile);
});
});
describe("render tool - validation edge cases", () => {
test("rejects empty code string", async () => {
const result = await render.execute(
{ code: "", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("empty");
expect(parsed.hint).toBeDefined();
});
test("rejects whitespace-only code", async () => {
const result = await render.execute(
{
code: " \n\t ",
file: undefined,
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("whitespace");
expect(parsed.hint).toBeDefined();
});
});
describe("render tool - file size edge cases", () => {
test("rejects oversized output file", async () => {
mockConfig.oversizedOutput = true;
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("exceeds maximum size");
expect(parsed.error).toContain("50MB");
expect(parsed.hint).toContain("simplifying");
});
});
describe("render tool - stdout handling", () => {
test("captures stdout during render", async () => {
// The mock emits stdout data for version check, but we need to verify
// that stdout is captured during render as well
const result = await render.execute(
{ code: "x -> y", file: undefined, format: "svg", returnBase64: false },
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
format: string;
};
expect(parsed.success).toBe(true);
// Verify spawn was called twice (version + render)
expect(spawnCalls.length).toBe(2);
});
});
describe("render tool - unexpected exceptions", () => {
test("handles unexpected exception in render", async () => {
// Create a scenario that causes an unexpected exception
// by having the mock throw during a critical operation
const originalExistsSync = existsSync;
const testFile = path.join(testDir, "exception.d2");
writeFileSync(testFile, "x -> y");
// Mock existsSync to throw for the specific file check path
const errorSpy = mock.module("node:fs", () => ({
existsSync: (p: string) => {
if (p.includes("exception.d2")) {
throw new Error("Unexpected filesystem error");
}
return originalExistsSync(p);
},
mkdirSync: mkdirSync,
rmSync: rmSync,
writeFileSync: writeFileSync,
statSync: statSync,
unlinkSync: unlinkSync,
}));
const result = await render.execute(
{
code: undefined,
file: "exception.d2",
format: "svg",
returnBase64: false,
},
mockContext,
);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("Unexpected filesystem error");
expect(parsed.hint).toContain("unexpected error");
// errorSpy may not have mockRestore in Bun
if (errorSpy && typeof (errorSpy as any).mockRestore === "function") {
(errorSpy as any).mockRestore();
}
});
});
describe("check tool - unexpected exceptions", () => {
test("handles unexpected exception in check", async () => {
// Force an unexpected error by making spawn throw synchronously
const errorSpy = mock.module("node:child_process", () => ({
spawn: () => {
throw new Error("Spawn crashed unexpectedly");
},
}));
const result = await check.execute({}, mockContext);
const parsed = parseResponse(result) as {
success: boolean;
error: string;
hint?: string;
};
expect(parsed.success).toBe(false);
expect(parsed.error).toContain("Spawn crashed unexpectedly");
expect(parsed.hint).toContain("unexpected error");
// errorSpy may not have mockRestore in Bun
if (errorSpy && typeof (errorSpy as any).mockRestore === "function") {
(errorSpy as any).mockRestore();
}
});
});