The agent that turns websites into APIs!
"""Tests for opencode_engineer.py - OpenCodeEngineer and helpers."""
import asyncio
import json
import os
from unittest.mock import AsyncMock, MagicMock, patch
import httpx2 as httpx
import pytest
from reverse_api.opencode_engineer import (
OpenCodeEngineer,
debug_log,
format_error,
run_opencode_engineering,
)
def _valid_catalog_response() -> MagicMock:
response = MagicMock()
response.raise_for_status = MagicMock()
response.json.return_value = {
"default": {"opencode": "big-pickle"},
"providers": [
{
"id": "opencode",
"models": {
"big-pickle": {
"status": "active",
"capabilities": {"toolcall": True},
}
},
},
{
"id": "anthropic",
"models": {
"claude-opus-4-6": {
"status": "active",
"capabilities": {"toolcall": True},
}
},
}
],
}
return response
class TestDebugLog:
"""Test debug_log function."""
def test_debug_disabled(self, capsys):
"""No output when DEBUG is disabled."""
with patch("reverse_api.opencode_engineer.DEBUG", False):
debug_log("test message")
captured = capsys.readouterr()
assert captured.out == ""
def test_debug_enabled(self, capsys):
"""Output when DEBUG is enabled."""
with patch("reverse_api.opencode_engineer.DEBUG", True):
debug_log("test message")
captured = capsys.readouterr()
assert "test message" in captured.out
assert "[DEBUG]" in captured.out
class TestFormatError:
"""Test format_error function."""
def test_basic_exception(self):
"""Formats basic exception."""
e = Exception("something went wrong")
result = format_error(e)
assert "Exception" in result
assert "something went wrong" in result
def test_empty_message(self):
"""Formats exception with empty message."""
e = Exception()
result = format_error(e)
assert "no message" in result
def test_http_status_error(self):
"""Formats HTTP status error."""
response = MagicMock()
response.status_code = 500
response.reason_phrase = "Internal Server Error"
response.json.return_value = {"error": "server error"}
e = httpx.HTTPStatusError("error", request=MagicMock(), response=response)
result = format_error(e)
assert "500" in result
def test_http_status_error_non_json(self):
"""Formats HTTP error with non-JSON response."""
response = MagicMock()
response.status_code = 500
response.reason_phrase = "Error"
response.json.side_effect = ValueError("not json")
response.text = "plain text error"
e = httpx.HTTPStatusError("error", request=MagicMock(), response=response)
result = format_error(e)
assert "500" in result
def test_http_status_error_empty_response_text(self):
"""Formats HTTP error with empty response text."""
response = MagicMock()
response.status_code = 500
response.reason_phrase = "Error"
response.json.side_effect = ValueError("not json")
response.text = ""
e = httpx.HTTPStatusError("error", request=MagicMock(), response=response)
result = format_error(e)
assert "500" in result
def test_connect_error(self):
"""Formats connect error."""
e = httpx.ConnectError("Connection refused")
result = format_error(e)
assert "ConnectError" in result
def test_read_error(self):
"""Formats read error."""
e = httpx.ReadError("Connection reset")
result = format_error(e)
assert "ReadError" in result
def test_timeout_error(self):
"""Formats timeout error."""
e = httpx.TimeoutException("Request timed out")
result = format_error(e)
assert "TimeoutException" in result
def test_debug_mode_includes_traceback(self):
"""Debug mode includes traceback."""
with patch("reverse_api.opencode_engineer.DEBUG", True):
try:
raise ValueError("test error")
except ValueError as e:
result = format_error(e)
assert "Traceback" in result
def test_http_error_with_json_body(self):
"""HTTP error with JSON body shows response content."""
response = MagicMock()
response.status_code = 422
response.reason_phrase = "Unprocessable Entity"
response.json.return_value = {"detail": "Validation error", "field": "name"}
e = httpx.HTTPStatusError("error", request=MagicMock(), response=response)
result = format_error(e)
assert "422" in result
assert "Unprocessable Entity" in result
def test_connect_error_with_connection_refused(self):
"""Connect error with 'Connection refused' in message."""
e = httpx.ConnectError("Connection refused")
result = format_error(e)
assert "Unable to connect" in result
def test_connect_error_with_other_message(self):
"""Connect error with non-refused message shows details."""
e = httpx.ConnectError("DNS resolution failed")
result = format_error(e)
assert "DNS resolution failed" in result
def test_http_status_error_response_access_fails(self):
"""HTTP status error where response access raises."""
response = MagicMock()
type(response).status_code = property(lambda self: (_ for _ in ()).throw(RuntimeError("oops")))
e = httpx.HTTPStatusError("error", request=MagicMock(), response=response)
result = format_error(e)
assert "HTTPStatusError" in result
class TestOpenCodeEngineerModelMap:
"""Test OpenCodeEngineer MODEL_MAP."""
def test_model_map(self):
"""MODEL_MAP has expected entries."""
assert OpenCodeEngineer.MODEL_MAP["sonnet"] == "claude-sonnet-4-6"
assert OpenCodeEngineer.MODEL_MAP["opus"] == "claude-opus-4-6"
assert OpenCodeEngineer.MODEL_MAP["haiku"] == "claude-haiku-4-5"
class TestOpenCodeEngineerInit:
"""Test OpenCodeEngineer initialization."""
def test_init(self, tmp_path):
"""Initializes with OpenCode-specific attributes."""
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore"):
with patch("reverse_api.opencode_engineer.OpenCodeUI"):
eng = OpenCodeEngineer(
run_id="test123",
har_path=har_path,
prompt="test prompt",
output_dir=str(tmp_path),
opencode_provider="anthropic",
opencode_model="claude-opus-4-6",
)
assert eng.opencode_provider == "anthropic"
assert eng.opencode_model == "claude-opus-4-6"
assert eng._session_id is None
def test_init_default_opencode_kwargs(self, tmp_path):
"""Default OpenCode kwargs."""
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore"):
with patch("reverse_api.opencode_engineer.OpenCodeUI"):
eng = OpenCodeEngineer(
run_id="test123",
har_path=har_path,
prompt="test prompt",
output_dir=str(tmp_path),
)
assert eng.opencode_provider == "opencode"
assert eng.opencode_model == "big-pickle"
class TestOpenCodeEngineerAuth:
"""Test authentication handling."""
def _make_engineer(self, tmp_path, **env_vars):
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore"):
with patch("reverse_api.opencode_engineer.OpenCodeUI"):
with patch.dict(os.environ, env_vars, clear=False):
return OpenCodeEngineer(
run_id="test123",
har_path=har_path,
prompt="test prompt",
output_dir=str(tmp_path),
)
def test_no_auth(self, tmp_path):
"""No auth when no password set."""
eng = self._make_engineer(tmp_path)
assert eng._get_auth() is None
def test_with_password(self, tmp_path):
"""Auth with password."""
eng = self._make_engineer(tmp_path, OPENCODE_SERVER_PASSWORD="secret123")
auth = eng._get_auth()
assert auth is not None
def test_custom_username(self, tmp_path):
"""Custom username."""
eng = self._make_engineer(
tmp_path,
OPENCODE_SERVER_PASSWORD="secret",
OPENCODE_SERVER_USERNAME="admin",
)
assert eng.opencode_username == "admin"
class TestOpenCodeEngineerHandlePartUpdate:
"""Test _handle_part_update method."""
def _make_engineer(self, tmp_path):
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore") as mock_ms:
mock_ms_instance = MagicMock()
mock_ms.return_value = mock_ms_instance
with patch("reverse_api.opencode_engineer.OpenCodeUI") as mock_ui:
mock_ui_instance = MagicMock()
mock_ui.return_value = mock_ui_instance
eng = OpenCodeEngineer(
run_id="test123",
har_path=har_path,
prompt="test prompt",
output_dir=str(tmp_path),
)
eng._session_id = "session_abc"
eng._assistant_message_ids.add("message_assistant")
return eng
@pytest.mark.asyncio
async def test_text_part(self, tmp_path):
"""Text part updates UI."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "part1",
"type": "text",
"text": "x" * 100,
"sessionID": "session_abc",
"messageID": "message_assistant",
},
"delta": None,
}
await eng._handle_part_update(properties, seen_parts)
eng.opencode_ui.update_text.assert_called_once()
assert "part1" in seen_parts
@pytest.mark.asyncio
async def test_text_part_short_not_saved(self, tmp_path):
"""Short text part is not saved to message store."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "part1",
"type": "text",
"text": "ok",
"sessionID": "session_abc",
"messageID": "message_assistant",
},
"delta": None,
}
await eng._handle_part_update(properties, seen_parts)
eng.message_store.save_thinking.assert_not_called()
@pytest.mark.asyncio
async def test_user_text_part_is_not_rendered(self, tmp_path):
"""The submitted internal prompt must not appear as assistant output."""
eng = self._make_engineer(tmp_path)
properties = {
"part": {
"id": "part-user",
"messageID": "message_user",
"type": "text",
"text": "There is no HAR file — capture all network data.",
"sessionID": "session_abc",
}
}
await eng._handle_part_update(properties, set())
eng.opencode_ui.update_text.assert_not_called()
eng.message_store.save_thinking.assert_not_called()
@pytest.mark.asyncio
async def test_tool_running(self, tmp_path):
"""Running tool part starts tool in UI."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "tool1",
"type": "tool",
"tool": "Read",
"sessionID": "session_abc",
"state": {"status": "running", "input": {"file_path": "/test.py"}},
},
}
await eng._handle_part_update(properties, seen_parts)
eng.opencode_ui.tool_start.assert_called_once_with("Read", {"file_path": "/test.py"})
assert "tool1" in seen_parts
@pytest.mark.asyncio
async def test_tool_completed(self, tmp_path):
"""Completed tool part shows result."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "tool1",
"type": "tool",
"tool": "Read",
"sessionID": "session_abc",
"state": {"status": "completed", "output": "file content"},
},
}
await eng._handle_part_update(properties, seen_parts)
eng.opencode_ui.tool_result.assert_called_once_with("Read", False, "file content")
@pytest.mark.asyncio
async def test_tool_error(self, tmp_path):
"""Error tool part shows error."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "tool1",
"type": "tool",
"tool": "Bash",
"sessionID": "session_abc",
"state": {"status": "error", "error": "command failed"},
},
}
await eng._handle_part_update(properties, seen_parts)
eng.opencode_ui.tool_result.assert_called_once_with("Bash", True, "command failed")
@pytest.mark.asyncio
async def test_step_finish(self, tmp_path):
"""Step finish updates usage metadata."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "step1",
"type": "step-finish",
"cost": 0.05,
"tokens": {
"input": 1000,
"output": 500,
"reasoning": 200,
"cache": {"read": 100, "write": 50},
},
"sessionID": "session_abc",
},
}
await eng._handle_part_update(properties, seen_parts)
assert eng.usage_metadata["input_tokens"] == 1000
assert eng.usage_metadata["output_tokens"] == 500
assert eng.usage_metadata["reasoning_tokens"] == 200
assert eng.usage_metadata["cache_read_tokens"] == 100
assert eng.usage_metadata["cache_creation_tokens"] == 50
assert eng.usage_metadata["cost"] == 0.05
@pytest.mark.asyncio
async def test_step_finish_calculates_cost_when_zero(self, tmp_path):
"""Step finish calculates cost locally when API returns 0."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "step1",
"type": "step-finish",
"cost": 0,
"tokens": {
"input": 1000,
"output": 500,
"reasoning": 0,
"cache": {"read": 0, "write": 0},
},
"sessionID": "session_abc",
},
}
await eng._handle_part_update(properties, seen_parts)
assert eng.usage_metadata["cost"] > 0 # Should have calculated locally
@pytest.mark.asyncio
async def test_wrong_session_ignored(self, tmp_path):
"""Parts for other sessions are ignored."""
eng = self._make_engineer(tmp_path)
seen_parts = set()
properties = {
"part": {
"id": "part1",
"type": "text",
"text": "ignored",
"sessionID": "other_session",
},
}
await eng._handle_part_update(properties, seen_parts)
eng.opencode_ui.update_text.assert_not_called()
class TestOpenCodeEngineerStreamEvents:
"""Test _stream_events method."""
def _make_engineer(self, tmp_path):
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore") as mock_ms:
mock_ms.return_value = MagicMock()
with patch("reverse_api.opencode_engineer.OpenCodeUI") as mock_ui:
mock_ui.return_value = MagicMock()
eng = OpenCodeEngineer(
run_id="test123",
har_path=har_path,
prompt="test prompt",
output_dir=str(tmp_path),
)
eng._session_id = "session_abc"
return eng
@pytest.mark.asyncio
async def test_session_idle_event(self, tmp_path):
"""session.idle event ends streaming."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
mock_response.status_code = 200
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
mock_client = AsyncMock()
mock_client.stream = MagicMock()
# Use async context manager mock
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client.stream.return_value = cm
await eng._stream_events(mock_client)
eng.opencode_ui.session_status.assert_called_with("idle")
@pytest.mark.asyncio
async def test_session_status_idle(self, tmp_path):
"""session.status with idle type ends streaming."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.status","properties":{"sessionID":"session_abc","status":{"type":"idle"}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
@pytest.mark.asyncio
async def test_session_status_retry(self, tmp_path):
"""session.status with retry type calls retry UI."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.status","properties":{"sessionID":"session_abc","status":{"type":"retry","attempt":2,"message":"Rate limited"}}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
eng.opencode_ui.session_retry.assert_called_with(2, "Rate limited")
@pytest.mark.asyncio
async def test_permission_updated_event(self, tmp_path):
"""permission.updated event auto-approves."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"permission.updated","properties":{"id":"perm1","sessionID":"session_abc","type":"write","title":"Write file"}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
mock_client.post = AsyncMock(return_value=MagicMock(status_code=200))
await eng._stream_events(mock_client)
eng.opencode_ui.permission_requested.assert_called_with("write", "Write file")
eng.opencode_ui.permission_approved.assert_called_with("write")
@pytest.mark.asyncio
async def test_permission_v2_event_uses_current_reply_endpoint(self, tmp_path):
"""OpenCode 1.18 permission.v2 events use the non-deprecated endpoint."""
eng = self._make_engineer(tmp_path)
lines = [
(
'data: {"type":"permission.v2.asked","properties":{"id":"per_1","sessionID":"session_abc",'
'"action":"write","resources":["/tmp/client.py"]}}'
),
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
stream = AsyncMock()
stream.__aenter__ = AsyncMock(return_value=mock_response)
stream.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=stream)
mock_client.post = AsyncMock(return_value=MagicMock(status_code=204))
await eng._stream_events(mock_client)
mock_client.post.assert_awaited_once_with(
"/api/session/session_abc/permission/per_1/reply",
json={"reply": "always"},
)
eng.opencode_ui.permission_requested.assert_called_once_with("write", "/tmp/client.py")
eng.opencode_ui.permission_approved.assert_called_once_with("write")
@pytest.mark.asyncio
async def test_todo_updated_event(self, tmp_path):
"""todo.updated event updates UI."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"todo.updated","properties":{"sessionID":"session_abc","todos":[{"text":"Do X"}]}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
eng.opencode_ui.todo_updated.assert_called_once()
@pytest.mark.asyncio
async def test_file_edited_event(self, tmp_path):
"""file.edited event updates UI."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"file.edited","properties":{"file":"/test.py"}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
eng.opencode_ui.file_edited.assert_called_with("/test.py")
@pytest.mark.asyncio
async def test_session_diff_event(self, tmp_path):
"""session.diff event updates UI."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.diff","properties":{"sessionID":"session_abc","diff":[{"file":"test.py"}]}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
eng.opencode_ui.session_diff.assert_called_once()
@pytest.mark.asyncio
async def test_session_compacted_event(self, tmp_path):
"""session.compacted event updates UI."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.compacted","properties":{"sessionID":"session_abc"}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
eng.opencode_ui.session_compacted.assert_called_once()
@pytest.mark.asyncio
async def test_session_error_event(self, tmp_path):
"""session.error event sets _last_error."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.error","properties":{"sessionID":"session_abc",'
'"error":{"name":"ProviderAuthError","data":{"providerID":"anthropic","message":"Invalid API key"}}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert "Auth error" in eng._last_error
assert "anthropic" in eng._last_error
eng.opencode_ui.error.assert_not_called()
@pytest.mark.asyncio
async def test_session_error_api_error(self, tmp_path):
"""session.error with APIError."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.error","properties":{"sessionID":"session_abc",'
'"error":{"name":"APIError","data":{"message":"Rate limited","statusCode":429}}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert "API error" in eng._last_error
assert "429" in eng._last_error
eng.opencode_ui.error.assert_not_called()
@pytest.mark.asyncio
async def test_session_error_no_provider_available(self, tmp_path):
"""Zen capacity errors are explained without being displayed twice."""
eng = self._make_engineer(tmp_path)
lines = [
"data: "
'{"type":"session.error","properties":{"sessionID":"session_abc",'
'"error":{"name":"APIError","data":{"message":"No provider available","statusCode":401}}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert eng._last_error == (
"OpenCode has no serving provider available for this model right now. "
"Try another free model or retry later."
)
eng.opencode_ui.error.assert_not_called()
@pytest.mark.asyncio
async def test_session_error_aborted(self, tmp_path):
"""session.error with MessageAbortedError."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.error","properties":{"sessionID":"session_abc","error":{"name":"MessageAbortedError","data":{}}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert eng._last_error == "Aborted"
@pytest.mark.asyncio
async def test_session_error_unknown_type(self, tmp_path):
"""session.error with unknown error type."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.error","properties":{"sessionID":"session_abc","error":{"name":"CustomError","data":{"message":"custom msg"}}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert "CustomError" in eng._last_error
@pytest.mark.asyncio
async def test_session_error_string(self, tmp_path):
"""session.error with string error object."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.error","properties":{"sessionID":"session_abc","error":"simple error string"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert eng._last_error == "simple error string"
@pytest.mark.asyncio
async def test_session_error_other_session_ignored(self, tmp_path):
"""session.error for other session is ignored."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"session.error","properties":{"sessionID":"other_session","error":"some error"}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert eng._last_error is None
@pytest.mark.asyncio
async def test_json_decode_error(self, tmp_path):
"""Invalid JSON in event stream is skipped."""
eng = self._make_engineer(tmp_path)
lines = [
'data: not-valid-json',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
# Should not error, just skip invalid line
@pytest.mark.asyncio
async def test_buffer_size_error(self, tmp_path):
"""Buffer size error is handled specially."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"invalid": "exceeded maximum buffer size 1048576', # Causes JSONDecodeError with buffer text
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
# The JSON parse will fail but "1048576" isn't in the JSONDecodeError message
# Let's directly test the error by checking for normal decode errors
await eng._stream_events(mock_client)
@pytest.mark.asyncio
async def test_buffer_size_json_error_with_keyword(self, tmp_path):
"""Buffer size error detected in JSONDecodeError message triggers special handling."""
eng = self._make_engineer(tmp_path)
# Patch json.loads to raise JSONDecodeError with buffer size in message
def mock_loads(s, *args, **kwargs):
raise json.JSONDecodeError("exceeded maximum buffer size 1048576", s, 0)
lines = [
'data: {"some":"data"}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
with patch("reverse_api.opencode_engineer.json.loads", side_effect=mock_loads):
await eng._stream_events(mock_client)
assert eng._last_error is not None
assert "Screenshot too large" in eng._last_error
@pytest.mark.asyncio
async def test_message_part_updated_event(self, tmp_path):
"""message.part.updated event calls _handle_part_update."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc","part":{"type":"text","text":"thinking..."}}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
with patch.object(eng, "_handle_part_update", new_callable=AsyncMock) as mock_handle:
await eng._stream_events(mock_client)
mock_handle.assert_called_once()
@pytest.mark.asyncio
async def test_stream_renders_only_assistant_text(self, tmp_path):
"""Parts arriving before their roles are known are safely buffered."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
'"part":{"id":"part_user","messageID":"message_user","sessionID":"session_abc",'
'"type":"text","text":"There is no HAR file — capture all network data."}}}',
'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
'"part":{"id":"part_assistant","messageID":"message_assistant","sessionID":"session_abc",'
'"type":"text","text":"Assistant answer","time":{"start":1,"end":2}}}}',
'data: {"type":"message.updated","properties":{"sessionID":"session_abc",'
'"info":{"id":"message_user","sessionID":"session_abc","role":"user"}}}',
'data: {"type":"message.updated","properties":{"sessionID":"session_abc",'
'"info":{"id":"message_assistant","sessionID":"session_abc","role":"assistant"}}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
eng.opencode_ui.update_text.assert_called_once_with("Assistant answer", None)
assert eng._pending_text_parts == {}
@pytest.mark.asyncio
@pytest.mark.parametrize(
"idle_event",
[
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
'data: {"type":"session.status","properties":{"sessionID":"session_abc","status":{"type":"idle"}}}',
],
)
async def test_idle_reconciles_buffered_assistant_role(self, tmp_path, idle_event):
"""Idle resolves buffered roles from final state without waiting on SSE order."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
'"part":{"id":"part_user","messageID":"message_user","sessionID":"session_abc",'
'"type":"text","text":"Internal user prompt"}}}',
'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
'"part":{"id":"part_assistant","messageID":"message_assistant","sessionID":"session_abc",'
'"type":"text","text":"Late assistant answer"}}}',
idle_event,
'data: {"type":"message.updated","properties":{"sessionID":"session_abc",'
'"info":{"id":"message_assistant","sessionID":"session_abc","role":"assistant"}}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
final_response = MagicMock(status_code=200)
final_response.json.return_value = [
{"info": {"id": "message_user", "sessionID": "session_abc", "role": "user"}},
{"info": {"id": "message_assistant", "sessionID": "session_abc", "role": "assistant"}},
]
mock_client.get = AsyncMock(return_value=final_response)
await eng._stream_events(mock_client)
assert eng._last_error is None
eng.opencode_ui.update_text.assert_called_once_with("Late assistant answer", None)
assert eng._pending_text_parts == {}
mock_client.get.assert_awaited_once_with("/session/session_abc/message")
@pytest.mark.asyncio
async def test_idle_with_unresolved_buffer_reports_specific_error(self, tmp_path):
"""A closed stream cannot turn unresolved buffered output into success."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"message.part.updated","properties":{"sessionID":"session_abc",'
'"part":{"id":"part_assistant","messageID":"message_assistant","sessionID":"session_abc",'
'"type":"text","text":"Unresolved answer"}}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
final_response = MagicMock(status_code=200)
final_response.json.return_value = []
mock_client.get = AsyncMock(return_value=final_response)
await eng._stream_events(mock_client)
assert eng._last_error == "OpenCode completed without role metadata for buffered message(s): message_assistant."
eng.opencode_ui.update_text.assert_not_called()
@pytest.mark.asyncio
async def test_empty_and_non_data_lines_skipped(self, tmp_path):
"""Empty lines and non-data lines are skipped."""
eng = self._make_engineer(tmp_path)
lines = [
"",
"event: message",
"data:",
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
@pytest.mark.asyncio
async def test_data_without_space(self, tmp_path):
"""data: (without space) prefix is handled."""
eng = self._make_engineer(tmp_path)
lines = [
'data:{"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
@pytest.mark.asyncio
async def test_read_error_in_stream(self, tmp_path):
"""httpx.ReadError during streaming sets _last_error."""
eng = self._make_engineer(tmp_path)
mock_response = AsyncMock()
async def mock_aiter_lines():
raise httpx.ReadError("Connection lost")
yield # Make it a generator
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert eng._last_error is not None
@pytest.mark.asyncio
async def test_general_exception_in_stream(self, tmp_path):
"""General exception during streaming sets _last_error."""
eng = self._make_engineer(tmp_path)
mock_response = AsyncMock()
async def mock_aiter_lines():
raise RuntimeError("Unexpected error")
yield
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
await eng._stream_events(mock_client)
assert eng._last_error is not None
@pytest.mark.asyncio
async def test_permission_approval_fails(self, tmp_path):
"""Permission transport failures stop the stream immediately."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"permission.updated","properties":{"id":"perm1","sessionID":"session_abc","type":"write","title":"Write"}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
mock_client.post = AsyncMock(side_effect=Exception("permission failed"))
await eng._stream_events(mock_client)
assert eng._last_error == "Permission approval failed for write: permission failed"
eng.opencode_ui.session_status.assert_not_called()
@pytest.mark.asyncio
async def test_permission_rejection_reports_status_and_stops_stream(self, tmp_path):
"""A rejected permission reply is fatal instead of timing out later."""
eng = self._make_engineer(tmp_path)
lines = [
'data: {"type":"permission.v2.asked","properties":{"id":"perm1","sessionID":"session_abc","action":"write"}}',
'data: {"type":"session.idle","properties":{"sessionID":"session_abc"}}',
]
mock_response = AsyncMock()
async def mock_aiter_lines():
for line in lines:
yield line
mock_response.aiter_lines = mock_aiter_lines
cm = AsyncMock()
cm.__aenter__ = AsyncMock(return_value=mock_response)
cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.stream = MagicMock(return_value=cm)
mock_client.post = AsyncMock(return_value=MagicMock(status_code=403))
await eng._stream_events(mock_client)
assert eng._last_error == "Permission approval failed for write: OpenCode returned HTTP 403."
eng.opencode_ui.permission_approved.assert_not_called()
eng.opencode_ui.session_status.assert_not_called()
class TestOpenCodeEngineerAnalyzeAndGenerate:
"""Test analyze_and_generate method."""
def _make_engineer(self, tmp_path):
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore") as mock_ms:
mock_ms.return_value = MagicMock()
with patch("reverse_api.opencode_engineer.OpenCodeUI") as mock_ui:
mock_ui.return_value = MagicMock()
eng = OpenCodeEngineer(
run_id="test123",
har_path=har_path,
prompt="test prompt",
output_dir=str(tmp_path),
)
eng.scripts_dir = tmp_path / "scripts"
eng.scripts_dir.mkdir(parents=True, exist_ok=True)
return eng
@pytest.mark.asyncio
async def test_prepare_server_configures_ollama_before_opencode(self, tmp_path):
eng = self._make_engineer(tmp_path)
eng.opencode_provider = "ollama"
eng.opencode_model = "qwen3:4b"
client = AsyncMock()
ollama_setup = MagicMock()
ollama_setup.status.started = False
server = MagicMock(started=True, package="opencode-ai@latest", health={"version": "1.18.4"})
with patch(
"reverse_api.opencode_engineer.prepare_ollama_model",
new=AsyncMock(return_value=ollama_setup),
) as prepare:
with patch(
"reverse_api.opencode_engineer.opencode_ollama_env",
return_value={"OPENCODE_CONFIG_CONTENT": "{}"},
):
with patch(
"reverse_api.opencode_engineer.ensure_opencode_server",
new=AsyncMock(return_value=server),
) as ensure:
with patch(
"reverse_api.opencode_engineer.validate_opencode_ollama_provider",
new=AsyncMock(),
) as validate:
with patch(
"reverse_api.opencode_engineer.validate_opencode_model",
new=AsyncMock(),
) as validate_model:
assert await eng._prepare_server(client) is True
prepare.assert_awaited_once_with("qwen3:4b")
ensure.assert_awaited_once_with(
client,
base_url=eng.BASE_URL,
env_overrides={"OPENCODE_CONFIG_CONTENT": "{}"},
)
validate.assert_awaited_once_with(client, "qwen3:4b")
validate_model.assert_awaited_once_with(client, "ollama", "qwen3:4b")
eng.opencode_ui.ollama_ready.assert_called_once_with("qwen3:4b", False)
@pytest.mark.asyncio
async def test_health_check_401(self, tmp_path):
"""401 on health check returns None."""
eng = self._make_engineer(tmp_path)
mock_response = MagicMock()
mock_response.status_code = 401
error = httpx.HTTPStatusError("401", request=MagicMock(), response=mock_response)
mock_client = AsyncMock()
mock_client.get = AsyncMock(side_effect=error)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_health_check_connection_error(self, tmp_path):
"""Connection error on health check returns None."""
eng = self._make_engineer(tmp_path)
mock_client = AsyncMock()
mock_client.get = AsyncMock(side_effect=ConnectionError("refused"))
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_connect_error(self, tmp_path):
"""httpx.ConnectError returns None."""
eng = self._make_engineer(tmp_path)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(
side_effect=httpx.ConnectError("Connection refused")
)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_general_exception(self, tmp_path):
"""General exception returns None."""
eng = self._make_engineer(tmp_path)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(
side_effect=RuntimeError("unexpected")
)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_http_401_during_session(self, tmp_path):
"""401 during session creation returns None."""
eng = self._make_engineer(tmp_path)
health_response = MagicMock()
health_response.status_code = 200
health_response.json.return_value = {"status": "ok"}
health_response.raise_for_status = MagicMock()
session_response = MagicMock()
session_response.status_code = 401
session_error = httpx.HTTPStatusError("401", request=MagicMock(), response=session_response)
mock_client = AsyncMock()
mock_client.get = AsyncMock(return_value=health_response)
mock_client.post = AsyncMock(side_effect=session_error)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_success_flow(self, tmp_path):
"""Full success flow: health check → session → event stream → result."""
eng = self._make_engineer(tmp_path)
health_response = MagicMock()
health_response.status_code = 200
health_response.json.return_value = {"status": "ok"}
health_response.raise_for_status = MagicMock()
session_response = MagicMock()
session_response.json.return_value = {"id": "sess_abc"}
session_response.raise_for_status = MagicMock()
prompt_response = MagicMock()
prompt_response.raise_for_status = MagicMock()
messages_response = MagicMock()
messages_response.status_code = 200
messages_response.json.return_value = [
{
"info": {"role": "assistant", "providerID": "anthropic", "modelID": "claude-sonnet-4-6"},
"parts": [{"type": "text", "text": "Here is the API client."}],
}
]
async def mock_get(path, **kwargs):
if path == "/global/health":
return health_response
if path == "/config/providers":
return _valid_catalog_response()
if "/message" in path:
return messages_response
return MagicMock()
post_count = [0]
async def mock_post(path, **kwargs):
post_count[0] += 1
if path == "/session":
return session_response
return prompt_response
# Mock event stream that completes immediately
mock_stream_resp = AsyncMock()
async def mock_aiter_lines():
yield 'data: {"type":"session.idle","properties":{"sessionID":"sess_abc"}}'
mock_stream_resp.aiter_lines = mock_aiter_lines
mock_stream_cm = AsyncMock()
mock_stream_cm.__aenter__ = AsyncMock(return_value=mock_stream_resp)
mock_stream_cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.get = mock_get
mock_client.post = mock_post
mock_client.stream = MagicMock(return_value=mock_stream_cm)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is not None
assert "script_path" in result
assert result["session_id"] == "sess_abc"
@pytest.mark.asyncio
async def test_health_401_custom_username(self, tmp_path):
"""401 with custom username shows username."""
eng = self._make_engineer(tmp_path)
eng.opencode_username = "custom_user"
mock_response = MagicMock()
mock_response.status_code = 401
error = httpx.HTTPStatusError("401", request=MagicMock(), response=mock_response)
mock_client = AsyncMock()
mock_client.get = AsyncMock(side_effect=error)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_http_non_401_error(self, tmp_path):
"""Non-401 HTTP error during session shows error details."""
eng = self._make_engineer(tmp_path)
health_response = MagicMock()
health_response.status_code = 200
health_response.json.return_value = {"status": "ok"}
health_response.raise_for_status = MagicMock()
mock_response = MagicMock()
mock_response.status_code = 500
mock_response.text = "Internal Server Error"
session_error = httpx.HTTPStatusError("500", request=MagicMock(), response=mock_response)
mock_client = AsyncMock()
mock_client.get = AsyncMock(return_value=health_response)
mock_client.post = AsyncMock(side_effect=session_error)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_success_message_fetch_exception(self, tmp_path):
"""Success flow handles exception when fetching session messages."""
eng = self._make_engineer(tmp_path)
health_response = MagicMock()
health_response.status_code = 200
health_response.json.return_value = {"status": "ok"}
health_response.raise_for_status = MagicMock()
session_response = MagicMock()
session_response.json.return_value = {"id": "sess_msgfail"}
session_response.raise_for_status = MagicMock()
prompt_response = MagicMock()
prompt_response.raise_for_status = MagicMock()
get_count = [0]
async def mock_get(path, **kwargs):
get_count[0] += 1
if path == "/global/health":
return health_response
if path == "/config/providers":
return _valid_catalog_response()
if "/message" in path:
raise Exception("message fetch failed")
return MagicMock()
async def mock_post(path, **kwargs):
if path == "/session":
return session_response
return prompt_response
mock_stream_resp = AsyncMock()
async def mock_aiter_lines():
yield 'data: {"type":"session.idle","properties":{"sessionID":"sess_msgfail"}}'
mock_stream_resp.aiter_lines = mock_aiter_lines
mock_stream_cm = AsyncMock()
mock_stream_cm.__aenter__ = AsyncMock(return_value=mock_stream_resp)
mock_stream_cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.get = mock_get
mock_client.post = mock_post
mock_client.stream = MagicMock(return_value=mock_stream_cm)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
# Should still succeed even if message fetch fails
assert result is not None
assert "script_path" in result
@pytest.mark.asyncio
async def test_health_401_with_custom_username_outer(self, tmp_path):
"""401 in session creation with custom username shows username (line 255)."""
eng = self._make_engineer(tmp_path)
eng.opencode_username = "admin"
health_response = MagicMock()
health_response.status_code = 200
health_response.json.return_value = {"status": "ok"}
health_response.raise_for_status = MagicMock()
mock_response = MagicMock()
mock_response.status_code = 401
session_error = httpx.HTTPStatusError("401", request=MagicMock(), response=mock_response)
mock_client = AsyncMock()
mock_client.get = AsyncMock(return_value=health_response)
mock_client.post = AsyncMock(side_effect=session_error)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
assert result is None
@pytest.mark.asyncio
async def test_health_non_401_raises(self, tmp_path):
"""Non-401 HTTPStatusError in health check re-raises (line 160)."""
eng = self._make_engineer(tmp_path)
mock_response = MagicMock()
mock_response.status_code = 500
mock_response.text = "Server Error"
error = httpx.HTTPStatusError("500", request=MagicMock(), response=mock_response)
mock_client = AsyncMock()
mock_client.get = AsyncMock(side_effect=error)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
result = await eng.analyze_and_generate()
# 500 should be caught by outer HTTPStatusError handler
assert result is None
@pytest.mark.asyncio
async def test_event_timeout(self, tmp_path):
"""Event stream timeout shows error."""
eng = self._make_engineer(tmp_path)
health_response = MagicMock()
health_response.status_code = 200
health_response.json.return_value = {"status": "ok"}
health_response.raise_for_status = MagicMock()
session_response = MagicMock()
session_response.json.return_value = {"id": "sess_timeout"}
session_response.raise_for_status = MagicMock()
prompt_response = MagicMock()
prompt_response.raise_for_status = MagicMock()
async def mock_get(path, **kwargs):
if path == "/global/health":
return health_response
return MagicMock(status_code=200, json=MagicMock(return_value=[]))
async def mock_post(path, **kwargs):
if path == "/session":
return session_response
return prompt_response
# Mock event stream that never yields
mock_stream_resp = AsyncMock()
async def mock_aiter_lines():
# Simulate hanging by not yielding idle
await asyncio.sleep(100)
yield "will never reach here"
mock_stream_resp.aiter_lines = mock_aiter_lines
mock_stream_cm = AsyncMock()
mock_stream_cm.__aenter__ = AsyncMock(return_value=mock_stream_resp)
mock_stream_cm.__aexit__ = AsyncMock(return_value=False)
mock_client = AsyncMock()
mock_client.get = mock_get
mock_client.post = mock_post
mock_client.stream = MagicMock(return_value=mock_stream_cm)
with patch("reverse_api.opencode_engineer.httpx.AsyncClient") as mock_async:
mock_async.return_value.__aenter__ = AsyncMock(return_value=mock_client)
mock_async.return_value.__aexit__ = AsyncMock(return_value=False)
# Patch timeout to be very short
with patch("reverse_api.opencode_engineer.asyncio.wait_for", side_effect=TimeoutError()):
result = await eng.analyze_and_generate()
# Should still return None due to _last_error being set
assert result is None
class TestRunOpenCodeEngineering:
"""Test run_opencode_engineering dispatch function."""
def test_dispatches_to_opencode(self, tmp_path):
"""Creates OpenCodeEngineer and runs async."""
har_path = tmp_path / "test.har"
har_path.touch()
with patch("reverse_api.base_engineer.get_scripts_dir", return_value=tmp_path / "scripts"):
with patch("reverse_api.base_engineer.MessageStore"):
with patch("reverse_api.opencode_engineer.OpenCodeUI"):
with patch("reverse_api.opencode_engineer.asyncio.run", return_value={"test": True}) as mock_run:
result = run_opencode_engineering(
run_id="test123",
har_path=har_path,
prompt="test prompt",
)
mock_run.assert_called_once()
assert result == {"test": True}