Add comprehensive test suite for pyavcontrol

- Add test_connection.py, test_device_client.py, test_device_library.py
- Add test_device_model.py, test_utils.py
- Update conftest.py with fixtures

Co-Authored-By: SageOx <ox@sageox.ai>

Author: rsnodgrass

tests/conftest.py

@@ -1,26 +1,21 @@
 """
-Pytest configuration and fixtures for testing pyavcontrol without physical devices.
+Pytest configuration and fixtures for testing pyavcontrol.
 
 All tests use mocked serial/IP connections to avoid needing real hardware.
 """
 
+from __future__ import annotations
+
 import asyncio
 from pathlib import Path
+from typing import Any
 from unittest.mock import AsyncMock, Mock
 
 import pytest
 
 
 @pytest.fixture
-def event_loop():
-    """Create an event loop for async tests."""
-    loop = asyncio.new_event_loop()
-    yield loop
-    loop.close()
-
-
-@pytest.fixture
-def mock_serial_transport():
+def mock_serial_transport() -> Mock:
     """Mock pyserial transport for RS232 connections."""
     transport = Mock()
     transport.serial = Mock()
@@ -31,23 +26,20 @@ def mock_serial_transport():
 
 
 @pytest.fixture
-def mock_serial_protocol(mock_serial_transport):
+def mock_serial_protocol(mock_serial_transport: Mock) -> AsyncMock:
     """Mock RS232 protocol for testing device communication."""
     protocol = AsyncMock()
     protocol._transport = mock_serial_transport
     protocol._connected = asyncio.Event()
-    protocol._connected.set()  # Start as connected
+    protocol._connected.set()
     protocol._q = asyncio.Queue()
-
-    # Mock send to return predefined responses
     protocol.send = AsyncMock(return_value=b'OK\r')
     protocol.receive_response = AsyncMock(return_value=b'OK\r')
-
     return protocol
 
 
 @pytest.fixture
-def mock_connection(mock_serial_protocol):
+def mock_connection(mock_serial_protocol: AsyncMock) -> AsyncMock:
     """Mock AsyncDeviceConnection for testing clients."""
     connection = AsyncMock()
     connection._legacy_connection = mock_serial_protocol
@@ -58,7 +50,7 @@ def mock_connection(mock_serial_protocol):
 
 
 @pytest.fixture
-def sample_device_definition():
+def sample_device_definition() -> dict[str, Any]:
     """Sample device definition for testing."""
     return {
         'id': 'test_device',
@@ -126,12 +118,12 @@ def sample_device_definition():
 
 
 @pytest.fixture
-def yaml_library_path():
+def yaml_library_path() -> Path:
     """Path to YAML device definitions."""
     return Path(__file__).parent.parent / 'pyavcontrol' / 'data' / 'src'
 
 
 @pytest.fixture
-def all_device_yaml_files(yaml_library_path):
+def all_device_yaml_files(yaml_library_path: Path) -> list[Path]:
     """List all device YAML files for integration testing."""
     return list(yaml_library_path.glob('*.yaml'))

tests/init.py

@@ -1,3 +1,97 @@
-"""
-Test behavior of the connection implementions
-"""
+"""Tests for connection implementations."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from pyavcontrol.connection import Connection, DeviceConnection, NullConnection
+
+
+class TestNullConnection:
+    """Test NullConnection implementation."""
+
+    def test_is_connected_always_true(self) -> None:
+        """NullConnection is always connected."""
+        conn = NullConnection()
+        assert conn.is_connected() is True
+
+    def test_send_returns_none(self) -> None:
+        """NullConnection send returns None."""
+        conn = NullConnection()
+        result = conn.send(b'test data')
+        assert result is None
+
+    def test_send_with_callback(self) -> None:
+        """NullConnection ignores callback."""
+        conn = NullConnection()
+        callback_called = False
+
+        def callback(data: bytes) -> None:
+            nonlocal callback_called
+            callback_called = True
+
+        conn.send(b'test', callback=callback)
+        assert not callback_called
+
+    def test_is_async_returns_false(self) -> None:
+        """NullConnection is synchronous."""
+        conn = NullConnection()
+        assert conn.is_async() is False
+
+
+class TestConnectionFactory:
+    """Test Connection factory method."""
+
+    def test_create_sync_connection(self) -> None:
+        """Test creating synchronous connection."""
+        with patch(
+            'pyavcontrol.connection.sync_connection.serial.serial_for_url'
+        ) as mock_serial:
+            mock_port = Mock()
+            mock_serial.return_value = mock_port
+
+            conn = Connection.create('/dev/ttyUSB0', {'baudrate': 9600})
+
+            assert conn is not None
+            assert not conn.is_async()
+
+    def test_create_async_connection(self) -> None:
+        """Test creating asynchronous connection with event loop."""
+        import asyncio
+
+        loop = asyncio.new_event_loop()
+        try:
+            with patch(
+                'pyavcontrol.connection.async_connection.asyncio.create_task'
+            ):
+                conn = Connection.create(
+                    '/dev/ttyUSB0', {'baudrate': 9600}, event_loop=loop
+                )
+
+                assert conn is not None
+                assert conn.is_async()
+        finally:
+            loop.close()
+
+    def test_create_with_empty_config(self) -> None:
+        """Test creating connection with no config."""
+        with patch(
+            'pyavcontrol.connection.sync_connection.serial.serial_for_url'
+        ) as mock_serial:
+            mock_port = Mock()
+            mock_serial.return_value = mock_port
+
+            conn = Connection.create('/dev/ttyUSB0')
+
+            assert conn is not None
+
+
+class TestDeviceConnectionInterface:
+    """Test DeviceConnection abstract interface."""
+
+    def test_repr_returns_class_name(self) -> None:
+        """Test default repr implementation."""
+        conn = NullConnection()
+        assert 'NullConnection' in repr(conn)