import { 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 = ``; 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 { 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(""); }); 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 = ''; const result = tryExtractSvgDimensions(svg); expect(result).toEqual({ width: 100, height: 200 }); }); test("extracts dimensions with decimal values", () => { const 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 = ''; const result = tryExtractSvgDimensions(svg); expect(result).toEqual({ width: 300, height: 400 }); }); test("extracts dimensions from viewBox with decimal values", () => { const svg = ''; const result = tryExtractSvgDimensions(svg); expect(result).toEqual({ width: 150.75, height: 200.5 }); }); test("prefers width/height over viewBox", () => { const svg = ''; const result = tryExtractSvgDimensions(svg); expect(result).toEqual({ width: 100, height: 200 }); }); test("returns null for SVG without dimensions", () => { const svg = ""; const result = tryExtractSvgDimensions(svg); expect(result).toBeNull(); }); test("returns null for viewBox with insufficient parts", () => { const svg = ''; const result = tryExtractSvgDimensions(svg); expect(result).toBeNull(); }); test("handles viewBox with extra whitespace", () => { const 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 = ''; 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(); } }); });