Clean up prior tests

Author: strohganoff

tests/actions/test_action_registry.py

@@ -1,21 +1,14 @@
 from __future__ import annotations
 
 import pytest
-from polyfactory.factories.pydantic_factory import ModelFactory
 from streamdeck.actions import Action, ActionRegistry
 from streamdeck.models import events
 
-
-class DialUpEventFactory(ModelFactory[events.DialUp]):
-    """Polyfactory factory for creating a fake dialUp event message based on our Pydantic model."""
-
-class DialDownEventFactory(ModelFactory[events.DialDown]):
-    """Polyfactory factory for creating a fake dialDown event message based on our Pydantic model."""
-
-class KeyUpEventFactory(ModelFactory[events.KeyUp]):
-    """Polyfactory factory for creating a fake keyUp event message based on our Pydantic model."""
-
-
+from tests.test_utils.fake_event_factories import (
+    DialDownEventFactory,
+    DialUpEventFactory,
+    KeyUpEventFactory,
+)
 
 
 def test_register_action():

tests/actions/test_event_handler_filtering.py

@@ -4,14 +4,21 @@
 from unittest.mock import create_autospec
 
 import pytest
-from polyfactory.factories.pydantic_factory import ModelFactory
 from streamdeck.actions import Action, ActionRegistry, GlobalAction
 from streamdeck.models import events
 
+from tests.test_utils.fake_event_factories import (
+    ApplicationDidLaunchEventFactory,
+    DeviceDidConnectFactory,
+    KeyDownEventFactory,
+)
+
 
 if TYPE_CHECKING:
     from unittest.mock import Mock
 
+    from polyfactory.factories.pydantic_factory import ModelFactory
+
 
 
 @pytest.fixture
@@ -22,28 +29,6 @@ def dummy_handler(event: events.EventBase) -> None:
     return create_autospec(dummy_handler, spec_set=True)
 
 
-class ApplicationDidLaunchEventFactory(ModelFactory[events.ApplicationDidLaunch]):
-    """Polyfactory factory for creating fake applicationDidLaunch event message based on our Pydantic model.
-
-    ApplicationDidLaunchEvent's hold no unique identifier properties, besides the almost irrelevant `event` name property.
-    """
-
-class DeviceDidConnectFactory(ModelFactory[events.DeviceDidConnect]):
-    """Polyfactory factory for creating fake deviceDidConnect event message based on our Pydantic model.
-
-    DeviceDidConnectEvent's have `device` unique identifier property.
-    """
-
-class KeyDownEventFactory(ModelFactory[events.KeyDown]):
-    """Polyfactory factory for creating fake keyDown event message based on our Pydantic model.
-
-    KeyDownEvent's have the unique identifier properties:
-        `device`: Identifies the Stream Deck device that this event is associated with.
-        `action`: Identifies the action that caused the event.
-        `context`: Identifies the *instance* of an action that caused the event.
-    """
-
-
 @pytest.mark.parametrize(("event_name","event_factory"), [
     ("keyDown", KeyDownEventFactory),
     ("deviceDidConnect", DeviceDidConnectFactory),

tests/actions/test_global_action.py

@@ -3,14 +3,11 @@
 from typing import TYPE_CHECKING
 
 import pytest
-from polyfactory.factories.pydantic_factory import ModelFactory
-from streamdeck.actions import Action, GlobalAction, available_event_names
-from streamdeck.models import events
+from streamdeck.actions import GlobalAction, available_event_names
 
 
 if TYPE_CHECKING:
     from streamdeck.models.events import EventBase
-    from streamdeck.types import EventNameStr
 
 
 def test_global_action_register_event_handler():

tests/plugin_manager/__init__.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import uuid
+from unittest.mock import Mock, create_autospec
+
+import pytest
+from streamdeck.manager import PluginManager
+from streamdeck.websocket import WebSocketClient
+
+
+@pytest.fixture
+def plugin_manager(port_number: int) -> PluginManager:
+    """Fixture that provides a configured instance of PluginManager for testing.
+
+    Returns:
+        PluginManager: An instance of PluginManager with test parameters.
+    """
+    plugin_uuid = "test-plugin-uuid"
+    plugin_registration_uuid = str(uuid.uuid1())
+    register_event = "registerPlugin"
+    info = {"some": "info"}
+
+    return PluginManager(
+        port=port_number,
+        plugin_uuid=plugin_uuid,
+        plugin_registration_uuid=plugin_registration_uuid,
+        register_event=register_event,
+        info=info,
+    )
+
+
+@pytest.fixture
+def patch_websocket_client(monkeypatch: pytest.MonkeyPatch) -> Mock:
+    """Fixture that uses pytest's MonkeyPatch to mock WebSocketClient for the PluginManager run method.
+
+    The mocked WebSocketClient can be given fake event messages to yield when listen_forever() is called:
+      ```patch_websocket_client.listen_forever.return_value = [fake_event_json1, fake_event_json2, ...]```
+
+    Args:
+        monkeypatch: pytest's monkeypatch fixture.
+
+    Returns:
+    """
+    mock_websocket_client: Mock = create_autospec(WebSocketClient, spec_set=True)
+    mock_websocket_client.__enter__.return_value = mock_websocket_client
+
+    monkeypatch.setattr("streamdeck.manager.WebSocketClient", (lambda *args, **kwargs: mock_websocket_client))
+
+    return mock_websocket_client
+
+
+@pytest.fixture
+def mock_command_sender(mocker: pytest_mock.MockerFixture) -> Mock:
+    """Fixture that patches the StreamDeckCommandSender.
+
+    Args:
+        mocker: pytest-mock's mocker fixture.
+
+    Returns:
+        Mock: Mocked instance of StreamDeckCommandSender
+    """
+    mock_cmd_sender = Mock()
+    mocker.patch("streamdeck.manager.StreamDeckCommandSender", return_value=mock_cmd_sender)
+    return mock_cmd_sender

tests/plugin_manager/conftest.py

@@ -1,77 +1,31 @@
-import uuid
 from typing import cast
-from unittest.mock import MagicMock, Mock
+from unittest.mock import Mock
 
 import pytest
 import pytest_mock
-from polyfactory.factories.pydantic_factory import ModelFactory
 from streamdeck.actions import Action
 from streamdeck.manager import PluginManager
 from streamdeck.models.events import DialRotate, EventBase, event_adapter
-from streamdeck.websocket import WebSocketClient
 
-
-class DialRotateEventFactory(ModelFactory[DialRotate]):
-    """Polyfactory factory for creating a fake event message based on our Pydantic model."""
-
-
-@pytest.fixture
-def plugin_manager(port_number: int) -> PluginManager:
-    """Fixture that provides a configured instance of PluginManager for testing.
-
-    Returns:
-        PluginManager: An instance of PluginManager with test parameters.
-    """
-    plugin_uuid = "test-plugin-uuid"
-    plugin_registration_uuid = str(uuid.uuid1())
-    register_event = "registerPlugin"
-    info = {"some": "info"}
-
-    return PluginManager(
-        port=port_number,
-        plugin_uuid=plugin_uuid,
-        plugin_registration_uuid=plugin_registration_uuid,
-        register_event=register_event,
-        info=info,
-    )
+from tests.test_utils.fake_event_factories import DialRotateEventFactory
 
 
 @pytest.fixture
-def patch_websocket_client(monkeypatch: pytest.MonkeyPatch) -> tuple[MagicMock, EventBase]:
-    """Fixture that uses pytest's MonkeyPatch to mock WebSocketClient and StreamDeckCommandSender for the PluginManager run method.
+def mock_websocket_client_with_event(patch_websocket_client: Mock) -> tuple[Mock, EventBase]:
+    """Fixture that mocks the WebSocketClient and provides a fake DialRotateEvent message.
 
     Args:
-        monkeypatch: pytest's monkeypatch fixture.
+        patch_websocket_client: Mocked instance of the patched WebSocketClient.
 
     Returns:
         tuple: Mocked instance of WebSocketClient, and a fake DialRotateEvent.
     """
-    mock_websocket_client = MagicMock(spec=WebSocketClient)
-
-    mock_websocket_client.__enter__.return_value = mock_websocket_client
-
     # Create a fake event message, and convert it to a json string to be passed back by the client.listen_forever() method.
     fake_event_message: DialRotate = DialRotateEventFactory.build()
-    mock_websocket_client.listen_forever.return_value = [fake_event_message.model_dump_json()]
+    patch_websocket_client.listen_forever.return_value = [fake_event_message.model_dump_json()]
 
-    monkeypatch.setattr("streamdeck.manager.WebSocketClient", lambda port: mock_websocket_client)
+    return patch_websocket_client, fake_event_message
 
-    return mock_websocket_client, fake_event_message
-
-
-@pytest.fixture
-def mock_command_sender(mocker: pytest_mock.MockerFixture) -> Mock:
-    """Fixture that patches the StreamDeckCommandSender.
-
-    Args:
-        mocker: pytest-mock's mocker fixture.
-
-    Returns:
-        Mock: Mocked instance of StreamDeckCommandSender
-    """
-    mock_cmd_sender = Mock()
-    mocker.patch("streamdeck.manager.StreamDeckCommandSender", return_value=mock_cmd_sender)
-    return mock_cmd_sender
 
 
 @pytest.fixture
@@ -114,7 +68,7 @@ def test_plugin_manager_register_action(plugin_manager: PluginManager):
     assert plugin_manager._registry._plugin_actions[0] == action
 
 
-@pytest.mark.usefixtures("patch_websocket_client")
+@pytest.mark.usefixtures("mock_websocket_client_with_event")
 def test_plugin_manager_sends_registration_event(
     mock_command_sender: Mock, plugin_manager: PluginManager
 ):
@@ -130,10 +84,10 @@ def test_plugin_manager_sends_registration_event(
 @pytest.mark.usefixtures("_spy_action_registry_get_action_handlers")
 @pytest.mark.usefixtures("_spy_event_adapter_validate_json")
 def test_plugin_manager_process_event(
-    patch_websocket_client: tuple[MagicMock, EventBase], plugin_manager: PluginManager
+    mock_websocket_client_with_event: tuple[Mock, EventBase], plugin_manager: PluginManager
 ):
     """Test that PluginManager processes events correctly, calling event_adapter.validate_json and action_registry.get_action_handlers."""
-    mock_websocket_client, fake_event_message = patch_websocket_client
+    mock_websocket_client, fake_event_message = mock_websocket_client_with_event
 
     plugin_manager.run()
 

tests/test_plugin_manager.py renamed to tests/plugin_manager/test_plugin_manager.py

@@ -0,0 +1,42 @@
+from polyfactory.factories.pydantic_factory import ModelFactory
+from streamdeck.models import events
+
+
+class DialDownEventFactory(ModelFactory[events.DialDown]):
+    """Polyfactory factory for creating a fake dialDown event message based on our Pydantic model."""
+
+
+class DialUpEventFactory(ModelFactory[events.DialUp]):
+    """Polyfactory factory for creating a fake dialUp event message based on our Pydantic model."""
+
+
+class DialRotateEventFactory(ModelFactory[events.DialRotate]):
+    """Polyfactory factory for creating a fake event message based on our Pydantic model."""
+
+
+class KeyDownEventFactory(ModelFactory[events.KeyDown]):
+    """Polyfactory factory for creating fake keyDown event message based on our Pydantic model.
+
+    KeyDownEvent's have the unique identifier properties:
+        `device`: Identifies the Stream Deck device that this event is associated with.
+        `action`: Identifies the action that caused the event.
+        `context`: Identifies the *instance* of an action that caused the event.
+    """
+
+
+class KeyUpEventFactory(ModelFactory[events.KeyUp]):
+    """Polyfactory factory for creating a fake keyUp event message based on our Pydantic model."""
+
+
+class ApplicationDidLaunchEventFactory(ModelFactory[events.ApplicationDidLaunch]):
+    """Polyfactory factory for creating fake applicationDidLaunch event message based on our Pydantic model.
+
+    ApplicationDidLaunchEvent's hold no unique identifier properties, besides the almost irrelevant `event` name property.
+    """
+
+
+class DeviceDidConnectFactory(ModelFactory[events.DeviceDidConnect]):
+    """Polyfactory factory for creating fake deviceDidConnect event message based on our Pydantic model.
+
+    DeviceDidConnectEvent's have `device` unique identifier property.
+    """