Skip to content

Home Information - Your home, your data, organized.

Python
21.5 KB
Raw Blame
import logging
from unittest.mock import Mock, patch
from threading import Timer
import threading

from django.core.exceptions import BadRequest
from django.test import RequestFactory

from hi.apps.security.enums import SecurityLevel, SecurityState, SecurityStateAction
from hi.apps.security.security_manager import SecurityManager
from hi.apps.security.transient_models import SecurityStatusData
from hi.constants import DIVID
from hi.testing.base_test_case import BaseTestCase

logging.disable(logging.CRITICAL)


class TestSecurityManager(BaseTestCase):

    def setUp(self):
        super().setUp()
        # Reset singleton instance for each test
        SecurityManager._instance = None

    def test_security_manager_singleton_behavior(self):
        """Test SecurityManager singleton pattern - critical for system consistency."""
        manager1 = SecurityManager()
        manager2 = SecurityManager()
        
        # Should be the same instance
        self.assertIs(manager1, manager2)
        
        # Should maintain state across references
        manager1._security_state = SecurityState.AWAY
        self.assertEqual(manager2._security_state, SecurityState.AWAY)

    def test_security_manager_initialization_state(self):
        """Test initial state values - important for system startup."""
        manager = SecurityManager()
        
        # Should start with default values
        self.assertEqual(manager._security_state, SecurityState.default())
        self.assertEqual(manager._security_level, SecurityLevel.OFF)
        self.assertIsNone(manager._delayed_security_state_timer)
        self.assertIsNone(manager._delayed_security_state)
        self.assertFalse(manager._was_initialized)

    @patch('hi.apps.security.security_manager.get_redis_client')
    def test_ensure_initialized_tracking(self, mock_get_redis_client):
        """Test initialization tracking - important for lazy loading."""
        mock_redis = Mock()
        mock_get_redis_client.return_value = mock_redis
        mock_redis.get.return_value = None
        
        manager = SecurityManager()
        
        # Should start uninitialized
        self.assertFalse(manager._was_initialized)
        
        # Should initialize once
        with patch.object(manager, 'settings_manager') as mock_settings:
            mock_settings_manager = Mock()
            mock_settings.return_value = mock_settings_manager
            mock_settings_manager.get_setting_value.side_effect = ['08:00', '23:00']
            
            manager.ensure_initialized()
            self.assertTrue(manager._was_initialized)
            
            # Should not reinitialize
            manager.ensure_initialized()
            self.assertTrue(manager._was_initialized)

    def test_update_security_state_immediate_state_level_mapping(self):
        """Test state to level mapping - critical for security system behavior."""
        manager = SecurityManager()
        
        # Test DISABLED -> OFF
        manager.update_security_state_immediate(SecurityState.DISABLED)
        self.assertEqual(manager.security_state, SecurityState.DISABLED)
        self.assertEqual(manager.security_level, SecurityLevel.OFF)
        
        # Test DAY -> LOW
        manager.update_security_state_immediate(SecurityState.DAY)
        self.assertEqual(manager.security_state, SecurityState.DAY)
        self.assertEqual(manager.security_level, SecurityLevel.LOW)
        
        # Test NIGHT -> HIGH
        manager.update_security_state_immediate(SecurityState.NIGHT)
        self.assertEqual(manager.security_state, SecurityState.NIGHT)
        self.assertEqual(manager.security_level, SecurityLevel.HIGH)
        
        # Test AWAY -> HIGH
        manager.update_security_state_immediate(SecurityState.AWAY)
        self.assertEqual(manager.security_state, SecurityState.AWAY)
        self.assertEqual(manager.security_level, SecurityLevel.HIGH)

    @patch('hi.apps.security.security_manager.get_redis_client')
    def test_update_security_state_immediate_redis_caching(self, mock_get_redis_client):
        """Test Redis state caching - important for persistence across restarts."""
        mock_redis = Mock()
        mock_get_redis_client.return_value = mock_redis
        
        manager = SecurityManager()
        manager.update_security_state_immediate(SecurityState.AWAY)
        
        # Should cache state in Redis
        mock_redis.set.assert_called_with(
            SecurityManager.SECURITY_STATE_CACHE_KEY,
            str(SecurityState.AWAY)
        )

    def test_update_security_state_immediate_cancels_delayed_transitions(self):
        """Test immediate update cancels delayed transitions - critical for state consistency."""
        manager = SecurityManager()
        
        # Set up a delayed transition
        mock_timer = Mock(spec=Timer)
        manager._delayed_security_state_timer = mock_timer
        manager._delayed_security_state = SecurityState.AWAY
        
        # Immediate update should cancel delayed state
        manager.update_security_state_immediate(SecurityState.DAY)
        
        mock_timer.cancel.assert_called_once()
        self.assertIsNone(manager._delayed_security_state)
        self.assertIsNone(manager._delayed_security_state_timer)

    def test_update_security_state_user_disable_action(self):
        """Test user disable action - immediate transition to DISABLED."""
        manager = SecurityManager()
        
        with patch.object(manager, '_update_security_state') as mock_update:
            manager.update_security_state_user(SecurityStateAction.DISABLE)
            
            mock_update.assert_called_once_with(
                immediate_security_state=SecurityState.DISABLED,
                future_security_state=None,
                delay_secs=0
            )

    def test_update_security_state_user_day_night_actions(self):
        """Test user day/night actions - immediate transitions."""
        manager = SecurityManager()
        
        with patch.object(manager, '_update_security_state') as mock_update:
            manager.update_security_state_user(SecurityStateAction.SET_DAY)
            mock_update.assert_called_with(
                immediate_security_state=SecurityState.DAY,
                future_security_state=None,
                delay_secs=0
            )
            
            mock_update.reset_mock()
            manager.update_security_state_user(SecurityStateAction.SET_NIGHT)
            mock_update.assert_called_with(
                immediate_security_state=SecurityState.NIGHT,
                future_security_state=None,
                delay_secs=0
            )

    def test_update_security_state_user_away_action_with_delay(self):
        """Test user away action - delayed transition behavior."""
        manager = SecurityManager()
        
        with patch.object(manager, 'settings_manager') as mock_settings:
            mock_settings_manager = Mock()
            mock_settings.return_value = mock_settings_manager
            mock_settings_manager.get_setting_value.return_value = '3'  # 3 minutes
            
            with patch.object(manager, '_update_security_state') as mock_update:
                manager.update_security_state_user(SecurityStateAction.SET_AWAY)
                
                mock_update.assert_called_once_with(
                    immediate_security_state=SecurityState.DISABLED,
                    future_security_state=SecurityState.AWAY,
                    delay_secs=180  # 3 minutes * 60 seconds
                )

    def test_update_security_state_user_snooze_action(self):
        """Test user snooze action - preserves current state with delay."""
        manager = SecurityManager()
        manager._security_state = SecurityState.NIGHT
        
        with patch.object(manager, 'settings_manager') as mock_settings:
            mock_settings_manager = Mock()
            mock_settings.return_value = mock_settings_manager
            mock_settings_manager.get_setting_value.return_value = '5'  # 5 minutes
            
            with patch.object(manager, '_update_security_state') as mock_update:
                manager.update_security_state_user(SecurityStateAction.SNOOZE)
                
                mock_update.assert_called_once_with(
                    immediate_security_state=SecurityState.DISABLED,
                    future_security_state=SecurityState.NIGHT,  # Current state preserved
                    delay_secs=300  # 5 minutes * 60 seconds
                )

    def test_update_security_state_user_invalid_delay_setting(self):
        """Test invalid delay setting handling - uses default delay."""
        manager = SecurityManager()
        
        with patch.object(manager, 'settings_manager') as mock_settings:
            mock_settings_manager = Mock()
            mock_settings.return_value = mock_settings_manager
            mock_settings_manager.get_setting_value.return_value = 'invalid'
            
            with patch.object(manager, '_update_security_state') as mock_update:
                manager.update_security_state_user(SecurityStateAction.SET_AWAY)
                
                mock_update.assert_called_once_with(
                    immediate_security_state=SecurityState.DISABLED,
                    future_security_state=SecurityState.AWAY,
                    delay_secs=SecurityManager.DEFAULT_TRANSITION_DELAY_SECS
                )

    def test_update_security_state_user_unsupported_action(self):
        """Test unsupported action handling - raises BadRequest."""
        manager = SecurityManager()
        
        # Create a mock action that's not in the enum
        mock_action = Mock()
        mock_action.__str__ = Mock(return_value='INVALID_ACTION')
        
        with self.assertRaises(BadRequest):
            manager.update_security_state_user(mock_action)

    @patch('hi.apps.security.security_manager.Timer')
    @patch('hi.apps.security.security_manager.get_redis_client')
    def test_update_security_state_delayed_timer_setup(self, mock_get_redis_client, mock_timer_class):
        """Test delayed state timer setup and Redis caching."""
        mock_redis = Mock()
        mock_get_redis_client.return_value = mock_redis
        mock_timer = Mock()
        mock_timer_class.return_value = mock_timer
        
        manager = SecurityManager()
        manager._update_security_state_delayed(SecurityState.AWAY, 300)
        
        # Should create and start timer
        mock_timer_class.assert_called_once_with(300, manager._apply_delayed_state)
        mock_timer.start.assert_called_once()
        
        # Should cache future state in Redis
        mock_redis.set.assert_called_with(
            SecurityManager.SECURITY_STATE_CACHE_KEY,
            str(SecurityState.AWAY)
        )
        
        # Should track delayed state
        self.assertEqual(manager._delayed_security_state, SecurityState.AWAY)
        self.assertEqual(manager._delayed_security_state_timer, mock_timer)

    @patch('hi.apps.security.security_manager.Timer')
    def test_update_security_state_delayed_cancels_existing_timer(self, mock_timer_class):
        """Test delayed state update cancels existing timer."""
        manager = SecurityManager()
        
        # Set up existing timer
        existing_timer = Mock()
        manager._delayed_security_state_timer = existing_timer
        
        new_timer = Mock()
        mock_timer_class.return_value = new_timer
        
        manager._update_security_state_delayed(SecurityState.AWAY, 300)
        
        # Should cancel existing timer
        existing_timer.cancel.assert_called_once()

    def test_apply_delayed_state(self):
        """Test apply delayed state - calls immediate update with delayed state."""
        manager = SecurityManager()
        manager._delayed_security_state = SecurityState.AWAY
        manager._redis_client = Mock()

        with patch.object(manager, 'update_security_state_immediate') as mock_update:
            manager._apply_delayed_state()

            mock_update.assert_called_once_with(new_security_state=SecurityState.AWAY)

    def test_apply_delayed_state_away_sets_lock_timestamp(self):
        """Test delayed AWAY transition sets console auto-lock timestamp."""
        manager = SecurityManager()
        manager._delayed_security_state = SecurityState.AWAY
        manager._redis_client = Mock()

        with patch.object( manager, 'update_security_state_immediate' ):
            manager._apply_delayed_state()

        manager._redis_client.set.assert_called_once_with(
            SecurityManager.CONSOLE_AWAY_LOCK_TIMESTAMP_CACHE_KEY,
            manager._redis_client.set.call_args[0][1],  # timestamp string
        )
        return

    def test_apply_delayed_state_non_away_does_not_set_timestamp(self):
        """Test delayed non-AWAY transition does not set auto-lock timestamp."""
        manager = SecurityManager()
        manager._delayed_security_state = SecurityState.NIGHT
        manager._redis_client = Mock()

        with patch.object( manager, 'update_security_state_immediate' ):
            manager._apply_delayed_state()

        manager._redis_client.set.assert_not_called()
        return

    def test_leaving_away_deletes_lock_timestamp(self):
        """Test transitioning out of AWAY deletes the auto-lock timestamp."""
        manager = SecurityManager()
        manager._security_state = SecurityState.AWAY
        manager._redis_client = Mock()

        manager.update_security_state_immediate( SecurityState.DAY )

        manager._redis_client.delete.assert_called_once_with(
            SecurityManager.CONSOLE_AWAY_LOCK_TIMESTAMP_CACHE_KEY,
        )
        return

    def test_staying_in_away_does_not_delete_timestamp(self):
        """Test re-entering AWAY does not delete the auto-lock timestamp."""
        manager = SecurityManager()
        manager._security_state = SecurityState.AWAY
        manager._redis_client = Mock()

        manager.update_security_state_immediate( SecurityState.AWAY )

        manager._redis_client.delete.assert_not_called()
        return

    def test_non_away_transition_does_not_delete_timestamp(self):
        """Test non-AWAY to non-AWAY transition does not delete timestamp."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DAY
        manager._redis_client = Mock()

        manager.update_security_state_immediate( SecurityState.NIGHT )

        manager._redis_client.delete.assert_not_called()
        return

    @patch('hi.apps.security.security_manager.get_redis_client')
    def test_initialize_away_sets_lock_timestamp(self, mock_get_redis_client):
        """Test initializing with AWAY state sets a fresh lock timestamp."""
        mock_redis = Mock()
        mock_get_redis_client.return_value = mock_redis
        mock_redis.get.return_value = str( SecurityState.AWAY )

        manager = SecurityManager()
        manager._initialize_security_state()

        # Should set the lock timestamp (second set call after the state set)
        set_calls = mock_redis.set.call_args_list
        timestamp_calls = [
            c for c in set_calls
            if c[0][0] == SecurityManager.CONSOLE_AWAY_LOCK_TIMESTAMP_CACHE_KEY
        ]
        self.assertEqual( len( timestamp_calls ), 1 )
        return

    def test_update_security_state_auto_blocked_by_state(self):
        """Test auto update blocked by non-auto-changeable state."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DISABLED  # auto_change_allowed = False
        
        with patch.object(manager, 'update_security_state_immediate') as mock_update:
            manager.update_security_state_auto(SecurityState.DAY)
            
            # Should not update when auto change is not allowed
            mock_update.assert_not_called()

    def test_update_security_state_auto_no_delayed_state(self):
        """Test auto update with no delayed state - normal immediate update."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DAY  # auto_change_allowed = True
        manager._delayed_security_state = None
        
        with patch.object(manager, 'update_security_state_immediate') as mock_update:
            manager.update_security_state_auto(SecurityState.NIGHT)
            
            mock_update.assert_called_once_with(
                new_security_state=SecurityState.NIGHT,
                lock_acquired=True
            )

    def test_update_security_state_auto_blocked_by_delayed_state(self):
        """Test auto update blocked by non-auto-changeable delayed state."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DAY  # auto_change_allowed = True
        manager._delayed_security_state = SecurityState.AWAY  # auto_change_allowed = False
        
        with patch.object(manager, 'update_security_state_immediate') as mock_update:
            manager.update_security_state_auto(SecurityState.NIGHT)
            
            # Should not update when delayed state doesn't allow auto change
            mock_update.assert_not_called()

    def test_update_security_state_auto_updates_snooze_target(self):
        """Test auto update modifies snooze target state - important for time transitions."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DAY  # auto_change_allowed = True
        manager._delayed_security_state = SecurityState.NIGHT  # Snoozing NIGHT state (auto_change_allowed = True)
        
        manager.update_security_state_auto(SecurityState.DAY)
        
        # Should update the delayed state to honor time-based transition
        self.assertEqual(manager._delayed_security_state, SecurityState.DAY)

    def test_get_security_status_data_basic_states(self):
        """Test security status data generation for basic states."""
        manager = SecurityManager()
        
        # Test DAY state
        manager._security_state = SecurityState.DAY
        manager._security_level = SecurityLevel.LOW
        status = manager.get_security_status_data()
        
        self.assertIsInstance(status, SecurityStatusData)
        self.assertEqual(status.current_security_level, SecurityLevel.LOW)
        self.assertEqual(status.current_security_state, SecurityState.DAY)
        self.assertEqual(status.current_action_value, str(SecurityStateAction.SET_DAY))
        self.assertEqual(status.current_action_label, 'Day')

    def test_get_security_status_data_delayed_away_state(self):
        """Test security status data with delayed away transition."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DISABLED
        manager._delayed_security_state = SecurityState.AWAY
        
        status = manager.get_security_status_data()
        
        self.assertEqual(status.current_action_label, SecurityManager.SECURITY_STATE_LABEL_DELAYED_AWAY)
        self.assertEqual(status.current_action_value, str(SecurityStateAction.SET_AWAY))

    def test_get_security_status_data_snoozed_state(self):
        """Test security status data with snoozed state."""
        manager = SecurityManager()
        manager._security_state = SecurityState.DISABLED
        manager._delayed_security_state = SecurityState.NIGHT  # Any non-AWAY state
        
        status = manager.get_security_status_data()
        
        self.assertEqual(status.current_action_label, SecurityManager.SECURITY_STATE_LABEL_SNOOZED)
        self.assertEqual(status.current_action_value, str(SecurityStateAction.SNOOZE))

    @patch('hi.apps.security.security_manager.get_template')
    def test_get_status_id_replace_map_template_rendering(self, mock_get_template):
        """Test status ID replace map template rendering."""
        mock_template = Mock()
        mock_get_template.return_value = mock_template
        mock_template.render.return_value = '<div>Security Control</div>'
        
        manager = SecurityManager()
        request = RequestFactory().get('/')
        
        result = manager.get_status_id_replace_map(request)
        
        # Should render template with security status data
        mock_get_template.assert_called_once()
        mock_template.render.assert_called_once()
        
        # Should return proper div ID mapping
        expected_result = {
            DIVID['SECURITY_STATE_CONTROL']: '<div>Security Control</div>'
        }
        self.assertEqual(result, expected_result)

    def test_thread_safety_concurrent_state_updates(self):
        """Test thread safety of concurrent state updates - critical for multi-threaded access."""
        manager = SecurityManager()
        results = []
        errors = []
        
        def update_state(state):
            try:
                manager.update_security_state_immediate(state)
                results.append(manager.security_state)
            except Exception as e:
                errors.append(e)
        
        # Create multiple threads updating state concurrently
        threads = []
        states = [SecurityState.DAY, SecurityState.NIGHT, SecurityState.AWAY, SecurityState.DISABLED] * 5
        
        for state in states:
            thread = threading.Thread(target=update_state, args=(state,))
            threads.append(thread)
        
        # Start all threads
        for thread in threads:
            thread.start()
        
        # Wait for completion
        for thread in threads:
            thread.join()
        
        # Should complete without errors
        self.assertEqual(len(errors), 0)
        self.assertEqual(len(results), len(states))
        
        # Final state should be one of the valid states
        self.assertIn(manager.security_state, [SecurityState.DAY, SecurityState.NIGHT, SecurityState.AWAY, SecurityState.DISABLED])