Skip to content

Home Information - Your home, your data, organized.

Python
16.6 KB
Raw Blame
import logging
from datetime import datetime
from unittest.mock import Mock

from django.test import TestCase
from django.utils import timezone

from hi.apps.console.transient_models import EntitySensorHistoryData
from hi.apps.sense.transient_models import SensorResponse
from hi.integrations.transient_models import IntegrationKey

logging.disable(logging.CRITICAL)


class TestEntitySensorHistoryData(TestCase):
    """Test EntitySensorHistoryData dataclass functionality."""

    def setUp(self):
        # Create mock sensor responses for testing
        self.mock_sensor = Mock()
        self.mock_sensor.id = 123
        
        # Create sample sensor responses
        base_time = timezone.now()
        self.sensor_responses = []
        
        for i in range(3):
            integration_key = IntegrationKey(
                integration_id='test_integration',
                integration_name=f'test_response_{i}'
            )
            
            response = SensorResponse(
                integration_key=integration_key,
                value=f'value_{i}',
                timestamp=base_time - timezone.timedelta(hours=i),
                sensor=self.mock_sensor,
                detail_attrs={
                    'duration_seconds': str(60 + i * 30)
                },
                has_event_video_clip=True,
                sensor_history_id=1000 + i  # Set as direct property
            )
            self.sensor_responses.append(response)
        
        # Create sample timeline groups
        self.timeline_groups = [
            {
                'label': 'Today',
                'date': base_time.date(),
                'items': self.sensor_responses[:2]
            },
            {
                'label': 'Yesterday',
                'date': (base_time - timezone.timedelta(days=1)).date(),
                'items': self.sensor_responses[2:]
            }
        ]
        
        # Sample pagination metadata
        self.pagination_metadata = {
            'has_older_records': True,
            'has_newer_records': False,
            'window_center_timestamp': base_time,
            'window_size': 50,
            'window_start_timestamp': base_time - timezone.timedelta(hours=2),
            'window_end_timestamp': base_time
        }

    def test_dataclass_timeline_group_navigation_logic(self):
        """Test business logic for timeline navigation in template rendering."""
        # Create timeline groups with different date patterns
        base_time = timezone.now()
        today_responses = self.sensor_responses[:2]
        yesterday_responses = self.sensor_responses[2:]
        
        timeline_groups = [
            {
                'label': 'Today',
                'date': base_time.date(),
                'items': today_responses
            },
            {
                'label': 'Yesterday', 
                'date': (base_time - timezone.timedelta(days=1)).date(),
                'items': yesterday_responses
            }
        ]
        
        data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses,
            current_sensor_response=self.sensor_responses[0],
            timeline_groups=timeline_groups,
            pagination_metadata=self.pagination_metadata,
            prev_sensor_response=self.sensor_responses[1],
            next_sensor_response=None
        )
        
        # Test business logic for timeline navigation
        # Verify navigation relationships work correctly
        current_response = data.current_sensor_response
        prev_response = data.prev_sensor_response
        
        # Current should be newer than previous (business rule)
        self.assertGreater(current_response.timestamp, prev_response.timestamp)
        
        # Test timeline group structure for template rendering
        self.assertEqual(len(data.timeline_groups), 2)
        
        # Verify today's group comes first (chronological ordering)
        today_group = data.timeline_groups[0]
        yesterday_group = data.timeline_groups[1]
        
        self.assertEqual(today_group['label'], 'Today')
        self.assertEqual(len(today_group['items']), 2)
        self.assertEqual(yesterday_group['label'], 'Yesterday')
        self.assertEqual(len(yesterday_group['items']), 1)
        
        # Test that items within groups maintain chronological order
        today_items = today_group['items']
        if len(today_items) > 1:
            self.assertGreaterEqual(today_items[0].timestamp, today_items[1].timestamp)

    def test_dataclass_handles_empty_and_edge_case_states(self):
        """Test dataclass behavior in edge cases and empty states."""
        # Test empty timeline state (no sensor history available)
        empty_data = EntitySensorHistoryData(
            sensor_responses=[],
            current_sensor_response=None,
            timeline_groups=[],
            pagination_metadata={'has_older_records': False, 'has_newer_records': False},
            prev_sensor_response=None,
            next_sensor_response=None
        )
        
        # Template should handle empty state gracefully
        self.assertEqual(len(empty_data.sensor_responses), 0)
        self.assertEqual(len(empty_data.timeline_groups), 0)
        self.assertIsNone(empty_data.current_sensor_response)
        
        # Test single record state (common for new sensors)
        single_record_data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses[:1],
            current_sensor_response=self.sensor_responses[0],
            timeline_groups=[{
                'label': 'Today',
                'date': timezone.now().date(),
                'items': self.sensor_responses[:1]
            }],
            pagination_metadata={'has_older_records': False, 'has_newer_records': False},
            prev_sensor_response=None,
            next_sensor_response=None
        )
        
        # Verify single record navigation logic
        self.assertEqual(len(single_record_data.sensor_responses), 1)
        self.assertIsNotNone(single_record_data.current_sensor_response)
        self.assertIsNone(single_record_data.prev_sensor_response)
        self.assertIsNone(single_record_data.next_sensor_response)
        
        # Template pagination buttons should be disabled
        pagination = single_record_data.pagination_metadata
        self.assertFalse(pagination['has_older_records'])
        self.assertFalse(pagination['has_newer_records'])

    def test_dataclass_supports_none_values_for_optional_fields(self):
        """Test that dataclass properly handles None values for optional fields."""
        data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses,
            current_sensor_response=None,  # Can be None if no records
            timeline_groups=[],             # Can be empty
            pagination_metadata=self.pagination_metadata,
            prev_sensor_response=None,
            next_sensor_response=None,
            window_start_timestamp=None,
            window_end_timestamp=None
        )
        
        # Should not raise any errors
        self.assertIsNone(data.current_sensor_response)
        self.assertEqual(data.timeline_groups, [])
        self.assertIsNone(data.prev_sensor_response)
        self.assertIsNone(data.next_sensor_response)
        self.assertIsNone(data.window_start_timestamp)
        self.assertIsNone(data.window_end_timestamp)

    def test_dataclass_fields_are_accessible(self):
        """Test that all dataclass fields are properly accessible."""
        window_start = timezone.now() - timezone.timedelta(hours=1)
        window_end = timezone.now()
        
        data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses,
            current_sensor_response=self.sensor_responses[1],
            timeline_groups=self.timeline_groups,
            pagination_metadata=self.pagination_metadata,
            prev_sensor_response=self.sensor_responses[2],
            next_sensor_response=self.sensor_responses[0],
            window_start_timestamp=window_start,
            window_end_timestamp=window_end
        )
        
        # Test field access
        self.assertIsInstance(data.sensor_responses, list)
        self.assertIsInstance(data.current_sensor_response, SensorResponse)
        self.assertIsInstance(data.timeline_groups, list)
        self.assertIsInstance(data.pagination_metadata, dict)
        self.assertIsInstance(data.prev_sensor_response, SensorResponse)
        self.assertIsInstance(data.next_sensor_response, SensorResponse)
        self.assertIsInstance(data.window_start_timestamp, datetime)
        self.assertIsInstance(data.window_end_timestamp, datetime)

    def test_dataclass_supports_timezone_aware_datetimes(self):
        """Test that dataclass properly handles timezone-aware datetime objects."""
        # Create timezone-aware timestamps
        window_start = timezone.now() - timezone.timedelta(hours=2)
        window_end = timezone.now()
        
        # Ensure they are timezone-aware
        self.assertIsNotNone(window_start.tzinfo)
        self.assertIsNotNone(window_end.tzinfo)
        
        data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses,
            current_sensor_response=self.sensor_responses[0],
            timeline_groups=self.timeline_groups,
            pagination_metadata=self.pagination_metadata,
            prev_sensor_response=None,
            next_sensor_response=None,
            window_start_timestamp=window_start,
            window_end_timestamp=window_end
        )
        
        # Verify timezone information is preserved
        self.assertIsNotNone(data.window_start_timestamp.tzinfo)
        self.assertIsNotNone(data.window_end_timestamp.tzinfo)
        self.assertEqual(data.window_start_timestamp, window_start)
        self.assertEqual(data.window_end_timestamp, window_end)

    def test_dataclass_can_be_used_in_template_context(self):
        """Test that dataclass can be properly used in template context patterns."""
        data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses,
            current_sensor_response=self.sensor_responses[0],
            timeline_groups=self.timeline_groups,
            pagination_metadata=self.pagination_metadata,
            prev_sensor_response=self.sensor_responses[1],
            next_sensor_response=None
        )
        
        # Simulate template context usage patterns
        context = {
            'entity': Mock(),
            'sensor': self.mock_sensor,
            'sensor_history_data': data
        }
        
        # Verify template-style access works
        sensor_history_data = context['sensor_history_data']
        self.assertEqual(sensor_history_data.sensor_responses, self.sensor_responses)
        
        # Test accessing nested data (like templates would)
        if sensor_history_data.current_sensor_response:
            current_value = sensor_history_data.current_sensor_response.value
            self.assertEqual(current_value, 'value_0')
        
        # Test timeline group access
        for group in sensor_history_data.timeline_groups:
            self.assertIn('label', group)
            self.assertIn('items', group)

    def test_dataclass_pagination_state_management(self):
        """Test pagination state preservation across requests."""
        # Test window boundary preservation logic
        window_start = timezone.now() - timezone.timedelta(hours=2)
        window_end = timezone.now() - timezone.timedelta(hours=1)
        
        pagination_metadata = {
            'has_older_records': True,
            'has_newer_records': True,
            'window_start_timestamp': window_start,
            'window_end_timestamp': window_end,
            'window_size': 50
        }
        
        data = EntitySensorHistoryData(
            sensor_responses=self.sensor_responses,
            current_sensor_response=self.sensor_responses[1],  # Middle response
            timeline_groups=self.timeline_groups,
            pagination_metadata=pagination_metadata,
            prev_sensor_response=self.sensor_responses[2],
            next_sensor_response=self.sensor_responses[0],
            window_start_timestamp=window_start,
            window_end_timestamp=window_end
        )
        
        # Test business logic for pagination state
        # Verify window boundaries are preserved for timeline navigation
        self.assertEqual(data.window_start_timestamp, window_start)
        self.assertEqual(data.window_end_timestamp, window_end)
        
        # Test pagination metadata accuracy for UI state management
        self.assertTrue(data.pagination_metadata['has_older_records'])
        self.assertTrue(data.pagination_metadata['has_newer_records'])
        
        # Verify navigation state consistency
        # Current response should be between prev and next chronologically
        current = data.current_sensor_response.timestamp
        prev = data.prev_sensor_response.timestamp
        next_time = data.next_sensor_response.timestamp
        
        self.assertLess(prev, current)  # Previous is older
        self.assertGreater(next_time, current)  # Next is newer
        
        # Test window boundary business rules
        # All sensor responses should be within or span the window boundaries
        for response in data.sensor_responses:
            # Responses can extend beyond window for context, but check reasonable bounds
            self.assertIsNotNone(response.timestamp)

    def test_dataclass_integration_with_template_context(self):
        """Test dataclass usage in real template rendering scenarios."""
        # Simulate complex template context scenarios
        window_start = timezone.now() - timezone.timedelta(hours=3)
        window_end = timezone.now()
        
        # Create data that represents different video sensor history browsing states
        browsing_states = [
            # State 1: Default view (recent records)
            {
                'current_sensor_response': self.sensor_responses[0],
                'has_older': True,
                'has_newer': False
            },
            # State 2: Historical browsing (middle of timeline)
            {
                'current_sensor_response': self.sensor_responses[1],
                'has_older': True,
                'has_newer': True
            },
            # State 3: Oldest records (end of pagination)
            {
                'current_sensor_response': self.sensor_responses[2],
                'has_older': False,
                'has_newer': True
            }
        ]
        
        for state in browsing_states:
            pagination_metadata = {
                'has_older_records': state['has_older'],
                'has_newer_records': state['has_newer'],
                'window_start_timestamp': window_start,
                'window_end_timestamp': window_end
            }
            
            data = EntitySensorHistoryData(
                sensor_responses=self.sensor_responses,
                current_sensor_response=state['current_sensor_response'],
                timeline_groups=self.timeline_groups,
                pagination_metadata=pagination_metadata,
                prev_sensor_response=None,
                next_sensor_response=None
            )
            
            # Test template context usage patterns
            template_context = {
                'entity': Mock(),
                'sensor': self.mock_sensor,
                'sensor_history_data': data
            }
            
            # Verify data accessibility patterns used in templates
            history_data = template_context['sensor_history_data']
            
            # Test accessing sensor_history_id for navigation URLs (critical for templates)
            if history_data.current_sensor_response:
                history_id = history_data.current_sensor_response.sensor_history_id
                self.assertIsNotNone(history_id)
            
            # Test pagination button logic (template conditional rendering)
            can_go_earlier = history_data.pagination_metadata.get('has_older_records', False)
            can_go_later = history_data.pagination_metadata.get('has_newer_records', False)
            
            self.assertEqual(can_go_earlier, state['has_older'])
            self.assertEqual(can_go_later, state['has_newer'])
            
            # Test timeline iteration patterns (template for loops)
            for group in history_data.timeline_groups:
                self.assertIn('label', group)  # Template displays group labels
                self.assertIn('items', group)  # Template iterates over items
                for item in group['items']:
                    # Template accesses sensor history ID for URLs
                    self.assertIsNotNone(item.sensor_history_id)