diffRendering.test.ts

import { hydratePartialDiff } from "@pierre/diffs";
import { describe, expect, it } from "vite-plus/test";
import { resolveDiffReviewPosition } from "../reviewCommentContext";
import {
  buildFileDiffContentVersion,
  buildFileDiffIdentityKey,
  buildFileDiffRenderKey,
  getDiffLineStat,
  getRenderablePatch,
  resolveFileDiffPath,
  resolveFileDiffPreviousPath,
} from "./diffRendering";

describe("getRenderablePatch", () => {
  it("hides indentation changes around inserted JSX without moving review lines", () => {
    const patch = [
      "diff --git a/item.tsx b/item.tsx",
      "--- a/item.tsx",
      "+++ b/item.tsx",
      "@@ -40,5 +40,7 @@",
      ' <ItemContent className="min-w-0">',
      "-  <ItemTitle>",
      '-    <h4 className="wrap-break-word">{name}</h4>',
      "-  </ItemTitle>",
      "+  {showName && (",
      "+    <ItemTitle>",
      '+      <h4 className="wrap-break-word">{name}</h4>',
      "+    </ItemTitle>",
      "+  )}",
      " </ItemContent>",
      "@@ -80 +82 @@",
      "-const value = 1;",
      "+const value = 2;",
    ].join("\n");
    const shown = getRenderablePatch(patch, "pr", { compactPartialHunkOffsets: true });
    const hidden = getRenderablePatch(patch, "pr", {
      compactPartialHunkOffsets: true,
      ignoreWhitespace: true,
    });
    expect(shown?.kind).toBe("files");
    expect(hidden?.kind).toBe("files");
    if (shown?.kind !== "files" || hidden?.kind !== "files") return;
    expect(getDiffLineStat(shown.files)).toEqual({ additions: 6, deletions: 4 });
    expect(getDiffLineStat(hidden.files)).toEqual({ additions: 3, deletions: 1 });
    const file = hidden.files[0]!;
    expect(file.additionLines).toEqual(shown.files[0]!.additionLines);
    expect(file.deletionLines).toEqual(shown.files[0]!.deletionLines);
    expect(file.cacheKey).not.toBe(shown.files[0]!.cacheKey);
    expect(resolveDiffReviewPosition(hidden.sourceFiles[0]!, 43, "additions")).toEqual({
      kind: "added",
      newLine: 43,
    });
    expect(resolveDiffReviewPosition(hidden.sourceFiles[0]!, 42, "deletions")).toEqual({
      kind: "deleted",
      oldLine: 42,
    });
    expect(file.hunks[0]?.hunkContent).toContainEqual({
      type: "context",
      lines: 3,
      additionLineIndex: 2,
      deletionLineIndex: 1,
    });
    expect(resolveDiffReviewPosition(file, 41, "additions")).toEqual({
      kind: "added",
      newLine: 41,
    });
    expect(resolveDiffReviewPosition(file, 43, "additions")).toEqual({
      kind: "context",
      oldLine: 42,
      newLine: 43,
      side: "right",
    });
    expect(resolveDiffReviewPosition(file, 42, "deletions")).toEqual({
      kind: "context",
      oldLine: 42,
      newLine: 43,
      side: "left",
    });
    expect(file.hunks[1]).toMatchObject({
      additionStart: 82,
      deletionStart: 80,
      splitLineStart: 7,
      unifiedLineStart: 7,
    });
    const prefix = "unchanged\n".repeat(39);
    const gap = "unchanged\n".repeat(35);
    const hydrated = hydratePartialDiff("clone", file, {
      oldFile: {
        name: file.name,
        contents: prefix + file.deletionLines.slice(0, 5).join("") + gap + "const value = 1;\n",
      },
      newFile: {
        name: file.name,
        contents: prefix + file.additionLines.slice(0, 7).join("") + gap + "const value = 2;\n",
      },
    });
    expect(getDiffLineStat([hydrated])).toEqual({ additions: 3, deletions: 1 });
    expect(resolveDiffReviewPosition(hydrated, 43, "additions")).toEqual(
      resolveDiffReviewPosition(file, 43, "additions"),
    );
  });

  it.each([
    ["  const x = 1;\t", "\tconst x=1;", 0, 0],
    ["const x = 1;", "const x = 2;", 1, 1],
    ["const x = 1;", "const x = 1;\n", 1, 0],
  ])("filters whitespace in %j to %j", (before, after, additions, deletions) => {
    const patch = [
      "diff --git a/example.ts b/example.ts",
      "--- a/example.ts",
      "+++ b/example.ts",
      `@@ -1 +1,${after.split("\n").length} @@`,
      `-${before}`,
      ...after.split("\n").map((line) => `+${line}`),
      "",
    ].join("\n");
    const filtered = getRenderablePatch(patch, "pr", { ignoreWhitespace: true });
    expect(filtered?.kind).toBe("files");
    if (filtered?.kind !== "files") return;
    expect(getDiffLineStat(filtered.files)).toEqual({ additions, deletions });
  });

  it.each(["+", "-"])("keeps %s blank lines without a final newline", (sign) => {
    const parsed = getRenderablePatch(
      [
        "diff --git a/blank.txt b/blank.txt",
        "--- a/blank.txt",
        "+++ b/blank.txt",
        sign === "+" ? "@@ -0,0 +1 @@" : "@@ -1 +0,0 @@",
        `${sign}  `,
        "\\ No newline at end of file",
      ].join("\n"),
      "pr",
      { ignoreWhitespace: true },
    );
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;
    expect(getDiffLineStat(parsed.files)).toEqual({
      additions: sign === "+" ? 1 : 0,
      deletions: sign === "-" ? 1 : 0,
    });
  });

  it.each([
    ["a/example.ts", "a/example.ts", "change"],
    ["b/example.ts", "b/example.ts", "change"],
    ["a/before.ts", "b/after.ts", "rename-changed"],
  ])("preserves repository paths from %s to %s", (previousPath, path, type) => {
    const parsed = getRenderablePatch(
      [
        `diff --git a/${previousPath} b/${path}`,
        ...(previousPath === path
          ? []
          : ["similarity index 50%", `rename from ${previousPath}`, `rename to ${path}`]),
        `--- a/${previousPath}`,
        `+++ b/${path}`,
        "@@ -1 +1 @@",
        "-before",
        "+after",
      ].join("\n"),
    );
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;
    const file = parsed.files[0];
    expect(file).toBeDefined();
    if (!file) return;
    expect(resolveFileDiffPath(file)).toBe(path);
    expect(resolveFileDiffPreviousPath(file)).toBe(previousPath);
    expect(buildFileDiffIdentityKey(file)).toBe(`${previousPath}\0${path}\0${type}`);
  });

  it("compacts partial hunk render offsets for virtualized review diffs", () => {
    const patch = [
      "diff --git a/example.ts b/example.ts",
      "index 1111111..2222222 100644",
      "--- a/example.ts",
      "+++ b/example.ts",
      "@@ -48,4 +48,4 @@",
      " context",
      "-before",
      "+after",
      " context",
      " context",
      "@@ -80,3 +80,4 @@",
      " context",
      "+added",
      " context",
      " context",
    ].join("\n");

    const parsed = getRenderablePatch(patch, "review", {
      compactPartialHunkOffsets: true,
    });
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;

    const file = parsed.files[0];
    expect(file?.hunks[0]?.collapsedBefore).toBe(47);
    expect(file?.hunks[0]?.unifiedLineStart).toBe(0);
    expect(file?.hunks[1]?.collapsedBefore).toBeGreaterThan(0);
    expect(file?.hunks[1]?.unifiedLineStart).toBe(file?.hunks[0]?.unifiedLineCount);
    expect(file?.unifiedLineCount).toBe(
      file?.hunks.reduce((total, hunk) => total + hunk.unifiedLineCount, 0),
    );
  });

  it("retains source-file offsets for checkpoint diffs", () => {
    const patch = [
      "diff --git a/example.ts b/example.ts",
      "--- a/example.ts",
      "+++ b/example.ts",
      "@@ -48,1 +48,1 @@",
      "-before",
      "+after",
    ].join("\n");

    const parsed = getRenderablePatch(patch, "checkpoint");
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;
    expect(parsed.files[0]?.hunks[0]?.unifiedLineStart).toBe(47);
  });

  it("keeps whitespace at the end of the last hunk", () => {
    const patch = (lastLines: string[]) =>
      [
        "diff --git a/example.ts b/example.ts",
        "--- a/example.ts",
        "+++ b/example.ts",
        ...lastLines,
        "",
      ].join("\n");

    const trailing = getRenderablePatch(patch(["@@ -1 +1 @@", "-a", "+  b \t"]), "review");
    expect(trailing?.kind).toBe("files");
    if (trailing?.kind !== "files") return;
    expect(trailing.files[0]?.additionLines).toEqual(["  b \t\n"]);

    const blankContext = getRenderablePatch(patch(["@@ -1,2 +1,2 @@", "-a", "+b", " "]), "review");
    expect(blankContext?.kind).toBe("files");
    if (blankContext?.kind !== "files") return;
    expect(blankContext.files[0]?.additionLines).toEqual(["b\n", "\n"]);
    expect(blankContext.files[0]?.hunks[0]?.unifiedLineCount).toBe(3);

    expect(getRenderablePatch(" \n\t\n", "review")).toBeNull();
  });

  it("caches patches that differ only in trailing whitespace separately", () => {
    const patch = (added: string) =>
      [
        "diff --git a/example.ts b/example.ts",
        "--- a/example.ts",
        "+++ b/example.ts",
        "@@ -1 +1 @@",
        "-a",
        `+${added}`,
        "",
      ].join("\n");

    const plain = getRenderablePatch(patch("b"), "review");
    const tabbed = getRenderablePatch(patch("b\t"), "review");
    expect(plain?.kind).toBe("files");
    expect(tabbed?.kind).toBe("files");
    if (plain?.kind !== "files" || tabbed?.kind !== "files") return;
    expect(tabbed.files[0]?.cacheKey).not.toBe(plain.files[0]?.cacheKey);
  });
});

describe("diff file reconciliation", () => {
  it("keeps Pierre's render key stable when a partial diff hydrates", () => {
    const patch = [
      "diff --git a/example.ts b/example.ts",
      "--- a/example.ts",
      "+++ b/example.ts",
      "@@ -1 +1 @@",
      "-before",
      "+after",
    ].join("\n");
    const parsed = getRenderablePatch(patch, "hydrated-key");
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;

    const file = parsed.files[0];
    expect(file).toBeDefined();
    if (!file) return;
    const key = buildFileDiffRenderKey(file);
    file.cacheKey = `${file.cacheKey}:hydrated`;

    expect(buildFileDiffRenderKey(file)).toBe(key);
  });

  it("gives a type change its own identity per block", () => {
    const patch = [
      "diff --git a/AGENTS.md b/AGENTS.md",
      "deleted file mode 100644",
      "--- a/AGENTS.md",
      "+++ /dev/null",
      "@@ -1 +0,0 @@",
      "-duplicated instructions",
      "diff --git a/AGENTS.md b/AGENTS.md",
      "new file mode 120000",
      "--- /dev/null",
      "+++ b/AGENTS.md",
      "@@ -0,0 +1 @@",
      "+CLAUDE.md",
    ].join("\n");
    const parsed = getRenderablePatch(patch, "type-change");
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;
    const [deleted, added] = parsed.files;
    expect(deleted?.type).toBe("deleted");
    expect(added?.type).toBe("new");
    if (!deleted || !added) return;

    expect(buildFileDiffIdentityKey(deleted)).not.toBe(buildFileDiffIdentityKey(added));
    expect(new Set(parsed.files.map(buildFileDiffIdentityKey)).size).toBe(parsed.files.length);
  });

  it("keeps identities stable and versions local to the changed file", () => {
    const patch = (secondLine: string) =>
      [
        "diff --git a/unchanged.ts b/unchanged.ts",
        "--- a/unchanged.ts",
        "+++ b/unchanged.ts",
        "@@ -1 +1 @@",
        "-before",
        "+after",
        "diff --git a/changed.ts b/changed.ts",
        "--- a/changed.ts",
        "+++ b/changed.ts",
        "@@ -1 +1 @@",
        "-old",
        `+${secondLine}`,
      ].join("\n");
    const before = getRenderablePatch(patch("new"), "before");
    const after = getRenderablePatch(patch("newer"), "after");
    expect(before?.kind).toBe("files");
    expect(after?.kind).toBe("files");
    if (before?.kind !== "files" || after?.kind !== "files") return;

    const [beforeUnchanged, beforeChanged] = before.files;
    const [afterUnchanged, afterChanged] = after.files;
    expect(beforeUnchanged).toBeDefined();
    expect(beforeChanged).toBeDefined();
    expect(afterUnchanged).toBeDefined();
    expect(afterChanged).toBeDefined();
    if (!beforeUnchanged || !beforeChanged || !afterUnchanged || !afterChanged) return;

    expect(buildFileDiffIdentityKey(afterUnchanged)).toBe(
      buildFileDiffIdentityKey(beforeUnchanged),
    );
    expect(buildFileDiffIdentityKey(afterChanged)).toBe(buildFileDiffIdentityKey(beforeChanged));
    expect(buildFileDiffContentVersion(afterUnchanged)).toBe(
      buildFileDiffContentVersion(beforeUnchanged),
    );
    expect(buildFileDiffContentVersion(afterChanged)).not.toBe(
      buildFileDiffContentVersion(beforeChanged),
    );
  });
});

describe("a file whose name a patch header cannot carry plainly", () => {
  const quotedPatch = (written: string) =>
    [
      `diff --git "a/${written}" "b/${written}"`,
      "index 1111111..2222222 100644",
      `--- "a/${written}"`,
      `+++ "b/${written}"`,
      "@@ -1 +1 @@",
      "-before",
      "+after",
      "",
    ].join("\n");

  const pathOf = (patch: string) => {
    const parsed = getRenderablePatch(patch, "review");
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") throw new Error("patch did not parse as files");
    const file = parsed.files[0];
    expect(file).toBeDefined();
    if (!file) throw new Error("patch carried no file");
    return resolveFileDiffPath(file);
  };

  it("reads the octal a host with core.quotePath on writes for a name outside ASCII", () => {
    expect(pathOf(quotedPatch("caf\\303\\251/r\\303\\251sum\\303\\251.ts"))).toBe("café/résumé.ts");
  });

  it("reads both sides of a rename under the names they really have", () => {
    const patch = [
      'diff --git "a/old\\tname.ts" "b/new\\tname.ts"',
      "similarity index 90%",
      'rename from "old\\tname.ts"',
      'rename to "new\\tname.ts"',
      "",
    ].join("\n");

    const parsed = getRenderablePatch(patch, "review");
    expect(parsed?.kind).toBe("files");
    if (parsed?.kind !== "files") return;
    const file = parsed.files[0];
    expect(file).toBeDefined();
    if (!file) return;

    expect(resolveFileDiffPath(file)).toBe("new\tname.ts");
    expect(resolveFileDiffPreviousPath(file)).toBe("old\tname.ts");
  });
});