Merge branch 'main' into feat/pause-functionality

chore: add copyright to all source files

See merge request ics/sp/2025/n25b/pepperplus-ri!29

src/robot_interface/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

src/robot_interface/core/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

src/robot_interface/core/config.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from __future__ import unicode_literals
 
 from robot_interface.utils.get_config import get_config

src/robot_interface/endpoints/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

src/robot_interface/endpoints/actuation_receiver.py

@@ -1,11 +1,19 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from __future__ import unicode_literals  # So that we can log texts with Unicode characters
 import logging
+from threading import Thread
 
+import Queue
 import zmq
 
 from robot_interface.endpoints.receiver_base import ReceiverBase
 from robot_interface.state import state
-
 from robot_interface.core.config import settings
 from robot_interface.endpoints.gesture_settings import GestureTags
 
@@ -32,6 +40,9 @@ class ActuationReceiver(ReceiverBase):
         self.socket.setsockopt_string(zmq.SUBSCRIBE, u"")  # Causes block if given in options
         self._tts_service = None
         self._animation_service = None
+        self._message_queue = Queue.Queue()
+        self.message_thread = Thread(target=self._handle_messages)
+        self.message_thread.start()
 
     def _handle_speech(self, message):
         """
@@ -58,8 +69,26 @@ class ActuationReceiver(ReceiverBase):
         if not self._tts_service:
             self._tts_service = state.qi_session.service("ALTextToSpeech")
 
-        # Returns instantly. Messages received while speaking will be queued.
-        getattr(qi, "async")(self._tts_service.say, text)
+        if message.get("is_priority"):
+            # Bypass queue and speak immediately
+            self.clear_queue()
+            self._message_queue.put(text)
+            logging.debug("Force speaking immediately: {}".format(text))
+        else: 
+            self._message_queue.put(text)
+
+    def clear_queue(self):
+        """
+        Safely drains all pending messages from the queue.
+        """
+        logging.info("Message queue size: {}".format(self._message_queue.qsize()))
+        try:
+            while True:
+                # Remove items one by one without waiting
+                self._message_queue.get_nowait()
+        except Queue.Empty:
+            pass
+        logging.info("Message queue cleared.")
 
     def _handle_gesture(self, message, is_single):
         """
@@ -122,6 +151,19 @@ class ActuationReceiver(ReceiverBase):
         if message["endpoint"] == "actuate/gesture/single":
             self._handle_gesture(message, True)
 
+    def _handle_messages(self):
+        while not state.exit_event.is_set():
+            try:
+                text = self._message_queue.get(timeout=0.1)
+                state.is_speaking = True
+                self._tts_service.say(text)
+            except Queue.Empty:
+                state.is_speaking = False
+            except RuntimeError:
+                logging.error("Lost connection to Pepper. Please check if you're connected to the "
+                              "local WiFi and restart this application.")
+                state.exit_event.set()        
+
     def endpoint_description(self):
         """
         Extend the default endpoint description with gesture tags.
@@ -129,6 +171,5 @@ class ActuationReceiver(ReceiverBase):
         """
         desc = super(ActuationReceiver, self).endpoint_description()
         desc["gestures"] = GestureTags.tags
-        desc["basic_gestures"] = GestureTags.basic_gestures
         desc["single_gestures"] = GestureTags.single_gestures
         return desc

src/robot_interface/endpoints/audio_sender.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from __future__ import unicode_literals  # So that `logging` can use Unicode characters in names
 import threading
 import logging
@@ -77,21 +84,33 @@ class AudioSender(SocketBase):
         chunk = audio_settings.chunk_size # 320 at 16000 Hz is 20ms, 512 is required for Silero-VAD
 
         # Docs say this only raises an error if neither `input` nor `output` is True
-        stream = self.audio.open(
-            format=pyaudio.paFloat32,
-            channels=audio_settings.channels,
-            rate=audio_settings.sample_rate,
-            input=True,
-            input_device_index=self.microphone["index"],
-            frames_per_buffer=chunk,
-        )
+        def open_stream():
+            return self.audio.open(
+                format=pyaudio.paFloat32,
+                channels=audio_settings.channels,
+                rate=audio_settings.sample_rate,
+                input=True,
+                input_device_index=self.microphone["index"],
+                frames_per_buffer=chunk,
+            )
+        
+        stream = None
 
         try:
+            # Test in case exit_event was set while waiting
+            if not state.exit_event.is_set():
+                stream = open_stream()
+            
             while not state.exit_event.is_set():
                 data = stream.read(chunk)
+                if (state.is_speaking): continue  # Do not send audio while the robot is speaking
                 self.socket.send(data)
         except IOError as e:
             logger.error("Stopped listening: failed to get audio from microphone.", exc_info=e)
         finally:
-            stream.stop_stream()
-            stream.close()
+            if stream:
+                try:
+                    stream.stop_stream()
+                    stream.close()
+                except IOError:
+                    pass # Ignore errors on closing

src/robot_interface/endpoints/gesture_settings.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 class GestureTags:
     tags = ["above", "affirmative", "afford", "agitated", "all", "allright", "alright", "any", 
             "assuage", "assuage", "attemper", "back", "bashful", "beg", "beseech", "blank", 
@@ -14,19 +21,6 @@ class GestureTags:
             "think", "timid", "top", "unless", "up", "upstairs", "void", "warm", "winner", "yeah", 
             "yes", "yoo-hoo", "you", "your", "zero", "zestful"]
     
-    basic_gestures = [
-        "animations/Stand/Gestures/Hey_1",
-        "animations/Stand/Emotions/Neutral/Puzzled_1",
-        "animations/Stand/Gestures/Explain_4",
-        "animations/Stand/Gestures/You_1"
-        "animations/Stand/Emotions/Positive/Happy_1",
-        "animations/Stand/Emotions/Positive/Laugh_2",
-        "animations/Stand/Emotions/Neutral/Lonely_1",
-        "animations/Stand/Emotions/Negative/Surprise_1",
-        "animations/Stand/Emotions/Negative/Hurt_2",
-        "animations/Stand/Emotions/Negative/Angry_4",
-    ]
-
     single_gestures = [
         "animations/Stand/BodyTalk/Listening/Listening_1",
         "animations/Stand/BodyTalk/Listening/Listening_2",

src/robot_interface/endpoints/main_receiver.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import zmq
 
 from robot_interface.endpoints.receiver_base import ReceiverBase
@@ -72,6 +79,30 @@ class MainReceiver(ReceiverBase):
 
         return {"endpoint": "negotiate/error", "data": "The requested endpoint is not implemented."}
     
+    @staticmethod
+    def _handle_pause(message):
+        """
+        Handle a pause request. Pauses or resumes the video and audio streams.
+
+        :param message: The pause request message.
+        :type message: dict
+
+        :return: A response dictionary indicating success.
+        :rtype: dict[str, str]
+        """
+        if message.get("data"):
+            if state.active_event.is_set():
+                state.active_event.clear()
+                return {"endpoint": "pause", "data": "Streams paused."}
+            else:
+                return {"endpoint": "pause", "data": "Streams are already paused."}
+        else:
+            if not state.active_event.is_set():
+                state.active_event.set()
+                return {"endpoint": "pause", "data": "Streams resumed."}
+            else:
+                return {"endpoint": "pause", "data": "Streams are already running."}
+
     def handle_message(self, message):
         """
         Main entry point for handling incoming messages.
@@ -88,5 +119,7 @@ class MainReceiver(ReceiverBase):
             return self._handle_ping(message)
         elif message["endpoint"].startswith("negotiate"):
             return self._handle_negotiation(message)
+        elif message["endpoint"] == "pause":
+            return self._handle_pause(message)
 
         return {"endpoint": "error", "data": "The requested endpoint is not supported."}

src/robot_interface/endpoints/receiver_base.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from abc import ABCMeta, abstractmethod
 
 from robot_interface.endpoints.socket_base import SocketBase

src/robot_interface/endpoints/socket_base.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from abc import ABCMeta
 
 import zmq

src/robot_interface/endpoints/video_sender.py

@@ -1,11 +1,22 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+import struct
 import zmq
 import threading
 import logging
+import numpy as np
+
+import cv2
 
 from robot_interface.endpoints.socket_base import SocketBase
 from robot_interface.state import state
 from robot_interface.core.config import settings
 
+
 class VideoSender(SocketBase):
     """
     Video sender endpoint, responsible for sending video frames.
@@ -18,7 +29,7 @@ class VideoSender(SocketBase):
     """
     def __init__(self, zmq_context, port=settings.agent_settings.video_sender_port):
         super(VideoSender, self).__init__("video")
-        self.create_socket(zmq_context, zmq.PUB, port, [(zmq.CONFLATE,1)])
+        self.create_socket(zmq_context, zmq.PUB, port, [(zmq.SNDHWM,3)])
     
     def start_video_rcv(self):
         """
@@ -28,6 +39,9 @@ class VideoSender(SocketBase):
         """
         if not state.qi_session:
             logging.info("No Qi session available. Not starting video loop.")
+            logging.info("Starting test video stream from local webcam.")
+            thread = threading.Thread(target=self.test_video_stream)
+            thread.start()
             return
 
         video = state.qi_session.service("ALVideoDevice")
@@ -41,9 +55,40 @@ class VideoSender(SocketBase):
         thread = threading.Thread(target=self.video_rcv_loop, args=(video, vid_stream_name))
         thread.start()
 
+    def test_video_stream(self):
+        """
+        Test function to send video from a local webcam instead of the robot.
+        """
+        cap = cv2.VideoCapture(0)
+        if not cap.isOpened():
+            logging.error("Could not open webcam for video stream test.")
+            return
+
+        while not state.exit_event.is_set():
+
+            ret, frame = cap.read()
+            if not ret:
+                logging.warning("Failed to read frame from webcam.")
+                continue
+
+            if cv2.waitKey(1) & 0xFF == ord('q'): # << Add this: Updates the window
+                break
+            
+            height, width, channels = frame.shape
+            
+            pixel_data = frame.tobytes()
+
+            width_bytes = struct.pack('<I', width)
+            height_bytes = struct.pack('<I', height)
+
+            self.socket.send_multipart([width_bytes, height_bytes, pixel_data])
+
+        cap.release()
+
     def video_rcv_loop(self, vid_service, vid_stream_name):
         """
         The main loop of retrieving video images from the robot.
+        Sends the image data over the ZMQ socket in 3 parts: image width, image height and raw image bytes.
 
         :param vid_service: The video service object that the active Qi session is connected to. 
         :type vid_service: Object (Qi service object)
@@ -51,10 +96,23 @@ class VideoSender(SocketBase):
         :param vid_stream_name: The name of a camera subscription on the video service object vid_service
         :type vid_stream_name: str
         """
-        while not state.exit_event.is_set():
-            try:
-                img = vid_service.getImageRemote(vid_stream_name)
-                #Possibly limit images sent if queuing issues arise
-                self.socket.send(img[settings.video_config.image_buffer])
-            except:
-                logging.warn("Failed to retrieve video image from robot.")
+        try:
+            while not state.exit_event.is_set():
+                try:
+                    img = vid_service.getImageRemote(vid_stream_name)
+                    if img is not None:
+                        image_bytes = img[6]
+                        width = img[0]
+                        height = img[1]
+
+                        width_bytes = struct.pack('<I', width)
+                        height_bytes = struct.pack('<I', height)
+
+                        self.socket.send_multipart([width_bytes, height_bytes, image_bytes])
+                except:
+                    logging.warn("Failed to retrieve video image from robot.")
+        except KeyboardInterrupt:
+            logging.info("Video receiving loop interrupted by user.")
+        finally:
+            vid_service.unsubscribe(vid_stream_name)
+            logging.info("Unsubscribed from video stream.")

src/robot_interface/main.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import logging
 
 from robot_interface.endpoints.audio_sender import AudioSender
@@ -84,6 +91,7 @@ def main():
     context = zmq.Context()
 
     state.initialize()
+    state.active_event.set()
 
     try:
         main_loop(context)

src/robot_interface/state.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import logging
 import signal
 import threading
@@ -30,6 +37,7 @@ class State(object):
         self.exit_event = None
         self.sockets = []  
         self.qi_session = None 
+        self.is_speaking = False
 
     def initialize(self):
         """
@@ -48,6 +56,8 @@ class State(object):
         signal.signal(signal.SIGINT, handle_exit)
         signal.signal(signal.SIGTERM, handle_exit)
 
+        self.active_event = threading.Event()
+
         self.qi_session = get_qi_session()
 
         self.is_initialized = True

src/robot_interface/utils/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

src/robot_interface/utils/get_config.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import os
 from dotenv import load_dotenv
 

src/robot_interface/utils/microphone.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from __future__ import unicode_literals  # So that `print` can print Unicode characters in names
 import logging
 import sys

src/robot_interface/utils/qi_utils.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import logging
 import sys
 

src/robot_interface/utils/timeblock.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import time
 
 

test/common/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

test/common/microphone_utils.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from __future__ import unicode_literals  # So that we can format strings with Unicode characters
 import random
 import sys

test/conftest.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
+from mock import patch, MagicMock
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def mock_zmq_context():
+    with patch("zmq.Context") as mock:
+        mock.instance.return_value = MagicMock()
+        yield mock

test/integration/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

test/integration/test_config.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from mock import patch, mock
 
 from robot_interface.core.config import Settings

test/integration/test_microphone_utils.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import pyaudio
 
 import pytest

test/unit/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""

test/unit/test_actuation_receiver.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import sys
 
 import mock
@@ -20,46 +27,109 @@ def zmq_context():
     yield context
 
 
-def test_handle_unimplemented_endpoint(zmq_context):
+def test_force_speech_clears_queue(mocker):
     """
-    Tests that the ``ActuationReceiver.handle_message`` method can
-    handle an unknown or unimplemented endpoint without raising an error.
+    Tests that a force speech message clears the existing queue
+    and places the high-priority message at the front.
     """
-    receiver = ActuationReceiver(zmq_context)
-    # Should not error
+    mocker.patch("threading.Thread")
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+    
+    mock_qi = mock.Mock()
+    sys.modules["qi"] = mock_qi 
+
+    mock_tts_service = mock.Mock()
+    mock_state.qi_session.service.return_value = mock_tts_service
+
+    # Use Mock Context
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
+    receiver._message_queue.put("old_message_1")
+    receiver._message_queue.put("old_message_2")
+    
+    assert receiver._message_queue.qsize() == 2
+
+    force_msg = {
+        "endpoint": "actuate/speech", 
+        "data": "Emergency Notification",
+        "is_priority": True,
+    }
+    receiver.handle_message(force_msg)
+
+    assert receiver._message_queue.qsize() == 1
+    queued_item = receiver._message_queue.get()
+    assert queued_item == "Emergency Notification"
+
+
+def test_handle_unimplemented_endpoint(mocker):
+    """
+    Tests handling of unknown endpoints.
+    """
+    mocker.patch("threading.Thread")
+    
+    # Use Mock Context
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
     receiver.handle_message({
         "endpoint": "some_endpoint_that_definitely_does_not_exist",
         "data": None,
     })
 
 
-def test_speech_message_no_data(zmq_context, mocker):
+def test_speech_message_no_data(mocker):
     """
-    Tests that the message handler logs a warning when a speech actuation
-    request (`actuate/speech`) is received but contains empty string data.
+    Tests that if the message data is empty, the receiver returns immediately
+    WITHOUT attempting to access the global robot state or session.
     """
-    mock_warn = mocker.patch("logging.warn")
+    # 1. Prevent background threads from running
+    mocker.patch("threading.Thread")
     
-    receiver = ActuationReceiver(zmq_context)
+    # 2. Mock the global state object
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+
+    # 3. Create a PropertyMock to track whenever 'qi_session' is accessed
+    # We attach it to the class type of the mock so it acts like a real property
+    mock_session_prop = mock.PropertyMock(return_value=None)
+    type(mock_state).qi_session = mock_session_prop
+
+    # 4. Initialize Receiver (Mocking the context to avoid ZMQ errors)
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
+    # 5. Send empty data
     receiver.handle_message({"endpoint": "actuate/speech", "data": ""})
 
-    mock_warn.assert_called_with(mock.ANY)
+    # 6. Assertion: 
+    # Because the code does `if not text: return` BEFORE `if not state.qi_session`,
+    # the state property should NEVER be read.
+    mock_session_prop.assert_not_called()
 
 
-def test_speech_message_invalid_data(zmq_context, mocker):
+def test_speech_message_invalid_data(mocker):
     """
-    Tests that the message handler logs a warning when a speech actuation
-    request (`actuate/speech`) is received with data that is not a string (e.g., a boolean).
+    Tests that if the message data is not a string, the function returns.     
+    :param mocker: Description
     """
-    mock_warn = mocker.patch("logging.warn")
+    mocker.patch("threading.Thread")
+
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+
+    mock_session_prop = mock.PropertyMock(return_value=None)
+    type(mock_state).qi_session = mock_session_prop
+
+    # Use Mock Context
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
     
-    receiver = ActuationReceiver(zmq_context)
     receiver.handle_message({"endpoint": "actuate/speech", "data": True})
 
-    mock_warn.assert_called_with(mock.ANY)
+    # Because the code does `if not text: return` BEFORE `if not state.qi_session`,
+    # the state property should NEVER be read.
+    mock_session_prop.assert_not_called()
 
-
-def test_speech_no_qi(zmq_context, mocker):
+def test_speech_no_qi(mocker):
     """
     Tests the actuation receiver's behavior when processing a speech request
     but the global state does not have an active QI session.
@@ -69,16 +139,21 @@ def test_speech_no_qi(zmq_context, mocker):
     mock_qi_session = mock.PropertyMock(return_value=None)
     type(mock_state).qi_session = mock_qi_session
 
-    receiver = ActuationReceiver(zmq_context)
+    mock_tts_service = mock.Mock()
+
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    receiver._tts_service = mock_tts_service
+
     receiver._handle_speech({"endpoint": "actuate/speech", "data": "Some message to speak."})
 
-    mock_qi_session.assert_called()
+    receiver._tts_service.assert_not_called()
 
 
-def test_speech(zmq_context, mocker):
+def test_speech(mocker):
     """
     Tests the core speech actuation functionality by mocking the QI TextToSpeech
-    service and verifying that it is called correctly.
+    service and verifying that the received message is put into the queue.
     """
     mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
 
@@ -89,17 +164,182 @@ def test_speech(zmq_context, mocker):
     mock_state.qi_session = mock.Mock()
     mock_state.qi_session.service.return_value = mock_tts_service
 
-    receiver = ActuationReceiver(zmq_context)
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+
     receiver._tts_service = None
     receiver._handle_speech({"endpoint": "actuate/speech", "data": "Some message to speak."})
 
-    mock_state.qi_session.service.assert_called_once_with("ALTextToSpeech")
+    assert receiver._message_queue.qsize() == 1
 
-    getattr(mock_qi, "async").assert_called_once()
-    call_args = getattr(mock_qi, "async").call_args[0]
-    assert call_args[0] == mock_tts_service.say
-    assert call_args[1] == "Some message to speak."
+    queued_item = receiver._message_queue.get()
+    assert queued_item == "Some message to speak."
 
+def test_speech_priority(mocker):
+    """
+    Tests that a priority speech message is handled correctly by clearing the queue
+    and placing the priority message at the front.
+    """
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+
+    mock_qi = mock.Mock()
+    sys.modules["qi"] = mock_qi
+
+    mock_tts_service = mock.Mock()
+    mock_state.qi_session = mock.Mock()
+    mock_state.qi_session.service.return_value = mock_tts_service
+
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+
+    receiver._message_queue.put("old_message_1")
+    receiver._message_queue.put("old_message_2")
+
+    assert receiver._message_queue.qsize() == 2
+
+    priority_msg = {
+        "endpoint": "actuate/speech", 
+        "data": "Urgent Message",
+        "is_priority": True,
+    }
+    receiver._handle_speech(priority_msg)
+
+    assert receiver._message_queue.qsize() == 1
+    queued_item = receiver._message_queue.get()
+    assert queued_item == "Urgent Message"
+
+def test_handle_messages_loop(mocker):
+    """
+    Tests the background consumer loop (_handle_messages) processing an item.
+    Runs SYNCHRONOUSLY to ensure coverage tools pick up the lines.
+    """
+    # Patch Thread so the real background thread NEVER starts automatically
+    mocker.patch("threading.Thread")
+
+    # Mock state
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+        
+    # Setup initial speaking state to False (covers "Started speaking" print)
+    mock_state.is_speaking = False
+    
+    # Mock the TextToSpeech service
+    mock_tts_service = mock.Mock()
+    mock_state.qi_session.service.return_value = mock_tts_service
+    
+    # Initialize receiver (Thread is patched, so no thread starts)
+    # Use Mock Context to avoid ZMQ errors
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
+    # Manually inject service (since lazy loading might handle it, but this is safer)
+    receiver._tts_service = mock_tts_service
+
+    # This ensures the while loop iterates exactly once
+    mock_state.exit_event.is_set.side_effect = [False, True]
+
+    # Put an item in the queue
+    receiver._message_queue.put("Hello World")
+
+    # RUN MANUALLY in the main thread
+    # This executes the code: while -> try -> get -> if print -> speaking=True -> say
+    receiver._handle_messages()
+
+    # Assertions
+    assert receiver._message_queue.empty()
+    mock_tts_service.say.assert_called_with("Hello World")
+    assert mock_state.is_speaking is True
+
+
+def test_handle_messages_queue_empty(mocker):
+    """
+    Tests the Queue.Empty exception handler in the consumer loop.
+    This covers the logic that resets 'state.is_speaking' to False.
+    """
+    # Prevent the real background thread from starting
+    mocker.patch("threading.Thread")
+
+    # Mock the state object
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+        
+    # Setup 'is_speaking' property mock
+    # We set return_value=True so the code enters the 'if state.is_speaking:' block.
+    # We use PropertyMock to track when this attribute is set.
+    type(mock_state).is_speaking = True
+    
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
+    # This ensures the while loop body runs exactly once for our test
+    mock_state.exit_event.is_set.side_effect = [False, True]
+
+    # Force get() to raise Queue.Empty immediately (simulate timeout)
+    # We patch the 'get' method on the specific queue instance of our receiver
+    #mocker.patch.object(receiver._message_queue, 'get', side_effect=Queue.Empty)
+    
+    # Run the loop logic manually (synchronously)
+    receiver._handle_messages()
+
+    # Final Assertion: Verify is_speaking was set to False
+    # The code execution order is: read (returns True) -> print -> set (to False)
+    # assert_called_with checks the arguments of the LAST call, which is the setter.
+    assert mock_state.is_speaking is False
+
+
+def test_handle_messages_runtime_error(mocker):
+    """
+    Tests the RuntimeError exception handler (e.g. lost WiFi connection).
+    Uses a Mock ZMQ context to avoid 'Address already in use' errors.
+    """
+    # Patch Thread so we don't accidentally spawn real threads
+    mocker.patch("threading.Thread")
+    
+    # Mock the state and logging
+    mock_state = mocker.patch("robot_interface.endpoints.actuation_receiver.state")
+        
+    # Use a MOCK ZMQ context. 
+    # This prevents the receiver from trying to bind to a real TCP port.
+    mock_zmq_ctx = mock.Mock()
+    
+    # Initialize receiver with the mock context
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
+    mock_state.exit_event.is_set.side_effect = [False, True]
+
+    receiver._message_queue.put("Test Message")
+    
+    # Setup: ...BUT the service raises RuntimeError when asked to speak
+    mock_tts = mock.Mock()
+    mock_tts.say.side_effect = RuntimeError("Connection lost")
+    receiver._tts_service = mock_tts
+    
+    # Run the loop logic manually
+    receiver._handle_messages()
+    
+    # Assertions
+    assert mock_state.exit_event.is_set.called
+
+def test_clear_queue(mocker):
+    """
+    Tests that the clear_queue method properly drains all items from the message queue.
+    """
+    mocker.patch("threading.Thread")
+    
+    # Use Mock Context
+    mock_zmq_ctx = mock.Mock()
+    receiver = ActuationReceiver(mock_zmq_ctx)
+    
+    # Populate the queue with multiple items
+    receiver._message_queue.put("msg1")
+    receiver._message_queue.put("msg2")
+    receiver._message_queue.put("msg3")
+    
+    assert receiver._message_queue.qsize() == 3
+
+    # Clear the queue
+    receiver.clear_queue()
+
+    # Assert the queue is empty
+    assert receiver._message_queue.qsize() == 0
 
 def test_gesture_no_data(zmq_context, mocker):
     receiver = ActuationReceiver(zmq_context)

test/unit/test_audio_sender.py

@@ -1,4 +1,10 @@
-# coding=utf-8
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import os
 
 import mock
@@ -33,7 +39,6 @@ def test_no_microphone(zmq_context, mocker):
 
     sender.start()
     assert sender.thread is None
-    mock_info_logger.assert_called()
 
     sender.wait_until_done()  # Should return early because we didn't start a thread
 
@@ -73,11 +78,12 @@ def test_sending_audio(mocker):
     mock_choose_mic.return_value = {"name": u"Some mic", "index": 0L}
 
     mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
-    mock_state.exit_event.is_set.side_effect = [False, True]
+    mock_state.exit_event.is_set.side_effect = [False, False, True]
 
     mock_zmq_context = mock.Mock()
     send_socket = mock.Mock()
     
+    mock_state.is_speaking = False
     # If there's something wrong with the microphone, it will raise an IOError when `read`ing.
     stream = mock.Mock()
     stream.read = _fake_read
@@ -92,6 +98,247 @@ def test_sending_audio(mocker):
 
     send_socket.assert_called()
 
+# SENDING PAUSE RESUME?
+
+def test_stream_initial_wait_exit(mocker):
+    mock_choose_mic = mocker.patch("robot_interface.endpoints.audio_sender.choose_mic")
+    mock_choose_mic.return_value = {"name": u"Some mic", "index": 0L}
+
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.exit_event.is_set.return_value = True
+    mock_state.active_event.is_set.return_value = False
+    
+    mock_zmq_context = mock.Mock()
+
+    sender = AudioSender(mock_zmq_context)
+    sender._stream()
+
+    mock_pyaudio_instance.open.assert_not_called()
+
+def test_stream_pause_and_resume(mocker):
+    mock_stream = mock.Mock()
+    mock_stream.read.return_value = b"data"
+
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    mock_pyaudio_instance.open.return_value = mock_stream
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.active_event.is_set.return_value = False
+
+    mock_state.exit_event.is_set.side_effect = [False, False, False, True]
+
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender.socket = mock.Mock()
+
+    sender._stream()
+
+    assert mock_pyaudio_instance.open.call_count == 2
+
+    assert mock_stream.close.call_count == 2
+    assert mock_stream.stop_stream.call_count == 2
+
+    assert mock_state.active_event.wait.called
+
+def test_stream_exit_during_pause(mocker):
+    mock_stream = mock.Mock()
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    mock_pyaudio_instance.open.return_value = mock_stream
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.active_event.is_set.return_value = False
+
+    mock_state.exit_event.is_set.side_effect = [False, False, True]
+
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender._stream()
+
+    assert mock_pyaudio_instance.open.call_count == 1
+    assert mock_stream.close.call_count == 1
+
+def test_stream_read_error_recovery(mocker):
+    stream_fail = mock.Mock()
+    stream_fail.read.side_effect = IOError("Overflow")
+
+    stream_ok = mock.Mock()
+    stream_ok.read.return_value = b"data"
+
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    mock_pyaudio_instance.open.side_effect = [stream_fail, stream_ok]
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.active_event.is_set.return_value = True
+    mock_state.exit_event.is_set.side_effect = [False, False, False, True]
+
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender.socket = mock.Mock()
+    sender._stream()
+    stream_fail.close.assert_called()
+    assert mock_pyaudio_instance.open.call_count == 2
+    sender.socket.send.assert_called_with(b"data")
+
+
+def test_stream_fatal_error(mocker):
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    mock_pyaudio_instance.open.side_effect = IOError("Fatal error")
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.active_event.is_set.return_value = True
+    mock_state.exit_event.is_set.return_value = False
+
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender._stream()
+
+def test_wait_until_done(mocker):
+    mock_zmq_context = mock.Mock()
+    
+    sender = AudioSender(mock_zmq_context)
+
+    sender.wait_until_done()
+
+    mock_thread = mocker.Mock()
+    sender.thread = mock_thread
+    sender.wait_until_done()
+
+    mock_thread.join.assert_called_once()
+    assert sender.thread is None
+
+def test_stream_pause_close_error(mocker):
+    """
+    Tests that an IOError during stream closure (when pausing) is ignored,
+    covering the 'pass' statement in the pause logic.
+    """
+    mock_stream = mock.Mock()
+    mock_stream.read.return_value = b"data"
+    # Raise IOError when stopping the stream during pause
+    mock_stream.stop_stream.side_effect = IOError("Failed to stop")
+
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    mock_pyaudio_instance.open.return_value = mock_stream
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    
+    # 1. First False triggers the pause block
+    # 2. Second True resumes the loop
+    mock_state.active_event.is_set.side_effect = [False, True] 
+
+    mock_state.exit_event.is_set.side_effect = [False, False, False, True]
+
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender.socket = mock.Mock()
+
+    sender._stream()
+
+    # Verification: The error should be swallowed, and the stream should re-open
+    assert mock_stream.stop_stream.called
+    assert mock_pyaudio_instance.open.call_count == 2
+
+
+def test_stream_finally_close_error(mocker):
+    """
+    Tests that an IOError during stream closure in the finally block is ignored,
+    covering the 'pass' statement in the finally logic.
+    """
+    mock_stream = mock.Mock()
+    mock_stream.read.return_value = b"data"
+    # Raise IOError when stopping the stream at exit
+    mock_stream.stop_stream.side_effect = IOError("Cleanup failed")
+
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    mock_pyaudio_instance.open.return_value = mock_stream
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.active_event.is_set.return_value = True
+    mock_state.exit_event.is_set.side_effect = [False, False, True]
+
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender.socket = mock.Mock()
+
+    # Run
+    sender._stream()
+
+    # Assert: Should finish without raising exception despite the IOError in finally
+    assert mock_stream.stop_stream.called
+
+
+def test_stream_recovery_failure(mocker):
+    """
+    Tests the case where recovering from a read error (re-opening stream) also fails.
+    This ensures the outer try-except catches exceptions from the inner except block.
+    """
+    mock_stream_initial = mock.Mock()
+    # Trigger the read error logic
+    mock_stream_initial.read.side_effect = IOError("Read failed")
+
+    mock_pyaudio_cls = mocker.patch("robot_interface.endpoints.audio_sender.pyaudio.PyAudio")
+    mock_pyaudio_instance = mock_pyaudio_cls.return_value
+    
+    # First open works, Second open (recovery) fails fatally
+    mock_pyaudio_instance.open.side_effect = [
+        mock_stream_initial, 
+        IOError("Recovery failed")
+    ]
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.active_event.is_set.return_value = True
+    mock_state.exit_event.is_set.return_value = False
+
+    mock_logger = mocker.patch("robot_interface.endpoints.audio_sender.logger")
+    
+    mock_zmq_context = mock.Mock()
+    sender = AudioSender(mock_zmq_context)
+    sender.socket = mock.Mock()
+
+    sender._stream()
+
+    # Assert we hit the outer error log
+    mock_logger.error.assert_called()
+
+
+
+def test_no_sending_if_speaking(mocker):
+    """
+    Tests the successful sending of audio data over a ZeroMQ socket.
+    """
+    mock_choose_mic = mocker.patch("robot_interface.endpoints.audio_sender.choose_mic")
+    mock_choose_mic.return_value = {"name": u"Some mic", "index": 0L}
+
+    mock_state = mocker.patch("robot_interface.endpoints.audio_sender.state")
+    mock_state.exit_event.is_set.side_effect = [False, True]
+
+    mock_zmq_context = mock.Mock()
+    send_socket = mock.Mock()
+    
+    mock_state.is_speaking = True
+
+    # If there's something wrong with the microphone, it will raise an IOError when `read`ing.
+    stream = mock.Mock()
+    stream.read = _fake_read
+
+    sender = AudioSender(mock_zmq_context)
+    sender.socket.send = send_socket
+    sender.audio.open = mock.Mock()
+    sender.audio.open.return_value = stream
+
+    sender.start()
+    sender.wait_until_done()
+
+    send_socket.assert_not_called()
+
 
 def _fake_read_error(num_frames):
     """

test/unit/test_get_config.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 from robot_interface.utils.get_config import get_config
 
 

test/unit/test_main.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import pytest
 import threading
 import zmq

test/unit/test_main_receiver.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import mock
 import pytest
 import zmq

test/unit/test_microphone_utils.py

@@ -1,4 +1,10 @@
-# coding=utf-8
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import mock
 import pytest
 

test/unit/test_qi_utils.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import sys
 
 # Import module under test

test/unit/test_reciever_base.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import pytest
 from robot_interface.endpoints.receiver_base import ReceiverBase
 

test/unit/test_socket_base.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import mock
 import zmq
 from robot_interface.endpoints.socket_base import SocketBase

test/unit/test_state.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import threading
 import signal
 import pytest

test/unit/test_time_block.py

@@ -1,3 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
+
 import time
 
 import mock

test/unit/test_video_sender.py

@@ -1,99 +1,171 @@
-# coding=utf-8
+# -*- coding: utf-8 -*-
+"""
+This program has been developed by students from the bachelor Computer Science at Utrecht
+University within the Software Project course.
+© Copyright Utrecht University (Department of Information and Computing Sciences)
+"""
 
 import mock
 import pytest
 import zmq
 
 from robot_interface.endpoints.video_sender import VideoSender
-from robot_interface.state import state
-from robot_interface.core.config import settings
-
 
 @pytest.fixture
 def zmq_context():
-    """Provide a ZMQ context."""
-    yield zmq.Context()
+    """
+    Yields a real ZMQ context for socket creation.
+    """
+    context = zmq.Context()
+    yield context
+    context.term()
 
+def test_init_defaults(zmq_context, mocker):
+    """
+    Test initialization of the VideoSender.
+    """
+    # We patch settings to ensure valid port access inside the class logic, 
+    # although the default arg is evaluated at import time.
+    mocker.patch("robot_interface.endpoints.video_sender.settings")
     
-def _patch_basics(mocker):
-    """Common patches: prevent real threads, port binds, and state errors."""
-    mocker.patch("robot_interface.endpoints.socket_base.zmq.Socket.bind")
-    mocker.patch("robot_interface.endpoints.video_sender.threading.Thread")
-    mocker.patch.object(state, "is_initialized", True)
+    mock_zmq = mock.Mock()
+    sender = VideoSender(mock_zmq)
     
+    # Verify socket type is PUB
+    assert sender.identifier == "video"
 
-def _patch_exit_event(mocker):
-    """Make exit_event stop the loop after one iteration."""
-    fake_event = mock.Mock()
-    fake_event.is_set.side_effect = [False, True]
-    mocker.patch.object(state, "exit_event", fake_event)
+def test_start_no_qi_session(mocker):
+    """
+    Test that the loop does not start if no Qi session is available.
+    """
+    # Mock state to return None for qi_session
+    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
+    mock_state.qi_session = None
     
+    mock_threading = mocker.patch("robot_interface.endpoints.video_sender.threading")
 
-def test_no_qi_session(zmq_context, mocker):
-    """Video loop should not start without a qi_session."""
-    _patch_basics(mocker)
-    mocker.patch.object(state, "qi_session", None)
-
-    sender = VideoSender(zmq_context)
+    mock_zmq = mock.Mock()
+    sender = VideoSender(mock_zmq)
     sender.start_video_rcv()
 
-    assert not hasattr(sender, "thread")
+    # Assertions
+    mock_threading.Thread.assert_not_called()
 
-
-def test_video_streaming(zmq_context, mocker):
-    """VideoSender should send retrieved image data."""
-    _patch_basics(mocker)
-    _patch_exit_event(mocker)
-
-    # Pepper's image buffer lives at index 6
-    mocker.patch.object(settings.video_config, "image_buffer", 6)
+def test_start_success(mocker):
+    """
+    Test successful startup of the video receiver thread.
+    """
+    # Mock the Qi Session and Service
+    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
+    mock_session = mock.Mock()
+    mock_state.qi_session = mock_session
     
     mock_video_service = mock.Mock()
-    mock_video_service.getImageRemote.return_value = [None]*6 + ["fake_img"]
+    mock_session.service.return_value = mock_video_service
+    mock_video_service.subscribeCamera.return_value = "test_subscriber_id"
 
-    fake_session = mock.Mock()
-    fake_session.service.return_value = mock_video_service
-    mocker.patch.object(state, "qi_session", fake_session)
+    # Mock Settings
+    mock_settings = mocker.patch("robot_interface.endpoints.video_sender.settings")
+    mock_settings.video_config.camera_index = 0
+    mock_settings.video_config.resolution = 2
+    mock_settings.video_config.color_space = 11
+    mock_settings.video_config.fps = 30
+    mock_settings.video_config.stream_name = "test_stream"
 
-    mocker.patch.object(
-        fake_session.service("ALVideoDevice"),
-        "subscribeCamera",
-        return_value="stream_name"
-    )
-
-    sender = VideoSender(zmq_context)
-    send_socket = mock.Mock()
-    sender.socket.send = send_socket
+    mock_threading = mocker.patch("robot_interface.endpoints.video_sender.threading")
 
+    # Run
+    mock_zmq = mock.Mock()  
+    sender = VideoSender(mock_zmq)
     sender.start_video_rcv()
-    sender.video_rcv_loop(mock_video_service, "stream_name")
 
-    send_socket.assert_called_with("fake_img")
+    # Assertions
+    mock_session.service.assert_called_with("ALVideoDevice")
+    mock_video_service.subscribeCamera.assert_called_with("test_stream", 0, 2, 11, 30)
     
+    mock_threading.Thread.assert_called_once()
+    # Verify arguments passed to the thread target
+    call_args = mock_threading.Thread.call_args[1]
+    assert call_args["target"] == sender.video_rcv_loop
+    assert call_args["args"] == (mock_video_service, "test_subscriber_id")
     
-def test_video_receive_error(zmq_context, mocker):
-    """Errors retrieving images should not call send()."""
-    _patch_basics(mocker)
-    _patch_exit_event(mocker)
+    # Ensure thread was started
+    mock_threading.Thread.return_value.start.assert_called_once()
 
-    mock_video_service = mock.Mock()
-    mock_video_service.getImageRemote.side_effect = Exception("boom")
+def test_video_loop_happy_path(mocker):
+    """
+    Test the main loop: Wait -> Get Image -> Send -> Repeat/Exit.
+    """
+    # Mock settings for image buffer index
+    mock_settings = mocker.patch("robot_interface.endpoints.video_sender.settings")
+    mock_settings.video_config.image_buffer = 6 
 
-    fake_session = mock.Mock()
-    fake_session.service.return_value = mock_video_service
-    mocker.patch.object(state, "qi_session", fake_session)
+    # Mock Video Service to return a fake image structure
+    # Standard NaoQi image is a list, binary data is usually at index 6
+    fake_image_data = b"binary_jpeg_data"
+    fake_image_list = [0] * 7
+    fake_image_list[6] = fake_image_data
     
-    mocker.patch.object(
-        fake_session.service("ALVideoDevice"),
-        "subscribeCamera",
-        return_value="stream_name"
-    )
+    mock_service = mock.Mock()
+    mock_service.getImageRemote.return_value = fake_image_list
 
-    sender = VideoSender(zmq_context)
-    send_socket = mock.Mock()
-    sender.socket.send = send_socket
+    # Mock Events: 
+    # exit_event: False (start), False (loop once), True (break)
+    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
+    mock_state.exit_event.is_set.side_effect = [False, False, True]
 
-    sender.start_video_rcv()
-    sender.video_rcv_loop(mock_video_service, "stream_name")
+    # Run
+    mock_zmq = mock.Mock()
+    sender = VideoSender(mock_zmq)
+    sender.socket = mock.Mock() # Mock the socket to verify send
     
-    send_socket.assert_not_called()
+    sender.video_rcv_loop(mock_service, "sub_id")
+
+    # Assertions
+    mock_state.active_event.wait.assert_called()
+    mock_service.getImageRemote.assert_called_with("sub_id")
+    sender.socket.send.assert_called_with(fake_image_data)
+
+def test_video_loop_exit_during_wait(zmq_context, mocker):
+    """
+    Test that the loop breaks immediately if exit_event is set while waiting.
+    """
+    mock_service = mock.Mock()
+    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
+    
+    # 1. Loop check: False (enter loop)
+    # 2. Wait happens (mock returns instantly)
+    # 3. Post-wait check: True (break)
+    mock_state.exit_event.is_set.side_effect = [False, True]
+
+    mock_zqm = mock.Mock()
+    sender = VideoSender(mock_zqm)
+    sender.video_rcv_loop(mock_service, "sub_id")
+
+    # Assert we never tried to get an image
+    mock_service.getImageRemote.assert_not_called()
+
+def test_video_loop_exception_handling(zmq_context, mocker):
+    """
+    Test that exceptions during image retrieval are caught and logged, 
+    and do not crash the thread.
+    """
+    mock_settings = mocker.patch("robot_interface.endpoints.video_sender.settings")
+    
+    mock_service = mock.Mock()
+    # First call raises Exception, Second call works (if we allowed it, but we exit)
+    mock_service.getImageRemote.side_effect = Exception("Camera disconnected")
+
+    mock_state = mocker.patch("robot_interface.endpoints.video_sender.state")
+    # Loop runs once then exits
+    mock_state.exit_event.is_set.side_effect = [False, False, True]
+
+    mock_zmq = mock.Mock()
+    sender = VideoSender(mock_zmq)
+    sender.socket = mock.Mock()
+    
+    sender.video_rcv_loop(mock_service, "sub_id")
+
+    # Assertions
+    # Ensure loop didn't crash; it should have completed the iteration and checked exit_event
+    assert mock_state.exit_event.is_set.call_count >= 2