Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/tools/test_search_giant_line_containment.py

@@ -0,0 +1,100 @@
+"""Giant single-line file containment in content search (cline/cline#13525 port).
+
+A match inside a serialized dump (multi-MB single-line JSON, minified
+bundle) used to make rg/grep emit the ENTIRE matched line into stdout:
+``head -n`` counts lines, so a 40MB match line crossed the transport
+untruncated and was buffered whole into Python before the per-match
+[:500] clamp ran (measured 42MB transport / ~180MB peak alloc for one
+match). The fix bounds lines at the search-engine layer: rg gets
+``--max-columns 2000 --max-columns-preview``; the grep fallbacks pipe
+through ``cut -c1-2000``.
+
+These tests run the REAL pipelines via bash (no mocked stdout) so the
+flag/pipe behavior of the installed rg/grep is what's exercised.
+"""
+
+import os
+import shutil
+import subprocess
+
+import pytest
+
+from tools.file_operations import ShellFileOperations
+
+# Big enough to prove containment, small enough to keep the test fast.
+GIANT = 5 * 1024 * 1024  # 5MB single line
+# Generous ceiling: pre-fix stdout for one giant match is >= GIANT bytes.
+STDOUT_CEILING = 1 * 1024 * 1024
+
+
+class RecordingEnv:
+    """Local bash executor that records the largest stdout it returned."""
+
+    def __init__(self, cwd):
+        self.cwd = cwd
+        self.max_stdout = 0
+
+    def execute(self, command, timeout=60, **kwargs):
+        proc = subprocess.run(
+            ["bash", "-c", command],
+            capture_output=True, text=True, errors="replace",
+            timeout=timeout + 30,
+        )
+        out = proc.stdout + (proc.stderr or "")
+        self.max_stdout = max(self.max_stdout, len(out))
+        return {"output": out, "returncode": proc.returncode}
+
+
+@pytest.fixture()
+def giant_dir(tmp_path):
+    (tmp_path / "trace.json").write_text(
+        '{"needle": "' + "x" * GIANT + '"}', encoding="utf-8"
+    )
+    (tmp_path / "small.py").write_text("needle = 1\n", encoding="utf-8")
+    return tmp_path
+
+
+def _ops(giant_dir, engine):
+    env = RecordingEnv(str(giant_dir))
+    ops = ShellFileOperations(env)
+    ops._has_command = lambda cmd: cmd == engine
+    return ops, env
+
+
+@pytest.mark.parametrize("engine", ["rg", "grep"])
+def test_giant_single_line_match_is_bounded(giant_dir, engine):
+    if shutil.which(engine) is None:
+        pytest.skip(f"{engine} not installed")
+    ops, env = _ops(giant_dir, engine)
+
+    result = ops.search("needle", path=str(giant_dir), target="content")
+
+    assert result.error is None
+    paths = {os.path.basename(m.path) for m in result.matches}
+    # The giant-file match must still be REPORTED (preview, not omission)...
+    assert paths == {"trace.json", "small.py"}
+    assert all(len(m.content) <= 500 for m in result.matches)
+    # ...but its full line must never have crossed the transport.
+    assert env.max_stdout < STDOUT_CEILING, (
+        f"{engine} pipeline returned {env.max_stdout} bytes of stdout — "
+        "giant matched line was not truncated at the engine layer"
+    )
+
+
+@pytest.mark.parametrize("engine", ["rg", "grep"])
+@pytest.mark.parametrize("output_mode", ["files_only", "count"])
+def test_line_cap_skipped_for_path_and_count_modes(giant_dir, engine, output_mode):
+    """files_only/count lines are paths/counts — never giant, never cut."""
+    if shutil.which(engine) is None:
+        pytest.skip(f"{engine} not installed")
+    ops, env = _ops(giant_dir, engine)
+
+    result = ops.search("needle", path=str(giant_dir), target="content",
+                        output_mode=output_mode)
+
+    assert result.error is None
+    if output_mode == "files_only":
+        assert {os.path.basename(f) for f in result.files} == {"trace.json", "small.py"}
+    else:
+        assert {os.path.basename(k) for k in result.counts} == {"trace.json", "small.py"}
+    assert env.max_stdout < STDOUT_CEILING