"""Committed tests for blackcat file tools (stdlib unittest, no network)."""
# retoor <retoor@molodetz.nl>
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()