refactor: testing

Redid testing structure, added tests and changed some tests.

ref: N25B-301

test/unit/agents/actuation/test_robot_speech_agent.py

@@ -0,0 +1,158 @@
+import json
+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.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 = 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")
+    assert swallow.calls == 1
+
+
+@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 = 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_handle_message_sends_command():
+    """Internal message is forwarded to robot pub socket as JSON."""
+    pubsocket = AsyncMock()
+    agent = RobotSpeechAgent("robot_speech")
+    agent.pubsocket = pubsocket
+
+    payload = {"endpoint": "actuate/speech", "data": "hello"}
+    msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))
+
+    await agent.handle_message(msg)
+
+    pubsocket.send_json.assert_awaited_once_with(payload)
+
+
+@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"}
+    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 = RobotSpeechAgent("robot_speech")
+    agent.subsocket = fake_socket
+    agent.pubsocket = fake_socket
+    agent._running = True
+
+    await agent._zmq_command_loop()
+
+    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.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()

test/unit/agents/bdi/bdi_core_agent/behaviours/test_belief_setter.py

@@ -1,211 +0,0 @@
-import json
-import logging
-from unittest.mock import AsyncMock, MagicMock, call
-
-import pytest
-from control_backend.agents.bdi.bdi_core_agent.behaviours.belief_setter_behaviour import (
-    BeliefSetterBehaviour,
-)
-
-# Define a constant for the collector agent name to use in tests
-COLLECTOR_AGENT_NAME = "belief_collector_agent"
-COLLECTOR_AGENT_JID = f"{COLLECTOR_AGENT_NAME}@test"
-
-
-@pytest.fixture
-def mock_agent(mocker):
-    """Fixture to create a mock BDIAgent."""
-    agent = MagicMock()
-    agent.bdi = MagicMock()
-    agent.jid = "bdi_agent@test"
-    return agent
-
-
-@pytest.fixture
-def belief_setter_behaviour(mock_agent, mocker):
-    """Fixture to create an instance of BeliefSetterBehaviour with a mocked agent."""
-    # Patch the settings to use a predictable agent name
-    mocker.patch(
-        "control_backend.agents.bdi.bdi_core_agent."
-        "behaviours.belief_setter_behaviour.settings.agent_settings.bdi_belief_collector_name",
-        COLLECTOR_AGENT_NAME,
-    )
-
-    setter = BeliefSetterBehaviour()
-    setter.agent = mock_agent
-    # Mock the receive method, we will control its return value in each test
-    setter.receive = AsyncMock()
-    return setter
-
-
-def create_mock_message(sender_node: str, body: str, thread: str) -> MagicMock:
-    """Helper function to create a configured mock message."""
-    msg = MagicMock()
-    msg.sender.node = sender_node  # MagicMock automatically creates nested mocks
-    msg.body = body
-    msg.thread = thread
-    return msg
-
-
-@pytest.mark.asyncio
-async def test_run_message_received(belief_setter_behaviour, mocker):
-    """
-    Test that when a message is received, _process_message is called.
-    """
-    # Arrange
-    msg = MagicMock()
-    belief_setter_behaviour.receive.return_value = msg
-    mocker.patch.object(belief_setter_behaviour, "_process_message")
-
-    # Act
-    await belief_setter_behaviour.run()
-
-    # Assert
-    belief_setter_behaviour._process_message.assert_called_once_with(msg)
-
-
-def test_process_message_from_bdi_belief_collector_agent(belief_setter_behaviour, mocker):
-    """
-    Test processing a message from the correct belief collector agent.
-    """
-    # Arrange
-    msg = create_mock_message(sender_node=COLLECTOR_AGENT_NAME, body="", thread="")
-    mock_process_belief = mocker.patch.object(belief_setter_behaviour, "_process_belief_message")
-
-    # Act
-    belief_setter_behaviour._process_message(msg)
-
-    # Assert
-    mock_process_belief.assert_called_once_with(msg)
-
-
-def test_process_message_from_other_agent(belief_setter_behaviour, mocker):
-    """
-    Test that messages from other agents are ignored.
-    """
-    # Arrange
-    msg = create_mock_message(sender_node="other_agent", body="", thread="")
-    mock_process_belief = mocker.patch.object(belief_setter_behaviour, "_process_belief_message")
-
-    # Act
-    belief_setter_behaviour._process_message(msg)
-
-    # Assert
-    mock_process_belief.assert_not_called()
-
-
-def test_process_belief_message_valid_json(belief_setter_behaviour, mocker):
-    """
-    Test processing a valid belief message with correct thread and JSON body.
-    """
-    # Arrange
-    beliefs_payload = {"is_hot": ["kitchen"], "is_clean": ["kitchen", "bathroom"]}
-    msg = create_mock_message(
-        sender_node=COLLECTOR_AGENT_JID, body=json.dumps(beliefs_payload), thread="beliefs"
-    )
-    mock_set_beliefs = mocker.patch.object(belief_setter_behaviour, "_set_beliefs")
-
-    # Act
-    belief_setter_behaviour._process_belief_message(msg)
-
-    # Assert
-    mock_set_beliefs.assert_called_once_with(beliefs_payload)
-
-
-def test_process_belief_message_invalid_json(belief_setter_behaviour, mocker, caplog):
-    """
-    Test that a message with invalid JSON is handled gracefully and an error is logged.
-    """
-    # Arrange
-    msg = create_mock_message(
-        sender_node=COLLECTOR_AGENT_JID, body="this is not a json string", thread="beliefs"
-    )
-    mock_set_beliefs = mocker.patch.object(belief_setter_behaviour, "_set_beliefs")
-
-    # Act
-    belief_setter_behaviour._process_belief_message(msg)
-
-    # Assert
-    mock_set_beliefs.assert_not_called()
-
-
-def test_process_belief_message_wrong_thread(belief_setter_behaviour, mocker):
-    """
-    Test that a message with an incorrect thread is ignored.
-    """
-    # Arrange
-    msg = create_mock_message(
-        sender_node=COLLECTOR_AGENT_JID, body='{"some": "data"}', thread="not_beliefs"
-    )
-    mock_set_beliefs = mocker.patch.object(belief_setter_behaviour, "_set_beliefs")
-
-    # Act
-    belief_setter_behaviour._process_belief_message(msg)
-
-    # Assert
-    mock_set_beliefs.assert_not_called()
-
-
-def test_process_belief_message_empty_body(belief_setter_behaviour, mocker):
-    """
-    Test that a message with an empty body is ignored.
-    """
-    # Arrange
-    msg = create_mock_message(sender_node=COLLECTOR_AGENT_JID, body="", thread="beliefs")
-    mock_set_beliefs = mocker.patch.object(belief_setter_behaviour, "_set_beliefs")
-
-    # Act
-    belief_setter_behaviour._process_belief_message(msg)
-
-    # Assert
-    mock_set_beliefs.assert_not_called()
-
-
-def test_set_beliefs_success(belief_setter_behaviour, mock_agent, caplog):
-    """
-    Test that beliefs are correctly set on the agent's BDI.
-    """
-    # Arrange
-    beliefs_to_set = {
-        "is_hot": ["kitchen"],
-        "door_opened": ["front_door", "back_door"],
-    }
-
-    # Act
-    with caplog.at_level(logging.INFO):
-        belief_setter_behaviour._set_beliefs(beliefs_to_set)
-
-    # Assert
-    expected_calls = [
-        call("is_hot", "kitchen"),
-        call("door_opened", "front_door", "back_door"),
-    ]
-    mock_agent.bdi.set_belief.assert_has_calls(expected_calls, any_order=True)
-    assert mock_agent.bdi.set_belief.call_count == 2
-
-
-# def test_responded_unset(belief_setter_behaviour, mock_agent):
-#     # Arrange
-#     new_beliefs = {"user_said": ["message"]}
-#
-#     # Act
-#     belief_setter_behaviour._set_beliefs(new_beliefs)
-#
-#     # Assert
-#     mock_agent.bdi.set_belief.assert_has_calls([call("user_said", "message")])
-#     mock_agent.bdi.remove_belief.assert_has_calls([call("responded")])
-
-# def test_set_beliefs_bdi_not_initialized(belief_setter_behaviour, mock_agent, caplog):
-#     """
-#     Test that a warning is logged if the agent's BDI is not initialized.
-#     """
-#     # Arrange
-#     mock_agent.bdi = None  # Simulate BDI not being ready
-#     beliefs_to_set = {"is_hot": ["kitchen"]}
-#
-#     # Act
-#     with caplog.at_level(logging.WARNING):
-#         belief_setter_behaviour._set_beliefs(beliefs_to_set)
-#
-#     # Assert
-#     assert "Cannot set beliefs, since agent's BDI is not yet initialized." in caplog.text

test/unit/agents/bdi/test_bdi_core_agent.py

@@ -0,0 +1,103 @@
+from unittest.mock import AsyncMock, MagicMock, mock_open, patch
+
+import pytest
+
+from control_backend.agents.bdi.bdi_core_agent.bdi_core_agent import BDICoreAgent
+from control_backend.core.agent_system import InternalMessage
+from control_backend.core.config import settings
+
+
+@pytest.fixture
+def mock_agentspeak_env():
+    with patch("agentspeak.runtime.Environment") as mock_env:
+        yield mock_env
+
+
+@pytest.fixture
+def agent():
+    agent = BDICoreAgent("bdi_agent", "dummy.asl")
+    agent.send = AsyncMock()
+    agent.bdi_agent = MagicMock()
+    return agent
+
+
+@pytest.mark.asyncio
+async def test_setup_loads_asl(mock_agentspeak_env, agent):
+    # Mock file opening
+    with patch("builtins.open", mock_open(read_data="+initial_goal.")):
+        await agent.setup()
+
+        # Check if environment tried to build agent
+        mock_agentspeak_env.return_value.build_agent.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_setup_no_asl(mock_agentspeak_env, agent):
+    with patch("builtins.open", side_effect=FileNotFoundError):
+        await agent.setup()
+
+        mock_agentspeak_env.return_value.build_agent.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_handle_belief_collector_message(agent):
+    """Test that incoming beliefs are added to the BDI agent"""
+    # Simulate message from belief collector
+    import json
+
+    beliefs = {"user_said": ["Hello"]}
+    msg = InternalMessage(
+        to="bdi_agent",
+        sender=settings.agent_settings.bdi_belief_collector_name,
+        body=json.dumps(beliefs),
+        thread="beliefs",
+    )
+
+    await agent.handle_message(msg)
+
+    # Expect bdi_agent.call to be triggered to add belief
+    assert agent.bdi_agent.call.called
+
+
+@pytest.mark.asyncio
+async def test_handle_llm_response(agent):
+    """Test that LLM responses are forwarded to the Robot Speech Agent"""
+    msg = InternalMessage(
+        to="bdi_agent", sender=settings.agent_settings.llm_name, body="This is the LLM reply"
+    )
+
+    await agent.handle_message(msg)
+
+    # Verify forward
+    assert agent.send.called
+    sent_msg = agent.send.call_args[0][0]
+    assert sent_msg.to == settings.agent_settings.robot_speech_name
+    assert "This is the LLM reply" in sent_msg.body
+
+
+@pytest.mark.asyncio
+async def test_custom_actions(agent):
+    agent._send_to_llm = MagicMock(side_effect=agent.send)  # Mock specific method
+
+    # Initialize actions manually since we didn't call setup with real file
+    agent._add_custom_actions()
+
+    # Find the action
+    action_fn = None
+    for (functor, _), fn in agent.actions.actions.items():
+        if functor == ".reply":
+            action_fn = fn
+            break
+
+    assert action_fn is not None
+
+    # Invoke action
+    mock_term = MagicMock()
+    mock_term.args = ["Hello"]
+    mock_intention = MagicMock()
+
+    # Run generator
+    gen = action_fn(agent, mock_term, mock_intention)
+    next(gen)  # Execute
+
+    agent._send_to_llm.assert_called_with("Hello")

test/unit/agents/bdi/test_text_extractor.py

@@ -7,16 +7,6 @@ from control_backend.agents.bdi.text_belief_extractor_agent.text_belief_extracto
     TextBeliefExtractorAgent,
 )
 from control_backend.core.agent_system import InternalMessage
-from control_backend.core.config import settings
-
-
-@pytest.fixture(autouse=True)
-def patch_settings(monkeypatch):
-    monkeypatch.setattr(settings.agent_settings, "transcription_name", "transcriber", raising=False)
-    monkeypatch.setattr(
-        settings.agent_settings, "bdi_belief_collector_name", "collector", raising=False
-    )
-    monkeypatch.setattr(settings.agent_settings, "host", "fake.host", raising=False)
 
 
 @pytest.fixture
@@ -40,29 +30,29 @@ async def test_handle_message_ignores_other_agents(agent):
 
 
 @pytest.mark.asyncio
-async def test_handle_message_from_transcriber(agent):
+async def test_handle_message_from_transcriber(agent, mock_settings):
     transcription = "hello world"
-    msg = make_msg(settings.agent_settings.transcription_name, transcription, None)
+    msg = make_msg(mock_settings.agent_settings.transcription_name, transcription, None)
 
     await agent.handle_message(msg)
 
     agent.send.assert_awaited_once()  # noqa  # `agent.send` has no such property, but we mock it.
     sent: InternalMessage = agent.send.call_args.args[0]  # noqa
-    assert sent.to == settings.agent_settings.bdi_belief_collector_name
+    assert sent.to == mock_settings.agent_settings.bdi_belief_collector_name
     assert sent.thread == "beliefs"
     parsed = json.loads(sent.body)
     assert parsed == {"beliefs": {"user_said": [transcription]}, "type": "belief_extraction_text"}
 
 
 @pytest.mark.asyncio
-async def test_process_transcription_demo(agent):
+async def test_process_transcription_demo(agent, mock_settings):
     transcription = "this is a test"
 
     await agent._process_transcription_demo(transcription)
 
     agent.send.assert_awaited_once()  # noqa  # `agent.send` has no such property, but we mock it.
     sent: InternalMessage = agent.send.call_args.args[0]  # noqa
-    assert sent.to == settings.agent_settings.bdi_belief_collector_name
+    assert sent.to == mock_settings.agent_settings.bdi_belief_collector_name
     assert sent.thread == "beliefs"
     parsed = json.loads(sent.body)
     assert parsed["beliefs"]["user_said"] == [transcription]

test/unit/agents/communication/test_ri_communication_agent.py

@@ -0,0 +1,354 @@
+import asyncio
+from unittest.mock import ANY, AsyncMock, MagicMock, patch
+
+import pytest
+
+from control_backend.agents.communication.ri_communication_agent import RICommunicationAgent
+
+
+def speech_agent_path():
+    return "control_backend.agents.communication.ri_communication_agent.RobotSpeechAgent"
+
+
+@pytest.fixture
+def zmq_context(mocker):
+    mock_context = mocker.patch(
+        "control_backend.agents.communication.ri_communication_agent.Context.instance"
+    )
+    mock_context.return_value = MagicMock()
+    return mock_context
+
+
+def negotiation_message(
+    actuation_port: int = 5556,
+    bind_main: bool = False,
+    bind_actuation: bool = True,
+    main_port: int = 5555,
+):
+    return {
+        "endpoint": "negotiate/ports",
+        "data": [
+            {"id": "main", "port": main_port, "bind": bind_main},
+            {"id": "actuation", "port": actuation_port, "bind": bind_actuation},
+        ],
+    }
+
+
+@pytest.mark.asyncio
+async def test_setup_success_connects_and_starts_robot(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    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()
+        agent = RICommunicationAgent("ri_comm", address="tcp://localhost:5555", bind=False)
+
+        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.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)
+    assert swallow.calls == 1
+    assert agent.connected is True
+
+
+@pytest.mark.asyncio
+async def test_setup_binds_when_requested(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    fake_socket.recv_json = AsyncMock(return_value=negotiation_message(bind_main=True))
+    fake_socket.send_multipart = AsyncMock()
+
+    agent = RICommunicationAgent("ri_comm", address="tcp://localhost:5555", bind=True)
+
+    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
+
+    with patch(speech_agent_path(), autospec=True) as MockRobot:
+        MockRobot.return_value.start = AsyncMock()
+        await agent.setup()
+
+    fake_socket.bind.assert_any_call("tcp://localhost:5555")
+    assert swallow.calls == 1
+
+
+@pytest.mark.asyncio
+async def test_negotiate_invalid_endpoint_retries(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    fake_socket.recv_json = AsyncMock(return_value={"endpoint": "ping", "data": {}})
+    fake_socket.send_multipart = AsyncMock()
+
+    agent = RICommunicationAgent("ri_comm", address="tcp://localhost:5555", bind=False)
+    agent._req_socket = fake_socket
+
+    success = await agent._negotiate_connection(max_retries=1)
+
+    assert success is False
+
+
+@pytest.mark.asyncio
+async def test_negotiate_timeout(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    fake_socket.recv_json = AsyncMock(side_effect=asyncio.TimeoutError)
+    fake_socket.send_multipart = AsyncMock()
+
+    agent = RICommunicationAgent("ri_comm", address="tcp://localhost:5555", bind=False)
+    agent._req_socket = fake_socket
+
+    success = await agent._negotiate_connection(max_retries=1)
+
+    assert success is False
+
+
+@pytest.mark.asyncio
+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()
+        await agent._handle_negotiation_response(
+            negotiation_message(
+                main_port=6000,
+                actuation_port=6001,
+                bind_main=False,
+                bind_actuation=False,
+            )
+        )
+
+    fake_socket.connect.assert_any_call("tcp://localhost:6000")
+
+
+@pytest.mark.asyncio
+async def test_handle_disconnection_publishes_and_reconnects():
+    pub_socket = AsyncMock()
+    agent = RICommunicationAgent("ri_comm")
+    agent.pub_socket = pub_socket
+    agent.connected = True
+    agent._negotiate_connection = AsyncMock(return_value=True)
+
+    await agent._handle_disconnection()
+
+    pub_socket.send_multipart.assert_awaited()
+    assert agent.connected is True
+
+
+@pytest.mark.asyncio
+async def test_listen_loop_handles_non_ping(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return {"endpoint": "negotiate/ports", "data": {}}
+
+    fake_socket.recv_json = recv_once
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = fake_socket
+    agent.pub_socket = AsyncMock()
+    agent.connected = True
+    agent._running = True
+
+    await agent._listen_loop()
+
+    fake_socket.send_json.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_negotiate_unexpected_error(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    fake_socket.recv_json = AsyncMock(side_effect=Exception("boom"))
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = fake_socket
+
+    assert await agent._negotiate_connection(max_retries=1) is False
+
+
+@pytest.mark.asyncio
+async def test_negotiate_handle_response_error(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    fake_socket.recv_json = AsyncMock(return_value=negotiation_message())
+
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = fake_socket
+    agent._handle_negotiation_response = AsyncMock(side_effect=Exception("bad response"))
+
+    assert await agent._negotiate_connection(max_retries=1) is False
+
+
+@pytest.mark.asyncio
+async def test_setup_warns_on_failed_negotiate(zmq_context, mocker):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    fake_socket.recv_json = AsyncMock()
+    agent = RICommunicationAgent("ri_comm")
+
+    async def swallow(coro):
+        coro.close()
+
+    agent.add_background_task = swallow
+    agent._negotiate_connection = AsyncMock(return_value=False)
+
+    await agent.setup()
+
+    assert agent.connected is False
+
+
+@pytest.mark.asyncio
+async def test_handle_negotiation_response_unhandled_id():
+    agent = RICommunicationAgent("ri_comm")
+
+    await agent._handle_negotiation_response(
+        {"data": [{"id": "other", "port": 5000, "bind": False}]}
+    )
+
+
+@pytest.mark.asyncio
+async def test_stop_closes_sockets():
+    req = MagicMock()
+    pub = MagicMock()
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = req
+    agent.pub_socket = pub
+
+    await agent.stop()
+
+    req.close.assert_called_once()
+    pub.close.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_listen_loop_not_connected(monkeypatch):
+    agent = RICommunicationAgent("ri_comm")
+    agent._running = True
+    agent.connected = False
+    agent._req_socket = AsyncMock()
+
+    async def fake_sleep(duration):
+        agent._running = False
+
+    monkeypatch.setattr("asyncio.sleep", fake_sleep)
+
+    await agent._listen_loop()
+
+
+@pytest.mark.asyncio
+async def test_listen_loop_send_and_recv_timeout():
+    req = AsyncMock()
+    req.send_json = AsyncMock(side_effect=TimeoutError)
+    req.recv_json = AsyncMock(side_effect=TimeoutError)
+
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = req
+    agent.pub_socket = AsyncMock()
+    agent.connected = True
+    agent._running = True
+
+    async def stop_run():
+        agent._running = False
+
+    agent._handle_disconnection = AsyncMock(side_effect=stop_run)
+
+    await agent._listen_loop()
+
+    agent._handle_disconnection.assert_awaited()
+
+
+@pytest.mark.asyncio
+async def test_listen_loop_missing_endpoint(monkeypatch):
+    req = AsyncMock()
+    req.send_json = AsyncMock()
+
+    async def recv_once():
+        agent._running = False
+        return {"data": {}}
+
+    req.recv_json = recv_once
+
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = req
+    agent.pub_socket = AsyncMock()
+    agent.connected = True
+    agent._running = True
+
+    await agent._listen_loop()
+
+
+@pytest.mark.asyncio
+async def test_listen_loop_generic_exception():
+    req = AsyncMock()
+    req.send_json = AsyncMock()
+    req.recv_json = AsyncMock(side_effect=ValueError("boom"))
+
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = req
+    agent.pub_socket = AsyncMock()
+    agent.connected = True
+    agent._running = True
+
+    with pytest.raises(ValueError):
+        await agent._listen_loop()
+
+
+@pytest.mark.asyncio
+async def test_handle_disconnection_timeout(monkeypatch):
+    pub = AsyncMock()
+    pub.send_multipart = AsyncMock(side_effect=TimeoutError)
+
+    agent = RICommunicationAgent("ri_comm")
+    agent.pub_socket = pub
+    agent._negotiate_connection = AsyncMock(return_value=False)
+
+    await agent._handle_disconnection()
+
+    pub.send_multipart.assert_awaited()
+
+
+@pytest.mark.asyncio
+async def test_listen_loop_ping_sends_internal(zmq_context):
+    fake_socket = zmq_context.return_value.socket.return_value
+    fake_socket.send_json = AsyncMock()
+    pub_socket = AsyncMock()
+
+    agent = RICommunicationAgent("ri_comm")
+    agent._req_socket = fake_socket
+    agent.pub_socket = pub_socket
+    agent.connected = True
+    agent._running = True
+
+    async def recv_once():
+        agent._running = False
+        return {"endpoint": "ping", "data": {}}
+
+    fake_socket.recv_json = recv_once
+
+    await agent._listen_loop()
+
+    pub_socket.send_multipart.assert_awaited()

test/unit/agents/llm/test_llm_agent.py

@@ -0,0 +1,124 @@
+"""Mocks `httpx` and tests chunking logic."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from control_backend.agents.llm.llm_agent import LLMAgent, LLMInstructions
+from control_backend.core.agent_system import InternalMessage
+
+
+@pytest.fixture
+def mock_httpx_client():
+    with patch("httpx.AsyncClient") as mock_cls:
+        mock_client = AsyncMock()
+        mock_cls.return_value.__aenter__.return_value = mock_client
+        yield mock_client
+
+
+@pytest.mark.asyncio
+async def test_llm_processing_success(mock_httpx_client, mock_settings):
+    # Setup the mock response for the stream
+    mock_response = MagicMock()
+    mock_response.raise_for_status = MagicMock()
+
+    # Simulate stream lines
+    lines = [
+        b'data: {"choices": [{"delta": {"content": "Hello"}}]}',
+        b'data: {"choices": [{"delta": {"content": " world"}}]}',
+        b'data: {"choices": [{"delta": {"content": "."}}]}',
+        b"data: [DONE]",
+    ]
+
+    async def aiter_lines_gen():
+        for line in lines:
+            yield line.decode()
+
+    mock_response.aiter_lines.side_effect = aiter_lines_gen
+
+    mock_stream_context = MagicMock()
+    mock_stream_context.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_stream_context.__aexit__ = AsyncMock(return_value=None)
+
+    # Configure the client
+    mock_httpx_client.stream = MagicMock(return_value=mock_stream_context)
+
+    # Setup Agent
+    agent = LLMAgent("llm_agent")
+    agent.send = AsyncMock()  # Mock the send method to verify replies
+
+    # Simulate receiving a message from BDI
+    msg = InternalMessage(
+        to="llm_agent", sender=mock_settings.agent_settings.bdi_core_name, body="Hi"
+    )
+
+    await agent.handle_message(msg)
+
+    # Verification
+    # "Hello world." constitutes one sentence/chunk based on punctuation split
+    # The agent should call send once with the full sentence
+    assert agent.send.called
+    args = agent.send.call_args[0][0]
+    assert args.to == mock_settings.agent_settings.bdi_core_name
+    assert "Hello world." in args.body
+
+
+@pytest.mark.asyncio
+async def test_llm_processing_errors(mock_httpx_client, mock_settings):
+    agent = LLMAgent("llm_agent")
+    agent.send = AsyncMock()
+    msg = InternalMessage(to="llm", sender=mock_settings.agent_settings.bdi_core_name, body="Hi")
+
+    # HTTP Error
+    mock_httpx_client.stream = MagicMock(side_effect=httpx.HTTPError("Fail"))
+    await agent.handle_message(msg)
+    assert "LLM service unavailable." in agent.send.call_args[0][0].body
+
+    # General Exception
+    agent.send.reset_mock()
+    mock_httpx_client.stream = MagicMock(side_effect=Exception("Boom"))
+    await agent.handle_message(msg)
+    assert "Error processing the request." in agent.send.call_args[0][0].body
+
+
+@pytest.mark.asyncio
+async def test_llm_json_error(mock_httpx_client, mock_settings):
+    # Test malformed JSON in stream
+    mock_response = MagicMock()
+    mock_response.raise_for_status = MagicMock()
+
+    async def aiter_lines_gen():
+        yield "data: {bad_json"
+        yield "data: [DONE]"
+
+    mock_response.aiter_lines.side_effect = aiter_lines_gen
+
+    mock_stream_context = MagicMock()
+    mock_stream_context.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_stream_context.__aexit__ = AsyncMock(return_value=None)
+    mock_httpx_client.stream = MagicMock(return_value=mock_stream_context)
+
+    agent = LLMAgent("llm_agent")
+    agent.send = AsyncMock()
+
+    with patch.object(agent.logger, "error") as log:
+        msg = InternalMessage(
+            to="llm", sender=mock_settings.agent_settings.bdi_core_name, body="Hi"
+        )
+        await agent.handle_message(msg)
+        log.assert_called()  # Should log JSONDecodeError
+
+
+def test_llm_instructions():
+    # Full custom
+    instr = LLMInstructions(norms="N", goals="G")
+    text = instr.build_developer_instruction()
+    assert "Norms to follow:\nN" in text
+    assert "Goals to reach:\nG" in text
+
+    # Defaults
+    instr_def = LLMInstructions()
+    text_def = instr_def.build_developer_instruction()
+    assert "Norms to follow" in text_def
+    assert "Goals to reach" in text_def

test/unit/agents/perception/transcription_agent/test_transcription_agent.py

@@ -0,0 +1,122 @@
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import numpy as np
+import pytest
+
+from control_backend.agents.perception.transcription_agent.speech_recognizer import (
+    MLXWhisperSpeechRecognizer,
+    OpenAIWhisperSpeechRecognizer,
+    SpeechRecognizer,
+)
+from control_backend.agents.perception.transcription_agent.transcription_agent import (
+    TranscriptionAgent,
+)
+
+
+@pytest.mark.asyncio
+async def test_transcription_agent_flow(mock_zmq_context):
+    mock_sub = MagicMock()
+    mock_sub.recv = AsyncMock()
+
+    # Setup context to return this specific mock socket
+    mock_zmq_context.instance.return_value.socket.return_value = mock_sub
+
+    # Data: [Audio Bytes, Cancel Loop]
+    fake_audio = np.zeros(16000, dtype=np.float32).tobytes()
+    mock_sub.recv.side_effect = [fake_audio, asyncio.CancelledError()]
+
+    # Mock Recognizer
+    with patch.object(SpeechRecognizer, "best_type") as mock_best:
+        mock_recognizer = MagicMock()
+        mock_recognizer.recognize_speech.return_value = "Hello"
+        mock_best.return_value = mock_recognizer
+
+        agent = TranscriptionAgent("tcp://in")
+        agent.send = AsyncMock()
+
+        agent._running = True
+        agent.add_background_task = AsyncMock()
+
+        await agent.setup()
+
+        try:
+            await agent._transcribing_loop()
+        except asyncio.CancelledError:
+            pass
+
+        # Check transcription happened
+        assert mock_recognizer.recognize_speech.called
+        # Check sending
+        assert agent.send.called
+        assert agent.send.call_args[0][0].body == "Hello"
+
+        await agent.stop()
+
+
+@pytest.mark.asyncio
+async def test_transcription_empty(mock_zmq_context):
+    mock_sub = MagicMock()
+    mock_sub.recv = AsyncMock()
+    mock_zmq_context.instance.return_value.socket.return_value = mock_sub
+
+    # Return valid audio, but recognizer returns empty string
+    fake_audio = np.zeros(10, dtype=np.float32).tobytes()
+    mock_sub.recv.side_effect = [fake_audio, asyncio.CancelledError()]
+
+    with patch.object(SpeechRecognizer, "best_type") as mock_best:
+        mock_recognizer = MagicMock()
+        mock_recognizer.recognize_speech.return_value = ""
+        mock_best.return_value = mock_recognizer
+
+        agent = TranscriptionAgent("tcp://in")
+        agent.send = AsyncMock()
+        await agent.setup()
+
+        try:
+            await agent._transcribing_loop()
+        except asyncio.CancelledError:
+            pass
+
+        # Should NOT send message
+        agent.send.assert_not_called()
+
+
+def test_speech_recognizer_factory():
+    # Test Factory Logic
+    with patch("torch.mps.is_available", return_value=True):
+        assert isinstance(SpeechRecognizer.best_type(), MLXWhisperSpeechRecognizer)
+
+    with patch("torch.mps.is_available", return_value=False):
+        assert isinstance(SpeechRecognizer.best_type(), OpenAIWhisperSpeechRecognizer)
+
+
+def test_openai_recognizer():
+    with patch("whisper.load_model") as load_mock:
+        with patch("whisper.transcribe") as trans_mock:
+            rec = OpenAIWhisperSpeechRecognizer()
+            rec.load_model()
+            load_mock.assert_called()
+
+            trans_mock.return_value = {"text": "Hi"}
+            res = rec.recognize_speech(np.zeros(10))
+            assert res == "Hi"
+
+
+def test_mlx_recognizer():
+    # Fix: On Linux, 'mlx_whisper' isn't imported by the module, so it's missing from dir().
+    # We must use create=True to inject it into the module namespace during the test.
+    module_path = "control_backend.agents.perception.transcription_agent.speech_recognizer"
+
+    with patch("sys.platform", "darwin"):
+        with patch(f"{module_path}.mlx_whisper", create=True) as mlx_mock:
+            with patch(f"{module_path}.ModelHolder", create=True) as holder_mock:
+                # We also need to mock mlx.core if it's used for types/constants
+                with patch(f"{module_path}.mx", create=True):
+                    rec = MLXWhisperSpeechRecognizer()
+                    rec.load_model()
+                    holder_mock.get_model.assert_called()
+
+                    mlx_mock.transcribe.return_value = {"text": "Hi"}
+                    res = rec.recognize_speech(np.zeros(10))
+                    assert res == "Hi"