Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

14.8 KB
Raw Blame
from __future__ import annotations

import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock

import pytest

from core.controller import Controller


def test_runtime_services_start_when_post_update_notification_fails() -> None:
    controller = Controller.__new__(Controller)
    opencode_agent = SimpleNamespace(restore_active_polls=AsyncMock(return_value=0))
    codex_agent = SimpleNamespace(prepare_model_hub_runtime=AsyncMock())
    controller.agent_service = SimpleNamespace(
        agents={"opencode": opencode_agent, "codex": codex_agent}
    )
    controller.primary_platform = "discord"
    controller.update_checker = SimpleNamespace(
        check_and_send_post_update_notification=AsyncMock(side_effect=ConnectionError("transport unavailable")),
        start=Mock(),
    )
    controller.scheduled_task_service = SimpleNamespace(
        start=Mock(),
        notify_transport_ready=Mock(),
        recover_processing_requests=Mock(),
    )
    controller.watch_service = SimpleNamespace(start=Mock())
    controller.runtime_command_watcher = SimpleNamespace(start=AsyncMock())
    controller.session_turns = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(return_value=[]),
        recover_persisted_agent_run_queue=AsyncMock(return_value=[]),
    )
    controller.runtime_work_supervisor = SimpleNamespace(activate=AsyncMock())
    seed_started = []

    async def seed_vibey_supply():
        # A first start may wait on models.dev; startup must not wait with it.
        seed_started.append(True)
        await asyncio.Event().wait()

    controller.model_hub_service = SimpleNamespace(
        recover_runtime_intent=AsyncMock(),
        seed_vibey_supply=seed_vibey_supply,
    )
    controller.vibey_model_supply_task = None
    controller._get_idle_cleanup_timeouts = Mock(return_value=(0, 0))
    controller.cleanup_task = None
    controller.trace_retention_task = None
    controller._delivery_recovery_complete = asyncio.Event()
    # This is the only test here that gets past the readiness boundary inside
    # `_on_runtime_ready()`, and the announcement asks the IM runtime whether it
    # died first. Publishing itself is a no-op in a process that does not hold
    # the service lock, which no test process does.
    controller._im_run_exception = None

    async def start_up():
        await asyncio.wait_for(controller._on_runtime_ready(), timeout=5)
        await asyncio.sleep(0)

    asyncio.run(start_up())
    assert seed_started == [True]

    opencode_agent.restore_active_polls.assert_awaited_once_with({"avibe"})
    codex_agent.prepare_model_hub_runtime.assert_awaited_once_with()
    controller.update_checker.check_and_send_post_update_notification.assert_awaited_once_with(
        ready_platform="avibe"
    )
    controller.update_checker.start.assert_called_once_with()
    controller.scheduled_task_service.start.assert_called_once_with()
    controller.watch_service.start.assert_called_once_with()
    controller.runtime_command_watcher.start.assert_awaited_once_with()
    controller.session_turns.recover_durable_delivery_state.assert_awaited_once_with(
        service_restart=True
    )
    controller.session_turns.recover_persisted_agent_run_queue.assert_awaited_once_with()
    controller.scheduled_task_service.recover_processing_requests.assert_called_once_with()
    controller.runtime_work_supervisor.activate.assert_awaited_once_with()
    controller.model_hub_service.recover_runtime_intent.assert_awaited_once_with()
    assert controller._delivery_recovery_complete.is_set()


def test_transport_ready_restores_only_its_state() -> None:
    controller = Controller.__new__(Controller)
    opencode_agent = SimpleNamespace(restore_active_polls=AsyncMock(return_value=1))
    controller.agent_service = SimpleNamespace(agents={"opencode": opencode_agent})
    controller.primary_platform = "discord"
    controller.update_checker = SimpleNamespace(
        check_and_send_post_update_notification=AsyncMock(return_value=True),
        notify_transport_ready=Mock(),
        start=Mock(),
    )
    controller.scheduled_task_service = SimpleNamespace(start=Mock(), notify_transport_ready=Mock())
    controller.session_turns = SimpleNamespace(
        notify_transport_ready=AsyncMock(return_value=0)
    )
    controller.watch_service = SimpleNamespace(start=Mock())
    controller.runtime_command_watcher = SimpleNamespace(start=AsyncMock())
    controller.runtime_work_supervisor = SimpleNamespace(notify=Mock())
    controller._delivery_recovery_complete = asyncio.Event()
    controller._delivery_recovery_complete.set()

    asyncio.run(controller._on_im_ready(platform="discord"))

    opencode_agent.restore_active_polls.assert_awaited_once_with({"discord", ""})
    controller.scheduled_task_service.notify_transport_ready.assert_called_once_with("discord")
    # Interruption reports held during recovery are owed to this transport.
    controller.session_turns.notify_transport_ready.assert_awaited_once_with("discord")
    controller.update_checker.notify_transport_ready.assert_called_once_with("discord")
    controller.update_checker.check_and_send_post_update_notification.assert_awaited_once_with(
        ready_platform="discord"
    )
    controller.update_checker.start.assert_not_called()
    controller.scheduled_task_service.start.assert_not_called()
    controller.watch_service.start.assert_not_called()
    controller.runtime_command_watcher.start.assert_not_awaited()
    controller.runtime_work_supervisor.notify.assert_not_called()


def test_transport_ready_registers_polls_before_owner_recovery() -> None:
    async def exercise() -> None:
        controller = Controller.__new__(Controller)
        restore_entered = asyncio.Event()

        async def restore_active_polls(platforms: set[str]) -> int:
            assert platforms == {"slack", ""}
            restore_entered.set()
            return 1

        controller.agent_service = SimpleNamespace(
            agents={
                "opencode": SimpleNamespace(
                    restore_active_polls=AsyncMock(side_effect=restore_active_polls)
                )
            }
        )
        controller.primary_platform = "slack"
        controller.update_checker = SimpleNamespace(
            check_and_send_post_update_notification=AsyncMock(return_value=True),
            notify_transport_ready=Mock(),
        )
        controller.scheduled_task_service = SimpleNamespace(
            notify_transport_ready=Mock()
        )
        controller.session_turns = SimpleNamespace(
            notify_transport_ready=AsyncMock(return_value=0)
        )
        controller._delivery_recovery_complete = asyncio.Event()

        ready = asyncio.create_task(controller._on_im_ready(platform="slack"))
        await restore_entered.wait()

        assert not ready.done()
        controller.session_turns.notify_transport_ready.assert_not_awaited()
        controller.scheduled_task_service.notify_transport_ready.assert_not_called()
        controller.update_checker.notify_transport_ready.assert_not_called()
        controller.update_checker.check_and_send_post_update_notification.assert_not_awaited()

        controller._delivery_recovery_complete.set()
        await ready

        controller.scheduled_task_service.notify_transport_ready.assert_called_once_with(
            "slack"
        )
        controller.session_turns.notify_transport_ready.assert_awaited_once_with("slack")
        controller.update_checker.notify_transport_ready.assert_called_once_with("slack")

    asyncio.run(exercise())


def test_runtime_owner_recovery_fails_closed_after_delivery_failure() -> None:
    controller = Controller.__new__(Controller)
    controller.session_turns = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(side_effect=RuntimeError("owner recovery failed")),
        recover_persisted_agent_run_queue=AsyncMock(return_value=[]),
    )
    controller.runtime_work_supervisor = SimpleNamespace(activate=AsyncMock())
    controller.scheduled_task_service = SimpleNamespace(
        recover_processing_requests=Mock()
    )
    controller._delivery_recovery_complete = asyncio.Event()

    with pytest.raises(RuntimeError, match="owner recovery failed"):
        asyncio.run(controller._recover_runtime_owners())

    controller.session_turns.recover_durable_delivery_state.assert_awaited_once_with(
        service_restart=True
    )
    controller.session_turns.recover_persisted_agent_run_queue.assert_not_awaited()
    controller.scheduled_task_service.recover_processing_requests.assert_not_called()
    controller.runtime_work_supervisor.activate.assert_not_awaited()
    assert not controller._delivery_recovery_complete.is_set()


def test_runtime_owner_recovery_isolates_optional_model_hub_failure(
    caplog: pytest.LogCaptureFixture,
) -> None:
    controller = Controller.__new__(Controller)
    controller.model_hub_service = SimpleNamespace(
        recover_runtime_intent=AsyncMock(
            side_effect=OSError("runtime directory is unwritable")
        )
    )
    controller.session_turns = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(return_value=[]),
        recover_persisted_agent_run_queue=AsyncMock(return_value=[]),
    )
    controller.scheduled_task_service = SimpleNamespace(
        recover_processing_requests=Mock()
    )
    controller.runtime_work_supervisor = SimpleNamespace(activate=AsyncMock())
    controller._delivery_recovery_complete = asyncio.Event()

    with caplog.at_level("ERROR"):
        asyncio.run(controller._recover_runtime_owners())

    controller.model_hub_service.recover_runtime_intent.assert_awaited_once_with()
    controller.session_turns.recover_durable_delivery_state.assert_awaited_once_with(
        service_restart=True
    )
    controller.session_turns.recover_persisted_agent_run_queue.assert_awaited_once_with()
    controller.scheduled_task_service.recover_processing_requests.assert_called_once_with()
    controller.runtime_work_supervisor.activate.assert_awaited_once_with()
    assert controller._delivery_recovery_complete.is_set()
    assert "Model Hub runtime recovery failed" in caplog.text


@pytest.mark.parametrize("vibey_recovery_fails", [False, True])
def test_runtime_owner_recovery_settles_vibey_tool_calls_before_turns(vibey_recovery_fails: bool) -> None:
    # recovery.md: T2 before T4. A Turn the restart interrupted is reported only after its
    # running command became a Watch, so the notice can say so instead of asking for a resend.
    order: list[str] = []

    async def vibey_pass() -> list[str]:
        order.append("vibey T2")
        if vibey_recovery_fails:
            raise OSError("jobs directory unreadable")
        return []

    async def turns_pass(**_kwargs) -> list[str]:
        order.append("Turn T4")
        return []

    controller = Controller.__new__(Controller)
    controller.vibey_recovery = SimpleNamespace(start=AsyncMock(side_effect=vibey_pass))
    controller.session_turns = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(side_effect=turns_pass),
        recover_persisted_agent_run_queue=AsyncMock(return_value=[]),
    )
    controller.scheduled_task_service = SimpleNamespace(recover_processing_requests=Mock())
    controller.runtime_work_supervisor = SimpleNamespace(activate=AsyncMock())
    controller._delivery_recovery_complete = asyncio.Event()

    asyncio.run(controller._recover_runtime_owners())

    # Best effort, as before: the Avibe pass retries on its own and never blocks the delivery owners.
    assert order == ["vibey T2", "Turn T4"]
    assert controller._delivery_recovery_complete.is_set()


def test_runtime_ready_fails_closed_after_queue_recovery_failure() -> None:
    controller = Controller.__new__(Controller)
    controller.agent_service = SimpleNamespace(agents={})
    controller.primary_platform = "discord"
    controller.update_checker = SimpleNamespace(
        check_and_send_post_update_notification=AsyncMock(),
        start=Mock(),
    )
    controller.scheduled_task_service = SimpleNamespace(
        start=Mock(),
        recover_processing_requests=Mock(),
    )
    controller.watch_service = SimpleNamespace(start=Mock())
    controller.runtime_command_watcher = SimpleNamespace(start=AsyncMock())
    controller.session_turns = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(return_value=[]),
        recover_persisted_agent_run_queue=AsyncMock(
            side_effect=RuntimeError("queue recovery failed")
        ),
    )
    controller.runtime_work_supervisor = SimpleNamespace(activate=AsyncMock())
    controller._delivery_recovery_complete = asyncio.Event()
    controller._shutdown_requested = False
    controller._loop = None

    with pytest.raises(RuntimeError, match="queue recovery failed"):
        asyncio.run(controller._on_runtime_ready())

    controller.runtime_work_supervisor.activate.assert_not_awaited()
    controller.scheduled_task_service.recover_processing_requests.assert_not_called()
    controller.scheduled_task_service.start.assert_not_called()
    controller.watch_service.start.assert_not_called()
    controller.runtime_command_watcher.start.assert_not_awaited()
    controller.update_checker.start.assert_not_called()
    assert not controller._delivery_recovery_complete.is_set()
    assert controller._shutdown_requested is True


def test_runtime_ready_fails_closed_after_fallback_recovery_failure() -> None:
    controller = Controller.__new__(Controller)
    controller.agent_service = SimpleNamespace(agents={})
    controller.primary_platform = "discord"
    controller.update_checker = SimpleNamespace(
        check_and_send_post_update_notification=AsyncMock(),
        start=Mock(),
    )
    controller.scheduled_task_service = SimpleNamespace(
        start=Mock(),
        recover_processing_requests=Mock(
            side_effect=RuntimeError("fallback recovery failed")
        ),
    )
    controller.watch_service = SimpleNamespace(start=Mock())
    controller.runtime_command_watcher = SimpleNamespace(start=AsyncMock())
    controller.session_turns = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(return_value=[]),
        recover_persisted_agent_run_queue=AsyncMock(return_value=[]),
    )
    controller.runtime_work_supervisor = SimpleNamespace(activate=AsyncMock())
    controller._delivery_recovery_complete = asyncio.Event()
    controller._shutdown_requested = False
    controller._loop = None

    with pytest.raises(RuntimeError, match="fallback recovery failed"):
        asyncio.run(controller._on_runtime_ready())

    controller.runtime_work_supervisor.activate.assert_not_awaited()
    controller.scheduled_task_service.start.assert_not_called()
    controller.watch_service.start.assert_not_called()
    controller.runtime_command_watcher.start.assert_not_awaited()
    controller.update_checker.start.assert_not_called()
    assert not controller._delivery_recovery_complete.is_set()
    assert controller._shutdown_requested is True