Fix some tests

Author: strohganoff

streamdeck/event_listener.py

@@ -88,8 +88,8 @@ def stop(self) -> None:
 
         for thread in self.listeners_lookup_by_thread:
             logger.debug("Stopping listener %s.")
+            self.listeners_lookup_by_thread[thread].stop()
             if thread.is_alive():
-                self.listeners_lookup_by_thread[thread].stop()
                 thread.join()
 
             logger.info("All listeners have been stopped.")

tests/event_listener/test_event_listener.py

@@ -1,17 +1,16 @@
 import threading
 import time
 from collections.abc import Generator
-from queue import Empty
-from typing import ClassVar, List, Optional
-from unittest.mock import MagicMock, Mock, patch
+from typing import Any, ClassVar
+from unittest.mock import Mock, patch
 
 import pytest
 from streamdeck.event_listener import EventListener, EventListenerManager
 from streamdeck.models.events import ApplicationDidLaunch, EventBase
 
 
-# Mock implementation of EventListener for testing
 class MockEventListener(EventListener):
+    """Mock implementation of EventListener for testing."""
     event_models: ClassVar[list[type[EventBase]]] = [ApplicationDidLaunch]
 
     def __init__(self):
@@ -33,6 +32,7 @@ def stop(self) -> None:
 
 
 class SlowMockEventListener(EventListener):
+    """Mock implementation of EventListener that yields events with a delay."""
     event_models: ClassVar[list[type[EventBase]]] = [ApplicationDidLaunch]
 
     def __init__(self, delay: float = 0.1):
@@ -52,11 +52,9 @@ def stop(self) -> None:
 
 
 class ExceptionEventListener(EventListener):
+    """Mock implementation of EventListener that raises an exception."""
     event_models: ClassVar[list[type[EventBase]]] = [ApplicationDidLaunch]
 
-    # def __init__(self):
-    #     self._running = True
-
     def listen(self) -> Generator[str, None, None]:
         self._running = True
         # Raise exception after yielding one event
@@ -65,7 +63,6 @@ def listen(self) -> Generator[str, None, None]:
 
     def stop(self) -> None:
         pass
-        # self._running = False
 
 
 
@@ -148,15 +145,15 @@ def test_stop():
 
 
 @patch("streamdeck.event_listener.logger")
-def test_listener_exception_handling(mock_logger):
+def test_listener_exception_handling(mock_logger: Mock):
     """Test that exceptions in listeners are properly caught and logged."""
     manager = EventListenerManager()
     listener = ExceptionEventListener()
 
     manager.add_listener(listener)
 
     # Collect events - should get one event before the exception
-    events = []
+    events: list[Any] = []
     for event in manager.event_stream():
         events.append(event)
         if len(events) >= 1:  # We expect 1 event before exception
@@ -166,7 +163,7 @@ def test_listener_exception_handling(mock_logger):
 
     assert "event_before_exception" in events
     # Check that the exception was logged
-    mock_logger.exception.assert_called_with("Error in wrapped listener.")
+    mock_logger.exception.assert_called_with("Unexpected error in wrapped listener %s. Stopping just this listener.", listener)
 
 
 def test_listener_wrapper():

tests/plugin_manager/test_plugin_manager.py

@@ -88,7 +88,6 @@ def test_plugin_manager_sends_registration_event(
 
     mock_command_sender.send_action_registration.assert_called_once_with(
         register_event=plugin_manager._register_event,
-        plugin_registration_uuid=plugin_manager._registration_uuid,
     )
 
 

tests/test_websocket.py

@@ -1,12 +1,20 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING
+from functools import partial
+from typing import TYPE_CHECKING, Any
 from unittest.mock import Mock
 
 import pytest
+from streamdeck.event_listener import StopStreaming
 from streamdeck.websocket import WebSocketClient
-from websockets import ConnectionClosedOK, WebSocketException
+from websockets import (
+    ConnectionClosed,
+    ConnectionClosedError,
+    ConnectionClosedOK,
+    InvalidHeader,
+    WebSocketException,
+)
 
 
 if TYPE_CHECKING:
@@ -18,13 +26,16 @@ def mock_connection() -> Mock:
     """Fixture to mock the ClientConnection object returned by websockets.sync.client.connect."""
     return Mock()
 
+
 @pytest.fixture
 def patched_connect(mocker: MockerFixture, mock_connection: Mock) -> Mock:
     """Fixture to mock the ClientConnection object returned by websockets.sync.client.connect."""
     return mocker.patch("streamdeck.websocket.connect", return_value=mock_connection)
 
 
-def test_initialization_calls_connect_correctly(patched_connect: Mock, mock_connection: Mock, port_number: int) -> None:
+def test_initialization_calls_connect_correctly(
+    patched_connect: Mock, mock_connection: Mock, port_number: int
+) -> None:
     """Test that WebSocketClient initializes correctly by calling the connect function with the appropriate URI."""
     with WebSocketClient(port=port_number) as client:
         # Assert that 'connect' was called once with the correct URI.
@@ -50,9 +61,38 @@ def test_send_event_serializes_and_sends(mock_connection: Mock, port_number: int
 def test_listen_yields_messages(mock_connection: Mock, port_number: int) -> None:
     """Test that listen yields messages from the WebSocket connection."""
     # Set up the mocked connection to return messages until closing
-    mock_connection.recv.side_effect = ["message1", b"message2", WebSocketException()]
+    expected_results = ["message1", b"message2", "message3"]
+    mock_connection.recv.side_effect = expected_results
 
     with WebSocketClient(port=port_number) as client:
-        messages = list(client.listen())
+        actual_messages: list[Any] = []
+        for i, msg in enumerate(client.listen()):
+            actual_messages.append(msg)
+            if i == 2:
+                break
+
+    assert actual_messages == expected_results
+
+
+@pytest.mark.parametrize(
+    "exception_class",
+    [
+        partial(ConnectionClosedOK, None, None),
+        partial(ConnectionClosedError, None, None),
+        partial(InvalidHeader, "header-name", None),
+        partial(ConnectionClosed, None, None),
+        WebSocketException,
+    ],
+)
+@pytest.mark.usefixtures("patched_connect")
+def test_listen_raises_StopStreaming_from_WebSocketException(
+    mock_connection: Mock, port_number: int, exception_class: type[WebSocketException]
+) -> None:
+    """Test that listen raises a StopStreaming exception when a WebSocketException is raised."""
+    # Set up the mocked connection to return messages until closing
+    mock_connection.recv.side_effect = ["message1", b"message2", exception_class()]
 
-    assert messages == ["message1", b"message2"]
+    # This should raise a StopStreaming exception when any WebSocketException is raised
+    with WebSocketClient(port=port_number) as client, pytest.raises(StopStreaming):
+        for _ in client.listen():
+            pass