Skip to content

Home Information - Your home, your data, organized.

Python
22.7 KB
Raw Blame
import logging

from hi.apps.event.models import EventDefinition, EventClause, AlarmAction, ControlAction, EventHistory
from hi.apps.event.enums import EventType
from hi.apps.alert.enums import AlarmLevel
from hi.apps.security.enums import SecurityLevel
from hi.apps.entity.models import Entity, EntityState
from hi.apps.control.models import Controller
from hi.testing.base_test_case import BaseTestCase

logging.disable(logging.CRITICAL)


class TestEventDefinition(BaseTestCase):

    def test_event_definition_integration_key_inheritance(self):
        """Test EventDefinition integration key inheritance - critical for integration system."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Should inherit integration key fields from IntegrationDetailsModel
        self.assertEqual(event_def.integration_id, 'test_id')
        self.assertEqual(event_def.integration_name, 'test_integration')
        return

    def test_event_definition_event_type_property_conversion(self):
        """Test event_type property enum conversion - custom business logic."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='AUTOMATION',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Test getter converts string to enum
        self.assertEqual(event_def.event_type, EventType.AUTOMATION)
        
        # Test setter converts enum to string
        event_def.event_type = EventType.MAINTENANCE
        self.assertEqual(event_def.event_type_str, 'maintenance')
        return

    def test_event_definition_timing_constraints(self):
        """Test event timing window constraints - critical for event logic."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=120,  # 2 minutes for all clauses to be satisfied
            dedupe_window_secs=600,  # 10 minutes before next event can be generated
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Should store timing constraints correctly
        self.assertEqual(event_def.event_window_secs, 120)
        self.assertEqual(event_def.dedupe_window_secs, 600)
        
        # Should allow reasonable timing values
        self.assertGreater(event_def.dedupe_window_secs, event_def.event_window_secs)
        return

    def test_event_definition_enabled_default(self):
        """Test EventDefinition enabled default - important for system behavior."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Should default to enabled
        self.assertTrue(event_def.enabled)
        return


class TestAlarmAction(BaseTestCase):

    def test_alarm_action_enum_property_conversions(self):
        """Test AlarmAction enum property conversions - custom business logic."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        alarm_action = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='HIGH',
            alarm_level_str='CRITICAL',
            alarm_lifetime_secs=3600
        )
        
        # Test getter converts string to enum
        self.assertEqual(alarm_action.security_level, SecurityLevel.HIGH)
        self.assertEqual(alarm_action.alarm_level, AlarmLevel.CRITICAL)
        
        # Test setter converts enum to string
        alarm_action.security_level = SecurityLevel.LOW
        alarm_action.alarm_level = AlarmLevel.WARNING
        self.assertEqual(alarm_action.security_level_str, 'low')
        self.assertEqual(alarm_action.alarm_level_str, 'warning')
        return

    def test_alarm_action_lifetime_configuration(self):
        """Test alarm lifetime configuration - critical for alarm management."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Test zero lifetime (manual acknowledgment only)
        manual_alarm = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='HIGH',
            alarm_level_str='CRITICAL',
            alarm_lifetime_secs=0
        )
        self.assertEqual(manual_alarm.alarm_lifetime_secs, 0)
        
        # Test timed lifetime
        timed_alarm = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='MEDIUM',
            alarm_level_str='WARNING',
            alarm_lifetime_secs=1800  # 30 minutes
        )
        self.assertEqual(timed_alarm.alarm_lifetime_secs, 1800)
        return


class TestEventHistory(BaseTestCase):

    def test_event_history_ordering_by_event_datetime(self):
        """Test EventHistory ordering - critical for history display."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        from django.utils import timezone
        
        # Create history entries with different timestamps
        history1 = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=timezone.now() - timezone.timedelta(hours=2)
        )
        history2 = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=timezone.now() - timezone.timedelta(hours=1)
        )
        history3 = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=timezone.now()
        )
        
        # Should be ordered by newest first
        history_list = list(EventHistory.objects.filter(event_definition=event_def))
        self.assertEqual(history_list[0], history3)  # Most recent
        self.assertEqual(history_list[1], history2)
        self.assertEqual(history_list[2], history1)  # Oldest
        return

    def test_event_history_datetime_indexing(self):
        """Test event_datetime field indexing - critical for query performance."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        from django.utils import timezone
        
        history = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=timezone.now()
        )
        
        # Test that datetime queries work efficiently
        # (The actual index performance isn't testable in unit tests,
        # but we can verify the field is accessible and queryable)
        recent_history = EventHistory.objects.filter(
            event_datetime__gte=history.event_datetime
        )
        self.assertIn(history, recent_history)
        return


class TestEventDefinitionAdvanced(BaseTestCase):
    """Advanced EventDefinition tests for edge cases and business logic."""

    def test_event_definition_timing_window_constraints_validation(self):
        """Test invalid timing window combinations and edge cases."""
        # Test zero event window (should be valid for immediate events)
        event_def = EventDefinition.objects.create(
            name='Immediate Event',
            event_type_str='AUTOMATION',
            event_window_secs=0,
            dedupe_window_secs=60,
            integration_id='test_id',
            integration_name='test_integration'
        )
        self.assertEqual(event_def.event_window_secs, 0)
        
        # Test zero dedupe window (should be valid for non-deduplicated events)
        event_def2 = EventDefinition.objects.create(
            name='No Dedupe Event',
            event_type_str='INFORMATION',
            event_window_secs=30,
            dedupe_window_secs=0,
            integration_id='test_id2',
            integration_name='test_integration2'
        )
        self.assertEqual(event_def2.dedupe_window_secs, 0)
        return

    def test_event_definition_enum_conversion_edge_cases(self):
        """Test enum conversion with invalid and edge case values."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='INVALID_TYPE',  # Invalid enum value
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Should handle invalid enum gracefully
        event_type = event_def.event_type
        self.assertEqual(event_type, EventType.SECURITY)  # from_name_safe returns default for invalid
        return

    def test_event_definition_multiple_clause_relationships(self):
        """Test EventDefinition with multiple clauses - critical for complex events."""
        entity1 = Entity.objects.create(name='Entity 1', entity_type_str='CAMERA')
        entity_state1 = EntityState.objects.create(
            entity=entity1,
            entity_state_type_str='ON_OFF'
        )
        
        entity2 = Entity.objects.create(name='Entity 2', entity_type_str='SENSOR')
        entity_state2 = EntityState.objects.create(
            entity=entity2,
            entity_state_type_str='DETECTED'
        )
        
        event_def = EventDefinition.objects.create(
            name='Multi-Clause Event',
            event_type_str='SECURITY',
            event_window_secs=120,
            dedupe_window_secs=600,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Create multiple clauses
        clause1 = EventClause.objects.create(
            event_definition=event_def,
            entity_state=entity_state1,
            value='on'
        )
        clause2 = EventClause.objects.create(
            event_definition=event_def,
            entity_state=entity_state2,
            value='detected'
        )
        
        # Should have multiple clauses accessible via relationship
        clauses = event_def.event_clauses.all()
        self.assertEqual(clauses.count(), 2)
        self.assertIn(clause1, clauses)
        self.assertIn(clause2, clauses)
        return

    def test_event_definition_multiple_action_types(self):
        """Test EventDefinition with both alarm and control actions."""
        entity = Entity.objects.create(name='Test Entity', entity_type_str='CAMERA')
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        controller = Controller.objects.create(
            name='Test Controller',
            entity_state=entity_state,
            controller_type_str='DEFAULT',
            integration_id='ctrl_id',
            integration_name='ctrl_integration'
        )
        
        event_def = EventDefinition.objects.create(
            name='Mixed Actions Event',
            event_type_str='AUTOMATION',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Create alarm action
        alarm_action = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='HIGH',
            alarm_level_str='WARNING',
            alarm_lifetime_secs=1800
        )
        
        # Create control action
        control_action = ControlAction.objects.create(
            event_definition=event_def,
            controller=controller,
            value='on'
        )
        
        # Should have both action types
        self.assertEqual(event_def.alarm_actions.count(), 1)
        self.assertEqual(event_def.control_actions.count(), 1)
        self.assertEqual(event_def.alarm_actions.first(), alarm_action)
        self.assertEqual(event_def.control_actions.first(), control_action)
        return


class TestAlarmActionAdvanced(BaseTestCase):
    """Advanced AlarmAction tests for business logic and edge cases."""

    def test_alarm_action_enum_conversion_invalid_values(self):
        """Test enum conversion with invalid security and alarm levels."""
        event_def = EventDefinition.objects.create(
            name='Test Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Create alarm action with invalid enum values
        alarm_action = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='INVALID_SECURITY',
            alarm_level_str='INVALID_ALARM',
            alarm_lifetime_secs=3600
        )
        
        # Should handle invalid enums gracefully  
        self.assertEqual(alarm_action.security_level, SecurityLevel.HIGH)  # from_name_safe returns default (first enum)
        self.assertEqual(alarm_action.alarm_level, AlarmLevel.NONE)  # from_name_safe returns default (first enum)
        return

    def test_alarm_action_multiple_per_event_definition(self):
        """Test multiple alarm actions for different security levels."""
        event_def = EventDefinition.objects.create(
            name='Multi-Level Alarm Event',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Create alarm actions for different security levels
        _ = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='HIGH',
            alarm_level_str='CRITICAL',
            alarm_lifetime_secs=7200
        )
        
        _ = AlarmAction.objects.create(
            event_definition=event_def,
            security_level_str='LOW',
            alarm_level_str='INFO',
            alarm_lifetime_secs=1800
        )
        
        # Should have multiple alarm actions with different configurations
        alarm_actions = event_def.alarm_actions.all()
        self.assertEqual(alarm_actions.count(), 2)
        
        security_levels = [action.security_level for action in alarm_actions]
        self.assertIn(SecurityLevel.HIGH, security_levels)
        self.assertIn(SecurityLevel.LOW, security_levels)
        return


class TestEventHistoryAdvanced(BaseTestCase):
    """Advanced EventHistory tests for performance and data integrity."""

    def test_event_history_bulk_insertion_performance(self):
        """Test bulk creation of event history records for performance."""
        event_def = EventDefinition.objects.create(
            name='High Volume Event',
            event_type_str='INFORMATION',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        from django.utils import timezone
        
        # Create multiple history records
        history_records = []
        base_time = timezone.now()
        
        for i in range(100):
            history_records.append(EventHistory(
                event_definition=event_def,
                event_datetime=base_time - timezone.timedelta(seconds=i)
            ))
        
        # Bulk create should handle large numbers efficiently
        EventHistory.objects.bulk_create(history_records)
        
        # Verify all records were created
        created_count = EventHistory.objects.filter(event_definition=event_def).count()
        self.assertEqual(created_count, 100)
        return

    def test_event_history_datetime_range_queries(self):
        """Test datetime range queries use database indexing efficiently."""
        event_def = EventDefinition.objects.create(
            name='Time Range Event',
            event_type_str='AUTOMATION',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        from django.utils import timezone
        
        # Create history records across different time ranges
        now = timezone.now()
        
        # Recent (last hour)
        recent_history = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=now - timezone.timedelta(minutes=30)
        )
        
        # Old (last week)
        old_history = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=now - timezone.timedelta(days=7)
        )
        
        # Test range queries that should use datetime index
        last_day = EventHistory.objects.filter(
            event_datetime__gte=now - timezone.timedelta(days=1)
        )
        self.assertIn(recent_history, last_day)
        self.assertNotIn(old_history, last_day)
        
        last_week = EventHistory.objects.filter(
            event_datetime__gte=now - timezone.timedelta(days=8)
        )
        self.assertIn(recent_history, last_week)
        self.assertIn(old_history, last_week)
        return

    def test_event_history_ordering_with_identical_timestamps(self):
        """Test ordering behavior with identical event timestamps."""
        event_def = EventDefinition.objects.create(
            name='Simultaneous Events',
            event_type_str='SECURITY',
            event_window_secs=60,
            dedupe_window_secs=300,
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        from django.utils import timezone
        
        # Create multiple events with same timestamp
        same_timestamp = timezone.now()
        
        _ = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=same_timestamp
        )
        _ = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=same_timestamp
        )
        _ = EventHistory.objects.create(
            event_definition=event_def,
            event_datetime=same_timestamp
        )
        
        # Should handle identical timestamps gracefully
        # Ordering should be consistent (by ID when timestamps are equal)
        all_history = list(EventHistory.objects.filter(event_definition=event_def))
        self.assertEqual(len(all_history), 3)
        
        # All should have the same timestamp
        timestamps = [h.event_datetime for h in all_history]
        self.assertTrue(all(t == same_timestamp for t in timestamps))
        return


class TestEventClauseInValueMembers(BaseTestCase):
    """``EventClause.in_value_members()`` is the parse side of the
    IN-operator comma-delimited storage. The matcher and the form
    both rely on it; pinning the contract at the lowest layer keeps
    behavior consistent across both consumers."""

    def _clause(self, value):
        return EventClause( value = value )

    def test_returns_empty_set_for_empty_string(self):
        self.assertEqual( self._clause( '' ).in_value_members(), set() )
        return

    def test_returns_empty_set_for_none_value(self):
        # value is normally a non-null CharField, but defensively the
        # parser tolerates a None — exercised when an EventClause is
        # constructed in memory without a value set yet.
        clause = EventClause()
        clause.value = None
        self.assertEqual( clause.in_value_members(), set() )
        return

    def test_returns_set_of_members(self):
        self.assertEqual(
            self._clause( 'a,b,c' ).in_value_members(),
            { 'a', 'b', 'c' },
        )
        return

    def test_strips_whitespace_around_members(self):
        self.assertEqual(
            self._clause( ' a , b , c ' ).in_value_members(),
            { 'a', 'b', 'c' },
        )
        return

    def test_dedupes_repeated_members(self):
        self.assertEqual(
            self._clause( 'a,a,b' ).in_value_members(),
            { 'a', 'b' },
        )
        return

    def test_drops_empty_members(self):
        for raw in ( ',,', '   ,   ,', 'a,,b' ):
            with self.subTest( raw = raw ):
                self.assertNotIn( '', self._clause( raw ).in_value_members() )
            continue
        return


class TestEventClauseSerializeInMembers(BaseTestCase):
    """``EventClause.serialize_in_members()`` is the inverse of
    :meth:`in_value_members`. It produces a deterministic
    (sorted, deduplicated, whitespace-stripped) storage shape from
    an arbitrary iterable of member strings."""

    def test_empty_iterable_returns_empty_string(self):
        self.assertEqual( EventClause.serialize_in_members( [] ), '' )
        return

    def test_none_returns_empty_string(self):
        self.assertEqual( EventClause.serialize_in_members( None ), '' )
        return

    def test_joins_members_sorted_for_determinism(self):
        self.assertEqual(
            EventClause.serialize_in_members([ 'c', 'a', 'b' ]),
            'a,b,c',
        )
        return

    def test_strips_whitespace_and_dedupes(self):
        self.assertEqual(
            EventClause.serialize_in_members([ ' a ', 'a', 'b ' ]),
            'a,b',
        )
        return

    def test_drops_empty_and_whitespace_only_members(self):
        self.assertEqual(
            EventClause.serialize_in_members([ '', '   ', 'a', None ]),
            'a',
        )
        return

    def test_round_trip_via_in_value_members_is_stable(self):
        # parse → serialize is idempotent: feeding the serialized form
        # back through the parser and re-serializing yields the same
        # string. Documents the contract storage-shape callers depend
        # on.
        original = 'a,b,c'
        clause = EventClause( value = original )
        re_serialized = EventClause.serialize_in_members(
            clause.in_value_members(),
        )
        self.assertEqual( re_serialized, original )
        return