mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
100% Coverage
This commit is contained in:
Renn F
@@ -0,0 +1,267 @@
|
||||
"""bootstrap.py coverage — orchestration entrypoint with all I/O patched.
|
||||
|
||||
`main()` wires database init, event-bus init, websocket-bridge,
|
||||
orchestrator startup, and the uvicorn API server. Every external call gets
|
||||
patched so the tests run in milliseconds without a real Redis/Postgres/HTTP
|
||||
stack. Helpers `_run_api_server` and `_wait_for_api_ready` get their own
|
||||
isolated checks.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import runpy
|
||||
from http import HTTPStatus
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
from roboco.bootstrap import (
|
||||
_BootstrapHolder,
|
||||
_run_api_server,
|
||||
_wait_for_api_ready,
|
||||
main,
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# _run_api_server
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_api_server_starts_uvicorn() -> None:
|
||||
"""_run_api_server constructs a uvicorn Config + Server and serves."""
|
||||
server_instance = MagicMock()
|
||||
server_instance.serve = AsyncMock()
|
||||
with (
|
||||
patch("roboco.bootstrap.uvicorn.Config") as cfg_cls,
|
||||
patch("roboco.bootstrap.uvicorn.Server", return_value=server_instance),
|
||||
):
|
||||
await _run_api_server()
|
||||
cfg_cls.assert_called_once()
|
||||
server_instance.serve.assert_awaited_once()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# _wait_for_api_ready
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_wait_for_api_ready_returns_when_health_ok() -> None:
|
||||
"""200 from /health → return immediately."""
|
||||
response = MagicMock()
|
||||
response.status_code = HTTPStatus.OK
|
||||
client_instance = MagicMock()
|
||||
client_instance.get = AsyncMock(return_value=response)
|
||||
client_instance.__aenter__ = AsyncMock(return_value=client_instance)
|
||||
client_instance.__aexit__ = AsyncMock(return_value=False)
|
||||
with patch("roboco.bootstrap.httpx.AsyncClient", return_value=client_instance):
|
||||
await _wait_for_api_ready(max_wait=4)
|
||||
client_instance.get.assert_awaited()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_wait_for_api_ready_swallows_errors_and_times_out() -> None:
|
||||
"""Connection errors are swallowed; loop times out and warns."""
|
||||
client_instance = MagicMock()
|
||||
client_instance.get = AsyncMock(side_effect=ConnectionError("boom"))
|
||||
client_instance.__aenter__ = AsyncMock(return_value=client_instance)
|
||||
client_instance.__aexit__ = AsyncMock(return_value=False)
|
||||
sleep_mock = AsyncMock()
|
||||
with (
|
||||
patch("roboco.bootstrap.httpx.AsyncClient", return_value=client_instance),
|
||||
patch("roboco.bootstrap.asyncio.sleep", sleep_mock),
|
||||
):
|
||||
await _wait_for_api_ready(max_wait=4)
|
||||
# Loop ran a couple of iterations (2s each) before timing out.
|
||||
assert sleep_mock.await_count >= 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_wait_for_api_ready_keeps_polling_on_non_200() -> None:
|
||||
"""Non-200 status → keep polling until max_wait."""
|
||||
response = MagicMock()
|
||||
response.status_code = HTTPStatus.SERVICE_UNAVAILABLE
|
||||
client_instance = MagicMock()
|
||||
client_instance.get = AsyncMock(return_value=response)
|
||||
client_instance.__aenter__ = AsyncMock(return_value=client_instance)
|
||||
client_instance.__aexit__ = AsyncMock(return_value=False)
|
||||
with (
|
||||
patch("roboco.bootstrap.httpx.AsyncClient", return_value=client_instance),
|
||||
patch("roboco.bootstrap.asyncio.sleep", AsyncMock()),
|
||||
):
|
||||
await _wait_for_api_ready(max_wait=4)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# main()
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _make_main_patches(*, raise_on_spawn: bool = False):
|
||||
"""Bundle the heavy IO mocks main() needs.
|
||||
|
||||
Returns a context manager and the orchestrator mock so the test can
|
||||
inspect calls afterward.
|
||||
"""
|
||||
orchestrator_mock = MagicMock()
|
||||
orchestrator_mock.start = AsyncMock()
|
||||
orchestrator_mock.stop = AsyncMock()
|
||||
if raise_on_spawn:
|
||||
orchestrator_mock.spawn_agent = AsyncMock(side_effect=RuntimeError("boom"))
|
||||
else:
|
||||
orchestrator_mock.spawn_agent = AsyncMock()
|
||||
|
||||
event_bus_mock = MagicMock()
|
||||
event_bus_mock.start_listening = AsyncMock()
|
||||
event_bus_mock.disconnect = AsyncMock()
|
||||
|
||||
api_task_mock = AsyncMock() # api_task awaited inside main
|
||||
|
||||
return orchestrator_mock, event_bus_mock, api_task_mock
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_main_skip_orchestrator_returns_after_db_bootstrap() -> None:
|
||||
"""skip_orchestrator=True → only DB bootstrap runs, then early return."""
|
||||
db_mock = AsyncMock()
|
||||
with (
|
||||
patch("roboco.bootstrap.bootstrap_database", db_mock),
|
||||
patch("roboco.bootstrap.init_event_bus") as bus,
|
||||
):
|
||||
await main(skip_orchestrator=True)
|
||||
db_mock.assert_awaited_once()
|
||||
bus.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_main_skip_db_skips_database_bootstrap() -> None:
|
||||
"""skip_db=True → bootstrap_database not called, but rest still runs."""
|
||||
db_mock = AsyncMock()
|
||||
with (
|
||||
patch("roboco.bootstrap.bootstrap_database", db_mock),
|
||||
# Skip orchestrator so we exit early — we just want to verify db
|
||||
# bootstrap path.
|
||||
patch("roboco.bootstrap.init_event_bus") as bus,
|
||||
):
|
||||
await main(skip_db=True, skip_orchestrator=True)
|
||||
db_mock.assert_not_called()
|
||||
bus.assert_not_called()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_main_full_path_starts_orchestrator_and_shuts_down() -> None:
|
||||
"""Happy path: bootstrap, init bus, start orchestrator, await api task."""
|
||||
orch, bus, _ = _make_main_patches()
|
||||
|
||||
with (
|
||||
patch("roboco.bootstrap.bootstrap_database", AsyncMock()),
|
||||
patch("roboco.bootstrap.init_event_bus", AsyncMock(return_value=bus)),
|
||||
patch("roboco.bootstrap.register_default_handlers"),
|
||||
patch("roboco.bootstrap.start_websocket_bridge", AsyncMock()),
|
||||
patch("roboco.bootstrap.AgentOrchestrator", return_value=orch),
|
||||
patch("roboco.bootstrap.set_orchestrator"),
|
||||
patch("roboco.bootstrap.NotificationService"),
|
||||
patch("roboco.bootstrap.set_event_context"),
|
||||
patch("roboco.bootstrap.set_reasoning_stream_callback"),
|
||||
patch("roboco.bootstrap._wait_for_api_ready", AsyncMock()),
|
||||
# Replace _run_api_server with an AsyncMock that returns immediately;
|
||||
# create_task wraps the coroutine into a real Task that completes
|
||||
# without warnings.
|
||||
patch("roboco.bootstrap._run_api_server", AsyncMock(return_value=None)),
|
||||
):
|
||||
await main()
|
||||
|
||||
orch.start.assert_awaited_once()
|
||||
orch.stop.assert_awaited_once()
|
||||
bus.start_listening.assert_awaited_once()
|
||||
bus.disconnect.assert_awaited_once()
|
||||
assert _BootstrapHolder.orchestrator is None # Cleared in finally.
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_main_spawns_requested_agents() -> None:
|
||||
"""spawn_agents list → orchestrator.spawn_agent called for each."""
|
||||
orch, bus, _ = _make_main_patches()
|
||||
|
||||
with (
|
||||
patch("roboco.bootstrap.bootstrap_database", AsyncMock()),
|
||||
patch("roboco.bootstrap.init_event_bus", AsyncMock(return_value=bus)),
|
||||
patch("roboco.bootstrap.register_default_handlers"),
|
||||
patch("roboco.bootstrap.start_websocket_bridge", AsyncMock()),
|
||||
patch("roboco.bootstrap.AgentOrchestrator", return_value=orch),
|
||||
patch("roboco.bootstrap.set_orchestrator"),
|
||||
patch("roboco.bootstrap.NotificationService"),
|
||||
patch("roboco.bootstrap.set_event_context"),
|
||||
patch("roboco.bootstrap.set_reasoning_stream_callback"),
|
||||
patch("roboco.bootstrap._wait_for_api_ready", AsyncMock()),
|
||||
patch("roboco.bootstrap._run_api_server", AsyncMock(return_value=None)),
|
||||
):
|
||||
await main(spawn_agents=["be-dev-1", "fe-dev-1"])
|
||||
|
||||
_EXPECTED_SPAWNS = 2
|
||||
assert orch.spawn_agent.await_count == _EXPECTED_SPAWNS
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_main_logs_and_continues_when_spawn_fails() -> None:
|
||||
"""spawn_agent failure logs error but doesn't abort startup."""
|
||||
orch, bus, _ = _make_main_patches(raise_on_spawn=True)
|
||||
|
||||
with (
|
||||
patch("roboco.bootstrap.bootstrap_database", AsyncMock()),
|
||||
patch("roboco.bootstrap.init_event_bus", AsyncMock(return_value=bus)),
|
||||
patch("roboco.bootstrap.register_default_handlers"),
|
||||
patch("roboco.bootstrap.start_websocket_bridge", AsyncMock()),
|
||||
patch("roboco.bootstrap.AgentOrchestrator", return_value=orch),
|
||||
patch("roboco.bootstrap.set_orchestrator"),
|
||||
patch("roboco.bootstrap.NotificationService"),
|
||||
patch("roboco.bootstrap.set_event_context"),
|
||||
patch("roboco.bootstrap.set_reasoning_stream_callback"),
|
||||
patch("roboco.bootstrap._wait_for_api_ready", AsyncMock()),
|
||||
patch("roboco.bootstrap._run_api_server", AsyncMock(return_value=None)),
|
||||
):
|
||||
# Should not raise — error is caught + logged.
|
||||
await main(spawn_agents=["broken-agent"])
|
||||
|
||||
orch.spawn_agent.assert_awaited_once()
|
||||
orch.stop.assert_awaited_once() # Cleanup still ran.
|
||||
|
||||
|
||||
def test_module_run_as_script_invokes_cli() -> None:
|
||||
"""`python -m roboco.bootstrap` → calls `roboco.cli.cli()`."""
|
||||
cli_mock = MagicMock()
|
||||
with patch.dict(
|
||||
"sys.modules",
|
||||
{"roboco.cli": MagicMock(cli=cli_mock)},
|
||||
):
|
||||
runpy.run_module("roboco.bootstrap", run_name="__main__")
|
||||
cli_mock.assert_called_once()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_main_handles_api_task_cancellation() -> None:
|
||||
"""If api_task is cancelled, finally block still runs cleanup."""
|
||||
orch, bus, _ = _make_main_patches()
|
||||
|
||||
async def _raise_cancelled() -> None:
|
||||
raise asyncio.CancelledError()
|
||||
|
||||
with (
|
||||
patch("roboco.bootstrap.bootstrap_database", AsyncMock()),
|
||||
patch("roboco.bootstrap.init_event_bus", AsyncMock(return_value=bus)),
|
||||
patch("roboco.bootstrap.register_default_handlers"),
|
||||
patch("roboco.bootstrap.start_websocket_bridge", AsyncMock()),
|
||||
patch("roboco.bootstrap.AgentOrchestrator", return_value=orch),
|
||||
patch("roboco.bootstrap.set_orchestrator"),
|
||||
patch("roboco.bootstrap.NotificationService"),
|
||||
patch("roboco.bootstrap.set_event_context"),
|
||||
patch("roboco.bootstrap.set_reasoning_stream_callback"),
|
||||
patch("roboco.bootstrap._wait_for_api_ready", AsyncMock()),
|
||||
patch("roboco.bootstrap._run_api_server", _raise_cancelled),
|
||||
):
|
||||
await main()
|
||||
|
||||
# Cleanup ran despite cancellation.
|
||||
orch.stop.assert_awaited_once()
|
||||
bus.disconnect.assert_awaited_once()
|
||||
Reference in New Issue
Block a user