Merge remote-tracking branch 'origin/dev' into feat/environment-variables

# Conflicts: # src/control_backend/core/config.py # test/unit/agents/actuation/test_robot_speech_agent.py
2025-12-29 12:35:39 +01:00
parent 0c682d6440 adbb7ffd5c
commit 5282c2471f
23 changed files with 1477 additions and 49 deletions
--- a/test/unit/agents/actuation/test_robot_gesture_agent.py
+++ b/test/unit/agents/actuation/test_robot_gesture_agent.py
@@ -0,0 +1,444 @@
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+import zmq
+
+from control_backend.agents.actuation.robot_gesture_agent import RobotGestureAgent
+from control_backend.core.agent_system import InternalMessage
+from control_backend.schemas.ri_message import RIEndpoint
+
+
+@pytest.fixture
+def zmq_context(mocker):
+    """Mock the ZMQ context."""
+    mock_context = mocker.patch(
+        "control_backend.agents.actuation.robot_gesture_agent.azmq.Context.instance"
+    )
+    mock_context.return_value = MagicMock()
+    return mock_context
+
+
+@pytest.mark.asyncio
+async def test_setup_bind(zmq_context, mocker):
+    """Setup binds and subscribes to internal commands."""
+    fake_socket = zmq_context.return_value.socket.return_value
+    agent = RobotGestureAgent("robot_gesture", address="tcp://localhost:5556", bind=True)
+
+    settings = mocker.patch("control_backend.agents.actuation.robot_gesture_agent.settings")
+    settings.zmq_settings.internal_sub_address = "tcp://internal:1234"
+
+    agent.add_behavior = MagicMock()
+
+    await agent.setup()
+
+    # Check PUB socket binding
+    fake_socket.bind.assert_any_call("tcp://localhost:5556")
+    # Check REP socket binding
+    fake_socket.bind.assert_called()
+
+    # Check SUB socket connection and subscriptions
+    fake_socket.connect.assert_any_call("tcp://internal:1234")
+    fake_socket.setsockopt.assert_any_call(zmq.SUBSCRIBE, b"command")
+    fake_socket.setsockopt.assert_any_call(zmq.SUBSCRIBE, b"send_gestures")
+
+    # Check behavior was added (twice: once for command loop, once for fetch gestures loop)
+    assert agent.add_behavior.call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_setup_connect(zmq_context, mocker):
+    """Setup connects when bind=False."""
+    fake_socket = zmq_context.return_value.socket.return_value
+    agent = RobotGestureAgent("robot_gesture", address="tcp://localhost:5556", bind=False)
+
+    settings = mocker.patch("control_backend.agents.actuation.robot_gesture_agent.settings")
+    settings.zmq_settings.internal_sub_address = "tcp://internal:1234"
+
+    agent.add_behavior = MagicMock()
+
+    await agent.setup()
+
+    # Check PUB socket connection (not binding)
+    fake_socket.connect.assert_any_call("tcp://localhost:5556")
+    fake_socket.connect.assert_any_call("tcp://internal:1234")
+    # Check REP socket binding (always binds)
+    fake_socket.bind.assert_called()
+
+    # Check behavior was added (twice)
+    assert agent.add_behavior.call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_handle_message_sends_valid_gesture_command():
+    """Internal message with valid gesture tag is forwarded to robot pub socket."""
+    pubsocket = AsyncMock()
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.pubsocket = pubsocket
+
+    payload = {
+        "endpoint": RIEndpoint.GESTURE_TAG,
+        "data": "hello",  # "hello" is in gesture_data
+    }
+    msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))
+
+    await agent.handle_message(msg)
+
+    pubsocket.send_json.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_handle_message_sends_non_gesture_command():
+    """Internal message with non-gesture endpoint is not forwarded by this agent."""
+    pubsocket = AsyncMock()
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.pubsocket = pubsocket
+
+    payload = {"endpoint": "some_other_endpoint", "data": "invalid_tag_not_in_list"}
+    msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))
+
+    await agent.handle_message(msg)
+
+    # Non-gesture endpoints should not be forwarded by this agent
+    pubsocket.send_json.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_handle_message_rejects_invalid_gesture_tag():
+    """Internal message with invalid gesture tag is not forwarded."""
+    pubsocket = AsyncMock()
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.pubsocket = pubsocket
+
+    # Use a tag that's not in gesture_data
+    payload = {"endpoint": RIEndpoint.GESTURE_TAG, "data": "invalid_tag_not_in_list"}
+    msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))
+
+    await agent.handle_message(msg)
+
+    pubsocket.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 = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    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_zmq_command_loop_valid_gesture_payload():
+    """UI command with valid gesture tag is read from SUB and published."""
+    command = {"endpoint": RIEndpoint.GESTURE_TAG, "data": "hello"}
+    fake_socket = AsyncMock()
+
+    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 = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
+
+    fake_socket.send_json.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_zmq_command_loop_valid_non_gesture_payload():
+    """UI command with non-gesture endpoint is not forwarded by this agent."""
+    command = {"endpoint": "some_other_endpoint", "data": "anything"}
+    fake_socket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return (b"command", json.dumps(command).encode("utf-8"))
+
+    fake_socket.recv_multipart = recv_once
+    fake_socket.send_json = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
+
+    fake_socket.send_json.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_zmq_command_loop_invalid_gesture_tag():
+    """UI command with invalid gesture tag is not forwarded."""
+    command = {"endpoint": RIEndpoint.GESTURE_TAG, "data": "invalid_tag_not_in_list"}
+    fake_socket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return (b"command", json.dumps(command).encode("utf-8"))
+
+    fake_socket.recv_multipart = recv_once
+    fake_socket.send_json = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
+
+    fake_socket.send_json.assert_not_awaited()
+
+
+@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 = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
+
+    fake_socket.send_json.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_zmq_command_loop_ignores_send_gestures_topic():
+    """send_gestures topic is ignored in command loop."""
+    fake_socket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return (b"send_gestures", b"{}")
+
+    fake_socket.recv_multipart = recv_once
+    fake_socket.send_json = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
+
+    fake_socket.send_json.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_fetch_gestures_loop_without_amount():
+    """Fetch gestures request without amount returns all tags."""
+    fake_repsocket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return b"{}"  # Empty JSON request
+
+    fake_repsocket.recv = recv_once
+    fake_repsocket.send = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no", "wave", "point"])
+    agent.repsocket = fake_repsocket
+    agent._running = True
+
+    await agent._fetch_gestures_loop()
+
+    fake_repsocket.send.assert_awaited_once()
+
+    # Check the response contains all tags
+    args, kwargs = fake_repsocket.send.call_args
+    response = json.loads(args[0])
+    assert "tags" in response
+    assert response["tags"] == ["hello", "yes", "no", "wave", "point"]
+
+
+@pytest.mark.asyncio
+async def test_fetch_gestures_loop_with_amount():
+    """Fetch gestures request with amount returns limited tags."""
+    fake_repsocket = AsyncMock()
+    amount = 3
+
+    async def recv_once():
+        agent._running = False
+        return json.dumps(amount).encode()
+
+    fake_repsocket.recv = recv_once
+    fake_repsocket.send = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no", "wave", "point"])
+    agent.repsocket = fake_repsocket
+    agent._running = True
+
+    await agent._fetch_gestures_loop()
+
+    fake_repsocket.send.assert_awaited_once()
+
+    args, kwargs = fake_repsocket.send.call_args
+    response = json.loads(args[0])
+    assert "tags" in response
+    assert len(response["tags"]) == amount
+    assert response["tags"] == ["hello", "yes", "no"]
+
+
+@pytest.mark.asyncio
+async def test_fetch_gestures_loop_with_integer_request():
+    """Fetch gestures request with integer amount."""
+    fake_repsocket = AsyncMock()
+    amount = 2
+
+    async def recv_once():
+        agent._running = False
+        return json.dumps(amount).encode()
+
+    fake_repsocket.recv = recv_once
+    fake_repsocket.send = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.repsocket = fake_repsocket
+    agent._running = True
+
+    await agent._fetch_gestures_loop()
+
+    fake_repsocket.send.assert_awaited_once()
+
+    args, kwargs = fake_repsocket.send.call_args
+    response = json.loads(args[0])
+    assert response["tags"] == ["hello", "yes"]
+
+
+@pytest.mark.asyncio
+async def test_fetch_gestures_loop_with_invalid_json():
+    """Invalid JSON request returns all tags."""
+    fake_repsocket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return b"not_json"
+
+    fake_repsocket.recv = recv_once
+    fake_repsocket.send = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.repsocket = fake_repsocket
+    agent._running = True
+
+    await agent._fetch_gestures_loop()
+
+    fake_repsocket.send.assert_awaited_once()
+
+    args, kwargs = fake_repsocket.send.call_args
+    response = json.loads(args[0])
+    assert response["tags"] == ["hello", "yes", "no"]
+
+
+@pytest.mark.asyncio
+async def test_fetch_gestures_loop_with_non_integer_json():
+    """Non-integer JSON request returns all tags."""
+    fake_repsocket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return json.dumps({"not": "an_integer"}).encode()
+
+    fake_repsocket.recv = recv_once
+    fake_repsocket.send = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.repsocket = fake_repsocket
+    agent._running = True
+
+    await agent._fetch_gestures_loop()
+
+    fake_repsocket.send.assert_awaited_once()
+
+    args, kwargs = fake_repsocket.send.call_args
+    response = json.loads(args[0])
+    assert response["tags"] == ["hello", "yes", "no"]
+
+
+def test_gesture_data_attribute():
+    """Test that gesture_data returns the expected list."""
+    gesture_data = ["hello", "yes", "no", "wave"]
+    agent = RobotGestureAgent("robot_gesture", gesture_data=gesture_data)
+
+    assert agent.gesture_data == gesture_data
+    assert isinstance(agent.gesture_data, list)
+    assert len(agent.gesture_data) == 4
+    assert "hello" in agent.gesture_data
+    assert "yes" in agent.gesture_data
+    assert "no" in agent.gesture_data
+    assert "invalid_tag_not_in_list" not in agent.gesture_data
+
+
+@pytest.mark.asyncio
+async def test_stop_closes_sockets():
+    """Stop method closes all sockets."""
+    pubsocket = MagicMock()
+    subsocket = MagicMock()
+    repsocket = MagicMock()
+    agent = RobotGestureAgent("robot_gesture")
+    agent.pubsocket = pubsocket
+    agent.subsocket = subsocket
+    agent.repsocket = repsocket
+
+    await agent.stop()
+
+    pubsocket.close.assert_called_once()
+    subsocket.close.assert_called_once()
+    # Note: repsocket is not closed in stop() method, but you might want to add it
+    # repsocket.close.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_initialization_with_custom_gesture_data():
+    """Agent can be initialized with custom gesture data."""
+    custom_gestures = ["custom1", "custom2", "custom3"]
+    agent = RobotGestureAgent("robot_gesture", gesture_data=custom_gestures)
+
+    assert agent.gesture_data == custom_gestures
+
+
+@pytest.mark.asyncio
+async def test_fetch_gestures_loop_handles_exception():
+    """Exception in fetch gestures loop is caught and logged."""
+    fake_repsocket = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        raise Exception("Test exception")
+
+    fake_repsocket.recv = recv_once
+    fake_repsocket.send = AsyncMock()
+
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent.repsocket = fake_repsocket
+    agent.logger = MagicMock()
+    agent._running = True
+
+    # Should not raise exception
+    await agent._fetch_gestures_loop()
+
+    # Exception should be logged
+    agent.logger.exception.assert_called_once()
--- a/test/unit/agents/actuation/test_robot_speech_agent.py
+++ b/test/unit/agents/actuation/test_robot_speech_agent.py
@@ -8,6 +8,11 @@ from control_backend.agents.actuation.robot_speech_agent import RobotSpeechAgent
 from control_backend.core.agent_system import InternalMessage


+def mock_speech_agent():
+    agent = RobotSpeechAgent("robot_speech", address="tcp://localhost:5555", bind=False)
+    return agent
+
+
@pytest.fixture
 def zmq_context(mocker):
    mock_context = mocker.patch(
@@ -56,10 +61,10 @@ async def test_setup_connect(zmq_context, mocker):
 async def test_handle_message_sends_command():
    """Internal message is forwarded to robot pub socket as JSON."""
    pubsocket = AsyncMock()
-    agent = RobotSpeechAgent("robot_speech", "tcp://localhost:3498")
+    agent = mock_speech_agent()
    agent.pubsocket = pubsocket

-    payload = {"endpoint": "actuate/speech", "data": "hello"}
+    payload = {"endpoint": "actuate/speech", "data": "hello", "is_priority": False}
    msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))

    await agent.handle_message(msg)
@@ -70,7 +75,7 @@ async def test_handle_message_sends_command():
@pytest.mark.asyncio
 async def test_zmq_command_loop_valid_payload(zmq_context):
    """UI command is read from SUB and published."""
-    command = {"endpoint": "actuate/speech", "data": "hello"}
+    command = {"endpoint": "actuate/speech", "data": "hello", "is_priority": False}
    fake_socket = AsyncMock()

    async def recv_once():
@@ -80,7 +85,7 @@ async def test_zmq_command_loop_valid_payload(zmq_context):

    fake_socket.recv_multipart = recv_once
    fake_socket.send_json = AsyncMock()
-    agent = RobotSpeechAgent("robot_speech", "tcp://localhost:3498")
+    agent = mock_speech_agent()
    agent.subsocket = fake_socket
    agent.pubsocket = fake_socket
    agent._running = True
@@ -101,7 +106,7 @@ async def test_zmq_command_loop_invalid_json():

    fake_socket.recv_multipart = recv_once
    fake_socket.send_json = AsyncMock()
-    agent = RobotSpeechAgent("robot_speech", "tcp://localhost:3498")
+    agent = mock_speech_agent()
    agent.subsocket = fake_socket
    agent.pubsocket = fake_socket
    agent._running = True
@@ -115,7 +120,7 @@ async def test_zmq_command_loop_invalid_json():
 async def test_handle_message_invalid_payload():
    """Invalid payload is caught and does not send."""
    pubsocket = AsyncMock()
-    agent = RobotSpeechAgent("robot_speech", "tcp://localhost:3498")
+    agent = mock_speech_agent()
    agent.pubsocket = pubsocket

    msg = InternalMessage(to="robot", sender="tester", body=json.dumps({"bad": "data"}))
@@ -129,7 +134,7 @@ async def test_handle_message_invalid_payload():
 async def test_stop_closes_sockets():
    pubsocket = MagicMock()
    subsocket = MagicMock()
-    agent = RobotSpeechAgent("robot_speech", "tcp://localhost:3498")
+    agent = mock_speech_agent()
    agent.pubsocket = pubsocket
    agent.subsocket = subsocket

--- a/test/unit/agents/communication/test_ri_communication_agent.py
+++ b/test/unit/agents/communication/test_ri_communication_agent.py
@@ -10,6 +10,10 @@ def speech_agent_path():
    return "control_backend.agents.communication.ri_communication_agent.RobotSpeechAgent"


+def gesture_agent_path():
+    return "control_backend.agents.communication.ri_communication_agent.RobotGestureAgent"
+
+
@pytest.fixture
 def zmq_context(mocker):
    mock_context = mocker.patch(
@@ -22,7 +26,7 @@ def zmq_context(mocker):
 def negotiation_message(
    actuation_port: int = 5556,
    bind_main: bool = False,
-    bind_actuation: bool = True,
+    bind_actuation: bool = False,
    main_port: int = 5555,
 ):
    return {
@@ -41,9 +45,12 @@ async def test_setup_success_connects_and_starts_robot(zmq_context):
    fake_socket.recv_json = AsyncMock(return_value=negotiation_message())
    fake_socket.send_multipart = AsyncMock()

-    with patch(speech_agent_path(), autospec=True) as MockRobot:
-        robot_instance = MockRobot.return_value
-        robot_instance.start = AsyncMock()
+    with (
+        patch(speech_agent_path(), autospec=True) as MockSpeech,
+        patch(gesture_agent_path(), autospec=True) as MockGesture,
+    ):
+        MockSpeech.return_value.start = AsyncMock()
+        MockGesture.return_value.start = AsyncMock()
        agent = RICommunicationAgent("ri_comm", address="tcp://localhost:5555", bind=False)

        agent.add_behavior = MagicMock()
@@ -52,9 +59,18 @@ async def test_setup_success_connects_and_starts_robot(zmq_context):

    fake_socket.connect.assert_any_call("tcp://localhost:5555")
    fake_socket.send_json.assert_any_call({"endpoint": "negotiate/ports", "data": {}})
-    robot_instance.start.assert_awaited_once()
-    MockRobot.assert_called_once_with(ANY, address="tcp://*:5556", bind=True)
+    MockSpeech.return_value.start.assert_awaited_once()
+    MockGesture.return_value.start.assert_awaited_once()
+    MockSpeech.assert_called_once_with(ANY, address="tcp://localhost:5556", bind=False)
+    MockGesture.assert_called_once_with(
+        ANY,
+        address="tcp://localhost:5556",
+        bind=False,
+        gesture_data=[],
+        single_gesture_data=[],
+    )
    agent.add_behavior.assert_called_once()
+
    assert agent.connected is True


@@ -69,10 +85,13 @@ async def test_setup_binds_when_requested(zmq_context):

    agent.add_behavior = MagicMock()

-    with patch(speech_agent_path(), autospec=True) as MockRobot:
-        MockRobot.return_value.start = AsyncMock()
+    with (
+        patch(speech_agent_path(), autospec=True) as MockSpeech,
+        patch(gesture_agent_path(), autospec=True) as MockGesture,
+    ):
+        MockSpeech.return_value.start = AsyncMock()
+        MockGesture.return_value.start = AsyncMock()
        await agent.setup()
-
    fake_socket.bind.assert_any_call("tcp://localhost:5555")
    agent.add_behavior.assert_called_once()

@@ -88,7 +107,6 @@ async def test_negotiate_invalid_endpoint_retries(zmq_context):
    agent._req_socket = fake_socket

    success = await agent._negotiate_connection(max_retries=1)
-
    assert success is False


@@ -112,8 +130,12 @@ async def test_handle_negotiation_response_updates_req_socket(zmq_context):
    fake_socket = zmq_context.return_value.socket.return_value
    agent = RICommunicationAgent("ri_comm", address="tcp://localhost:5555", bind=False)
    agent._req_socket = fake_socket
-    with patch(speech_agent_path(), autospec=True) as MockRobot:
-        MockRobot.return_value.start = AsyncMock()
+    with (
+        patch(speech_agent_path(), autospec=True) as MockSpeech,
+        patch(gesture_agent_path(), autospec=True) as MockGesture,
+    ):
+        MockSpeech.return_value.start = AsyncMock()
+        MockGesture.return_value.start = AsyncMock()
        await agent._handle_negotiation_response(
            negotiation_message(
                main_port=6000,
@@ -135,7 +157,6 @@ async def test_handle_disconnection_publishes_and_reconnects():
    agent._negotiate_connection = AsyncMock(return_value=True)

    await agent._handle_disconnection()
-
    pub_socket.send_multipart.assert_awaited()
    assert agent.connected is True

@@ -192,7 +213,7 @@ async def test_setup_warns_on_failed_negotiate(zmq_context, mocker):
    fake_socket.recv_json = AsyncMock()
    agent = RICommunicationAgent("ri_comm")

-    async def swallow(coro):
+    def swallow(coro):
        coro.close()

    agent.add_behavior = swallow
--- a/test/unit/agents/llm/test_llm_agent.py
+++ b/test/unit/agents/llm/test_llm_agent.py
@@ -49,6 +49,9 @@ async def test_llm_processing_success(mock_httpx_client, mock_settings):
    agent = LLMAgent("llm_agent")
    agent.send = AsyncMock()  # Mock the send method to verify replies

+    mock_logger = MagicMock()
+    agent.logger = mock_logger
+
    # Simulate receiving a message from BDI
    prompt = LLMPromptMessage(text="Hi", norms=[], goals=[])
    msg = InternalMessage(
@@ -194,6 +197,9 @@ async def test_query_llm_yields_final_tail_chunk(mock_settings):
    agent = LLMAgent("llm_agent")
    agent.send = AsyncMock()

+    agent.logger = MagicMock()
+    agent.logger.llm = MagicMock()
+
    # Patch _stream_query_llm to yield tokens that do NOT end with punctuation
    async def fake_stream(messages):
        yield "Hello"
--- a/test/unit/agents/user_interrupt/test_user_interrupt.py
+++ b/test/unit/agents/user_interrupt/test_user_interrupt.py
@@ -0,0 +1,146 @@
+import asyncio
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from control_backend.agents.user_interrupt.user_interrupt_agent import UserInterruptAgent
+from control_backend.core.agent_system import InternalMessage
+from control_backend.core.config import settings
+from control_backend.schemas.ri_message import RIEndpoint
+
+
+@pytest.fixture
+def agent():
+    agent = UserInterruptAgent(name="user_interrupt_agent")
+    agent.send = AsyncMock()
+    agent.logger = MagicMock()
+    agent.sub_socket = AsyncMock()
+    return agent
+
+
+@pytest.mark.asyncio
+async def test_send_to_speech_agent(agent):
+    """Verify speech command format."""
+    await agent._send_to_speech_agent("Hello World")
+
+    agent.send.assert_awaited_once()
+    sent_msg: InternalMessage = agent.send.call_args.args[0]
+
+    assert sent_msg.to == settings.agent_settings.robot_speech_name
+    body = json.loads(sent_msg.body)
+    assert body["data"] == "Hello World"
+    assert body["is_priority"] is True
+
+
+@pytest.mark.asyncio
+async def test_send_to_gesture_agent(agent):
+    """Verify gesture command format."""
+    await agent._send_to_gesture_agent("wave_hand")
+
+    agent.send.assert_awaited_once()
+    sent_msg: InternalMessage = agent.send.call_args.args[0]
+
+    assert sent_msg.to == settings.agent_settings.robot_gesture_name
+    body = json.loads(sent_msg.body)
+    assert body["data"] == "wave_hand"
+    assert body["is_priority"] is True
+    assert body["endpoint"] == RIEndpoint.GESTURE_SINGLE.value
+
+
+@pytest.mark.asyncio
+async def test_send_to_program_manager(agent):
+    """Verify belief update format."""
+    context_str = "2"
+
+    await agent._send_to_program_manager(context_str)
+
+    agent.send.assert_awaited_once()
+    sent_msg: InternalMessage = agent.send.call_args.args[0]
+
+    assert sent_msg.to == settings.agent_settings.bdi_program_manager_name
+    assert sent_msg.thread == "belief_override_id"
+
+    body = json.loads(sent_msg.body)
+
+    assert body["belief"] == context_str
+
+
+@pytest.mark.asyncio
+async def test_receive_loop_routing_success(agent):
+    """
+    Test that the loop correctly:
+    1. Receives 'button_pressed' topic from ZMQ
+    2. Parses the JSON payload to find 'type' and 'context'
+    3. Calls the correct handler method based on 'type'
+    """
+    # Prepare JSON payloads as bytes
+    payload_speech = json.dumps({"type": "speech", "context": "Hello Speech"}).encode()
+    payload_gesture = json.dumps({"type": "gesture", "context": "Hello Gesture"}).encode()
+    payload_override = json.dumps({"type": "override", "context": "Hello Override"}).encode()
+
+    agent.sub_socket.recv_multipart.side_effect = [
+        (b"button_pressed", payload_speech),
+        (b"button_pressed", payload_gesture),
+        (b"button_pressed", payload_override),
+        asyncio.CancelledError,  # Stop the infinite loop
+    ]
+
+    agent._send_to_speech_agent = AsyncMock()
+    agent._send_to_gesture_agent = AsyncMock()
+    agent._send_to_program_manager = AsyncMock()
+
+    try:
+        await agent._receive_button_event()
+    except asyncio.CancelledError:
+        pass
+
+    await asyncio.sleep(0)
+
+    # Speech
+    agent._send_to_speech_agent.assert_awaited_once_with("Hello Speech")
+
+    # Gesture
+    agent._send_to_gesture_agent.assert_awaited_once_with("Hello Gesture")
+
+    # Override
+    agent._send_to_program_manager.assert_awaited_once_with("Hello Override")
+
+    assert agent._send_to_speech_agent.await_count == 1
+    assert agent._send_to_gesture_agent.await_count == 1
+    assert agent._send_to_program_manager.await_count == 1
+
+
+@pytest.mark.asyncio
+async def test_receive_loop_unknown_type(agent):
+    """Test that unknown 'type' values in the JSON log a warning and do not crash."""
+
+    # Prepare a payload with an unknown type
+    payload_unknown = json.dumps({"type": "unknown_thing", "context": "some_data"}).encode()
+
+    agent.sub_socket.recv_multipart.side_effect = [
+        (b"button_pressed", payload_unknown),
+        asyncio.CancelledError,
+    ]
+
+    agent._send_to_speech_agent = AsyncMock()
+    agent._send_to_gesture_agent = AsyncMock()
+    agent._send_to_belief_collector = AsyncMock()
+
+    try:
+        await agent._receive_button_event()
+    except asyncio.CancelledError:
+        pass
+
+    await asyncio.sleep(0)
+
+    # Ensure no handlers were called
+    agent._send_to_speech_agent.assert_not_called()
+    agent._send_to_gesture_agent.assert_not_called()
+    agent._send_to_belief_collector.assert_not_called()
+
+    agent.logger.warning.assert_called_with(
+        "Received button press with unknown type '%s' (context: '%s').",
+        "unknown_thing",
+        "some_data",
+    )