@aria-cli/tools 1.0.8 → 1.0.10

package/tests/definitions/apply-patch.test.ts

@@ -1,586 +0,0 @@
-/**
- * @aria/tools - apply_patch unit tests
- *
- * Tests for the patch parser, fuzzy matching, and sandbox path validation.
- * These are the core subsystems of the extended apply_patch tool.
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  parsePatchText,
-  normalizeUnicodeSpaces,
-  checkPatchBoundariesLenient,
-  parseOneHunk,
-  BEGIN_PATCH_MARKER,
-  END_PATCH_MARKER,
-} from "../../src/definitions/patch/patch-parser.js";
-import { applyUpdateHunk } from "../../src/definitions/patch/fuzzy-match.js";
-import {
-  resolveSandboxPath,
-  assertSandboxPath,
-} from "../../src/definitions/patch/sandbox-paths.js";
-
-// ── Patch Parser ──────────────────────────────────────────────────────
-
-describe("apply_patch", () => {
-  describe("patch-parser", () => {
-    it("parses Add File hunk", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Add File: src/hello.ts",
-        '+export const hello = "world";',
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      expect(hunks[0]!.kind).toBe("add");
-      if (hunks[0]!.kind === "add") {
-        expect(hunks[0]!.path).toBe("src/hello.ts");
-        expect(hunks[0]!.contents).toBe('export const hello = "world";\n');
-      }
-    });
-
-    it("parses Add File with multiple lines", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Add File: README.md",
-        "+# Title",
-        "+",
-        "+Some content",
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      if (hunks[0]!.kind === "add") {
-        expect(hunks[0]!.contents).toBe("# Title\n\nSome content\n");
-      }
-    });
-
-    it("parses Delete File hunk", () => {
-      const input = ["*** Begin Patch", "*** Delete File: old/deprecated.ts", "*** End Patch"].join(
-        "\n",
-      );
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      expect(hunks[0]!.kind).toBe("delete");
-      if (hunks[0]!.kind === "delete") {
-        expect(hunks[0]!.path).toBe("old/deprecated.ts");
-      }
-    });
-
-    it("parses Update File hunk with @@ chunks", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Update File: src/main.ts",
-        "@@ export function main() {",
-        '-  console.log("old");',
-        '+  console.log("new");',
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      expect(hunks[0]!.kind).toBe("update");
-      if (hunks[0]!.kind === "update") {
-        expect(hunks[0]!.path).toBe("src/main.ts");
-        expect(hunks[0]!.chunks).toHaveLength(1);
-        expect(hunks[0]!.chunks[0]!.changeContext).toBe("export function main() {");
-        expect(hunks[0]!.chunks[0]!.oldLines).toEqual(['  console.log("old");']);
-        expect(hunks[0]!.chunks[0]!.newLines).toEqual(['  console.log("new");']);
-      }
-    });
-
-    it("parses Update File with context lines (space prefix)", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Update File: src/config.ts",
-        "@@ const config = {",
-        "   debug: false,",
-        "-  port: 3000,",
-        "+  port: 8080,",
-        '   host: "localhost",',
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      if (hunks[0]!.kind === "update") {
-        const chunk = hunks[0]!.chunks[0]!;
-        // Context lines appear in both old and new
-        expect(chunk.oldLines).toEqual([
-          "  debug: false,",
-          "  port: 3000,",
-          '  host: "localhost",',
-        ]);
-        expect(chunk.newLines).toEqual([
-          "  debug: false,",
-          "  port: 8080,",
-          '  host: "localhost",',
-        ]);
-      }
-    });
-
-    it("handles *** Move to: rename", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Update File: old-name.ts",
-        "*** Move to: new-name.ts",
-        "@@ ",
-        "-const OLD = true;",
-        "+const NEW = true;",
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      if (hunks[0]!.kind === "update") {
-        expect(hunks[0]!.path).toBe("old-name.ts");
-        expect(hunks[0]!.movePath).toBe("new-name.ts");
-      }
-    });
-
-    it("validates *** Begin Patch / *** End Patch boundaries", () => {
-      // Missing Begin Patch
-      expect(() => parsePatchText(["*** Delete File: foo.ts", "*** End Patch"].join("\n"))).toThrow(
-        "*** Begin Patch",
-      );
-
-      // Missing End Patch
-      expect(() =>
-        parsePatchText(["*** Begin Patch", "*** Delete File: foo.ts"].join("\n")),
-      ).toThrow("*** End Patch");
-
-      // Valid boundaries should not throw
-      expect(() =>
-        parsePatchText(["*** Begin Patch", "*** Delete File: foo.ts", "*** End Patch"].join("\n")),
-      ).not.toThrow();
-    });
-
-    it("rejects empty input", () => {
-      expect(() => parsePatchText("")).toThrow("input is empty");
-      expect(() => parsePatchText("   ")).toThrow("input is empty");
-    });
-
-    it("handles <<EOF heredoc wrapper", () => {
-      const input = [
-        "<<EOF",
-        "*** Begin Patch",
-        "*** Delete File: tmp.ts",
-        "*** End Patch",
-        "EOF",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      expect(hunks[0]!.kind).toBe("delete");
-    });
-
-    it("handles <<'EOF' (single-quoted) heredoc wrapper", () => {
-      const input = [
-        "<<'EOF'",
-        "*** Begin Patch",
-        "*** Delete File: tmp.ts",
-        "*** End Patch",
-        "EOF",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-    });
-
-    it('handles <<"EOF" (double-quoted) heredoc wrapper', () => {
-      const input = [
-        '<<"EOF"',
-        "*** Begin Patch",
-        "*** Delete File: tmp.ts",
-        "*** End Patch",
-        "EOF",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-    });
-
-    it("normalizes Unicode spaces in paths", () => {
-      // \u00A0 = non-breaking space
-      const result = normalizeUnicodeSpaces("src/my\u00A0file.ts");
-      expect(result).toBe("src/my file.ts");
-
-      // \u2003 = em space
-      const result2 = normalizeUnicodeSpaces("src/my\u2003file.ts");
-      expect(result2).toBe("src/my file.ts");
-    });
-
-    it("parses multiple hunks in one patch", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Add File: a.ts",
-        "+a",
-        "*** Delete File: b.ts",
-        "*** Add File: c.ts",
-        "+c",
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(3);
-      expect(hunks[0]!.kind).toBe("add");
-      expect(hunks[1]!.kind).toBe("delete");
-      expect(hunks[2]!.kind).toBe("add");
-    });
-
-    it("handles empty @@ context marker", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Update File: src/main.ts",
-        "@@",
-        "-old",
-        "+new",
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      expect(hunks).toHaveLength(1);
-      if (hunks[0]!.kind === "update") {
-        expect(hunks[0]!.chunks[0]!.changeContext).toBeUndefined();
-      }
-    });
-
-    it("handles *** End of File marker", () => {
-      const input = [
-        "*** Begin Patch",
-        "*** Update File: src/main.ts",
-        "@@",
-        "-old line",
-        "+new line",
-        "*** End of File",
-        "*** End Patch",
-      ].join("\n");
-
-      const { hunks } = parsePatchText(input);
-      if (hunks[0]!.kind === "update") {
-        expect(hunks[0]!.chunks[0]!.isEndOfFile).toBe(true);
-      }
-    });
-
-    it("throws on invalid hunk header", () => {
-      const input = ["*** Begin Patch", "not a valid header", "*** End Patch"].join("\n");
-
-      expect(() => parsePatchText(input)).toThrow("not a valid hunk header");
-    });
-
-    it("throws on empty Update File hunk", () => {
-      const input = ["*** Begin Patch", "*** Update File: src/main.ts", "*** End Patch"].join("\n");
-
-      expect(() => parsePatchText(input)).toThrow("empty");
-    });
-  });
-
-  // ── Fuzzy Match ───────────────────────────────────────────────────────
-
-  describe("fuzzy-match", () => {
-    const mockReadFile = (content: string) => async (_path: string) => content;
-
-    it("matches exact lines (pass 1)", async () => {
-      const original = "line one\nline two\nline three\n";
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            oldLines: ["line two"],
-            newLines: ["line TWO replaced"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("line TWO replaced");
-      expect(result).not.toContain("line two");
-      expect(result).toContain("line one");
-      expect(result).toContain("line three");
-    });
-
-    it("matches trimmed trailing whitespace (pass 2)", async () => {
-      // Original has trailing spaces on "line two   "
-      const original = "line one\nline two   \nline three\n";
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            // Pattern has no trailing spaces
-            oldLines: ["line two"],
-            newLines: ["replaced"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("replaced");
-      expect(result).not.toContain("line two");
-    });
-
-    it("matches fully trimmed lines (pass 3)", async () => {
-      // Original has leading whitespace
-      const original = "  line one\n  line two\n  line three\n";
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            // Pattern without leading whitespace
-            oldLines: ["line two"],
-            newLines: ["replaced"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("replaced");
-    });
-
-    it("matches after Unicode punctuation normalization (pass 4)", async () => {
-      // \u201C and \u201D are "smart quotes"
-      const original = "const msg = \u201Chello world\u201D;\n";
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            oldLines: ['const msg = "hello world";'],
-            newLines: ['const msg = "goodbye world";'],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("goodbye world");
-    });
-
-    it("matches with Unicode dash normalization (pass 4)", async () => {
-      // \u2014 is em dash
-      const original = "value \u2014 default\n";
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            oldLines: ["value - default"],
-            newLines: ["value - override"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("override");
-    });
-
-    it("returns null when no match found", async () => {
-      const original = "line one\nline two\nline three\n";
-
-      await expect(
-        applyUpdateHunk(
-          "test.txt",
-          [
-            {
-              oldLines: ["completely nonexistent line"],
-              newLines: ["replaced"],
-              isEndOfFile: false,
-            },
-          ],
-          { readFile: mockReadFile(original) },
-        ),
-      ).rejects.toThrow("Failed to find expected lines");
-    });
-
-    it("applies hunks in reverse order to preserve line numbers", async () => {
-      const original = "line 1\nline 2\nline 3\nline 4\nline 5\n";
-
-      // Two replacements: one near start, one near end
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            oldLines: ["line 2"],
-            newLines: ["LINE TWO"],
-            isEndOfFile: false,
-          },
-          {
-            oldLines: ["line 4"],
-            newLines: ["LINE FOUR"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      const lines = result.split("\n");
-      expect(lines).toContain("LINE TWO");
-      expect(lines).toContain("LINE FOUR");
-      expect(lines).not.toContain("line 2");
-      expect(lines).not.toContain("line 4");
-    });
-
-    it("handles insertion with empty oldLines (append)", async () => {
-      const original = "existing content\n";
-
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            oldLines: [],
-            newLines: ["appended line"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("appended line");
-      expect(result).toContain("existing content");
-    });
-
-    it("handles changeContext to seek correct location", async () => {
-      const original = [
-        "function a() {",
-        "  return 1;",
-        "}",
-        "function b() {",
-        "  return 2;",
-        "}",
-        "",
-      ].join("\n");
-
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            changeContext: "function b() {",
-            oldLines: ["  return 2;"],
-            newLines: ["  return 42;"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result).toContain("return 42");
-      expect(result).toContain("return 1"); // function a untouched
-    });
-
-    it("ensures output ends with newline", async () => {
-      const original = "line one\nline two\n";
-
-      const result = await applyUpdateHunk(
-        "test.txt",
-        [
-          {
-            oldLines: ["line two"],
-            newLines: ["replaced"],
-            isEndOfFile: false,
-          },
-        ],
-        { readFile: mockReadFile(original) },
-      );
-
-      expect(result.endsWith("\n")).toBe(true);
-    });
-  });
-
-  // ── Sandbox Paths ─────────────────────────────────────────────────────
-
-  describe("sandbox-paths", () => {
-    it("rejects path traversal with ..", () => {
-      expect(() =>
-        resolveSandboxPath({
-          filePath: "../../../etc/passwd",
-          cwd: "/home/user/project",
-          root: "/home/user/project",
-        }),
-      ).toThrow("escapes sandbox root");
-    });
-
-    it("rejects absolute paths outside root", () => {
-      expect(() =>
-        resolveSandboxPath({
-          filePath: "/etc/passwd",
-          cwd: "/home/user/project",
-          root: "/home/user/project",
-        }),
-      ).toThrow("escapes sandbox root");
-    });
-
-    it("allows paths within cwd", () => {
-      const result = resolveSandboxPath({
-        filePath: "src/main.ts",
-        cwd: "/home/user/project",
-        root: "/home/user/project",
-      });
-
-      expect(result.resolved).toBe("/home/user/project/src/main.ts");
-      expect(result.relative).toBe("src/main.ts");
-    });
-
-    it("allows the root path itself", () => {
-      const result = resolveSandboxPath({
-        filePath: ".",
-        cwd: "/home/user/project",
-        root: "/home/user/project",
-      });
-
-      expect(result.resolved).toBe("/home/user/project");
-      expect(result.relative).toBe("");
-    });
-
-    it("expands ~ to homedir", () => {
-      const os = require("node:os");
-      const home = os.homedir();
-      const root = home;
-
-      const result = resolveSandboxPath({
-        filePath: "~/somefile.ts",
-        cwd: home,
-        root,
-      });
-
-      expect(result.resolved).toBe(`${home}/somefile.ts`);
-    });
-
-    it("normalizes Unicode spaces in paths", () => {
-      // resolveSandboxPath goes through expandPath which normalizes Unicode spaces
-      const result = resolveSandboxPath({
-        filePath: "src/my\u00A0file.ts",
-        cwd: "/home/user/project",
-        root: "/home/user/project",
-      });
-
-      expect(result.resolved).toBe("/home/user/project/src/my file.ts");
-    });
-
-    it("assertSandboxPath checks symlink escapes", async () => {
-      // For a path that doesn't exist yet, assertNoSymlinkEscape returns
-      // early with ENOENT — so it should succeed (no symlink to check)
-      const result = await assertSandboxPath({
-        filePath: "nonexistent/path.ts",
-        cwd: "/tmp",
-        root: "/tmp",
-      });
-
-      expect(result.resolved).toBe("/tmp/nonexistent/path.ts");
-    });
-
-    it("rejects relative path that escapes via multiple segments", () => {
-      expect(() =>
-        resolveSandboxPath({
-          filePath: "a/b/../../../../../../etc/passwd",
-          cwd: "/home/user/project",
-          root: "/home/user/project",
-        }),
-      ).toThrow("escapes sandbox root");
-    });
-  });
-});