codeplain 0.3.11.dev20__py3-none-any.whl → 0.3.11.dev22__py3-none-any.whl

tests/test_agent_tools.py

@@ -1,166 +0,0 @@
-"""Tests for the client-side agent tool implementations."""
-
-import os
-from types import SimpleNamespace
-
-import pytest
-
-from render_machine import agent_tools
-from render_machine.render_context import RenderContext
-from render_machine.render_types import UnitTestsRunningContext
-
-
-class FakeRenderContext(SimpleNamespace):
-    unit_tests_agent_session = RenderContext.unit_tests_agent_session
-
-
-@pytest.fixture
-def project(tmp_path, monkeypatch):
-    build = tmp_path / "plain_modules" / "m"
-    build.mkdir(parents=True)
-    (build / "app.py").write_text("def add(a, b):\n    return a - b\n\n\ndef sub(a, b):\n    return a - b\n")
-    (tmp_path / "outside.txt").write_text("outside\n")
-    monkeypatch.chdir(tmp_path)
-    render_context = FakeRenderContext(
-        build_folder=str(build),
-        unit_tests_running_context=UnitTestsRunningContext(fix_attempts=1),
-        conformance_tests_running_context=None,
-        unittests_script=None,
-        test_script_timeout=None,
-        stop_event=None,
-    )
-    return SimpleNamespace(root=tmp_path, build=build, rc=render_context)
-
-
-def test_read_file_resolves_relative_to_build_folder_with_paging(project):
-    out = agent_tools.read_file({"file_path": "app.py", "offset": 2, "limit": 1}, project.rc)
-    assert out.startswith("2:     return a - b")
-    assert "use offset=3 to continue" in out
-
-
-def test_read_is_confined_to_build_folder(project):
-    outside = str(project.root / "outside.txt")
-    assert agent_tools.read_file({"file_path": outside}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.read_file({"file_path": "../../outside.txt"}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.grep({"pattern": "outside", "file_path": outside}, project.rc).startswith("Error: read access")
-    assert agent_tools.ls_files({"pattern": str(project.root)}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.read_file({"file_path": "/etc/hosts"}, project.rc).startswith("Error: read access denied")
-    assert agent_tools.read_file({"file_path": "missing.py"}, project.rc).startswith("Error: file not found")
-
-
-def test_edit_file_requires_unique_match_and_tracks_change(project):
-    ambiguous = agent_tools.edit_file({"file_path": "app.py", "search": "return a - b", "replace": "x"}, project.rc)
-    assert "found 2 times" in ambiguous
-    assert project.rc.unit_tests_running_context.changed_files == set()
-
-    ok = agent_tools.edit_file(
-        {
-            "file_path": "app.py",
-            "search": "def add(a, b):\n    return a - b",
-            "replace": "def add(a, b):\n    return a + b",
-        },
-        project.rc,
-    )
-    assert ok.startswith("Edited")
-    assert "return a + b" in (project.build / "app.py").read_text()
-    assert project.rc.unit_tests_running_context.changed_files == {"app.py"}
-
-
-def test_write_and_delete_are_confined_to_build_folder(project):
-    denied = agent_tools.write_file({"file_path": str(project.root / "evil.py"), "content": "x"}, project.rc)
-    assert denied.startswith("Error: write access denied")
-    assert not (project.root / "evil.py").exists()
-
-    assert agent_tools.write_file({"file_path": "pkg/new.py", "content": "print(1)\n"}, project.rc).startswith("Wrote")
-    assert (project.build / "pkg" / "new.py").read_text() == "print(1)\n"
-    assert agent_tools.delete_file({"file_path": "pkg/new.py"}, project.rc).startswith("Deleted")
-    assert not (project.build / "pkg" / "new.py").exists()
-    assert project.rc.unit_tests_running_context.changed_files == {os.path.join("pkg", "new.py")}
-
-
-def test_grep_and_ls(project):
-    hits = agent_tools.grep({"pattern": "def sub"}, project.rc)
-    assert hits == "app.py:5:def sub(a, b):"
-    assert agent_tools.grep({"pattern": "nope"}, project.rc).startswith("No matches")
-    assert agent_tools.grep({"pattern": ""}, project.rc).startswith("Error")
-
-    assert agent_tools.ls_files({}, project.rc).splitlines()[1:] == ["app.py"]
-    assert agent_tools.ls_files({"pattern": "**/*.py"}, project.rc).endswith("app.py")
-
-
-def test_execute_calls_answers_every_call_and_captures_errors(project, monkeypatch):
-    def boom(_args, _rc):
-        raise RuntimeError("kaput")
-
-    monkeypatch.setitem(agent_tools.TOOLS, "boom", boom)
-    results = agent_tools.execute_calls(
-        [
-            {"id": "1", "name": "read_file", "args": {"file_path": "app.py", "limit": 1}},
-            {"id": "2", "name": "unknown_tool", "args": {}},
-            {"id": "3", "name": "boom"},
-        ],
-        project.rc,
-    )
-    assert [r["call_id"] for r in results] == ["1", "2", "3"]
-    assert results[0]["output"].startswith("1: def add")
-    assert results[1]["output"] == "Error: unknown tool 'unknown_tool'."
-    assert results[2]["output"] == "Error: tool 'boom' failed: RuntimeError: kaput"
-
-
-def test_run_unit_tests_reports_pass_and_failure(project, monkeypatch):
-    log = project.root.parent / "log.txt"
-    log.write_text("FAILED test_x\nCaused by: boom\n")
-    outcomes = iter([(0, "", "/tmp/pass.txt"), (1, "FAILED test_x", str(log))])
-    monkeypatch.setattr(agent_tools.render_utils, "execute_script", lambda *a, **k: next(outcomes))
-    project.rc.unittests_script = "run_tests.sh"
-    context = project.rc.unit_tests_running_context
-
-    assert agent_tools.run_unit_tests({}, project.rc) == {"output": "All unit tests passed."}
-    assert context.verified_passing and context.verified_passing_log_path == "/tmp/pass.txt"
-
-    failure = agent_tools.run_unit_tests({}, project.rc)
-    assert failure["output"].startswith(f"Unit tests failed (exit code 1). Full log: {log}")
-    # raw output goes to the server for condensing, not truncated here
-    assert failure["test_output"] == "FAILED test_x"
-    # the full log is outside the build folder but greppable
-    assert agent_tools.grep({"pattern": "Caused by", "file_path": str(log)}, project.rc).endswith("Caused by: boom")
-
-
-def test_file_change_invalidates_verified_pass_and_read_cache(project):
-    context = project.rc.unit_tests_running_context
-    context.verified_passing = True
-    first = agent_tools.execute_calls([{"id": "1", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
-    repeat = agent_tools.execute_calls([{"id": "2", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
-    assert first[0]["output"].startswith("1: def add")
-    assert repeat[0]["output"].startswith("Same call as an earlier one")
-
-    agent_tools.write_file({"file_path": "other.py", "content": "y = 1\n"}, project.rc)
-    assert context.verified_passing is False
-    again = agent_tools.execute_calls([{"id": "3", "name": "read_file", "args": {"file_path": "app.py"}}], project.rc)
-    assert again[0]["output"].startswith("1: def add")
-
-
-def test_edit_file_returns_the_edited_region(project):
-    out = agent_tools.edit_file(
-        {
-            "file_path": "app.py",
-            "search": "def sub(a, b):\n    return a - b",
-            "replace": "def sub(a, b):\n    return b",
-        },
-        project.rc,
-    )
-    assert out.startswith("Edited") and "5: def sub(a, b):\n6:     return b" in out
-    assert "2:     return a - b" in out and "1: def add" not in out
-
-
-def test_grep_context_lines_and_include(project):
-    (project.build / "notes.txt").write_text("def sub is documented here\n")
-    hits = agent_tools.grep({"pattern": "def sub", "context_lines": 1, "include": "*.py"}, project.rc)
-    assert "notes.txt" not in hits
-    assert "app.py-4-" in hits and "app.py:5:def sub(a, b):" in hits and "app.py-6-" in hits
-
-
-def test_bound_truncates_long_lines_and_large_output():
-    bounded = agent_tools._bound("a" * (agent_tools.MAX_LINE_CHARS + 5) + "\n" + "b\n" * 40_000)
-    assert "[line truncated]" in bounded and "[truncated" in bounded
-    assert len(bounded) < agent_tools.MAX_OUTPUT_CHARS + 200

tests/test_fix_unit_tests_action.py

@@ -1,239 +0,0 @@
-"""Tests for the agentic FixUnitTests action driving a scripted fake API."""
-
-from types import SimpleNamespace
-
-import pytest
-import requests
-
-import plain_spec
-from render_machine.actions.fix_unit_tests import MAX_AGENT_TURNS_PER_ATTEMPT, MAX_RELEVANT_FILES_CHARS, FixUnitTests
-from render_machine.actions.run_unit_tests import RunUnitTests
-from render_machine.render_context import RenderContext
-from render_machine.render_types import ScriptExecutionHistory, UnitTestsRunningContext
-
-
-class FakeRenderContext(SimpleNamespace):
-    """A render context with just the attributes FixUnitTests uses, and the real session lookup."""
-
-    unit_tests_agent_session = RenderContext.unit_tests_agent_session
-
-
-class FakeAPI:
-    def __init__(self, responses):
-        self.responses = list(responses)
-        self.calls = []
-
-    def agent_start(self, task_type, task_params, frid, module_name, run_state):
-        self.calls.append(("start", task_type, task_params, frid, module_name))
-        return self.responses.pop(0)
-
-    def agent_continue(self, session_id, tool_results, frid, module_name, run_state):
-        self.calls.append(("continue", session_id, tool_results, frid, module_name))
-        response = self.responses.pop(0)
-        if isinstance(response, Exception):
-            raise response
-        return response
-
-
-def _tool_calls(*calls):
-    return {"session_id": "s1", "status": "tool_calls", "calls": list(calls)}
-
-
-@pytest.fixture
-def render_context(tmp_path, monkeypatch):
-    build = tmp_path / "build"
-    build.mkdir()
-    (build / "a.py").write_text("x = 1\n")
-    monkeypatch.chdir(tmp_path)
-    plain_source_tree = {"spec": True}
-    specifications = {
-        plain_spec.DEFINITIONS: ["- :Foo: is a thing."],
-        plain_spec.NON_FUNCTIONAL_REQUIREMENTS: ["- Python 3.11."],
-        plain_spec.FUNCTIONAL_REQUIREMENTS: ["- Old feature.", "- New feature."],
-    }
-    monkeypatch.setattr(plain_spec, "get_specifications_for_frid", lambda tree, frid: (specifications, None))
-    return FakeRenderContext(
-        codeplain_api=None,
-        build_folder=str(build),
-        module_name="m",
-        run_state=object(),
-        plain_source_tree=plain_source_tree,
-        unittests_script=None,
-        test_script_timeout=None,
-        stop_event=None,
-        frid_context=SimpleNamespace(frid="2", linked_resources={"schema.json": "{}"}, changed_files={"a.py"}),
-        unit_tests_running_context=UnitTestsRunningContext(fix_attempts=1),
-        conformance_tests_running_context=None,
-        script_execution_history=ScriptExecutionHistory(),
-        get_required_modules_functionalities=lambda: {"base": ["- Base feature."]},
-    )
-
-
-def test_first_attempt_starts_session_runs_tools_and_stops_at_submit_fix(render_context):
-    api = FakeAPI(
-        [
-            _tool_calls({"id": "c1", "name": "read_file", "args": {"file_path": "a.py"}}),
-            _tool_calls(
-                {"id": "c2", "name": "edit_file", "args": {"file_path": "a.py", "search": "x = 1", "replace": "x = 2"}},
-                {"id": "c3", "name": "submit_fix", "args": {"root_cause": "off by one", "changes_made": "x = 2"}},
-            ),
-        ]
-    )
-    render_context.codeplain_api = api
-
-    outcome, payload = FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED test_a"})
-
-    assert (outcome, payload) == (FixUnitTests.SUCCESSFUL_OUTCOME, None)
-    kind, task_type, task_params, frid, module_name = api.calls[0]
-    assert (kind, task_type, frid, module_name) == ("start", "fix_unit_tests", "2", "m")
-    assert task_params["unittests_issue"] == "FAILED test_a"
-    assert task_params["definitions"] == "- :Foo: is a thing."
-    assert task_params["linked_resources"] == {"schema.json": "{}"}
-    assert (
-        "### Module: base (Already Implemented, for context)\n- Base feature." in task_params["functional_requirements"]
-    )
-    assert "### Module: m (Already Implemented, for context)\n- Old feature." in task_params["functional_requirements"]
-    assert task_params["functional_requirements"].endswith(
-        "### Module: m (Currently Being Implemented)\n- New feature."
-    )
-
-    # the read_file result went back to the server; the edit was applied locally
-    assert api.calls[1][0] == "continue" and api.calls[1][2][0]["call_id"] == "c1"
-    assert "1: x = 1" in api.calls[1][2][0]["output"]
-    assert open(render_context.build_folder + "/a.py").read() == "x = 2\n"
-
-    context = render_context.unit_tests_running_context
-    session = context.agent_session
-    assert session.session_id == "s1"
-    assert session.pending_submit_call_id == "c3"
-    assert [r["call_id"] for r in session.pending_tool_results] == ["c2"]
-    assert context.changed_files == {"a.py"}
-    assert "conformance_tests_fixes" not in task_params
-
-
-def test_second_attempt_continues_session_answering_submit_fix(render_context):
-    context = render_context.unit_tests_running_context
-    context.agent_used_in_this_loop = True
-    session = context.agent_session
-    session.session_id = "s1"
-    session.pending_submit_call_id = "c3"
-    session.pending_tool_results = [{"call_id": "c2", "output": "Edited"}]
-    api = FakeAPI([_tool_calls({"id": "c4", "name": "submit_fix", "args": {"changes_made": "again"}})])
-    render_context.codeplain_api = api
-
-    outcome, _ = FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED test_b"})
-
-    assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
-    kind, session_id, tool_results, frid, module_name = api.calls[0]
-    assert (kind, session_id, frid, module_name) == ("continue", "s1", "2", "m")
-    assert tool_results[0] == {"call_id": "c2", "output": "Edited"}
-    assert tool_results[1]["call_id"] == "c3" and "still fail" in tool_results[1]["output"]
-    assert tool_results[1]["test_output"] == "FAILED test_b"
-    assert "conformance_tests_fixes" not in tool_results[1]
-    assert session.session_id == "s1" and session.pending_submit_call_id == "c4"
-    assert session.pending_tool_results == []
-
-
-@pytest.mark.parametrize(
-    "final_response",
-    [
-        {"session_id": "s1", "status": "completed", "result": "done"},
-        {"session_id": "s1", "status": "failed", "error": "x"},
-    ],
-)
-def test_session_ending_without_submission_resets_the_session(render_context, final_response):
-    render_context.codeplain_api = FakeAPI([final_response])
-    outcome, _ = FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED"})
-    assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
-    session = render_context.unit_tests_running_context.agent_session
-    assert session.session_id is None and session.pending_submit_call_id is None
-
-
-def test_turn_cap_per_attempt_resets_the_session(render_context):
-    call = {"id": "c", "name": "ls_files", "args": {}}
-    render_context.codeplain_api = FakeAPI([_tool_calls(call)] * (MAX_AGENT_TURNS_PER_ATTEMPT + 1))
-    FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED"})
-    assert len(render_context.codeplain_api.calls) == MAX_AGENT_TURNS_PER_ATTEMPT + 1
-    assert render_context.unit_tests_running_context.agent_session.session_id is None
-
-
-def test_missing_issue_is_an_internal_error(render_context):
-    from plain2code_exceptions import InternalClientError
-
-    with pytest.raises(InternalClientError):
-        FixUnitTests().execute(render_context, {})
-
-
-def test_first_turn_is_seeded_with_file_tree_relevant_files_and_log_path(render_context, tmp_path):
-    (tmp_path / "build" / "tests").mkdir()
-    (tmp_path / "build" / "tests" / "test_a.py").write_text("assert True\n")
-    log = tmp_path / "unit.log"
-    log.write_text("full log\nCaused by: boom\n")
-    render_context.script_execution_history.latest_unit_test_output_path = str(log)
-    api = FakeAPI([{"session_id": "s1", "status": "completed", "result": "done"}])
-    render_context.codeplain_api = api
-
-    FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED"})
-
-    task_params = api.calls[0][2]
-    assert task_params["file_tree"].split("\n") == ["a.py", "tests/test_a.py"]
-    assert task_params["relevant_files"] == {"a.py": "x = 1\n"}
-    assert task_params["unittests_log_path"] == str(log)
-    assert "previous_session_id" not in task_params
-    # the agent may grep the full log although it is outside the build folder and project root
-    assert str(log) in render_context.unit_tests_running_context.agent_session.readable_log_paths
-
-
-def test_relevant_files_stay_within_budget(tmp_path):
-    (tmp_path / "small.py").write_text("s")
-    (tmp_path / "big.py").write_text("b" * MAX_RELEVANT_FILES_CHARS)
-    assert FixUnitTests._relevant_files(str(tmp_path), {"small.py", "big.py", "deleted.py"}) == {"small.py": "s"}
-
-
-def test_new_session_after_abandoned_one_references_it(render_context):
-    call = {"id": "c", "name": "ls_files", "args": {}}
-    render_context.codeplain_api = FakeAPI([_tool_calls(call)] * (MAX_AGENT_TURNS_PER_ATTEMPT + 1))
-    FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED"})
-    assert render_context.unit_tests_running_context.agent_session.previous_session_id == "s1"
-
-    api = FakeAPI([{"session_id": "s2", "status": "completed", "result": "done"}])
-    render_context.codeplain_api = api
-    FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED again"})
-    assert api.calls[0][0] == "start" and api.calls[0][2]["previous_session_id"] == "s1"
-
-
-def test_run_unit_tests_action_skips_the_suite_after_a_verified_agent_run(render_context, monkeypatch):
-    import render_machine.render_utils as render_utils
-
-    context = render_context.unit_tests_running_context
-    context.verified_passing, context.verified_passing_log_path = True, "/logs/pass.log"
-    monkeypatch.setattr(render_utils, "execute_script", lambda *a, **k: pytest.fail("suite must not run"))
-
-    assert RunUnitTests().execute(render_context, None) == (RunUnitTests.SUCCESSFUL_OUTCOME, None)
-    assert context.verified_passing is False
-    assert render_context.script_execution_history.latest_unit_test_output_path == "/logs/pass.log"
-
-
-def test_expired_session_is_replaced_by_a_new_one(render_context):
-    context = render_context.unit_tests_running_context
-    context.agent_used_in_this_loop = True
-    session = context.agent_session
-    session.session_id, session.pending_submit_call_id = "expired", "c3"
-    not_found = requests.exceptions.HTTPError(response=SimpleNamespace(status_code=404))
-    api = FakeAPI([not_found, {"session_id": "s2", "status": "completed", "result": "done"}])
-    render_context.codeplain_api = api
-
-    outcome, _ = FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED test_b"})
-
-    assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
-    assert [call[0] for call in api.calls] == ["continue", "start"]
-    assert api.calls[1][2]["unittests_issue"] == "FAILED test_b"
-
-
-def test_other_http_errors_on_continue_are_not_swallowed(render_context):
-    context = render_context.unit_tests_running_context
-    context.agent_used_in_this_loop = True
-    context.agent_session.session_id, context.agent_session.pending_submit_call_id = "s1", "c3"
-    render_context.codeplain_api = FakeAPI([requests.exceptions.HTTPError(response=SimpleNamespace(status_code=500))])
-    with pytest.raises(requests.exceptions.HTTPError):
-        FixUnitTests().execute(render_context, {"previous_unittests_issue": "FAILED"})