refactor: change test folder structure, rename functions to account for (non)changing behaviours and clarity

ref: N25B-257

test/unit/agents/bdi_agents/bdi_belief_collector_agent/behaviours/test_continuous_collect.py

@@ -0,0 +1,101 @@
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from control_backend.agents.bdi_agents.bdi_belief_collector_agent.behaviours.bel_collector_behaviour import (  # noqa: E501
+    BelCollectorBehaviour,
+)
+
+
+def create_mock_message(sender_node: str, body: 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
+    return msg
+
+
+@pytest.fixture
+def mock_agent(mocker):
+    """Fixture to create a mock Agent."""
+    agent = MagicMock()
+    agent.jid = "bdi_belief_collector_agent@test"
+    return agent
+
+
+@pytest.fixture
+def bel_collector_behaviouror(mock_agent, mocker):
+    """Fixture to create an instance of BelCollectorBehaviour with a mocked agent."""
+    # Patch asyncio.sleep to prevent tests from actually waiting
+    mocker.patch("asyncio.sleep", return_value=None)
+
+    collector = BelCollectorBehaviour()
+    collector.agent = mock_agent
+    # Mock the receive method, we will control its return value in each test
+    collector.receive = AsyncMock()
+    return collector
+
+
+@pytest.mark.asyncio
+async def test_run_message_received(bel_collector_behaviouror, mocker):
+    """
+    Test that when a message is received, _process_message is called with that message.
+    """
+    # Arrange
+    mock_msg = MagicMock()
+    bel_collector_behaviouror.receive.return_value = mock_msg
+    mocker.patch.object(bel_collector_behaviouror, "_process_message")
+
+    # Act
+    await bel_collector_behaviouror.run()
+
+    # Assert
+    bel_collector_behaviouror._process_message.assert_awaited_once_with(mock_msg)
+
+
+@pytest.mark.asyncio
+async def test_routes_to_handle_belief_text_by_type(bel_collector_behaviouror, mocker):
+    msg = create_mock_message(
+        "anyone",
+        json.dumps({"type": "belief_extraction_text", "beliefs": {"user_said": [["hi"]]}}),
+    )
+    spy = mocker.patch.object(bel_collector_behaviouror, "_handle_belief_text", new=AsyncMock())
+    await bel_collector_behaviouror._process_message(msg)
+    spy.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_routes_to_handle_belief_text_by_sender(bel_collector_behaviouror, mocker):
+    msg = create_mock_message(
+        "bel_text_agent_mock", json.dumps({"beliefs": {"user_said": [["hi"]]}})
+    )
+    spy = mocker.patch.object(bel_collector_behaviouror, "_handle_belief_text", new=AsyncMock())
+    await bel_collector_behaviouror._process_message(msg)
+    spy.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_routes_to_handle_emo_text(bel_collector_behaviouror, mocker):
+    msg = create_mock_message("anyone", json.dumps({"type": "emotion_extraction_text"}))
+    spy = mocker.patch.object(bel_collector_behaviouror, "_handle_emo_text", new=AsyncMock())
+    await bel_collector_behaviouror._process_message(msg)
+    spy.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_belief_text_happy_path_sends(bel_collector_behaviouror, mocker):
+    payload = {"type": "belief_extraction_text", "beliefs": {"user_said": ["hello test", "No"]}}
+    bel_collector_behaviouror.send = AsyncMock()
+    await bel_collector_behaviouror._handle_belief_text(payload, "bel_text_agent_mock")
+
+    # make sure we attempted a send
+    bel_collector_behaviouror.send.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_belief_text_coerces_non_strings(bel_collector_behaviouror, mocker):
+    payload = {"type": "belief_extraction_text", "beliefs": {"user_said": [["hi", 123]]}}
+    bel_collector_behaviouror.send = AsyncMock()
+    await bel_collector_behaviouror._handle_belief_text(payload, "origin")
+    bel_collector_behaviouror.send.assert_awaited_once()

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

@@ -0,0 +1,212 @@
+import json
+import logging
+from unittest.mock import AsyncMock, MagicMock, call
+
+import pytest
+
+from control_backend.agents.bdi_agents.bdi_core_agent.behaviours.belief_setter_behaviour import (
+    BeliefSetterBehaviour,
+)
+
+# Define a constant for the collector agent name to use in tests
+COLLECTOR_AGENT_NAME = "bdi_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_agents.bdi_core_agent."
+        "behaviours.belief_setter_behaviour.settings.agent_settings.bdi_belief_collector_agent_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_agents/bdi_text_belief_agent/behaviours/test_belief_from_text.py

@@ -0,0 +1,190 @@
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from spade.message import Message
+
+from control_backend.agents.bdi_agents.bdi_text_belief_agent.behaviours.bdi_text_belief_behaviour import (  # noqa: E501, We can't shorten this import.
+    BDITextBeliefBehaviour,
+)
+
+
+@pytest.fixture
+def mock_settings():
+    """
+    Mocks the settings object that the behaviour imports.
+    We patch it at the source where it's imported by the module under test.
+    """
+    # Create a mock object that mimics the nested structure
+    settings_mock = MagicMock()
+    settings_mock.agent_settings.per_transcription_agent_name = "transcriber"
+    settings_mock.agent_settings.bdi_belief_collector_agent_name = "collector"
+    settings_mock.agent_settings.host = "fake.host"
+
+    # Use patch to replace the settings object during the test
+    # Adjust 'control_backend.behaviours.belief_from_text.settings' to where
+    # your behaviour file imports it from.
+    with patch(
+        "control_backend.agents.bdi_agents.bdi_text_belief_agent.behaviours.bdi_text_belief_behaviour.settings",
+        settings_mock,
+    ):
+        yield settings_mock
+
+
+@pytest.fixture
+def behavior(mock_settings):
+    """
+    Creates an instance of the BDITextBeliefBehaviour behaviour and mocks its
+    agent, logger, send, and receive methods.
+    """
+    b = BDITextBeliefBehaviour()
+
+    b.agent = MagicMock()
+    b.send = AsyncMock()
+    b.receive = AsyncMock()
+
+    return b
+
+
+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_no_message(behavior):
+    """
+    Tests the run() method when no message is received.
+    """
+    # Arrange: Configure receive to return None
+    behavior.receive.return_value = None
+
+    # Act: Run the behavior
+    await behavior.run()
+
+    # Assert
+    # 1. Check that receive was called
+    behavior.receive.assert_called_once()
+    # 2. Check that no message was sent
+    behavior.send.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_run_message_from_other_agent(behavior):
+    """
+    Tests the run() method when a message is received from an
+    unknown agent (not the transcriber).
+    """
+    # Arrange: Create a mock message from an unknown sender
+    mock_msg = create_mock_message("unknown", "some data", None)
+    behavior.receive.return_value = mock_msg
+    behavior._process_transcription_demo = MagicMock()
+
+    # Act
+    await behavior.run()
+
+    # Assert
+    # 1. Check that receive was called
+    behavior.receive.assert_called_once()
+    # 2. Check that _process_transcription_demo was not sent
+    behavior._process_transcription_demo.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_run_message_from_transcriber_demo(behavior, mock_settings, monkeypatch):
+    """
+    Tests the main success path: receiving a message from the
+    transcription agent, which triggers _process_transcription_demo.
+    """
+    # Arrange: Create a mock message from the transcriber
+    transcription_text = "hello world"
+    mock_msg = create_mock_message(
+        mock_settings.agent_settings.per_transcription_agent_name, transcription_text, None
+    )
+    behavior.receive.return_value = mock_msg
+
+    # Act
+    await behavior.run()
+
+    # Assert
+    # 1. Check that receive was called
+    behavior.receive.assert_called_once()
+
+    # 2. Check that send was called *once*
+    behavior.send.assert_called_once()
+
+    # 3. Deeply inspect the message that was sent
+    sent_msg: Message = behavior.send.call_args[0][0]
+
+    assert (
+        sent_msg.to
+        == mock_settings.agent_settings.bdi_belief_collector_agent_name
+        + "@"
+        + mock_settings.agent_settings.host
+    )
+
+    # Check thread
+    assert sent_msg.thread == "beliefs"
+
+    # Parse the received JSON string back into a dict
+    expected_dict = {
+        "beliefs": {"user_said": [transcription_text]},
+        "type": "belief_extraction_text",
+    }
+    sent_dict = json.loads(sent_msg.body)
+
+    # Assert that the dictionaries are equal
+    assert sent_dict == expected_dict
+
+
+@pytest.mark.asyncio
+async def test_process_transcription_success(behavior, mock_settings):
+    """
+    Tests the (currently unused) _process_transcription method's
+    success path, using its hardcoded mock response.
+    """
+    # Arrange
+    test_text = "I am feeling happy"
+    # This is the hardcoded response inside the method
+    expected_response_body = '{"mood": [["happy"]]}'
+
+    # Act
+    await behavior._process_transcription(test_text)
+
+    # Assert
+    # 1. Check that a message was sent
+    behavior.send.assert_called_once()
+
+    # 2. Inspect the sent message
+    sent_msg: Message = behavior.send.call_args[0][0]
+    expected_to = (
+        mock_settings.agent_settings.bdi_belief_collector_agent_name
+        + "@"
+        + mock_settings.agent_settings.host
+    )
+    assert str(sent_msg.to) == expected_to
+    assert sent_msg.thread == "beliefs"
+    assert sent_msg.body == expected_response_body
+
+
+@pytest.mark.asyncio
+async def test_process_transcription_json_decode_error(behavior, mock_settings):
+    """
+    Tests the _process_transcription method's error handling
+    when the (mocked) response is invalid JSON.
+    We do this by patching json.loads to raise an error.
+    """
+    # Arrange
+    test_text = "I am feeling happy"
+    # Patch json.loads to raise an error when called
+    with patch("json.loads", side_effect=json.JSONDecodeError("Mock error", "", 0)):
+        # Act
+        await behavior._process_transcription(test_text)
+
+    # Assert
+    # 1. Check that NO message was sent
+    behavior.send.assert_not_called()