test: make integration tests work again

ref: N25B-301

test/integration/agents/actuation/test_robot_speech_agent.py

@@ -1,16 +1,17 @@
 import json
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 import zmq
 
 from control_backend.agents.actuation.robot_speech_agent import RobotSpeechAgent
+from control_backend.core.agent_system import InternalMessage
 
 
 @pytest.fixture
 def zmq_context(mocker):
     mock_context = mocker.patch(
-        "control_backend.agents.actuation.robot_speech_agent.zmq.Context.instance"
+        "control_backend.agents.actuation.robot_speech_agent.azmq.Context.instance"
     )
     mock_context.return_value = MagicMock()
     return mock_context
@@ -18,81 +19,140 @@ def zmq_context(mocker):
 
 @pytest.mark.asyncio
 async def test_setup_bind(zmq_context, mocker):
-    """Test setup with bind=True"""
+    """Setup binds and subscribes to internal commands."""
     fake_socket = zmq_context.return_value.socket.return_value
-
-    agent = RobotSpeechAgent("test@server", "password", address="tcp://localhost:5555", bind=True)
+    agent = RobotSpeechAgent("robot_speech", address="tcp://localhost:5555", bind=True)
     settings = mocker.patch("control_backend.agents.actuation.robot_speech_agent.settings")
     settings.zmq_settings.internal_sub_address = "tcp://internal:1234"
 
+    # Swallow background task coroutines to avoid un-awaited warnings
+    class Swallow:
+        def __init__(self):
+            self.calls = 0
+
+        async def __call__(self, coro):
+            self.calls += 1
+            coro.close()
+
+    swallow = Swallow()
+    agent.add_background_task = swallow
+
     await agent.setup()
 
     fake_socket.bind.assert_any_call("tcp://localhost:5555")
     fake_socket.connect.assert_any_call("tcp://internal:1234")
     fake_socket.setsockopt.assert_any_call(zmq.SUBSCRIBE, b"command")
-
-    # Ensure behaviour attached
-    assert any(isinstance(b, agent.SendZMQCommandsBehaviour) for b in agent.behaviours)
+    assert swallow.calls == 1
 
 
 @pytest.mark.asyncio
 async def test_setup_connect(zmq_context, mocker):
-    """Test setup with bind=False"""
+    """Setup connects when bind=False."""
     fake_socket = zmq_context.return_value.socket.return_value
-
-    agent = RobotSpeechAgent("test@server", "password", address="tcp://localhost:5555", bind=False)
+    agent = RobotSpeechAgent("robot_speech", address="tcp://localhost:5555", bind=False)
     settings = mocker.patch("control_backend.agents.actuation.robot_speech_agent.settings")
     settings.zmq_settings.internal_sub_address = "tcp://internal:1234"
 
+    class Swallow:
+        def __init__(self):
+            self.calls = 0
+
+        async def __call__(self, coro):
+            self.calls += 1
+            coro.close()
+
+    swallow = Swallow()
+    agent.add_background_task = swallow
+
     await agent.setup()
 
     fake_socket.connect.assert_any_call("tcp://localhost:5555")
+    fake_socket.connect.assert_any_call("tcp://internal:1234")
+    assert swallow.calls == 1
 
 
 @pytest.mark.asyncio
-async def test_send_commands_behaviour_valid_message():
-    """Test behaviour with valid JSON message"""
-    fake_socket = AsyncMock()
-    message_dict = {"message": "hello"}
-    fake_socket.recv_multipart = AsyncMock(
-        return_value=(b"command", json.dumps(message_dict).encode("utf-8"))
-    )
-    fake_socket.send_json = AsyncMock()
+async def test_handle_message_sends_command():
+    """Internal message is forwarded to robot pub socket as JSON."""
+    pubsocket = AsyncMock()
+    agent = RobotSpeechAgent("robot_speech")
+    agent.pubsocket = pubsocket
 
-    agent = RobotSpeechAgent("test@server", "password")
-    agent.subsocket = fake_socket
-    agent.pubsocket = fake_socket
+    payload = {"endpoint": "actuate/speech", "data": "hello"}
+    msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))
 
-    behaviour = agent.SendZMQCommandsBehaviour()
-    behaviour.agent = agent
+    await agent.handle_message(msg)
 
-    with patch(
-        "control_backend.agents.actuation.robot_speech_agent.SpeechCommand"
-    ) as MockSpeechCommand:
-        mock_message = MagicMock()
-        MockSpeechCommand.model_validate.return_value = mock_message
-
-        await behaviour.run()
-
-    fake_socket.recv_multipart.assert_awaited()
-    fake_socket.send_json.assert_awaited_with(mock_message.model_dump())
+    pubsocket.send_json.assert_awaited_once_with(payload)
 
 
 @pytest.mark.asyncio
-async def test_send_commands_behaviour_invalid_message():
-    """Test behaviour with invalid JSON message triggers error logging"""
+async def test_zmq_command_loop_valid_payload(zmq_context):
+    """UI command is read from SUB and published."""
+    command = {"endpoint": "actuate/speech", "data": "hello"}
     fake_socket = AsyncMock()
-    fake_socket.recv_multipart = AsyncMock(return_value=(b"command", b"{invalid_json}"))
-    fake_socket.send_json = AsyncMock()
 
-    agent = RobotSpeechAgent("test@server", "password")
+    async def recv_once():
+        # stop after first iteration
+        agent._running = False
+        return (b"command", json.dumps(command).encode("utf-8"))
+
+    fake_socket.recv_multipart = recv_once
+    fake_socket.send_json = AsyncMock()
+    agent = RobotSpeechAgent("robot_speech")
     agent.subsocket = fake_socket
     agent.pubsocket = fake_socket
+    agent._running = True
 
-    behaviour = agent.SendZMQCommandsBehaviour()
-    behaviour.agent = agent
+    await agent._zmq_command_loop()
 
-    await behaviour.run()
+    fake_socket.send_json.assert_awaited_once_with(command)
+
+
+@pytest.mark.asyncio
+async def test_zmq_command_loop_invalid_json():
+    """Invalid JSON is ignored without sending."""
+    fake_socket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return (b"command", b"{not_json}")
+
+    fake_socket.recv_multipart = recv_once
+    fake_socket.send_json = AsyncMock()
+    agent = RobotSpeechAgent("robot_speech")
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
 
-    fake_socket.recv_multipart.assert_awaited()
     fake_socket.send_json.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_handle_message_invalid_payload():
+    """Invalid payload is caught and does not send."""
+    pubsocket = AsyncMock()
+    agent = RobotSpeechAgent("robot_speech")
+    agent.pubsocket = pubsocket
+
+    msg = InternalMessage(to="robot", sender="tester", body=json.dumps({"bad": "data"}))
+
+    await agent.handle_message(msg)
+
+    pubsocket.send_json.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_stop_closes_sockets():
+    pubsocket = MagicMock()
+    subsocket = MagicMock()
+    agent = RobotSpeechAgent("robot_speech")
+    agent.pubsocket = pubsocket
+    agent.subsocket = subsocket
+
+    await agent.stop()
+
+    pubsocket.close.assert_called_once()
+    subsocket.close.assert_called_once()