repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by bugabinga

opencode/tests/d2.test.ts

Raw
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 =
                    `<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();
    }
  });
});