Timmy-time-dashboard/tests/loop/test_heartbeat.py

"""Tests for Heartbeat v2 — WorldInterface-driven cognitive loop.

Acceptance criteria:
- With MockWorldAdapter: heartbeat runs, logs show observe→reason→act→reflect
- Without adapter: existing think_once() behaviour unchanged
- WebSocket broadcasts include current action and reasoning summary
"""

import asyncio
from unittest.mock import AsyncMock, patch

import pytest

from infrastructure.world.adapters.mock import MockWorldAdapter
from infrastructure.world.types import ActionStatus
from loop.heartbeat import CycleRecord, Heartbeat


@pytest.fixture
def mock_adapter():
    adapter = MockWorldAdapter(
        location="Balmora",
        entities=["Guard", "Merchant"],
        events=["player_entered"],
    )
    adapter.connect()
    return adapter


class TestHeartbeatWithAdapter:
    """With MockWorldAdapter: heartbeat runs full embodied cycle."""

    @pytest.mark.asyncio
    async def test_run_once_returns_cycle_record(self, mock_adapter):
        hb = Heartbeat(world=mock_adapter)
        record = await hb.run_once()
        assert isinstance(record, CycleRecord)
        assert record.cycle_id == 1

    @pytest.mark.asyncio
    async def test_observation_populated(self, mock_adapter):
        hb = Heartbeat(world=mock_adapter)
        record = await hb.run_once()
        assert record.observation["location"] == "Balmora"
        assert "Guard" in record.observation["entities"]
        assert "player_entered" in record.observation["events"]

    @pytest.mark.asyncio
    async def test_action_dispatched_to_world(self, mock_adapter):
        """Act phase should dispatch to world.act() for non-idle actions."""
        hb = Heartbeat(world=mock_adapter)
        record = await hb.run_once()
        # The default loop phases don't set an explicit action, so it
        # falls through to "idle" → NOOP. That's correct behaviour —
        # the real LLM-powered reason phase will set action metadata.
        assert record.action_status in (
            ActionStatus.NOOP.value,
            ActionStatus.SUCCESS.value,
        )

    @pytest.mark.asyncio
    async def test_reflect_notes_present(self, mock_adapter):
        hb = Heartbeat(world=mock_adapter)
        record = await hb.run_once()
        assert "Balmora" in record.reflect_notes

    @pytest.mark.asyncio
    async def test_cycle_count_increments(self, mock_adapter):
        hb = Heartbeat(world=mock_adapter)
        await hb.run_once()
        await hb.run_once()
        assert hb.cycle_count == 2
        assert len(hb.history) == 2

    @pytest.mark.asyncio
    async def test_duration_recorded(self, mock_adapter):
        hb = Heartbeat(world=mock_adapter)
        record = await hb.run_once()
        assert record.duration_ms >= 0

    @pytest.mark.asyncio
    async def test_on_cycle_callback(self, mock_adapter):
        received = []
        async def callback(record):
            received.append(record)

        hb = Heartbeat(world=mock_adapter, on_cycle=callback)
        await hb.run_once()
        assert len(received) == 1
        assert received[0].cycle_id == 1


class TestHeartbeatWithoutAdapter:
    """Without adapter: existing think_once() behaviour unchanged."""

    @pytest.mark.asyncio
    async def test_passive_cycle(self):
        hb = Heartbeat(world=None)
        record = await hb.run_once()
        assert record.action_taken == "think"
        assert record.action_status == "noop"
        assert "Passive" in record.reflect_notes

    @pytest.mark.asyncio
    async def test_passive_no_observation(self):
        hb = Heartbeat(world=None)
        record = await hb.run_once()
        assert record.observation == {}


class TestHeartbeatLifecycle:
    def test_interval_property(self):
        hb = Heartbeat(interval=60.0)
        assert hb.interval == 60.0
        hb.interval = 10.0
        assert hb.interval == 10.0

    def test_interval_minimum(self):
        hb = Heartbeat()
        hb.interval = 0.1
        assert hb.interval == 1.0

    def test_world_property(self):
        hb = Heartbeat()
        assert hb.world is None
        adapter = MockWorldAdapter()
        hb.world = adapter
        assert hb.world is adapter

    def test_stop_sets_flag(self):
        hb = Heartbeat()
        assert not hb.is_running
        hb.stop()
        assert not hb.is_running


class TestHeartbeatBroadcast:
    """WebSocket broadcasts include action and reasoning summary."""

    @pytest.mark.asyncio
    async def test_broadcast_called(self, mock_adapter):
        with patch(
            "loop.heartbeat.ws_manager",
            create=True,
        ) as mock_ws:
            mock_ws.broadcast = AsyncMock()
            # Patch the import inside heartbeat
            with patch(
                "infrastructure.ws_manager.handler.ws_manager"
            ) as ws_mod:
                ws_mod.broadcast = AsyncMock()
                hb = Heartbeat(world=mock_adapter)
                await hb.run_once()
                ws_mod.broadcast.assert_called_once()
                call_args = ws_mod.broadcast.call_args
                assert call_args[0][0] == "heartbeat.cycle"
                data = call_args[0][1]
                assert "action" in data
                assert "reasoning_summary" in data
                assert "observation" in data


class TestHeartbeatLog:
    """Verify logging of observe→reason→act→reflect cycle."""

    @pytest.mark.asyncio
    async def test_embodied_cycle_logs(self, mock_adapter, caplog):
        import logging

        with caplog.at_level(logging.INFO):
            hb = Heartbeat(world=mock_adapter)
            await hb.run_once()

        messages = caplog.text
        assert "Phase 1 (Gather)" in messages
        assert "Phase 2 (Reason)" in messages
        assert "Phase 3 (Act)" in messages
        assert "Heartbeat cycle #1 complete" in messages