"""Committed tests for blackcat file tools (stdlib unittest, no network).""" # retoor import os import stat import tempfile import unittest from blackcat.fstate import FileState, line_id, parse_line_id from blackcat.tools import FileTools class ToolCase(unittest.IsolatedAsyncioTestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() self.addCleanup(self.tmp.cleanup) self.root = os.path.join(self.tmp.name, "ws") os.mkdir(self.root) self.state = FileState(self.root) self.tools = FileTools(self.state) def write(self, name, data): path = os.path.join(self.root, name) mode = "wb" if isinstance(data, bytes) else "w" with open(path, mode) as fh: fh.write(data) return path def read_bytes(self, name): with open(os.path.join(self.root, name), "rb") as fh: return fh.read() class TestRead(ToolCase): async def test_window_and_nudge(self): self.write("f.txt", "l1\nl2\nl3\nl4\nl5\n") first = await self.tools.read("f.txt", limit=2) self.assertTrue(first["ok"]) self.assertEqual(first["shown"], 2) self.assertEqual(first["total_lines"], 5) self.assertTrue(first["truncated"]) self.assertIn("offset=3", first["nudge"]) second = await self.tools.read("f.txt", offset=3) self.assertFalse(second["truncated"]) self.assertIsNone(second["nudge"]) async def test_line_hash_format(self): self.write("f.txt", "hello\n") out = await self.tools.read("f.txt") self.assertTrue(out["ok"]) self.assertRegex(out["lines"][0], r"^1:[0-9a-f]{2}\|hello$") plain = await self.tools.read("f.txt", line_hashes=False) self.assertEqual(plain["lines"][0], "1|hello") async def test_missing_and_past_eof(self): self.assertFalse((await self.tools.read("nope.txt"))["ok"]) self.write("f.txt", "a\n") bad = await self.tools.read("f.txt", offset=9) self.assertFalse(bad["ok"]) self.assertIn("past end", bad["error"]) async def test_byte_gate_forces_paging(self): self.write("big.txt", ("x" * 3000 + "\n") * 100) whole = await self.tools.read("big.txt") self.assertFalse(whole["ok"]) self.assertEqual(whole["code"], "too_large") window = await self.tools.read("big.txt", offset=50, limit=10) self.assertTrue(window["ok"]) self.assertEqual(window["shown"], 10) async def test_binary_rejected(self): self.write("b.bin", b"\x00\x01\x02binary") out = await self.tools.read("b.bin") self.assertFalse(out["ok"]) self.assertIn("binary", out["error"]) class TestSecurity(ToolCase): async def test_escape_rejected(self): out = await self.tools.read("../outside.txt") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "security") out = await self.tools.write_file("/etc/blackcat-nope.txt", "x") self.assertEqual(out["code"], "security") async def test_symlink_escape_rejected(self): outside = os.path.join(self.tmp.name, "out.txt") with open(outside, "w") as fh: fh.write("secret") os.symlink(outside, os.path.join(self.root, "link.txt")) out = await self.tools.read("link.txt") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "security") async def test_write_disabled(self): self.write("f.txt", "a\n") ro = FileTools(FileState(self.root, write=False)) self.assertTrue((await ro.read("f.txt"))["ok"]) out = await ro.edit("f.txt", "a", "b") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "security") async def test_unsandboxed_allows_escape(self): outside = os.path.join(self.tmp.name, "out.txt") with open(outside, "w") as fh: fh.write("free\n") free = FileTools(FileState(self.root, sandbox=False)) self.assertFalse(free.state.sandboxed) self.assertTrue((await free.read("../out.txt"))["ok"]) out = await free.write_file("../new.txt", "made\n") self.assertTrue(out["ok"]) self.assertTrue(os.path.exists( os.path.join(self.tmp.name, "new.txt"))) async def test_filetools_sandbox_passthrough(self): self.assertTrue(FileTools(root=self.root).state.sandboxed) self.assertFalse( FileTools(root=self.root, sandbox=False).state.sandboxed) class TestReadBeforeWrite(ToolCase): async def test_edit_needs_read(self): self.write("f.txt", "a\n") out = await self.tools.edit("f.txt", "a", "b") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "must_read_first") self.assertTrue((await self.tools.read("f.txt"))["ok"]) out = await self.tools.edit("f.txt", "a", "b") self.assertTrue(out["ok"]) out = await self.tools.edit("f.txt", "b", "c") self.assertTrue(out["ok"]) self.assertEqual(self.read_bytes("f.txt"), b"c\n") async def test_stale_rejected_then_recovered(self): path = self.write("f.txt", "a\n") self.assertTrue((await self.tools.read("f.txt"))["ok"]) with open(path, "w") as fh: fh.write("externally changed\n") out = await self.tools.edit("f.txt", "a", "b") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "stale") self.assertTrue((await self.tools.read("f.txt"))["ok"]) out = await self.tools.edit("f.txt", "externally changed", "b") self.assertTrue(out["ok"]) async def test_mtime_touch_with_same_content_passes(self): path = self.write("f.txt", "a\n") self.assertTrue((await self.tools.read("f.txt"))["ok"]) st = os.stat(path) os.utime(path, (st.st_atime, st.st_mtime + 5)) out = await self.tools.edit("f.txt", "a", "b") self.assertTrue(out["ok"]) class TestEdit(ToolCase): async def test_exact_and_ranges(self): self.write("f.txt", "a\nb\nc\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "b", "B") self.assertTrue(out["ok"]) self.assertEqual(out["matched"], "exact") self.assertEqual(out["ranges"], [[2, 2]]) self.assertEqual(self.read_bytes("f.txt"), b"a\nB\nc\n") async def test_ambiguous_lists_locations(self): self.write("f.txt", "x = 1\ny = 2\nx = 1\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "x = 1", "x = 9") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "ambiguous") self.assertEqual(len(out["locations"]), 2) self.assertEqual(self.read_bytes("f.txt"), b"x = 1\ny = 2\nx = 1\n") async def test_replace_all(self): self.write("f.txt", "x = 1\ny = 2\nx = 1\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "x = 1", "x = 9", replace_all=True) self.assertTrue(out["ok"]) self.assertEqual(out["replacements"], 2) self.assertEqual(self.read_bytes("f.txt"), b"x = 9\ny = 2\nx = 9\n") async def test_no_match_suggests(self): self.write("f.txt", "def divide(a, b):\n return a / b\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "def divide(a, c):", "x") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "no_match") self.assertTrue(out["suggestions"]) async def test_escaped_literal_recovery(self): self.write("f.txt", "a\nb\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "a\\nb", "A\nB") self.assertTrue(out["ok"]) self.assertEqual(out["matched"], "escaped") self.assertIn("hint", out) self.assertEqual(self.read_bytes("f.txt"), b"A\nB\n") async def test_fuzzy_reindents(self): self.write("f.txt", " x = 1\n y = 2\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "x = 1\ny = 2", "x = 10\ny = 20") self.assertTrue(out["ok"]) self.assertEqual(out["matched"], "fuzzy") self.assertEqual(self.read_bytes("f.txt"), b" x = 10\n y = 20\n") async def test_tabs_vs_spaces_refused(self): before = b"\tx = 1\n" self.write("f.txt", before) await self.tools.read("f.txt") out = await self.tools.edit("f.txt", " x = 1", " x = 2") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "indent_mismatch") self.assertEqual(self.read_bytes("f.txt"), before) async def test_crlf_preserved(self): self.write("f.txt", b"a\r\nb\r\n") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "a", "A") self.assertTrue(out["ok"]) raw = self.read_bytes("f.txt") self.assertEqual(raw, b"A\r\nb\r\n") self.assertNotRegex(raw.decode("utf-8").replace("\r\n", ""), r"\n") async def test_mixed_endings_kept_per_line(self): self.write("f.txt", b"a\r\nb\nc") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "b", "B") self.assertTrue(out["ok"]) self.assertEqual(self.read_bytes("f.txt"), b"a\r\nB\nc") async def test_missing_trailing_newline_preserved(self): self.write("f.txt", b"a\nb") await self.tools.read("f.txt") out = await self.tools.edit("f.txt", "b", "B1\nB2") self.assertTrue(out["ok"]) self.assertEqual(self.read_bytes("f.txt"), b"a\nB1\nB2") async def test_mode_bits_preserved(self): path = self.write("f.txt", "a\n") os.chmod(path, 0o755) await self.tools.read("f.txt") await self.tools.edit("f.txt", "a", "b") self.assertTrue(os.stat(path).st_mode & stat.S_IXUSR) class TestMultiEdit(ToolCase): async def test_atomic_success_and_abort(self): self.write("f.txt", "a\nb\nc\n") await self.tools.read("f.txt") out = await self.tools.multi_edit("f.txt", [ {"old_string": "a", "new_string": "A"}, {"old_string": "b", "new_string": "B"}]) self.assertTrue(out["ok"]) self.assertEqual(out["edits"], 2) out = await self.tools.multi_edit("f.txt", [ {"old_string": "A", "new_string": "AA"}, {"old_string": "missing", "new_string": "x"}]) self.assertFalse(out["ok"]) self.assertEqual(out["edit_index"], 1) self.assertEqual(self.read_bytes("f.txt"), b"A\nB\nc\n") class TestWriteFile(ToolCase): async def test_create_and_overwrite(self): out = await self.tools.write_file("new.txt", "hi\n") self.assertTrue(out["ok"]) self.assertTrue(out["created"]) await self.tools.read("new.txt") out = await self.tools.write_file("new.txt", "bye\n") self.assertTrue(out["ok"]) self.assertFalse(out["created"]) self.assertEqual(self.read_bytes("new.txt"), b"bye\n") async def test_existing_needs_read(self): self.write("f.txt", "a\n") out = await self.tools.write_file("f.txt", "b\n") self.assertEqual(out["code"], "must_read_first") async def test_large_overwrite_capped(self): self.write("big.txt", "x\n" * 500) await self.tools.read("big.txt", limit=10) out = await self.tools.write_file("big.txt", "y\n") self.assertFalse(out["ok"]) self.assertEqual(out["code"], "too_large") out = await self.tools.write_file("big.txt", "y\n", force=True) self.assertTrue(out["ok"]) async def test_overwrite_takes_file_endings(self): self.write("f.txt", b"a\r\nb\r\n") await self.tools.read("f.txt") out = await self.tools.write_file("f.txt", "A\nB\n") self.assertTrue(out["ok"]) self.assertEqual(self.read_bytes("f.txt"), b"A\r\nB\r\n") class TestApplyPatch(ToolCase): async def test_update_and_add(self): self.write("calc.py", "def divide(a, b):\n return a / b\n") await self.tools.read("calc.py") patch = ("*** Begin Patch\n" "*** Update File: calc.py\n" "@@ divide\n" " def divide(a, b):\n" "- return a / b\n" "+ if b == 0:\n" "+ raise ZeroDivisionError\n" "+ return a / b\n" "*** End Patch\n") out = await self.tools.apply_patch(patch) self.assertTrue(out["ok"]) raw = self.read_bytes("calc.py").decode("utf-8") self.assertIn("ZeroDivisionError", raw) add = ("*** Begin Patch\n" "*** Add File: new.txt\n" "@@\n" "+hello\n" "+world\n" "*** End of File\n" "*** End Patch\n") out = await self.tools.apply_patch(add) self.assertTrue(out["ok"]) self.assertEqual(self.read_bytes("new.txt"), b"hello\nworld") async def test_overlap_refused_atomically(self): self.write("f.txt", "a\nb\nc\n") await self.tools.read("f.txt") patch = ("*** Begin Patch\n" "*** Update File: f.txt\n" "@@ first\n" " a\n" "-b\n" "+B\n" " c\n" "@@ overlap\n" " B\n" "-c\n" "+C\n" "*** End Patch\n") out = await self.tools.apply_patch(patch) self.assertFalse(out["ok"]) self.assertEqual(out["code"], "patch_refused") self.assertEqual(self.read_bytes("f.txt"), b"a\nb\nc\n") async def test_drift_refused(self): self.write("f.txt", "a\nb\nc\n") await self.tools.read("f.txt") patch = ("*** Begin Patch\n" "*** Update File: f.txt\n" "@@\n" " a\n" "-zzz\n" "+B\n" "*** End Patch\n") out = await self.tools.apply_patch(patch) self.assertFalse(out["ok"]) self.assertEqual(out["code"], "patch_refused") async def test_no_whitespace_fuzz(self): self.write("f.txt", b"\tx = 1\n") await self.tools.read("f.txt") patch = ("*** Begin Patch\n" "*** Update File: f.txt\n" "@@\n" "- x = 1\n" "+ x = 2\n" "*** End Patch\n") out = await self.tools.apply_patch(patch) self.assertFalse(out["ok"]) self.assertEqual(out["code"], "patch_refused") self.assertEqual(self.read_bytes("f.txt"), b"\tx = 1\n") async def test_crlf_patch_keeps_endings(self): self.write("f.txt", b"a\r\nb\r\n") await self.tools.read("f.txt") patch = ("*** Begin Patch\n" "*** Update File: f.txt\n" "@@\n" " a\n" "-b\n" "+B\n" "*** End Patch\n") out = await self.tools.apply_patch(patch) self.assertTrue(out["ok"]) self.assertEqual(self.read_bytes("f.txt"), b"a\r\nB\r\n") async def test_garbage_and_add_existing(self): out = await self.tools.apply_patch("hello") self.assertEqual(out["code"], "patch_parse") self.write("f.txt", "a\n") dup = ("*** Begin Patch\n*** Add File: f.txt\n@@\n+x\n" "*** End Patch\n") out = await self.tools.apply_patch(dup) self.assertEqual(out["code"], "patch_refused") class TestGrep(ToolCase): async def test_hits_and_truncation(self): self.write("a.txt", "needle here\nnothing\nneedle again\n") self.write("b.txt", "nothing\n") out = await self.tools.grep("needle", limit=10) self.assertTrue(out["ok"]) self.assertEqual(len(out["hits"]), 2) self.assertEqual(out["hits"][0]["line"], 1) self.assertFalse(out["truncated"]) out = await self.tools.grep("needle", limit=1) self.assertEqual(len(out["hits"]), 1) self.assertTrue(out["truncated"]) async def test_no_match_and_bad_regex(self): self.write("a.txt", "nothing\n") out = await self.tools.grep("needle") self.assertTrue(out["ok"]) self.assertEqual(out["hits"], []) out = await self.tools.grep("(unclosed") self.assertFalse(out["ok"]) class TestOutline(ToolCase): async def test_python_and_markdown(self): self.write("m.py", "class A:\n def m(self):\n pass\n\n" "def f(x):\n return x\n") out = await self.tools.outline("m.py") self.assertTrue(out["ok"]) names = [n["name"] for n in out["nodes"]] self.assertEqual(names, ["A", "A.m", "f"]) self.write("d.md", "# Title\n\n## Sub\n") out = await self.tools.outline("d.md") self.assertEqual([n["name"] for n in out["nodes"]], ["Title", "Sub"]) async def test_unsupported_and_syntax_error(self): self.write("f.txt", "hi\n") out = await self.tools.outline("f.txt") self.assertEqual(out["code"], "unsupported") self.write("bad.py", "def broken(:\n") out = await self.tools.outline("bad.py") self.assertEqual(out["code"], "parse") class TestLineIds(unittest.TestCase): async def test_format_and_verify(self): lid = line_id(42, "content") self.assertRegex(lid, r"^42:[0-9a-f]{2}$") self.assertEqual(parse_line_id(lid), (42, lid.split(":")[1])) self.assertIsNone(parse_line_id("nope")) ok = FileState.verify_line(2, line_id(2, "b").split(":")[1], ["a", "b", "c"]) self.assertEqual(ok["status"], "ok") moved_hash = line_id(2, "b").split(":")[1] stale = FileState.verify_line(2, moved_hash, ["a", "x", "b"]) self.assertEqual(stale["status"], "stale") self.assertEqual(stale["moved_to"], 3) if __name__ == "__main__": unittest.main()