Delete test_models.py

test_models.py

@@ -1,614 +0,0 @@
-"""
-Unit tests for Pydantic models with validation and security tests
-"""
-
-import pytest
-from datetime import datetime, timezone
-from pydantic import ValidationError
-from models import (
-    ReliabilityEvent,
-    EventSeverity,
-    HealingPolicy,
-    HealingAction,
-    PolicyCondition,
-    AnomalyResult,
-    ForecastResult
-)
-
-
-class TestReliabilityEventValidation:
-    """Test ReliabilityEvent validation"""
-    
-    def test_valid_event_creation(self):
-        """Test creating a valid event"""
-        event = ReliabilityEvent(
-            component="api-service",
-            latency_p99=150.0,
-            error_rate=0.05,
-            throughput=1000.0,
-            cpu_util=0.7,
-            memory_util=0.6
-        )
-        
-        assert event.component == "api-service"
-        assert event.latency_p99 == 150.0
-        assert event.error_rate == 0.05
-        assert isinstance(event.timestamp, datetime)
-        assert event.severity == EventSeverity.LOW
-    
-    def test_component_validation_valid(self):
-        """Test valid component IDs"""
-        valid_ids = ["api-service", "auth-service", "payment-service-v2", "db-01"]
-        
-        for component_id in valid_ids:
-            event = ReliabilityEvent(
-                component=component_id,
-                latency_p99=100.0,
-                error_rate=0.01,
-                throughput=1000.0
-            )
-            assert event.component == component_id
-    
-    def test_component_validation_invalid(self):
-        """Test invalid component IDs are rejected"""
-        invalid_ids = [
-            "API-SERVICE",  # Uppercase
-            "api_service",  # Underscore
-            "api service",  # Space
-            "api@service",  # Special char
-            "",  # Empty
-        ]
-        
-        for component_id in invalid_ids:
-            with pytest.raises(ValidationError) as exc_info:
-                ReliabilityEvent(
-                    component=component_id,
-                    latency_p99=100.0,
-                    error_rate=0.01,
-                    throughput=1000.0
-                )
-            assert "component" in str(exc_info.value).lower()
-    
-    def test_latency_bounds(self):
-        """Test latency validation bounds"""
-        # Valid latency
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.01,
-            throughput=1000.0
-        )
-        assert event.latency_p99 == 100.0
-        
-        # Negative latency should fail
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="test-service",
-                latency_p99=-10.0,
-                error_rate=0.01,
-                throughput=1000.0
-            )
-        
-        # Extremely high latency should fail (> 5 minutes)
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="test-service",
-                latency_p99=400000.0,  # > 300000ms limit
-                error_rate=0.01,
-                throughput=1000.0
-            )
-    
-    def test_error_rate_bounds(self):
-        """Test error rate validation"""
-        # Valid error rate
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.5,
-            throughput=1000.0
-        )
-        assert event.error_rate == 0.5
-        
-        # Negative error rate should fail
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="test-service",
-                latency_p99=100.0,
-                error_rate=-0.1,
-                throughput=1000.0
-            )
-        
-        # Error rate > 1 should fail
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="test-service",
-                latency_p99=100.0,
-                error_rate=1.5,
-                throughput=1000.0
-            )
-    
-    def test_resource_utilization_bounds(self):
-        """Test CPU and memory utilization bounds"""
-        # Valid utilization
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.01,
-            throughput=1000.0,
-            cpu_util=0.85,
-            memory_util=0.75
-        )
-        assert event.cpu_util == 0.85
-        assert event.memory_util == 0.75
-        
-        # CPU > 1 should fail
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="test-service",
-                latency_p99=100.0,
-                error_rate=0.01,
-                throughput=1000.0,
-                cpu_util=1.5
-            )
-        
-        # Memory < 0 should fail
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="test-service",
-                latency_p99=100.0,
-                error_rate=0.01,
-                throughput=1000.0,
-                memory_util=-0.1
-            )
-
-
-class TestEventFingerprint:
-    """Test event fingerprint generation (SHA-256)"""
-    
-    def test_fingerprint_is_sha256(self):
-        """Test that fingerprint uses SHA-256 (64 hex chars)"""
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        # SHA-256 produces 64 hex characters
-        assert len(event.fingerprint) == 64
-        assert all(c in '0123456789abcdef' for c in event.fingerprint)
-    
-    def test_fingerprint_deterministic(self):
-        """Test that same inputs produce same fingerprint"""
-        event1 = ReliabilityEvent(
-            component="test-service",
-            service_mesh="default",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        event2 = ReliabilityEvent(
-            component="test-service",
-            service_mesh="default",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        # Should produce same fingerprint (timestamp not included)
-        assert event1.fingerprint == event2.fingerprint
-    
-    def test_fingerprint_different_for_different_events(self):
-        """Test that different events produce different fingerprints"""
-        event1 = ReliabilityEvent(
-            component="service-1",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        event2 = ReliabilityEvent(
-            component="service-2",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        assert event1.fingerprint != event2.fingerprint
-    
-    def test_fingerprint_not_md5(self):
-        """Test that fingerprint is NOT MD5 (security fix verification)"""
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        # MD5 produces 32 hex chars, SHA-256 produces 64
-        assert len(event.fingerprint) != 32
-        assert len(event.fingerprint) == 64
-
-
-class TestEventImmutability:
-    """Test that events are immutable (frozen)"""
-    
-    def test_event_is_frozen(self):
-        """Test that ReliabilityEvent is frozen"""
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        # Attempting to modify should raise ValidationError
-        with pytest.raises(ValidationError):
-            event.latency_p99 = 200.0
-    
-    def test_model_copy_with_update(self):
-        """Test that model_copy creates new instance with updates"""
-        event1 = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0,
-            severity=EventSeverity.LOW
-        )
-        
-        # Create modified copy
-        event2 = event1.model_copy(update={'severity': EventSeverity.HIGH})
-        
-        # Original unchanged
-        assert event1.severity == EventSeverity.LOW
-        # Copy updated
-        assert event2.severity == EventSeverity.HIGH
-        # Other fields same
-        assert event2.component == event1.component
-        assert event2.latency_p99 == event1.latency_p99
-
-
-class TestDependencyValidation:
-    """Test dependency cycle detection"""
-    
-    def test_valid_dependencies(self):
-        """Test valid dependency configuration"""
-        event = ReliabilityEvent(
-            component="api-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0,
-            upstream_deps=["auth-service", "database"],
-            downstream_deps=["frontend", "mobile-app"]
-        )
-        
-        assert "auth-service" in event.upstream_deps
-        assert "frontend" in event.downstream_deps
-    
-    def test_circular_dependency_detected(self):
-        """Test that circular dependencies are detected"""
-        with pytest.raises(ValidationError) as exc_info:
-            ReliabilityEvent(
-                component="api-service",
-                latency_p99=100.0,
-                error_rate=0.05,
-                throughput=1000.0,
-                upstream_deps=["auth-service", "database"],
-                downstream_deps=["database", "frontend"]  # 'database' in both
-            )
-        
-        error_msg = str(exc_info.value).lower()
-        assert "circular" in error_msg or "database" in error_msg
-    
-    def test_dependency_name_validation(self):
-        """Test that dependency names follow same rules as component IDs"""
-        # Valid dependency names
-        event = ReliabilityEvent(
-            component="api-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0,
-            upstream_deps=["auth-service", "db-01", "cache-v2"]
-        )
-        assert len(event.upstream_deps) == 3
-        
-        # Invalid dependency names
-        with pytest.raises(ValidationError):
-            ReliabilityEvent(
-                component="api-service",
-                latency_p99=100.0,
-                error_rate=0.05,
-                throughput=1000.0,
-                upstream_deps=["AUTH_SERVICE"]  # Uppercase/underscore
-            )
-
-
-class TestPolicyConditionModel:
-    """Test PolicyCondition structured model"""
-    
-    def test_valid_policy_condition(self):
-        """Test creating valid policy conditions"""
-        condition = PolicyCondition(
-            metric="latency_p99",
-            operator="gt",
-            threshold=150.0
-        )
-        
-        assert condition.metric == "latency_p99"
-        assert condition.operator == "gt"
-        assert condition.threshold == 150.0
-    
-    def test_policy_condition_frozen(self):
-        """Test that PolicyCondition is immutable"""
-        condition = PolicyCondition(
-            metric="error_rate",
-            operator="gt",
-            threshold=0.1
-        )
-        
-        with pytest.raises(ValidationError):
-            condition.threshold = 0.2
-    
-    def test_invalid_metric(self):
-        """Test that invalid metrics are rejected"""
-        with pytest.raises(ValidationError):
-            PolicyCondition(
-                metric="invalid_metric",
-                operator="gt",
-                threshold=100.0
-            )
-    
-    def test_invalid_operator(self):
-        """Test that invalid operators are rejected"""
-        with pytest.raises(ValidationError):
-            PolicyCondition(
-                metric="latency_p99",
-                operator="invalid_op",
-                threshold=100.0
-            )
-    
-    def test_negative_threshold(self):
-        """Test that negative thresholds are rejected"""
-        with pytest.raises(ValidationError):
-            PolicyCondition(
-                metric="latency_p99",
-                operator="gt",
-                threshold=-100.0
-            )
-
-
-class TestHealingPolicyModel:
-    """Test HealingPolicy model"""
-    
-    def test_valid_healing_policy(self):
-        """Test creating valid healing policy"""
-        policy = HealingPolicy(
-            name="high_latency_restart",
-            conditions=[
-                PolicyCondition(metric="latency_p99", operator="gt", threshold=300.0)
-            ],
-            actions=[HealingAction.RESTART_CONTAINER, HealingAction.ALERT_TEAM],
-            priority=1,
-            cool_down_seconds=300
-        )
-        
-        assert policy.name == "high_latency_restart"
-        assert len(policy.conditions) == 1
-        assert len(policy.actions) == 2
-        assert policy.priority == 1
-    
-    def test_policy_frozen(self):
-        """Test that HealingPolicy is immutable"""
-        policy = HealingPolicy(
-            name="test_policy",
-            conditions=[
-                PolicyCondition(metric="error_rate", operator="gt", threshold=0.1)
-            ],
-            actions=[HealingAction.ROLLBACK],
-            priority=2
-        )
-        
-        with pytest.raises(ValidationError):
-            policy.priority = 5
-    
-    def test_empty_conditions_rejected(self):
-        """Test that policies must have at least one condition"""
-        with pytest.raises(ValidationError):
-            HealingPolicy(
-                name="empty_policy",
-                conditions=[],  # Empty
-                actions=[HealingAction.ALERT_TEAM],
-                priority=3
-            )
-    
-    def test_empty_actions_rejected(self):
-        """Test that policies must have at least one action"""
-        with pytest.raises(ValidationError):
-            HealingPolicy(
-                name="empty_actions",
-                conditions=[
-                    PolicyCondition(metric="latency_p99", operator="gt", threshold=100.0)
-                ],
-                actions=[],  # Empty
-                priority=3
-            )
-    
-    def test_priority_bounds(self):
-        """Test priority validation (1-5)"""
-        # Valid priority
-        policy = HealingPolicy(
-            name="test",
-            conditions=[PolicyCondition(metric="latency_p99", operator="gt", threshold=100.0)],
-            actions=[HealingAction.ALERT_TEAM],
-            priority=3
-        )
-        assert policy.priority == 3
-        
-        # Priority < 1 should fail
-        with pytest.raises(ValidationError):
-            HealingPolicy(
-                name="test",
-                conditions=[PolicyCondition(metric="latency_p99", operator="gt", threshold=100.0)],
-                actions=[HealingAction.ALERT_TEAM],
-                priority=0
-            )
-        
-        # Priority > 5 should fail
-        with pytest.raises(ValidationError):
-            HealingPolicy(
-                name="test",
-                conditions=[PolicyCondition(metric="latency_p99", operator="gt", threshold=100.0)],
-                actions=[HealingAction.ALERT_TEAM],
-                priority=10
-            )
-
-
-class TestAnomalyResultModel:
-    """Test AnomalyResult model"""
-    
-    def test_valid_anomaly_result(self):
-        """Test creating valid anomaly result"""
-        result = AnomalyResult(
-            is_anomaly=True,
-            confidence=0.85,
-            anomaly_score=0.75,
-            affected_metrics=["latency", "error_rate"]
-        )
-        
-        assert result.is_anomaly is True
-        assert result.confidence == 0.85
-        assert isinstance(result.detection_timestamp, datetime)
-    
-    def test_confidence_bounds(self):
-        """Test confidence is bounded 0-1"""
-        # Valid
-        result = AnomalyResult(
-            is_anomaly=True,
-            confidence=0.5,
-            anomaly_score=0.6
-        )
-        assert result.confidence == 0.5
-        
-        # Confidence > 1 should fail
-        with pytest.raises(ValidationError):
-            AnomalyResult(
-                is_anomaly=True,
-                confidence=1.5,
-                anomaly_score=0.5
-            )
-
-
-class TestForecastResultModel:
-    """Test ForecastResult model"""
-    
-    def test_valid_forecast(self):
-        """Test creating valid forecast"""
-        result = ForecastResult(
-            metric="latency",
-            predicted_value=250.0,
-            confidence=0.75,
-            trend="increasing",
-            time_to_threshold=15.5,
-            risk_level="high"
-        )
-        
-        assert result.metric == "latency"
-        assert result.trend == "increasing"
-        assert result.risk_level == "high"
-    
-    def test_trend_validation(self):
-        """Test that only valid trends are accepted"""
-        valid_trends = ["increasing", "decreasing", "stable"]
-        
-        for trend in valid_trends:
-            result = ForecastResult(
-                metric="latency",
-                predicted_value=200.0,
-                confidence=0.7,
-                trend=trend,
-                risk_level="medium"
-            )
-            assert result.trend == trend
-        
-        # Invalid trend
-        with pytest.raises(ValidationError):
-            ForecastResult(
-                metric="latency",
-                predicted_value=200.0,
-                confidence=0.7,
-                trend="invalid_trend",
-                risk_level="medium"
-            )
-    
-    def test_risk_level_validation(self):
-        """Test that only valid risk levels are accepted"""
-        valid_levels = ["low", "medium", "high", "critical"]
-        
-        for level in valid_levels:
-            result = ForecastResult(
-                metric="error_rate",
-                predicted_value=0.08,
-                confidence=0.8,
-                trend="stable",
-                risk_level=level
-            )
-            assert result.risk_level == level
-        
-        # Invalid risk level
-        with pytest.raises(ValidationError):
-            ForecastResult(
-                metric="error_rate",
-                predicted_value=0.08,
-                confidence=0.8,
-                trend="stable",
-                risk_level="extreme"
-            )
-
-
-class TestTimestampHandling:
-    """Test datetime timestamp handling"""
-    
-    def test_timestamp_is_datetime(self):
-        """Test that timestamp is datetime, not string"""
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        # Should be datetime object
-        assert isinstance(event.timestamp, datetime)
-        
-        # Should have timezone
-        assert event.timestamp.tzinfo is not None
-    
-    def test_timestamp_is_utc(self):
-        """Test that timestamp uses UTC"""
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        assert event.timestamp.tzinfo == timezone.utc
-    
-    def test_timestamp_serialization(self):
-        """Test that timestamp can be serialized"""
-        event = ReliabilityEvent(
-            component="test-service",
-            latency_p99=100.0,
-            error_rate=0.05,
-            throughput=1000.0
-        )
-        
-        # Can convert to ISO format
-        iso_str = event.timestamp.isoformat()
-        assert isinstance(iso_str, str)
-        assert 'T' in iso_str  # ISO format
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v", "--tb=short"])