Skip to content

Home Information - Your home, your data, organized.

Python
23.9 KB
Raw Blame
import logging
from unittest.mock import Mock, patch, AsyncMock

from hi.testing.async_task_utils import AsyncTaskFastTestCase

import hi.apps.common.datetimeproxy as datetimeproxy
from hi.apps.security.enums import SecurityState
from hi.apps.security.monitors import SecurityMonitor
from hi.apps.security.settings import SecuritySetting

logging.disable(logging.CRITICAL)


class TestSecurityMonitor(AsyncTaskFastTestCase):
    """Test SecurityMonitor async behavior and time-based transitions.
    
    Uses AsyncTaskTestCase to avoid database locking issues with async code.
    """
    
    def setUp(self):
        super().setUp()
        datetimeproxy.reset()
    
    def test_security_monitor_initialization(self):
        """Test SecurityMonitor initialization - basic monitor setup."""
        monitor = SecurityMonitor()
        
        # Should be properly configured as periodic monitor
        self.assertEqual(monitor.id, monitor.MONITOR_ID)
        self.assertEqual(monitor.get_polling_interval_secs(), SecurityMonitor.SECURITY_POLLING_INTERVAL_SECS)
        self.assertIsNotNone(monitor._last_security_state_check_datetime)
    
    def test_security_monitor_interval_timing(self):
        """Test monitor interval configuration - important for polling frequency."""
        monitor = SecurityMonitor()
        
        # Should use configured polling interval
        self.assertEqual(monitor.get_polling_interval_secs(), 5)  # SECURITY_POLLING_INTERVAL_SECS
    
    async def test_do_work_calls_check_security_state(self):
        """Test do_work method calls security state checking."""
        monitor = SecurityMonitor()
        
        with patch.object(monitor, '_check_security_state', new_callable=AsyncMock) as mock_check:
            await monitor.do_work()
            
            mock_check.assert_called_once()
    
    async def test_check_security_state_no_settings_manager(self):
        """Test security state check with missing settings manager - graceful handling."""
        monitor = SecurityMonitor()
        
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = None
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                await monitor._check_security_state()
                
                # Should not call security manager if settings manager unavailable
                mock_security.assert_not_called()
    
    async def test_check_security_state_no_security_manager(self):
        """Test security state check with missing security manager - graceful handling."""
        monitor = SecurityMonitor()
        
        mock_settings_manager = Mock()
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = mock_settings_manager
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                mock_security.return_value = None
                
                await monitor._check_security_state()
                
                # Should exit gracefully without error
                # (No exceptions should be raised)
    
    @patch('hi.apps.security.monitors.datetimeproxy')
    @patch('hi.apps.security.monitors.ConsoleSettingsHelper')
    async def test_check_security_state_day_start_transition(self, mock_console_helper, mock_datetimeproxy):
        """Test day start time transition - critical time-based automation."""
        monitor = SecurityMonitor()
        
        # Mock datetime and timezone
        mock_current_time = Mock()
        mock_datetimeproxy.now.return_value = mock_current_time
        mock_console_helper.return_value.get_tz_name.return_value = 'UTC'
        
        # Mock time interval check to return True for day start
        mock_datetimeproxy.is_time_of_day_in_interval.side_effect = [True, False]  # Day=True, Night=False
        
        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.side_effect = ['08:00', '23:00']  # Day start, Night start
        
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.NIGHT  # auto_change_allowed = True
        
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = mock_settings_manager
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                mock_security.return_value = mock_security_manager
                
                await monitor._check_security_state()
                
                # Should transition to DAY state
                mock_security_manager.update_security_state_auto.assert_called_once_with(
                    new_security_state=SecurityState.DAY
                )
                
                # Should check day start time interval (returns early when day=True)
                calls = mock_datetimeproxy.is_time_of_day_in_interval.call_args_list
                self.assertEqual(len(calls), 1)  # Only day check, returns early
                
                # Verify day check call
                day_call = calls[0]
                self.assertEqual(day_call[1]['time_of_day_str'], '08:00')
                self.assertEqual(day_call[1]['tz_name'], 'UTC')
    
    @patch('hi.apps.security.monitors.datetimeproxy')
    @patch('hi.apps.security.monitors.ConsoleSettingsHelper')
    async def test_check_security_state_night_start_transition(self, mock_console_helper, mock_datetimeproxy):
        """Test night start time transition - critical time-based automation."""
        monitor = SecurityMonitor()
        
        # Mock datetime and timezone
        mock_current_time = Mock()
        mock_datetimeproxy.now.return_value = mock_current_time
        mock_console_helper.return_value.get_tz_name.return_value = 'UTC'
        
        # Mock time interval check to return False for day, True for night
        mock_datetimeproxy.is_time_of_day_in_interval.side_effect = [False, True]  # Day=False, Night=True
        
        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.side_effect = ['08:00', '23:00']  # Day start, Night start
        
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.DAY  # auto_change_allowed = True
        
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = mock_settings_manager
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                mock_security.return_value = mock_security_manager
                
                await monitor._check_security_state()
                
                # Should transition to NIGHT state
                mock_security_manager.update_security_state_auto.assert_called_once_with(
                    new_security_state=SecurityState.NIGHT
                )
                
                # Should check night start time interval
                calls = mock_datetimeproxy.is_time_of_day_in_interval.call_args_list
                self.assertEqual(len(calls), 2)  # Day check, then Night check
                
                # Verify night check call
                night_call = calls[1]
                self.assertEqual(night_call[1]['time_of_day_str'], '23:00')
                self.assertEqual(night_call[1]['tz_name'], 'UTC')
    
    @patch('hi.apps.security.monitors.datetimeproxy')
    @patch('hi.apps.security.monitors.ConsoleSettingsHelper')
    async def test_check_security_state_no_transition_needed(self, mock_console_helper, mock_datetimeproxy):
        """Test no transition when not in time intervals - maintains current state."""
        monitor = SecurityMonitor()
        
        # Mock datetime and timezone
        mock_current_time = Mock()
        mock_datetimeproxy.now.return_value = mock_current_time
        mock_console_helper.return_value.get_tz_name.return_value = 'UTC'
        
        # Mock time interval check to return False for both day and night
        mock_datetimeproxy.is_time_of_day_in_interval.side_effect = [False, False]  # Day=False, Night=False
        
        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.side_effect = ['08:00', '23:00']  # Day start, Night start
        
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.DAY  # auto_change_allowed = True
        
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = mock_settings_manager
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                mock_security.return_value = mock_security_manager
                
                await monitor._check_security_state()
                
                # Should not call state update when no transition needed
                mock_security_manager.update_security_state_auto.assert_not_called()
    
    @patch('hi.apps.security.monitors.datetimeproxy')
    async def test_check_security_state_updates_last_check_time(self, mock_datetimeproxy):
        """Test last check time tracking - important for time interval calculations."""
        monitor = SecurityMonitor()
        initial_time = monitor._last_security_state_check_datetime
        
        mock_current_time = Mock()
        mock_datetimeproxy.now.return_value = mock_current_time
        
        mock_settings_manager = Mock()
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.DAY  # auto_change_allowed = True
        
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = mock_settings_manager
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                mock_security.return_value = mock_security_manager
                
                await monitor._check_security_state()
                
                # Should update last check time even if no state change
                self.assertEqual(monitor._last_security_state_check_datetime, mock_current_time)
                self.assertNotEqual(monitor._last_security_state_check_datetime, initial_time)
    
    @patch('hi.apps.security.monitors.datetimeproxy')
    async def test_check_security_state_updates_time_on_exception(self, mock_datetimeproxy):
        """Test last check time updated even when exceptions occur - ensures proper time tracking."""
        monitor = SecurityMonitor()
        
        mock_current_time = Mock()
        mock_datetimeproxy.now.return_value = mock_current_time
        
        mock_settings_manager = Mock()
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.DAY
        
        # Force an exception during processing after try block starts
        with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = mock_settings_manager
            
            with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                mock_security.return_value = mock_security_manager
                # Force exception in the try block
                mock_security_manager.security_state.auto_change_allowed = True
                mock_settings_manager.get_setting_value.side_effect = Exception("Test exception")
                
                # Should handle exception gracefully and still update time
                try:
                    await monitor._check_security_state()
                except Exception:
                    pass  # Exception is expected but handled by finally
                
                # Should still update last check time due to finally block
                self.assertEqual(monitor._last_security_state_check_datetime, mock_current_time)
    
    async def test_check_security_state_time_interval_parameters(self):
        """Test time interval checking uses correct parameters - validates time calculation logic."""
        monitor = SecurityMonitor()
        
        # Set up initial last check time
        initial_time = datetimeproxy.now()
        monitor._last_security_state_check_datetime = initial_time
        
        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.side_effect = ['06:30', '22:45']  # Day start, Night start
        
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.NIGHT  # auto_change_allowed = True
        
        with patch('hi.apps.security.monitors.datetimeproxy.is_time_of_day_in_interval') as mock_interval_check:
            mock_interval_check.return_value = False  # No transitions
            
            with patch('hi.apps.security.monitors.ConsoleSettingsHelper') as mock_console_helper:
                mock_console_helper.return_value.get_tz_name.return_value = 'America/New_York'
                
                with patch.object(monitor, 'settings_manager_async', new_callable=AsyncMock) as mock_settings:
                    mock_settings.return_value = mock_settings_manager
                    
                    with patch.object(monitor, 'security_manager_async', new_callable=AsyncMock) as mock_security:
                        mock_security.return_value = mock_security_manager
                        
                        await monitor._check_security_state()
                        
                        # Should check both day and night intervals with correct parameters
                        calls = mock_interval_check.call_args_list
                        self.assertEqual(len(calls), 2)
                        
                        # Verify day start check
                        day_call = calls[0]
                        self.assertEqual(day_call[1]['time_of_day_str'], '06:30')
                        self.assertEqual(day_call[1]['tz_name'], 'America/New_York')
                        self.assertEqual(day_call[1]['start_datetime'], initial_time)
                        
                        # Verify night start check
                        night_call = calls[1]
                        self.assertEqual(night_call[1]['time_of_day_str'], '22:45')
                        self.assertEqual(night_call[1]['tz_name'], 'America/New_York')
                        self.assertEqual(night_call[1]['start_datetime'], initial_time)
    
    def test_security_monitor_mixin_inheritance(self):
        """Test SecurityMonitor inheritance - ensures proper mixin integration."""
        monitor = SecurityMonitor()
        
        # Should inherit from PeriodicMonitor
        from hi.apps.monitor.periodic_monitor import PeriodicMonitor
        self.assertIsInstance(monitor, PeriodicMonitor)
        
        # Should inherit from SecurityMixin
        from hi.apps.security.security_mixins import SecurityMixin
        self.assertIsInstance(monitor, SecurityMixin)
        
        # Should inherit from SettingsMixin
        from hi.apps.config.settings_mixins import SettingsMixin
        self.assertIsInstance(monitor, SettingsMixin)
        
        # Should have access to mixin methods
        self.assertTrue(hasattr(monitor, 'security_manager'))
        self.assertTrue(hasattr(monitor, 'security_manager_async'))
        self.assertTrue(hasattr(monitor, 'settings_manager'))
        self.assertTrue(hasattr(monitor, 'settings_manager_async'))


    async def test_do_work_reports_health_status_success(self):
        """Test do_work reports healthy status when security state check succeeds."""
        monitor = SecurityMonitor()
        
        with patch.object(monitor, "_check_security_state", new_callable=AsyncMock) as mock_check:
            with patch.object(monitor, "record_healthy") as mock_healthy:
                mock_check.return_value = "No change needed (Day mode)"
                
                await monitor.do_work()
                
                mock_check.assert_called_once()
                mock_healthy.assert_called_once_with("No change needed (Day mode)")

    async def test_do_work_reports_health_status_error(self):
        """Test do_work reports error status when security state check fails."""
        monitor = SecurityMonitor()
        
        with patch.object(monitor, "_check_security_state", new_callable=AsyncMock) as mock_check:
            with patch.object(monitor, "record_error") as mock_error:
                mock_check.side_effect = Exception("Test exception")
                
                await monitor.do_work()
                
                mock_check.assert_called_once()
                mock_error.assert_called_once()
                # Check that error message contains the exception
                error_call_args = mock_error.call_args[0][0]
                self.assertIn("Security state check failed", error_call_args)
                self.assertIn("Test exception", error_call_args)

    async def test_check_security_state_returns_appropriate_messages(self):
        """Test _check_security_state returns appropriate status messages."""
        monitor = SecurityMonitor()
        
        # Test settings manager not available
        with patch.object(monitor, "settings_manager_async", new_callable=AsyncMock) as mock_settings:
            mock_settings.return_value = None
            
            result = await monitor._check_security_state()
            
            self.assertEqual(result, "Settings manager not available")

    async def test_check_security_state_security_manager_not_available(self):
        """Test _check_security_state handles missing security manager."""
        monitor = SecurityMonitor()
        
        mock_settings_manager = Mock()
        
        with patch.object(monitor, "settings_manager_async", new_callable=AsyncMock) as mock_settings:
            with patch.object(monitor, "security_manager_async", new_callable=AsyncMock) as mock_security:
                mock_settings.return_value = mock_settings_manager
                mock_security.return_value = None
                
                result = await monitor._check_security_state()
                
                self.assertEqual(result, "Security manager not available")

    async def test_check_security_state_auto_change_blocked(self):
        """Test _check_security_state reports when auto-change is blocked."""
        monitor = SecurityMonitor()

        mock_settings_manager = Mock()
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.AWAY  # auto_change_allowed = False

        with patch.object(monitor, "settings_manager_async", new_callable=AsyncMock) as mock_settings:
            with patch.object(monitor, "security_manager_async", new_callable=AsyncMock) as mock_security:
                with patch("hi.apps.security.monitors.ConsoleSettingsHelper") as mock_console:
                    mock_settings.return_value = mock_settings_manager
                    mock_security.return_value = mock_security_manager
                    mock_console.return_value.get_tz_name.return_value = "UTC"

                    result = await monitor._check_security_state()

                    self.assertEqual(result, "Auto-change blocked (Away mode)")

    async def test_check_security_state_no_change_needed(self):
        """Test _check_security_state reports when no change is needed."""
        monitor = SecurityMonitor()

        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.return_value = "06:00"  # Day/night start times

        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.DAY  # auto_change_allowed = True

        with patch.object(monitor, "settings_manager_async", new_callable=AsyncMock) as mock_settings:
            with patch.object(monitor, "security_manager_async", new_callable=AsyncMock) as mock_security:
                with patch("hi.apps.security.monitors.datetimeproxy.is_time_of_day_in_interval") as mock_interval:
                    with patch("hi.apps.security.monitors.ConsoleSettingsHelper") as mock_console:
                        mock_settings.return_value = mock_settings_manager
                        mock_security.return_value = mock_security_manager
                        mock_console.return_value.get_tz_name.return_value = "UTC"
                        mock_interval.return_value = False  # No time interval match

                        result = await monitor._check_security_state()

                        self.assertEqual(result, "No change needed (Day mode)")

    async def test_check_security_state_day_transition(self):
        """Test _check_security_state reports day transition."""
        monitor = SecurityMonitor()
        
        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.side_effect = lambda setting: {
            SecuritySetting.SECURITY_DAY_START: "06:00"
        }.get(setting, "18:00")
        
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.NIGHT  # auto_change_allowed = True
        
        with patch.object(monitor, "settings_manager_async", new_callable=AsyncMock) as mock_settings:
            with patch.object(monitor, "security_manager_async", new_callable=AsyncMock) as mock_security:
                with patch("hi.apps.security.monitors.datetimeproxy.is_time_of_day_in_interval") as mock_interval:
                    with patch("hi.apps.security.monitors.ConsoleSettingsHelper") as mock_console:
                        mock_settings.return_value = mock_settings_manager
                        mock_security.return_value = mock_security_manager
                        mock_console.return_value.get_tz_name.return_value = "UTC"
                        mock_interval.side_effect = [True, False]  # Day start time matches, night does not

                        result = await monitor._check_security_state()

                        self.assertEqual(result, "Transitioned Night → Day")
                        mock_security_manager.update_security_state_auto.assert_called_once_with(
                            new_security_state=SecurityState.DAY
                        )

    async def test_check_security_state_night_transition(self):
        """Test _check_security_state reports night transition."""
        monitor = SecurityMonitor()
        
        mock_settings_manager = Mock()
        mock_settings_manager.get_setting_value.side_effect = lambda setting: {
            SecuritySetting.SECURITY_NIGHT_START: "18:00"
        }.get(setting, "06:00")
        
        mock_security_manager = Mock()
        mock_security_manager.security_state = SecurityState.DAY  # auto_change_allowed = True
        
        with patch.object(monitor, "settings_manager_async", new_callable=AsyncMock) as mock_settings:
            with patch.object(monitor, "security_manager_async", new_callable=AsyncMock) as mock_security:
                with patch("hi.apps.security.monitors.datetimeproxy.is_time_of_day_in_interval") as mock_interval:
                    with patch("hi.apps.security.monitors.ConsoleSettingsHelper") as mock_console:
                        mock_settings.return_value = mock_settings_manager
                        mock_security.return_value = mock_security_manager
                        mock_console.return_value.get_tz_name.return_value = "UTC"
                        mock_interval.side_effect = [False, True]  # Day start doesnt match, night does

                        result = await monitor._check_security_state()

                        self.assertEqual(result, "Transitioned Day → Night")
                        mock_security_manager.update_security_state_auto.assert_called_once_with(
                            new_security_state=SecurityState.NIGHT
                        )