update

Author: Tom Softreck

tests/unit/test_connectors.py

@@ -1,250 +1,75 @@
 """Unit tests for the connectors module."""
 import asyncio
-import json
-from unittest.mock import AsyncMock, MagicMock, patch
-
 import pytest
-import aiohttp
-import pytest_asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
 
 from dialogchain import connectors
-from dialogchain.config import Config
-
-
-class TestBaseConnector:
-    """Test the base connector functionality."""
-
-    def test_init(self):
-        """Test connector initialization."""
-        config = {"name": "test_connector", "type": "test", "timeout": 30}
-        connector = connectors.BaseConnector(config)
-        assert connector.name == "test_connector"
-        assert connector.timeout == 30
-        assert connector.is_connected is False
-
-    @pytest.mark.asyncio
-    async def test_connect_disconnect(self):
-        """Test connect and disconnect methods."""
-        connector = connectors.BaseConnector({"name": "test"})
-        await connector.connect()
-        assert connector.is_connected is True
-        await connector.disconnect()
-        assert connector.is_connected is False
-
-    @pytest.mark.asyncio
-    async def test_context_manager(self):
-        """Test connector as a context manager."""
-        connector = connectors.BaseConnector({"name": "test"})
-        async with connector:
-            assert connector.is_connected is True
-        assert connector.is_connected is False
 
 
-class TestHttpConnector:
-    """Test the HTTP connector implementation."""
+class TestSourceConnector:
+    """Test the Source connector functionality."""
 
-    @pytest.fixture
-    def connector_config(self):
-        """Return a sample HTTP connector config."""
-        return {
-            "name": "http_test",
-            "type": "http",
-            "base_url": "http://example.com/api",
-            "timeout": 10,
-            "headers": {"X-Test": "test"},
-            "auth": {"username": "user", "password": "pass"},
-        }
+    def test_source_initialization(self):
+        """Test source connector initialization."""
+        class TestSource(connectors.Source):
+            async def receive(self):
+                yield "test"
+                
+        source = TestSource()
+        assert isinstance(source, connectors.Source)
 
-    @pytest.fixture
-    def mock_response(self):
-        """Create a mock aiohttp response."""
-        response = AsyncMock(spec=aiohttp.ClientResponse)
-        response.status = 200
-        response.json.return_value = {"status": "ok"}
-        response.text.return_value = '{"status": "ok"}'
-        response.__aenter__.return_value = response
-        return response
 
-    @pytest.fixture
-    def mock_session(self, mock_response):
-        """Create a mock aiohttp client session."""
-        session = AsyncMock(spec=aiohttp.ClientSession)
-        session.request.return_value = mock_response
-        session.__aenter__.return_value = session
-        return session
+class TestDestinationConnector:
+    """Test the Destination connector functionality."""
 
-    @pytest.mark.asyncio
-    async def test_http_connector_init(self, connector_config):
-        """Test HTTP connector initialization."""
-        connector = connectors.HttpConnector(connector_config)
-        assert connector.base_url == "http://example.com/api"
-        assert connector.timeout == 10
-        assert connector.headers == {"X-Test": "test"}
-        assert connector.auth == aiohttp.BasicAuth("user", "pass")
+    def test_destination_initialization(self):
+        """Test destination connector initialization."""
+        class TestDestination(connectors.Destination):
+            async def send(self, message):
+                pass
+                
+        destination = TestDestination()
+        assert isinstance(destination, connectors.Destination)
 
-    @pytest.mark.asyncio
-    async def test_http_connector_connect(self, connector_config, mock_session):
-        """Test HTTP connector connection."""
-        with patch('aiohttp.ClientSession', return_value=mock_session):
-            connector = connectors.HttpConnector(connector_config)
-            await connector.connect()
-            assert connector.is_connected is True
-            assert connector.session is not None
 
+class TestRTSPSource:
+    """Test the RTSP source connector."""
+    
     @pytest.mark.asyncio
-    async def test_http_connector_request(self, connector_config, mock_session, mock_response):
-        """Test HTTP connector request method."""
-        with patch('aiohttp.ClientSession', return_value=mock_session):
-            connector = connectors.HttpConnector(connector_config)
-            await connector.connect()
+    async def test_rtsp_source_receive(self):
+        """Test RTSP source receive method."""
+        with patch('cv2.VideoCapture') as mock_capture:
+            # Setup mock
+            mock_capture.return_value.isOpened.return_value = True
+            mock_capture.return_value.grab.return_value = True
+            mock_capture.return_value.retrieve.return_value = (True, "frame_data")
 
-            # Test GET request
-            response = await connector.request("GET", "/test")
-            assert response == {"status": "ok"}
-            mock_session.request.assert_called_once_with(
-                "GET",
-                "http://example.com/api/test",
-                headers={"X-Test": "test"},
-                auth=aiohttp.BasicAuth("user", "pass"),
-                timeout=10,
-                json=None,
-                data=None,
-                params=None
-            )
-            
-            # Reset mock for next test
-            mock_session.request.reset_mock()
-            
-            # Test POST with data
-            await connector.request(
-                "POST",
-                "/test",
-                json={"key": "value"},
-                headers={"X-Custom": "header"},
-                params={"q": "test"}
-            )
-            mock_session.request.assert_called_once_with(
-                "POST",
-                "http://example.com/api/test",
-                headers={"X-Test": "test", "X-Custom": "header"},
-                auth=aiohttp.BasicAuth("user", "pass"),
-                timeout=10,
-                json={"key": "value"},
-                data=None,
-                params={"q": "test"}
-            )
-
-    @pytest.mark.asyncio
-    async def test_http_connector_http_errors(self, connector_config, mock_session, mock_response):
-        """Test HTTP connector error handling."""
-        # Test 404 error
-        mock_response.status = 404
-        mock_response.text.return_value = '{"error": "Not found"}'
-        
-        with patch('aiohttp.ClientSession', return_value=mock_session):
-            connector = connectors.HttpConnector(connector_config)
-            await connector.connect()
+            source = connectors.RTSPSource("rtsp://test")
+            source.reconnect_attempts = 1  # Limit reconnect attempts for test
 
-            with pytest.raises(connectors.ConnectorError) as exc_info:
-                await connector.request("GET", "/nonexistent")
-            assert "404" in str(exc_info.value)
+            # Test receive generator
+            async for frame in source.receive():
+                assert frame == {"frame": "frame_data", "metadata": {}}
+                break  # Just test one iteration
 
 
-class TestMqttConnector:
-    """Test the MQTT connector implementation."""
-
-    @pytest.fixture
-    def connector_config(self):
-        """Return a sample MQTT connector config."""
-        return {
-            "name": "mqtt_test",
-            "type": "mqtt",
-            "host": "test.mosquitto.org",
-            "port": 1883,
-            "client_id": "test_client",
-            "clean_session": True,
-            "topics": ["test/topic"],
-        }
-
-    @pytest.fixture
-    def mock_mqtt_client(self):
-        """Create a mock MQTT client."""
-        client = AsyncMock()
-        client.connect = AsyncMock()
-        client.disconnect = AsyncMock()
-        client.subscribe = AsyncMock()
-        client.unsubscribe = AsyncMock()
-        client.publish = AsyncMock()
-        return client
-
-    @pytest.mark.asyncio
-    async def test_mqtt_connector_init(self, connector_config):
-        """Test MQTT connector initialization."""
-        with patch('asyncio_mqtt.Client') as mock_client:
-            connector = connectors.MqttConnector(connector_config)
-            assert connector.host == "test.mosquitto.org"
-            assert connector.port == 1883
-            assert connector.client_id == "test_client"
-
+class TestHTTPDestination:
+    """Test the HTTP destination connector."""
+    
     @pytest.mark.asyncio
-    async def test_mqtt_connector_connect_disconnect(self, connector_config, mock_mqtt_client):
-        """Test MQTT connector connection and disconnection."""
-        with patch('asyncio_mqtt.Client', return_value=mock_mqtt_client):
-            connector = connectors.MqttConnector(connector_config)
-            
-            # Test connect
-            await connector.connect()
-            assert connector.is_connected is True
-            mock_mqtt_client.connect.assert_awaited_once()
+    async def test_http_destination_send(self):
+        """Test HTTP destination send method."""
+        with patch('aiohttp.ClientSession.post') as mock_post:
+            # Setup mock response
+            mock_response = AsyncMock()
+            mock_response.status = 200
+            mock_response.json.return_value = {"status": "success"}
+            mock_post.return_value.__aenter__.return_value = mock_response
 
-            # Test subscribe on connect
-            mock_mqtt_client.subscribe.assert_awaited_once_with("test/topic")
+            destination = connectors.HTTPDestination("http://test")
+            await destination.send({"test": "data"})
 
-            # Test disconnect
-            await connector.disconnect()
-            assert connector.is_connected is False
-            mock_mqtt_client.disconnect.assert_awaited_once()
-
-    @pytest.mark.asyncio
-    async def test_mqtt_connector_publish(self, connector_config, mock_mqtt_client):
-        """Test MQTT connector publish method."""
-        with patch('asyncio_mqtt.Client', return_value=mock_mqtt_client):
-            connector = connectors.MqttConnector(connector_config)
-            await connector.connect()
-            
-            # Test publish
-            await connector.publish("test/topic", {"key": "value"}, qos=1)
-            mock_mqtt_client.publish.assert_awaited_once()
-            
-            # Get the actual call arguments
-            args, kwargs = mock_mqtt_client.publish.call_args
-            assert args[0] == "test/topic"
-            assert json.loads(args[1]) == {"key": "value"}
-            assert kwargs["qos"] == 1
-
-
-class TestConnectorFactory:
-    """Test the connector factory."""
-
-    def test_create_connector_http(self):
-        """Test creating an HTTP connector."""
-        config = {"name": "http_test", "type": "http", "base_url": "http://example.com"}
-        connector = connectors.create_connector(config)
-        assert isinstance(connector, connectors.HttpConnector)
-        assert connector.name == "http_test"
-        assert connector.base_url == "http://example.com"
-
-    def test_create_connector_mqtt(self):
-        """Test creating an MQTT connector."""
-        config = {"name": "mqtt_test", "type": "mqtt", "host": "test.mosquitto.org"}
-        connector = connectors.create_connector(config)
-        assert isinstance(connector, connectors.MqttConnector)
-        assert connector.name == "mqtt_test"
-        assert connector.host == "test.mosquitto.org"
-
-    def test_create_connector_invalid_type(self):
-        """Test creating a connector with an invalid type."""
-        config = {"name": "invalid", "type": "invalid_type"}
-        with pytest.raises(ValueError) as exc_info:
-            connectors.create_connector(config)
-        assert "Unknown connector type" in str(exc_info.value)
+            # Verify the request was made correctly
+            mock_post.assert_called_once()
+            args, kwargs = mock_post.call_args
+            assert kwargs['json'] == {"test": "data"}

tests/unit/test_engine.py

@@ -3,9 +3,9 @@
 import pytest
 from unittest.mock import AsyncMock, MagicMock, patch, call
 
-from dialogchain.engine import CamelRouterEngine
-from dialogchain.connectors import Source, Destination
-from dialogchain.config import RouteConfig, ConfigError
+from dialogchain.engine import CamelRouterEngine, parse_uri
+from dialogchain.connectors import Source, Destination, RTSPSource, HTTPDestination
+from dialogchain.config import RouteConfig, ValidationError
 
 
 class MockSource(Source):
@@ -62,7 +62,17 @@ def sample_config(self):
                         }
                     ]
                 }
-            ]
+            ],
+            "sources": {
+                "rtsp://camera1": {
+                    "type": "rtsp"
+                }
+            },
+            "destinations": {
+                "http://api.example.com/webhook": {
+                    "type": "http"
+                }
+            }
         }
 
     @pytest.fixture
@@ -81,13 +91,30 @@ async def test_engine_initialization(self, sample_config):
         engine = CamelRouterEngine(sample_config)
         assert engine.config == sample_config
         assert len(engine.routes) == 1
-        assert engine.routes[0].name == "test_route"
+        assert engine.routes[0]["name"] == "test_route"
+    
+    @pytest.mark.asyncio
+    async def test_parse_uri(self):
+        """Test the parse_uri function."""
+        # Test with standard URI
+        scheme, path = parse_uri("http://example.com/path")
+        assert scheme == "http"
+        assert path == "//example.com/path"
+        
+        # Test with simple scheme:path format
+        scheme, path = parse_uri("timer:5s")
+        assert scheme == "timer"
+        assert path == "5s"
+        
+        # Test with invalid URI
+        with pytest.raises(ValueError):
+            parse_uri("invalid_uri")
 
     @pytest.mark.asyncio
     async def test_engine_start_stop(self, sample_config, mock_source, mock_destination):
         """Test starting and stopping the engine."""
-        with patch('dialogchain.connectors.create_source', return_value=mock_source), \
-             patch('dialogchain.connectors.create_destination', return_value=mock_destination):
+        with patch('dialogchain.connectors.RTSPSource', return_value=mock_source), \
+             patch('dialogchain.connectors.HTTPDestination', return_value=mock_destination):
 
             engine = CamelRouterEngine(sample_config)
             await engine.start()
@@ -108,8 +135,8 @@ async def test_engine_process_message(self, sample_config, mock_source, mock_des
         test_message = {"frame": "test_frame", "confidence": 0.7}
         mock_source.messages = [test_message]
 
-        with patch('dialogchain.connectors.create_source', return_value=mock_source), \
-             patch('dialogchain.connectors.create_destination', return_value=mock_destination):
+        with patch('dialogchain.connectors.RTSPSource', return_value=mock_source), \
+             patch('dialogchain.connectors.HTTPDestination', return_value=mock_destination):
 
             engine = CamelRouterEngine(sample_config)
             await engine.start()
@@ -130,14 +157,14 @@ async def test_engine_invalid_config(self):
         """Test engine initialization with invalid config."""
         invalid_config = {"routes": [{"name": "invalid"}]}  # Missing required fields
 
-        with pytest.raises(ConfigError):
+        with pytest.raises(ValidationError):
             CamelRouterEngine(invalid_config)
 
     @pytest.mark.asyncio
     async def test_engine_context_manager(self, sample_config, mock_source, mock_destination):
         """Test using the engine as a context manager."""
-        with patch('dialogchain.connectors.create_source', return_value=mock_source), \
-             patch('dialogchain.connectors.create_destination', return_value=mock_destination):
+        with patch('dialogchain.connectors.RTSPSource', return_value=mock_source), \
+             patch('dialogchain.connectors.HTTPDestination', return_value=mock_destination):
 
             async with CamelRouterEngine(sample_config) as engine:
                 # Verify engine is running