Skip to content
Repos

blackcat

Python 17.8 KB459 lines Opens in site

Directory Raw Download

"""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()
30.7ms