update

Author: Tom Softreck

tests/unit/test_config_module.py

@@ -74,38 +74,40 @@ def test_resolve_env_vars(self):
             "DB_PORT": "5432"
         }
 
-        # Test with direct variable
+        # Test with direct variable using Jinja2 syntax
         result = resolver.resolve_env_vars(
-            "postgresql://${DB_HOST}:${DB_PORT}/mydb",
+            "postgresql://{{DB_HOST}}:{{DB_PORT}}/mydb",
             env_vars
         )
         assert result == "postgresql://localhost:5432/mydb"
 
-        # Test with default value
+        # Test with direct variable using ${} syntax
         result = resolver.resolve_env_vars(
-            "postgresql://${DB_HOST:127.0.0.1}:${DB_PORT:5432}/mydb",
-            {}
+            "postgresql://${DB_HOST}:${DB_PORT}/mydb",
+            env_vars
         )
-        assert result == "postgresql://127.0.0.1:5432/mydb"
+        assert result == "postgresql://localhost:5432/mydb"
 
     def test_check_required_env_vars(self):
         """Test required environment variable validation."""
         resolver = ConfigResolver()
 
-        # Test with all required vars present
-        env_vars = {
-            "REQUIRED_VAR_1": "value1",
-            "REQUIRED_VAR_2": "value2"
-        }
-        resolver.check_required_env_vars(["REQUIRED_VAR_1", "REQUIRED_VAR_2"], env_vars)
+        # Set up environment variables
+        os.environ["REQUIRED_VAR_1"] = "value1"
+        os.environ["REQUIRED_VAR_2"] = "value2"
 
-        # Test with missing required var
-        with pytest.raises(ValueError) as exc_info:
-            resolver.check_required_env_vars(
-                ["REQUIRED_VAR_1", "MISSING_VAR"],
-                env_vars
-            )
-        assert "Missing required environment variable: MISSING_VAR" in str(exc_info.value)
+        try:
+            # Test with all required vars present
+            missing = resolver.check_required_env_vars(["REQUIRED_VAR_1", "REQUIRED_VAR_2"])
+            assert missing == [], "Expected no missing variables"
+            
+            # Test with missing required var
+            missing = resolver.check_required_env_vars(["REQUIRED_VAR_1", "MISSING_VAR"])
+            assert missing == ["MISSING_VAR"], "Expected MISSING_VAR to be missing"
+        finally:
+            # Clean up
+            os.environ.pop("REQUIRED_VAR_1", None)
+            os.environ.pop("REQUIRED_VAR_2", None)
 
 
 class TestConfigValidator:
@@ -114,41 +116,48 @@ class TestConfigValidator:
     def test_validate_uri(self):
         """Test URI validation."""
         # Test valid RTSP URI
-        assert ConfigValidator.validate_uri("rtsp://camera1:554/stream", "sources") is None
+        errors = ConfigValidator.validate_uri("rtsp://camera1:554/stream", "sources")
+        assert not errors, f"Expected no errors, got: {errors}"
 
         # Test invalid scheme
-        with pytest.raises(ValueError) as exc_info:
-            ConfigValidator.validate_uri("invalid://test", "sources")
-        assert "Unsupported scheme 'invalid' for source" in str(exc_info.value)
+        errors = ConfigValidator.validate_uri("invalid://test", "sources")
+        assert any("Unsupported scheme 'invalid' for sources" in e for e in errors), \
+            f"Expected unsupported scheme error, got: {errors}"
 
         # Test invalid destination
-        with pytest.raises(ValueError) as exc_info:
-            ConfigValidator.validate_uri("rtsp://test", "destinations")
-        assert "Unsupported scheme 'rtsp' for destination" in str(exc_info.value)
+        errors = ConfigValidator.validate_uri("rtsp://test", "destinations")
+        assert any("Unsupported scheme 'rtsp' for destinations" in e for e in errors), \
+            f"Expected unsupported scheme error for destination, got: {errors}"
 
     def test_validate_processor(self):
         """Test processor configuration validation."""
         # Test valid processor
         valid_processor = {
             "type": "filter",
-            "config": {"min_confidence": 0.5}
+            "condition": "some_condition"
         }
-        assert ConfigValidator.validate_processor(valid_processor) is None
+        errors = ConfigValidator.validate_processor(valid_processor)
+        assert not errors, f"Expected no errors, got: {errors}"
 
         # Test missing type
-        with pytest.raises(ValueError) as exc_info:
-            ConfigValidator.validate_processor({"config": {}})
-        assert "Processor config missing 'type' field" in str(exc_info.value)
+        errors = ConfigValidator.validate_processor({"config": {}})
+        assert any("Unsupported processor type 'None'" in e for e in errors), \
+            f"Expected missing type error, got: {errors}"
 
         # Test invalid type
-        with pytest.raises(ValueError) as exc_info:
-            ConfigValidator.validate_processor({"type": "invalid"})
-        assert "Unsupported processor type: invalid" in str(exc_info.value)
+        errors = ConfigValidator.validate_processor({"type": "invalid"})
+        assert any("Unsupported processor type 'invalid'" in e for e in errors), \
+            f"Expected unsupported type error, got: {errors}"
 
-        # Test missing config
-        with pytest.raises(ValueError) as exc_info:
-            ConfigValidator.validate_processor({"type": "filter"})
-        assert "Processor config missing 'config' field" in str(exc_info.value)
+        # Test missing required fields for filter type
+        errors = ConfigValidator.validate_processor({"type": "filter"})
+        assert any("Filter processor requires 'condition' field" in e for e in errors), \
+            f"Expected missing condition error, got: {errors}"
+            
+        # Test external processor validation
+        errors = ConfigValidator.validate_processor({"type": "external"})
+        assert any("External processor requires 'command' field" in e for e in errors), \
+            f"Expected missing command error, got: {errors}"
 
 
 def test_config_loading_from_file(tmp_path):

tests/unit/test_connectors.py

@@ -40,17 +40,23 @@ 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")
+            mock_cap = mock_capture.return_value
+            mock_cap.isOpened.return_value = True
+            mock_cap.read.return_value = (True, "frame_data")
 
             source = connectors.RTSPSource("rtsp://test")
             source.reconnect_attempts = 1  # Limit reconnect attempts for test
 
             # Test receive generator
+            count = 0
             async for frame in source.receive():
-                assert frame == {"frame": "frame_data", "metadata": {}}
-                break  # Just test one iteration
+                assert frame["type"] == "camera_frame"
+                assert "timestamp" in frame
+                assert frame["frame"] == "frame_data"
+                assert frame["source"] == "rtsp://test"
+                count += 1
+                if count >= 1:  # Just test one iteration
+                    break
 
 
 class TestHTTPDestination:

tests/unit/test_connectors_destinations.py

@@ -35,11 +35,11 @@ def email_dest(self):
     @pytest.mark.asyncio
     async def test_send_email(self, email_dest):
         """Test sending an email."""
-        mock_smtp = MagicMock()
-        mock_server = MagicMock()
-        mock_smtp.return_value = mock_server
-        
-        with patch('smtplib.SMTP', mock_smtp):
+        with patch('smtplib.SMTP') as mock_smtp:
+            mock_server = MagicMock()
+            mock_smtp.return_value = mock_server
+            
+            # Test with string message
             await email_dest.send("Test email content")
 
             # Verify SMTP connection and login
@@ -52,6 +52,16 @@ async def test_send_email(self, email_dest):
             assert msg['From'] == 'test@example.com'
             assert msg['To'] == 'recipient@example.com'
             assert 'Test email content' in msg.as_string()
+            
+            # Test with dict message
+            mock_smtp.reset_mock()
+            mock_server.reset_mock()
+            mock_smtp.return_value = mock_server
+            
+            await email_dest.send({"subject": "Test Subject", "body": "Test Body"})
+            msg = mock_server.send_message.call_args[0][0]
+            assert 'Test Subject' in msg['Subject']
+            assert 'Test Body' in msg.as_string()
 
 
 class TestHTTPDestination:
@@ -65,20 +75,30 @@ def http_dest(self):
     @pytest.mark.asyncio
     async def test_send_http_request(self, http_dest):
         """Test sending an HTTP request."""
-        mock_session = AsyncMock()
         mock_response = AsyncMock()
         mock_response.status = 200
-        mock_session.post.return_value.__aenter__.return_value = mock_response
 
-        with patch('aiohttp.ClientSession', return_value=mock_session):
+        with patch('aiohttp.ClientSession') as mock_session:
+            mock_session.return_value.__aenter__.return_value.post.return_value.__aenter__.return_value = mock_response
+            
+            # Test with dict message
             await http_dest.send({"key": "value"})
 
             # Verify HTTP POST request was made
-            mock_session.post.assert_awaited_once_with(
+            mock_session.return_value.__aenter__.return_value.post.assert_awaited_once_with(
                 'http://example.com/webhook',
                 json={"key": "value"},
                 headers={'Content-Type': 'application/json'}
             )
+            
+            # Test with string message
+            mock_session.return_value.__aenter__.return_value.post.reset_mock()
+            await http_dest.send("test message")
+            mock_session.return_value.__aenter__.return_value.post.assert_awaited_once_with(
+                'http://example.com/webhook',
+                json="test message",
+                headers={'Content-Type': 'application/json'}
+            )
 
 
 class TestMQTTDestination:
@@ -92,19 +112,27 @@ def mqtt_dest(self):
     @pytest.mark.asyncio
     async def test_send_mqtt_message(self, mqtt_dest):
         """Test sending an MQTT message."""
-        mock_client = AsyncMock()
-        
-        with patch('paho.mqtt.client.Client', return_value=mock_client):
-            # Mock the connect method to avoid actual connection
-            with patch.object(mqtt_dest, 'connect', new_callable=AsyncMock) as mock_connect:
-                await mqtt_dest.send("test message")
-                
-                # Verify connection and message publishing
-                mock_connect.assert_awaited_once()
-                mock_client.publish.assert_called_once_with(
-                    'test/topic',
-                    'test message'
-                )
+        with patch('paho.mqtt.client.Client') as mock_client:
+            mock_client.return_value.connect_sync = MagicMock()
+            mock_client.return_value.publish = MagicMock()
+            
+            # Test with string message
+            await mqtt_dest.send("test message")
+            
+            # Verify connection and message publishing
+            mock_client.return_value.connect_sync.assert_called_once_with('broker.example.com', 1883, 60)
+            mock_client.return_value.publish.assert_called_once_with(
+                'test/topic',
+                'test message'
+            )
+            
+            # Test with dict message
+            mock_client.return_value.publish.reset_mock()
+            await mqtt_dest.send({"key": "value"})
+            mock_client.return_value.publish.assert_called_once_with(
+                'test/topic',
+                '{"key": "value"}'
+            )
 
 
 class TestFileDestination: