753 lines
30 KiB
Python
753 lines
30 KiB
Python
"""Tests for agents/runner.py — agent execution with mocked claude CLI."""
|
||
|
||
import json
|
||
import subprocess
|
||
import pytest
|
||
from unittest.mock import patch, MagicMock
|
||
from core.db import init_db
|
||
from core import models
|
||
from agents.runner import run_agent, run_pipeline, run_audit, _try_parse_json
|
||
|
||
|
||
@pytest.fixture
|
||
def conn():
|
||
c = init_db(":memory:")
|
||
models.create_project(c, "vdol", "ВДОЛЬ", "~/projects/vdolipoperek",
|
||
tech_stack=["vue3"])
|
||
models.create_task(c, "VDOL-001", "vdol", "Fix bug",
|
||
brief={"route_type": "debug"})
|
||
yield c
|
||
c.close()
|
||
|
||
|
||
def _mock_claude_success(output_data):
|
||
"""Create a mock subprocess result with successful claude output."""
|
||
mock = MagicMock()
|
||
mock.stdout = json.dumps(output_data) if isinstance(output_data, dict) else output_data
|
||
mock.stderr = ""
|
||
mock.returncode = 0
|
||
return mock
|
||
|
||
|
||
def _mock_claude_failure(error_msg):
|
||
mock = MagicMock()
|
||
mock.stdout = ""
|
||
mock.stderr = error_msg
|
||
mock.returncode = 1
|
||
return mock
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# run_agent
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestRunAgent:
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_successful_agent_run(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": "Found race condition in useSearch.ts",
|
||
"usage": {"total_tokens": 5000},
|
||
"cost_usd": 0.015,
|
||
})
|
||
|
||
result = run_agent(conn, "debugger", "VDOL-001", "vdol")
|
||
|
||
assert result["success"] is True
|
||
assert result["role"] == "debugger"
|
||
assert result["model"] == "sonnet"
|
||
assert result["duration_seconds"] >= 0
|
||
|
||
# Verify claude was called with right args
|
||
call_args = mock_run.call_args
|
||
cmd = call_args[0][0]
|
||
assert "claude" in cmd[0]
|
||
assert "-p" in cmd
|
||
assert "--output-format" in cmd
|
||
assert "json" in cmd
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_failed_agent_run(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_failure("API error")
|
||
|
||
result = run_agent(conn, "debugger", "VDOL-001", "vdol")
|
||
|
||
assert result["success"] is False
|
||
|
||
# Should be logged in agent_logs
|
||
logs = conn.execute("SELECT * FROM agent_logs WHERE task_id='VDOL-001'").fetchall()
|
||
assert len(logs) == 1
|
||
assert logs[0]["success"] == 0
|
||
|
||
def test_dry_run_returns_prompt(self, conn):
|
||
result = run_agent(conn, "debugger", "VDOL-001", "vdol", dry_run=True)
|
||
|
||
assert result["dry_run"] is True
|
||
assert result["prompt"] is not None
|
||
assert "VDOL-001" in result["prompt"]
|
||
assert result["output"] is None
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_agent_logs_to_db(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
|
||
run_agent(conn, "tester", "VDOL-001", "vdol")
|
||
|
||
logs = conn.execute("SELECT * FROM agent_logs WHERE agent_role='tester'").fetchall()
|
||
assert len(logs) == 1
|
||
assert logs[0]["project_id"] == "vdol"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_full_output_saved_to_db(self, mock_run, conn):
|
||
"""Bug fix: output_summary must contain the FULL output, not truncated."""
|
||
long_json = json.dumps({
|
||
"result": json.dumps({
|
||
"summary": "Security audit complete",
|
||
"findings": [{"title": f"Finding {i}", "severity": "HIGH"} for i in range(50)],
|
||
}),
|
||
})
|
||
mock = MagicMock()
|
||
mock.stdout = long_json
|
||
mock.stderr = ""
|
||
mock.returncode = 0
|
||
mock_run.return_value = mock
|
||
|
||
run_agent(conn, "security", "VDOL-001", "vdol")
|
||
|
||
logs = conn.execute("SELECT output_summary FROM agent_logs WHERE agent_role='security'").fetchall()
|
||
assert len(logs) == 1
|
||
output = logs[0]["output_summary"]
|
||
assert output is not None
|
||
assert len(output) > 1000 # Must not be truncated
|
||
# Should contain all 50 findings
|
||
assert "Finding 49" in output
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_dict_output_saved_as_json_string(self, mock_run, conn):
|
||
"""When claude returns structured JSON, it must be saved as string."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": {"status": "ok", "files": ["a.py", "b.py"]},
|
||
})
|
||
|
||
result = run_agent(conn, "debugger", "VDOL-001", "vdol")
|
||
|
||
# output should be a string (JSON serialized), not a dict
|
||
assert isinstance(result["raw_output"], str)
|
||
|
||
logs = conn.execute("SELECT output_summary FROM agent_logs WHERE agent_role='debugger'").fetchall()
|
||
saved = logs[0]["output_summary"]
|
||
assert isinstance(saved, str)
|
||
assert "a.py" in saved
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_previous_output_passed(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "tests pass"})
|
||
|
||
run_agent(conn, "tester", "VDOL-001", "vdol",
|
||
previous_output="Found bug in line 42")
|
||
|
||
call_args = mock_run.call_args
|
||
prompt = call_args[0][0][2] # -p argument
|
||
assert "line 42" in prompt
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# run_pipeline
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestRunPipeline:
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_successful_pipeline(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
|
||
steps = [
|
||
{"role": "debugger", "brief": "find bug"},
|
||
{"role": "tester", "depends_on": "debugger", "brief": "verify"},
|
||
]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
assert result["steps_completed"] == 2
|
||
assert len(result["results"]) == 2
|
||
|
||
# Pipeline created in DB
|
||
pipe = conn.execute("SELECT * FROM pipelines WHERE task_id='VDOL-001'").fetchone()
|
||
assert pipe is not None
|
||
assert pipe["status"] == "completed"
|
||
|
||
# Task updated to review
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "review"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_pipeline_fails_on_step(self, mock_run, conn):
|
||
# First step succeeds, second fails
|
||
mock_run.side_effect = [
|
||
_mock_claude_success({"result": "found bug"}),
|
||
_mock_claude_failure("compilation error"),
|
||
]
|
||
|
||
steps = [
|
||
{"role": "debugger", "brief": "find"},
|
||
{"role": "frontend_dev", "brief": "fix"},
|
||
{"role": "tester", "brief": "test"},
|
||
]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is False
|
||
assert result["steps_completed"] == 1 # Only debugger completed
|
||
assert "frontend_dev" in result["error"]
|
||
|
||
# Pipeline marked as failed
|
||
pipe = conn.execute("SELECT * FROM pipelines WHERE task_id='VDOL-001'").fetchone()
|
||
assert pipe["status"] == "failed"
|
||
|
||
# Task marked as blocked
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "blocked"
|
||
|
||
def test_pipeline_dry_run(self, conn):
|
||
steps = [
|
||
{"role": "debugger", "brief": "find"},
|
||
{"role": "tester", "brief": "verify"},
|
||
]
|
||
result = run_pipeline(conn, "VDOL-001", steps, dry_run=True)
|
||
|
||
assert result["dry_run"] is True
|
||
assert result["success"] is True
|
||
assert result["steps_completed"] == 2
|
||
|
||
# No pipeline created in DB
|
||
pipes = conn.execute("SELECT * FROM pipelines").fetchall()
|
||
assert len(pipes) == 0
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_pipeline_chains_output(self, mock_run, conn):
|
||
"""Output from step N is passed as previous_output to step N+1."""
|
||
call_count = [0]
|
||
|
||
def side_effect(*args, **kwargs):
|
||
call_count[0] += 1
|
||
if call_count[0] == 1:
|
||
return _mock_claude_success({"result": "bug is in line 42"})
|
||
return _mock_claude_success({"result": "test written"})
|
||
|
||
mock_run.side_effect = side_effect
|
||
|
||
steps = [
|
||
{"role": "debugger", "brief": "find"},
|
||
{"role": "tester", "brief": "write test"},
|
||
]
|
||
run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
# Second call should include first step's output in prompt
|
||
second_call = mock_run.call_args_list[1]
|
||
prompt = second_call[0][0][2] # -p argument
|
||
assert "line 42" in prompt or "bug" in prompt
|
||
|
||
def test_pipeline_task_not_found(self, conn):
|
||
result = run_pipeline(conn, "NONEXISTENT", [{"role": "debugger"}])
|
||
assert result["success"] is False
|
||
assert "not found" in result["error"]
|
||
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_hooks_called_after_successful_pipeline(self, mock_run, mock_hooks, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.return_value = []
|
||
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
mock_hooks.assert_called_once()
|
||
call_kwargs = mock_hooks.call_args
|
||
assert call_kwargs[1].get("event") == "pipeline_completed" or \
|
||
call_kwargs[0][3] == "pipeline_completed"
|
||
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_hooks_not_called_on_failed_pipeline(self, mock_run, mock_hooks, conn):
|
||
mock_run.return_value = _mock_claude_failure("compilation error")
|
||
mock_hooks.return_value = []
|
||
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is False
|
||
mock_hooks.assert_not_called()
|
||
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_hook_failure_does_not_affect_pipeline_result(self, mock_run, mock_hooks, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.side_effect = Exception("hook exploded")
|
||
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
# Must not raise — hook failures must not propagate
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Auto mode
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestAutoMode:
|
||
@patch("core.followup.generate_followups")
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_auto_mode_generates_followups(self, mock_run, mock_hooks, mock_followup, conn):
|
||
"""Auto mode должен вызывать generate_followups после task_auto_approved."""
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.return_value = []
|
||
mock_followup.return_value = {"created": [], "pending_actions": []}
|
||
|
||
models.update_project(conn, "vdol", execution_mode="auto")
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
mock_followup.assert_called_once_with(conn, "VDOL-001")
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "done"
|
||
|
||
@patch("core.followup.generate_followups")
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_review_mode_skips_followups(self, mock_run, mock_hooks, mock_followup, conn):
|
||
"""Review mode НЕ должен вызывать generate_followups автоматически."""
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.return_value = []
|
||
mock_followup.return_value = {"created": [], "pending_actions": []}
|
||
|
||
# Проект остаётся в default "review" mode
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
mock_followup.assert_not_called()
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "review"
|
||
|
||
@patch("core.followup.generate_followups")
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_auto_mode_skips_followups_for_followup_tasks(self, mock_run, mock_hooks, mock_followup, conn):
|
||
"""Auto mode НЕ должен генерировать followups для followup-задач (предотвращение рекурсии)."""
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.return_value = []
|
||
mock_followup.return_value = {"created": [], "pending_actions": []}
|
||
|
||
models.update_project(conn, "vdol", execution_mode="auto")
|
||
models.update_task(conn, "VDOL-001", brief={"source": "followup:VDOL-000"})
|
||
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
mock_followup.assert_not_called()
|
||
|
||
@patch("core.followup.generate_followups")
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_auto_mode_fires_task_done_event(self, mock_run, mock_hooks, mock_followup, conn):
|
||
"""Auto mode должен вызывать run_hooks с event='task_done' после task_auto_approved."""
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.return_value = []
|
||
mock_followup.return_value = {"created": [], "pending_actions": []}
|
||
|
||
models.update_project(conn, "vdol", execution_mode="auto")
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
events_fired = [call[1].get("event") or call[0][3]
|
||
for call in mock_hooks.call_args_list]
|
||
assert "task_done" in events_fired
|
||
|
||
@patch("core.followup.auto_resolve_pending_actions")
|
||
@patch("core.followup.generate_followups")
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_auto_mode_resolves_pending_actions(self, mock_run, mock_hooks, mock_followup, mock_resolve, conn):
|
||
"""Auto mode должен авто-резолвить pending_actions из followup generation."""
|
||
mock_run.return_value = _mock_claude_success({"result": "done"})
|
||
mock_hooks.return_value = []
|
||
|
||
pending = [{"type": "permission_fix", "description": "Fix X",
|
||
"original_item": {}, "options": ["rerun"]}]
|
||
mock_followup.return_value = {"created": [], "pending_actions": pending}
|
||
mock_resolve.return_value = [{"resolved": "rerun", "result": {}}]
|
||
|
||
models.update_project(conn, "vdol", execution_mode="auto")
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
mock_resolve.assert_called_once_with(conn, "VDOL-001", pending)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Retry on permission error
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestRetryOnPermissionError:
|
||
@patch("core.followup.generate_followups")
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_retry_on_permission_error_auto_mode(self, mock_run, mock_hooks, mock_followup, conn):
|
||
"""Auto mode: retry при permission error должен срабатывать."""
|
||
permission_fail = _mock_claude_failure("permission denied: cannot write file")
|
||
retry_success = _mock_claude_success({"result": "fixed"})
|
||
|
||
mock_run.side_effect = [permission_fail, retry_success]
|
||
mock_hooks.return_value = []
|
||
mock_followup.return_value = {"created": [], "pending_actions": []}
|
||
|
||
models.update_project(conn, "vdol", execution_mode="auto")
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is True
|
||
assert mock_run.call_count == 2
|
||
# Second call must include --dangerously-skip-permissions
|
||
second_cmd = mock_run.call_args_list[1][0][0]
|
||
assert "--dangerously-skip-permissions" in second_cmd
|
||
|
||
@patch("agents.runner.run_hooks")
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_review_mode_does_not_retry_on_permission_error(self, mock_run, mock_hooks, conn):
|
||
"""Review mode: retry при permission error НЕ должен срабатывать."""
|
||
permission_fail = _mock_claude_failure("permission denied: cannot write file")
|
||
|
||
mock_run.return_value = permission_fail
|
||
mock_hooks.return_value = []
|
||
|
||
# Проект остаётся в default "review" mode
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is False
|
||
assert mock_run.call_count == 1
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# JSON parsing
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestTryParseJson:
|
||
def test_direct_json(self):
|
||
assert _try_parse_json('{"a": 1}') == {"a": 1}
|
||
|
||
def test_json_in_code_fence(self):
|
||
text = 'Some text\n```json\n{"a": 1}\n```\nMore text'
|
||
assert _try_parse_json(text) == {"a": 1}
|
||
|
||
def test_json_embedded_in_text(self):
|
||
text = 'Here is the result: {"status": "ok", "count": 42} and more'
|
||
result = _try_parse_json(text)
|
||
assert result == {"status": "ok", "count": 42}
|
||
|
||
def test_empty_string(self):
|
||
assert _try_parse_json("") is None
|
||
|
||
def test_no_json(self):
|
||
assert _try_parse_json("just plain text") is None
|
||
|
||
def test_json_array(self):
|
||
assert _try_parse_json('[1, 2, 3]') == [1, 2, 3]
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Non-interactive mode
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestNonInteractive:
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_noninteractive_sets_stdin_devnull(self, mock_run, conn):
|
||
"""When noninteractive=True, subprocess.run should get stdin=subprocess.DEVNULL."""
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", noninteractive=True)
|
||
call_kwargs = mock_run.call_args[1]
|
||
assert call_kwargs.get("stdin") == subprocess.DEVNULL
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_noninteractive_uses_300s_timeout(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", noninteractive=True)
|
||
call_kwargs = mock_run.call_args[1]
|
||
assert call_kwargs.get("timeout") == 300
|
||
|
||
@patch.dict("os.environ", {"KIN_NONINTERACTIVE": ""})
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_interactive_uses_600s_timeout(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", noninteractive=False)
|
||
call_kwargs = mock_run.call_args[1]
|
||
assert call_kwargs.get("timeout") == 600
|
||
|
||
@patch.dict("os.environ", {"KIN_NONINTERACTIVE": ""})
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_interactive_no_stdin_override(self, mock_run, conn):
|
||
"""In interactive mode, stdin should not be set to DEVNULL."""
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", noninteractive=False)
|
||
call_kwargs = mock_run.call_args[1]
|
||
assert call_kwargs.get("stdin") is None
|
||
|
||
@patch.dict("os.environ", {"KIN_NONINTERACTIVE": "1"})
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_env_var_activates_noninteractive(self, mock_run, conn):
|
||
"""KIN_NONINTERACTIVE=1 env var should activate non-interactive mode."""
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", noninteractive=False)
|
||
call_kwargs = mock_run.call_args[1]
|
||
assert call_kwargs.get("stdin") == subprocess.DEVNULL
|
||
assert call_kwargs.get("timeout") == 300
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_allow_write_adds_skip_permissions(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", allow_write=True)
|
||
cmd = mock_run.call_args[0][0]
|
||
assert "--dangerously-skip-permissions" in cmd
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_no_allow_write_no_skip_permissions(self, mock_run, conn):
|
||
mock_run.return_value = _mock_claude_success({"result": "ok"})
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol", allow_write=False)
|
||
cmd = mock_run.call_args[0][0]
|
||
assert "--dangerously-skip-permissions" not in cmd
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# run_audit
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestRunAudit:
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_success(self, mock_run, conn):
|
||
"""Audit should return parsed already_done/still_pending/unclear."""
|
||
audit_output = json.dumps({
|
||
"already_done": [{"id": "VDOL-001", "reason": "Fixed in runner.py"}],
|
||
"still_pending": [],
|
||
"unclear": [],
|
||
})
|
||
mock_run.return_value = _mock_claude_success({"result": audit_output})
|
||
|
||
result = run_audit(conn, "vdol")
|
||
|
||
assert result["success"] is True
|
||
assert len(result["already_done"]) == 1
|
||
assert result["already_done"][0]["id"] == "VDOL-001"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_logs_to_db(self, mock_run, conn):
|
||
"""Audit should log to agent_logs with role=backlog_audit."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": json.dumps({"already_done": [], "still_pending": [], "unclear": []}),
|
||
})
|
||
|
||
run_audit(conn, "vdol")
|
||
|
||
logs = conn.execute(
|
||
"SELECT * FROM agent_logs WHERE agent_role='backlog_audit'"
|
||
).fetchall()
|
||
assert len(logs) == 1
|
||
assert logs[0]["action"] == "audit"
|
||
|
||
def test_audit_no_pending_tasks(self, conn):
|
||
"""If no pending tasks, return success with empty lists."""
|
||
# Mark existing task as done
|
||
models.update_task(conn, "VDOL-001", status="done")
|
||
|
||
result = run_audit(conn, "vdol")
|
||
|
||
assert result["success"] is True
|
||
assert result["already_done"] == []
|
||
assert "No pending tasks" in result.get("message", "")
|
||
|
||
def test_audit_project_not_found(self, conn):
|
||
result = run_audit(conn, "nonexistent")
|
||
assert result["success"] is False
|
||
assert "not found" in result["error"]
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_uses_sonnet(self, mock_run, conn):
|
||
"""Audit should use sonnet model."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": json.dumps({"already_done": [], "still_pending": [], "unclear": []}),
|
||
})
|
||
|
||
run_audit(conn, "vdol")
|
||
|
||
cmd = mock_run.call_args[0][0]
|
||
model_idx = cmd.index("--model")
|
||
assert cmd[model_idx + 1] == "sonnet"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_includes_tasks_in_prompt(self, mock_run, conn):
|
||
"""The prompt should contain the task title."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": json.dumps({"already_done": [], "still_pending": [], "unclear": []}),
|
||
})
|
||
|
||
run_audit(conn, "vdol")
|
||
|
||
prompt = mock_run.call_args[0][0][2] # -p argument
|
||
assert "VDOL-001" in prompt
|
||
assert "Fix bug" in prompt
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_auto_apply_marks_done(self, mock_run, conn):
|
||
"""auto_apply=True should mark already_done tasks as done in DB."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": json.dumps({
|
||
"already_done": [{"id": "VDOL-001", "reason": "Done"}],
|
||
"still_pending": [],
|
||
"unclear": [],
|
||
}),
|
||
})
|
||
|
||
result = run_audit(conn, "vdol", auto_apply=True)
|
||
|
||
assert result["success"] is True
|
||
assert "VDOL-001" in result["applied"]
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "done"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_no_auto_apply_keeps_pending(self, mock_run, conn):
|
||
"""auto_apply=False should NOT change task status."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": json.dumps({
|
||
"already_done": [{"id": "VDOL-001", "reason": "Done"}],
|
||
"still_pending": [],
|
||
"unclear": [],
|
||
}),
|
||
})
|
||
|
||
result = run_audit(conn, "vdol", auto_apply=False)
|
||
|
||
assert result["success"] is True
|
||
assert result["applied"] == []
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "pending"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_audit_uses_dangerously_skip_permissions(self, mock_run, conn):
|
||
"""Audit must use --dangerously-skip-permissions for tool access."""
|
||
mock_run.return_value = _mock_claude_success({
|
||
"result": json.dumps({"already_done": [], "still_pending": [], "unclear": []}),
|
||
})
|
||
|
||
run_audit(conn, "vdol")
|
||
|
||
cmd = mock_run.call_args[0][0]
|
||
assert "--dangerously-skip-permissions" in cmd
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# KIN-019: Silent FAILED diagnostics (regression tests)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class TestSilentFailedDiagnostics:
|
||
"""Regression: агент падает без вывода — runner должен сохранять диагностику в БД."""
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_agent_empty_stdout_saves_stderr_as_error_message_in_db(self, mock_run, conn):
|
||
"""Когда stdout пустой и returncode != 0, stderr должен сохраняться как error_message в agent_logs."""
|
||
mock = MagicMock()
|
||
mock.stdout = ""
|
||
mock.stderr = "API rate limit exceeded (429)"
|
||
mock.returncode = 1
|
||
mock_run.return_value = mock
|
||
|
||
run_agent(conn, "debugger", "VDOL-001", "vdol")
|
||
|
||
log = conn.execute(
|
||
"SELECT error_message FROM agent_logs WHERE task_id='VDOL-001'"
|
||
).fetchone()
|
||
assert log is not None
|
||
assert log["error_message"] is not None
|
||
assert "rate limit" in log["error_message"]
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_agent_empty_stdout_returns_error_key_with_stderr(self, mock_run, conn):
|
||
"""run_agent должен вернуть ключ 'error' с содержимым stderr при пустом stdout и ненулевом returncode."""
|
||
mock = MagicMock()
|
||
mock.stdout = ""
|
||
mock.stderr = "Permission denied: cannot write to /etc/hosts"
|
||
mock.returncode = 1
|
||
mock_run.return_value = mock
|
||
|
||
result = run_agent(conn, "debugger", "VDOL-001", "vdol")
|
||
|
||
assert result["success"] is False
|
||
assert "error" in result
|
||
assert result["error"] is not None
|
||
assert "Permission denied" in result["error"]
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_pipeline_error_message_includes_agent_stderr(self, mock_run, conn):
|
||
"""Сообщение об ошибке pipeline должно включать stderr агента, а не только generic 'step failed'."""
|
||
mock = MagicMock()
|
||
mock.stdout = ""
|
||
mock.stderr = "Internal server error: unexpected EOF"
|
||
mock.returncode = 1
|
||
mock_run.return_value = mock
|
||
|
||
steps = [{"role": "tester", "brief": "run tests"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is False
|
||
assert "Internal server error" in result["error"] or "unexpected EOF" in result["error"]
|
||
|
||
@patch("agents.runner.build_context")
|
||
def test_pipeline_exception_in_run_agent_marks_task_blocked(self, mock_ctx, conn):
|
||
"""Исключение внутри run_agent (например, из build_context) должно ставить задачу в blocked."""
|
||
mock_ctx.side_effect = RuntimeError("DB connection lost")
|
||
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
result = run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
assert result["success"] is False
|
||
|
||
task = models.get_task(conn, "VDOL-001")
|
||
assert task["status"] == "blocked"
|
||
|
||
@patch("agents.runner.build_context")
|
||
def test_pipeline_exception_logs_to_agent_logs(self, mock_ctx, conn):
|
||
"""Исключение в run_agent должно быть залогировано в agent_logs с success=False."""
|
||
mock_ctx.side_effect = ValueError("bad context data")
|
||
|
||
steps = [{"role": "tester", "brief": "test"}]
|
||
run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
logs = conn.execute(
|
||
"SELECT * FROM agent_logs WHERE task_id='VDOL-001' AND success=0"
|
||
).fetchall()
|
||
assert len(logs) >= 1
|
||
|
||
@patch("agents.runner.build_context")
|
||
def test_pipeline_exception_marks_pipeline_failed_in_db(self, mock_ctx, conn):
|
||
"""При исключении запись pipeline должна существовать в БД и иметь статус failed."""
|
||
mock_ctx.side_effect = RuntimeError("network timeout")
|
||
|
||
steps = [{"role": "debugger", "brief": "find"}]
|
||
run_pipeline(conn, "VDOL-001", steps)
|
||
|
||
pipe = conn.execute("SELECT * FROM pipelines WHERE task_id='VDOL-001'").fetchone()
|
||
assert pipe is not None
|
||
assert pipe["status"] == "failed"
|
||
|
||
@patch("agents.runner.subprocess.run")
|
||
def test_agent_success_has_no_error_key_populated(self, mock_run, conn):
|
||
"""При успешном запуске агента ключ 'error' в результате должен быть None (нет ложных срабатываний)."""
|
||
mock_run.return_value = _mock_claude_success({"result": "all good"})
|
||
|
||
result = run_agent(conn, "debugger", "VDOL-001", "vdol")
|
||
|
||
assert result["success"] is True
|
||
assert result.get("error") is None
|