Skip to content

Your lightweight open-source personal agent.

14.6 KB
Raw Blame
import { act, render, screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { describe, expect, it, vi } from "vitest";
import type { HighlightedCodeProps } from "@/components/HighlightedCode";

import { CodeBlock } from "@/components/CodeBlock";
import { ThemeProvider } from "@/hooks/useTheme";

const failures = vi.hoisted(() => new Set<string>());

// Test CodeBlock's controls and enhancement boundary here; token/DOM rendering has dedicated real-engine and browser coverage.
vi.mock("@/components/HighlightedCode", () => ({
  HighlightedCode: ({ code, language, viewportHighlight }: HighlightedCodeProps) => {
    if (failures.has(code)) throw new Error("Grammar download failed");
    return <pre data-testid="highlighted-code" data-language={language || "text"}
      style={{ overflow: viewportHighlight ? "visible" : "auto" }}><code data-code-text="">{code}</code></pre>;
  },
}));

describe("CodeBlock", () => {
  it("contains a failed grammar, preserves source and copy, and enhances changed source", async () => {
    const source = "; 中文 😀\r\n[server]\r\nhost=localhost\r\n";
    failures.add(source);
    const user = userEvent.setup();
    const writeText = vi.fn().mockResolvedValue(undefined);
    Object.defineProperty(navigator, "clipboard", { configurable: true, value: { writeText } });
    const errors = vi.spyOn(console, "error").mockImplementation(() => {});
    const warnings = vi.spyOn(console, "warn").mockImplementation(() => {});
    try {
      const { rerender } = render(<><textarea defaultValue="keep draft" /><CodeBlock code={source} language="ini" /></>);
      await waitFor(() => expect(warnings).toHaveBeenCalledWith("Code highlighting failed.", expect.any(Error)));
      expect(screen.getByTestId("plain-code-fallback").textContent).toBe(source);
      expect(screen.getByRole("textbox")).toHaveValue("keep draft");
      await user.click(screen.getByRole("button", { name: "Copy code" }));
      expect(writeText).toHaveBeenCalledWith(source);
      rerender(<><textarea defaultValue="keep draft" /><CodeBlock code={source + "; updated"} language="ini" /></>);
      expect((await screen.findByTestId("highlighted-code")).textContent).toBe(source + "; updated");
      expect(screen.getByRole("textbox")).toHaveValue("keep draft");
    } finally {
      failures.clear();
      errors.mockRestore();
      warnings.mockRestore();
      Reflect.deleteProperty(navigator, "clipboard");
    }
  });

  it("renders and copies a large code block in full without pagination", async () => {
    const user = userEvent.setup();
    const writeText = vi.fn().mockResolvedValue(undefined);
    Object.defineProperty(navigator, "clipboard", {
      configurable: true,
      value: { writeText },
    });
    const source = Array.from({ length: 1200 }, (_, i) => `const value${i} = ${i};`).join("\n");

    try {
      render(<CodeBlock code={source} language="typescript" showLineNumbers />);
      const code = await screen.findByTestId("highlighted-code");
      expect([...code.querySelectorAll("[data-code-text]")].map(node => node.textContent).join("")).toBe(source);
      expect(screen.getAllByRole("button")).toHaveLength(1);
      await user.click(screen.getByRole("button", { name: "Copy code" }));
      expect(writeText).toHaveBeenCalledWith(source);
    } finally {
      Reflect.deleteProperty(navigator, "clipboard");
    }
  });

  it("renders long plain text with Unicode in full", () => {
    const source = "x".repeat(23999) + "😀tail";
    render(<CodeBlock code={source} highlight={false} />);
    expect(screen.getByTestId("plain-code-fallback").textContent).toBe(source);
    expect(screen.getAllByRole("button")).toHaveLength(1);
  });

  it.each([
    ["many lines", "x\n".repeat(60_000)],
    ["many short lines", "\n".repeat(2_000)],
    ["a minified line", "x".repeat(2_001) + "😀tail"],
  ])("keeps an oversized file preview (%s) complete without a huge token/line DOM", (_name, code) => {
    const { container } = render(<CodeBlock code={code} language="html" chrome="none"
      showLineNumbers wrapLongLines={false} viewportHighlight />);
    expect(screen.queryByTestId("highlighted-code")).not.toBeInTheDocument();
    expect(screen.getByTestId("plain-code-fallback").querySelector("code > span > span:last-child")?.textContent).toBe(code);
    expect(container.querySelectorAll("*").length).toBeLessThan(10);
  });

  it("keeps a Python module beyond the preview budget available as complete plain text", () => {
    const code = Array.from({ length: 2800 }, (_, index) => `def function_${index}(): return "a realistic source line"`).join("\n");
    render(<CodeBlock code={code} language="python" chrome="none"
      showLineNumbers wrapLongLines={false} viewportHighlight />);
    expect(screen.getByTestId("plain-code-fallback").querySelector("code > span > span:last-child")?.textContent).toBe(code);
  });

  it("paints large preview text before enhancing it, and cancels enhancement on unmount", async () => {
    const callbacks = new Map<number, FrameRequestCallback>();
    let next = 0;
    const raf = vi.spyOn(window, "requestAnimationFrame").mockImplementation(callback => {
      callbacks.set(++next, callback);
      return next;
    });
    const cancel = vi.spyOn(window, "cancelAnimationFrame").mockImplementation(id => { callbacks.delete(id); });
    const code = "const value = 1;\n".repeat(600);
    try {
      const { unmount } = render(<CodeBlock code={code} language="ts" chrome="none"
        showLineNumbers wrapLongLines={false} viewportHighlight />);
      expect(screen.getByTestId("plain-code-fallback")).toBeInTheDocument();
      expect(screen.queryByTestId("highlighted-code")).not.toBeInTheDocument();
      expect(screen.getByTestId("plain-code-fallback")).toHaveClass("overflow-visible");
      expect(screen.getByTestId("plain-code-fallback").parentElement).toHaveClass("overflow-visible");
      // Clicking a tab can clear a previous selection. That browser event must
      // not bypass the initial paint opportunity reserved for the new tab.
      await act(async () => { document.dispatchEvent(new Event("selectionchange")); });
      expect(screen.getByTestId("plain-code-fallback")).toBeInTheDocument();
      await act(async () => { callbacks.get(1)?.(0); });
      expect(screen.getByTestId("plain-code-fallback")).toBeInTheDocument();
      await act(async () => { document.dispatchEvent(new Event("selectionchange")); });
      expect(screen.getByTestId("plain-code-fallback")).toBeInTheDocument();
      const selection = document.getSelection()!;
      const range = document.createRange();
      range.selectNodeContents(screen.getByTestId("plain-code-fallback"));
      act(() => selection.addRange(range));
      await act(async () => { callbacks.get(2)?.(16); });
      expect(screen.getByTestId("plain-code-fallback")).toBeInTheDocument();
      await act(async () => { selection.removeAllRanges(); document.dispatchEvent(new Event("selectionchange")); });
      expect(await screen.findByTestId("highlighted-code")).toBeInTheDocument();
      expect(screen.getByTestId("highlighted-code")).toHaveStyle({ overflow: "visible" });
      unmount();
      expect(cancel).toHaveBeenCalledWith(2);
      const second = render(<CodeBlock code={code} language="ts" chrome="none"
        showLineNumbers wrapLongLines={false} viewportHighlight />);
      const pending = next;
      second.unmount();
      expect(callbacks.has(pending)).toBe(false);
    } finally {
      raf.mockRestore();
      cancel.mockRestore();
    }
  });

  it("renders plain code without mounting the highlighter when highlighting is disabled", () => {
    render(
      <ThemeProvider theme="dark">
        <CodeBlock language="ts" code="const value = 1;" highlight={false} />
      </ThemeProvider>,
    );

    expect(screen.queryByTestId("highlighted-code")).not.toBeInTheDocument();
    expect(screen.getByText("const value = 1;")).toBeInTheDocument();
    expect(screen.queryByText("ts")).not.toBeInTheDocument();
    expect(screen.getByTestId("plain-code-fallback")).toHaveClass("text-foreground/90");
    expect(screen.getByTestId("plain-code-fallback")).toHaveClass("bg-transparent");
    expect(screen.getByTestId("plain-code-fallback")).toHaveClass("py-4", "pl-5", "pr-14");

    const container = screen.getByTestId("plain-code-fallback").closest(".not-prose");
    expect(container).toHaveClass("relative", "rounded-floating", "bg-secondary/70");
    expect(container).not.toHaveClass("border");
    expect(container).toHaveAttribute("data-language", "ts");

    const copyButton = screen.getByRole("button", { name: "Copy code" });
    expect(copyButton.parentElement).toBe(container);
    expect(copyButton).toHaveClass("absolute", "h-8", "w-8", "rounded-full");
    expect(copyButton).toHaveTextContent("");
  });

  it("can render without chat-style chrome for file previews", () => {
    render(
      <ThemeProvider theme="light">
        <CodeBlock
          language="html"
          code="<main />"
          chrome="none"
          highlight={false}
          showLineNumbers
        />
      </ThemeProvider>,
    );

    expect(screen.queryByText("html")).not.toBeInTheDocument();
    expect(screen.queryByRole("button", { name: /copy/i })).not.toBeInTheDocument();
    expect(screen.getByText("1")).toBeInTheDocument();
    expect(screen.getByTestId("plain-code-fallback")).toHaveClass("bg-transparent");
  });

  it("falls back to 'text' language when language is undefined", async () => {
    render(
      <ThemeProvider theme="dark">
        <CodeBlock language={undefined} code="const value = 1;" />
      </ThemeProvider>,
    );

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });

    expect(screen.getByTestId("highlighted-code")).toBeInTheDocument();
    expect(screen.getByTestId("highlighted-code")).toHaveAttribute("data-language", "text");
    expect(screen.getByText("const value = 1;")).toBeInTheDocument();
  });

  it("normalizes file language aliases before highlighting", async () => {
    render(
      <ThemeProvider theme="light">
        <CodeBlock language="html" code="<main />" />
      </ThemeProvider>,
    );

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });

    expect(screen.getByTestId("highlighted-code")).toHaveAttribute("data-language", "markup");
  });

  it("renders ANSI output without mounting the syntax highlighter", () => {
    render(
      <ThemeProvider theme="dark">
        <CodeBlock
          language="ansi"
          code={"\x1b[32mPASS\x1b[0m <script>alert(1)</script>"}
        />
      </ThemeProvider>,
    );

    expect(screen.queryByTestId("highlighted-code")).not.toBeInTheDocument();
    expect(screen.getByTestId("ansi-code")).toBeInTheDocument();
    expect(screen.getByTestId("ansi-code").closest(".not-prose")).toHaveAttribute(
      "data-language",
      "ansi",
    );
    expect(screen.queryByText("ansi")).not.toBeInTheDocument();
    expect(screen.getByText("PASS")).toHaveStyle({ color: "#86efac" });
    expect(screen.getByText("<script>alert(1)</script>")).toBeInTheDocument();
    expect(document.querySelector("script")).toBeNull();
  });

  it("detects ANSI sequences in regular code blocks", () => {
    render(
      <ThemeProvider theme="light">
        <CodeBlock
          language="text"
          code={"\x1b[38;2;35;209;139mtruecolor\x1b[0m"}
        />
      </ThemeProvider>,
    );

    expect(screen.queryByTestId("highlighted-code")).not.toBeInTheDocument();
    expect(screen.getByText("truecolor")).toHaveStyle({
      color: "rgb(35, 209, 139)",
    });
  });

  it("clears ANSI foreground and background colors on reset", () => {
    render(<CodeBlock language="ansi" code={"\x1b[31;47merror\x1b[0m normal"} />);

    expect(screen.getByText("error")).toHaveStyle({ color: "#cd3131", backgroundColor: "#e5e5e5" });
    expect(screen.getByText("normal")).not.toHaveAttribute("style");
  });

  it("copies ANSI output as clean text", async () => {
    const user = userEvent.setup();
    const writeText = vi.fn().mockResolvedValue(undefined);
    Object.defineProperty(navigator, "clipboard", {
      configurable: true,
      value: { writeText },
    });

    try {
      render(
        <ThemeProvider theme="dark">
          <CodeBlock language="ansi" code={"\x1b[32mPASS\x1b[0m"} />
        </ThemeProvider>,
      );

      await user.click(screen.getByRole("button", { name: /copy/i }));

      expect(writeText).toHaveBeenCalledWith("PASS");
    } finally {
      Reflect.deleteProperty(navigator, "clipboard");
    }
  });

  it("copies with the textarea fallback when Clipboard API is unavailable", async () => {
    const user = userEvent.setup();
    Object.defineProperty(navigator, "clipboard", {
      configurable: true,
      value: undefined,
    });
    const execCommand = vi.fn().mockReturnValue(true);
    Object.defineProperty(document, "execCommand", {
      configurable: true,
      value: execCommand,
    });

    try {
      render(
        <ThemeProvider theme="dark">
          <CodeBlock language="ts" code="const value = 1;" highlight={false} />
        </ThemeProvider>,
      );

      await user.click(screen.getByRole("button", { name: /copy/i }));

      await waitFor(() => expect(execCommand).toHaveBeenCalledWith("copy"));
      expect(screen.getByRole("button", { name: "Copied" })).toBeInTheDocument();
    } finally {
      Reflect.deleteProperty(navigator, "clipboard");
      Reflect.deleteProperty(document, "execCommand");
    }
  });

  it("reads theme from context without creating per-block observers", async () => {
    const originalMutationObserver = globalThis.MutationObserver;
    const observer = vi.fn();
    class MockMutationObserver {
      constructor(callback: MutationCallback) {
        observer(callback);
      }

      observe = vi.fn();

      disconnect = vi.fn();

      takeRecords() {
        return [];
      }
    }
    vi.stubGlobal("MutationObserver", MockMutationObserver);

    try {
      const { rerender } = render(
        <ThemeProvider theme="dark">
          <CodeBlock language="ansi" code={"\x1b[32mPASS\x1b[0m"} />
        </ThemeProvider>,
      );

      await act(async () => {
        await Promise.resolve();
        await Promise.resolve();
      });

      expect(screen.getByText("PASS")).toHaveStyle({ color: "#86efac" });

      rerender(
        <ThemeProvider theme="light">
          <CodeBlock language="ansi" code={"\x1b[32mPASS\x1b[0m"} />
        </ThemeProvider>,
      );

      await act(async () => {
        await Promise.resolve();
      });

      expect(screen.getByText("PASS")).toHaveStyle({ color: "#166534" });
      expect(observer).not.toHaveBeenCalled();
    } finally {
      vi.stubGlobal("MutationObserver", originalMutationObserver);
    }
  });
});