test_safety.py

"""Comprehensive tests for failure safety system."""

import pytest
import numpy as np
from unittest.mock import Mock
from dataclasses import dataclass

from kernel.safety import (
    FailureSafetyMonitor, SafetyThresholds, SafetyStatus, SafetyAlert, SafetyReport
)


@dataclass
class MockState:
    """Mock spacecraft state."""
    position: np.ndarray
    velocity: np.ndarray
    mass: float


# ============================================================================
# SAFETY THRESHOLDS TESTS
# ============================================================================

class TestSafetyThresholds:
    """Test safety threshold configuration."""
    
    def test_default_thresholds(self):
        """Test creating default thresholds."""
        thresholds = SafetyThresholds()
        
        assert thresholds.max_position_magnitude == 1e15
        assert thresholds.max_velocity_magnitude == 1e8
        assert thresholds.min_mass == 1e-6
        assert thresholds.max_energy_drift_percent == 5.0
    
    def test_custom_thresholds(self):
        """Test custom threshold configuration."""
        thresholds = SafetyThresholds(
            max_velocity_magnitude=1e7,
            min_mass=0.1
        )
        
        assert thresholds.max_velocity_magnitude == 1e7
        assert thresholds.min_mass == 0.1
        assert thresholds.max_position_magnitude == 1e15  # Default


# ============================================================================
# SAFETY ALERT TESTS
# ============================================================================

class TestSafetyAlert:
    """Test safety alert creation."""
    
    def test_create_alert(self):
        """Test creating a safety alert."""
        alert = SafetyAlert(
            severity="warning",
            check_name="test_check",
            message="Test message",
            value=1.5,
            threshold=1.0,
            step_number=100
        )
        
        assert alert.severity == "warning"
        assert alert.check_name == "test_check"
        assert alert.value == 1.5


# ============================================================================
# SAFETY REPORT TESTS
# ============================================================================

class TestSafetyReport:
    """Test safety report generation."""
    
    def test_report_creation(self):
        """Test creating a safety report."""
        report = SafetyReport()
        
        assert report.total_warnings == 0
        assert report.total_criticals == 0
        assert report.simulation_halted is False
    
    def test_report_status_nominal(self):
        """Test nominal status."""
        report = SafetyReport()
        assert report.overall_status() == SafetyStatus.NOMINAL
    
    def test_report_status_warning(self):
        """Test warning status."""
        report = SafetyReport(total_warnings=1)
        assert report.overall_status() == SafetyStatus.WARNING
    
    def test_report_status_danger(self):
        """Test danger status."""
        report = SafetyReport(total_criticals=1)
        assert report.overall_status() == SafetyStatus.DANGER
    
    def test_report_status_halted(self):
        """Test halted status."""
        report = SafetyReport(simulation_halted=True)
        assert report.overall_status() == SafetyStatus.HALTED
    
    def test_report_summary(self):
        """Test report summary generation."""
        report = SafetyReport(
            total_warnings=2,
            total_criticals=1,
            simulation_halted=True
        )
        summary = report.summary()
        
        assert "HALTED" in summary.upper()
        assert "2" in summary
        assert "1" in summary


# ============================================================================
# FAILURE SAFETY MONITOR TESTS
# ============================================================================

class TestFailureSafetyMonitor:
    """Test main failure safety monitor."""
    
    def test_monitor_creation(self):
        """Test creating safety monitor."""
        monitor = FailureSafetyMonitor()
        
        assert monitor.auto_halt is True
        assert monitor.halt_triggered is False
        assert len(monitor.alerts) == 0
    
    def test_nominal_step(self):
        """Test nominal step processing."""
        monitor = FailureSafetyMonitor()
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=100.0,
            acceleration_magnitude=0.01,
            energy=-1e20,
            time_value=0.0
        )
        
        assert result is True  # Should continue
        assert len(monitor.alerts) == 0
        assert monitor.get_status() == SafetyStatus.NOMINAL
    
    def test_position_divergence(self):
        """Test position divergence detection."""
        monitor = FailureSafetyMonitor()
        
        state = MockState(
            position=np.array([2e15, 0, 0]),  # Way too far
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert result is False  # Should halt
        assert monitor.halt_triggered is True
        assert monitor.get_status() == SafetyStatus.HALTED
        assert len(monitor.alerts) > 0
        assert monitor.alerts[0].check_name == "position_divergence"
    
    def test_velocity_divergence(self):
        """Test velocity divergence detection."""
        monitor = FailureSafetyMonitor()
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([1e9, 0, 0]),  # Way too fast
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert result is False
        assert monitor.halt_triggered is True
        assert monitor.alerts[0].check_name == "velocity_divergence"
    
    def test_negative_mass(self):
        """Test negative mass detection."""
        monitor = FailureSafetyMonitor()
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=-50.0  # Negative!
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert result is False
        assert monitor.halt_triggered is True
        assert monitor.alerts[0].check_name == "negative_or_zero_mass"
    
    def test_nan_detection(self):
        """Test NaN in state detection."""
        monitor = FailureSafetyMonitor()
        
        state = MockState(
            position=np.array([np.nan, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert result is False
        assert monitor.halt_triggered is True
        assert monitor.alerts[0].check_name == "nan_inf_detection"
    
    def test_cfl_warning(self):
        """Test CFL condition warning."""
        monitor = FailureSafetyMonitor(
            thresholds=SafetyThresholds(cfl_max_ratio=1.0)
        )
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([1e7, 0, 0]),  # Fast
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=100.0,  # Large time step
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert result is True  # Warning doesn't halt
        assert monitor.get_status() == SafetyStatus.WARNING
        assert any(a.check_name == "cfl_violation" for a in monitor.alerts)
    
    def test_high_acceleration_warning(self):
        """Test excessive acceleration detection."""
        monitor = FailureSafetyMonitor(
            thresholds=SafetyThresholds(max_acceleration_magnitude=1e3)
        )
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=1e4,  # Very high
            time_value=0.0
        )
        
        assert result is True
        assert len(monitor.alerts) > 0
        assert monitor.alerts[0].check_name == "acceleration_high"
    
    def test_energy_drift_warning(self):
        """Test energy drift detection."""
        monitor = FailureSafetyMonitor(
            thresholds=SafetyThresholds(max_energy_drift_percent=2.0)
        )
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        result1 = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            energy=1e20,
            time_value=0.0
        )
        
        # Energy drift significantly
        result2 = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            energy=1.1e20,  # 10% change
            time_value=1.0
        )
        
        assert result1 is True
        assert result2 is True  # Warning doesn't halt
        assert any(a.check_name == "energy_drift_high" for a in monitor.alerts)
    
    def test_callbacks_on_warning(self):
        """Test warning callbacks."""
        monitor = FailureSafetyMonitor(
            thresholds=SafetyThresholds(max_acceleration_magnitude=100)
        )
        
        callback_called = False
        
        def on_warning_callback(alert):
            nonlocal callback_called
            callback_called = True
        
        monitor.on_warning.append(on_warning_callback)
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=1e3,
            time_value=0.0
        )
        
        assert callback_called is True
    
    def test_callbacks_on_critical(self):
        """Test critical callbacks."""
        monitor = FailureSafetyMonitor()
        
        callback_called = False
        
        def on_critical_callback(alert):
            nonlocal callback_called
            callback_called = True
        
        monitor.on_critical.append(on_critical_callback)
        
        state = MockState(
            position=np.array([2e15, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert callback_called is True
    
    def test_callbacks_on_halt(self):
        """Test halt callbacks."""
        monitor = FailureSafetyMonitor()
        
        halt_reason = None
        
        def on_halt_callback(reason):
            nonlocal halt_reason
            halt_reason = reason
        
        monitor.on_halt.append(on_halt_callback)
        
        state = MockState(
            position=np.array([2e15, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        assert halt_reason is not None
        assert "Position divergence" in halt_reason
    
    def test_auto_halt_disabled(self):
        """Test disabling auto-halt."""
        monitor = FailureSafetyMonitor(auto_halt=False)
        
        state = MockState(
            position=np.array([2e15, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        result = monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=0.01,
            time_value=0.0
        )
        
        # Alert created but halt not triggered
        assert len(monitor.alerts) > 0
        assert monitor.halt_triggered is False
        assert result is True
    
    def test_get_report(self):
        """Test generating safety report."""
        monitor = FailureSafetyMonitor(
            thresholds=SafetyThresholds(max_acceleration_magnitude=100)
        )
        
        state = MockState(
            position=np.array([1e11, 0, 0]),
            velocity=np.array([30000, 0, 0]),
            mass=1000.0
        )
        
        # Generate warning
        monitor.on_step_complete(
            state=state,
            dt=1.0,
            acceleration_magnitude=1e3,
            time_value=0.0
        )
        
        report = monitor.get_report()
        
        assert report.total_warnings == 1
        assert report.total_criticals == 0
        assert report.simulation_halted is False
    
    def test_multiple_steps(self):
        """Test monitoring multiple simulation steps."""
        monitor = FailureSafetyMonitor()
        
        state = MockState(
            position=np.array([1e11, 1e9, 0]),
            velocity=np.array([30000, 1000, 0]),
            mass=1000.0
        )
        
        # Run 50 nominal steps
        for i in range(50):
            result = monitor.on_step_complete(
                state=state,
                dt=1.0,
                acceleration_magnitude=0.01,
                energy=-1e20,
                time_value=float(i)
            )
            assert result is True
        
        assert monitor.step_count == 50
        assert len(monitor.alerts) == 0
        assert monitor.get_status() == SafetyStatus.NOMINAL


# ============================================================================
# INTEGRATION TESTS
# ============================================================================

class TestSafetyIntegration:
    """Integration tests with simulation scenarios."""
    
    def test_moon_encounter_safety(self):
        """Test safety monitoring during Moon encounter."""
        monitor = FailureSafetyMonitor()
        
        # Spacecraft approaching Moon
        # Position: 384,400 km from Earth → Moon
        times = np.linspace(0, 100000, 1000)
        
        for i, t in enumerate(times):
            # Simple circular trajectory approaching
            distance = 3.84e8 - t * 1000  # Approaching
            state = MockState(
                position=np.array([distance, 0, 0]),
                velocity=np.array([0, 1000, 0]),
                mass=1000.0
            )
            
            result = monitor.on_step_complete(
                state=state,
                dt=100.0,
                acceleration_magnitude=0.01,
                time_value=t
            )
            
            if not result:
                break
        
        # Should run to completion without halt
        assert monitor.halt_triggered is False
        assert monitor.get_status() == SafetyStatus.NOMINAL
    
    def test_unstable_orbit_detection(self):
        """Test detecting unstable orbit conditions."""
        monitor = FailureSafetyMonitor()
        
        # Simulate degrading orbit
        for i in range(100):
            velocity_magnitude = 30000 + i * 500  # Increasing velocity
            
            state = MockState(
                position=np.array([6.371e6 + 400e3, 0, 0]),
                velocity=np.array([0, velocity_magnitude, 0]),
                mass=1000.0 - i * 1.0  # Losing mass
            )
            
            result = monitor.on_step_complete(
                state=state,
                dt=1.0,
                acceleration_magnitude=1.0 + i * 0.1,
                time_value=float(i),
                energy=-1e20 - i * 1e18
            )
            
            if not result:
                # Should halt on mass loss or other issue
                assert monitor.halt_triggered is True
                break


if __name__ == "__main__":
    pytest.main([__file__, "-v"])