Skip to content

Home Information - Your home, your data, organized.

Python
12.3 KB
Raw Blame
import logging
from unittest.mock import Mock

from hi.apps.monitor.display_data import EntityDisplayData
from hi.apps.monitor.status_data import EntityStateStatusData, EntityStatusData
from hi.apps.entity.models import Entity, EntityState
from hi.apps.sense.transient_models import SensorResponse
from hi.apps.control.transient_models import ControllerData
from hi.apps.common.svg_models import SvgIconItem
from hi.testing.base_test_case import BaseTestCase

logging.disable(logging.CRITICAL)


class TestEntityStateStatusData(BaseTestCase):

    def test_latest_sensor_response_returns_most_recent_from_ordered_list(self):
        """Test latest_sensor_response returns first item from time-ordered list."""
        entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='CAMERA'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        # Create responses ordered by time (newest first as expected)
        newest_response = Mock(spec=SensorResponse)
        newest_response.response_datetime = '2023-01-01T12:00:00Z'
        newest_response.value = 'ON'
        
        older_response = Mock(spec=SensorResponse)
        older_response.response_datetime = '2023-01-01T11:00:00Z'
        older_response.value = 'OFF'
        
        sensor_response_list = [newest_response, older_response]
        
        status_data = EntityStateStatusData(
            entity_state=entity_state,
            sensor_response_list=sensor_response_list,
            controller_data_list=[]
        )
        
        # Should return the first (most recent) response
        latest = status_data.latest_sensor_response
        self.assertEqual(latest.value, 'ON')
        self.assertEqual(latest.response_datetime, '2023-01-01T12:00:00Z')

    def test_latest_sensor_response_handles_empty_list_gracefully(self):
        """Test latest_sensor_response returns None for empty sensor list."""
        entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='CAMERA'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        status_data = EntityStateStatusData(
            entity_state=entity_state,
            sensor_response_list=[],
            controller_data_list=[]
        )
        
        self.assertIsNone(status_data.latest_sensor_response)

    def test_entity_state_status_data_provides_access_to_related_controllers(self):
        """Test controller data access for entity state control operations."""
        entity = Entity.objects.create(
            name='Controllable Entity',
            entity_type_str='LIGHT'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        # Mock controller data
        controller_data1 = Mock(spec=ControllerData)
        controller_data1.controller = Mock()
        controller_data1.controller.name = 'Power Switch'
        controller_data2 = Mock(spec=ControllerData)
        controller_data2.controller = Mock()
        controller_data2.controller.name = 'Dimmer'
        
        status_data = EntityStateStatusData(
            entity_state=entity_state,
            sensor_response_list=[],
            controller_data_list=[controller_data1, controller_data2]
        )
        
        # Should provide access to all available controllers
        self.assertEqual(len(status_data.controller_data_list), 2)
        self.assertIn(controller_data1, status_data.controller_data_list)
        self.assertIn(controller_data2, status_data.controller_data_list)

    def test_entity_state_status_data_handles_mixed_sensor_and_controller_data(self):
        """Test status data with both sensor responses and controller data."""
        entity = Entity.objects.create(
            name='Smart Switch',
            entity_type_str='SWITCH'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        sensor_response = Mock(spec=SensorResponse)
        sensor_response.value = 'ON'
        
        controller_data = Mock(spec=ControllerData)
        controller_data.controller = Mock()
        controller_data.controller.name = 'Toggle'
        
        status_data = EntityStateStatusData(
            entity_state=entity_state,
            sensor_response_list=[sensor_response],
            controller_data_list=[controller_data]
        )
        
        # Should maintain both sensor and controller data
        self.assertEqual(status_data.latest_sensor_response.value, 'ON')
        self.assertEqual(len(status_data.controller_data_list), 1)
        self.assertEqual(status_data.controller_data_list[0].controller.name, 'Toggle')


class TestEntityStatusData(BaseTestCase):

    def test_display_data_exposes_per_state_projections(self):
        """``EntityDisplayData`` wraps the raw status data with a
        display-ordered per-state list and a role-keyed map; both are
        the entry points templates use to find state-specific data."""
        entity = Entity.objects.create(
            name='Display Entity',
            entity_type_str='CAMERA',
        )
        state_1 = EntityState.objects.create(
            entity=entity, name='State 1',
            entity_state_type_str='ON_OFF',
        )
        state_2 = EntityState.objects.create(
            entity=entity, name='State 2',
            entity_state_type_str='MOVEMENT',
        )
        status_data = EntityStatusData(
            entity=entity,
            entity_state_status_data_list=[
                EntityStateStatusData(
                    entity_state=state_1,
                    sensor_response_list=[], controller_data_list=[],
                ),
                EntityStateStatusData(
                    entity_state=state_2,
                    sensor_response_list=[], controller_data_list=[],
                ),
            ],
        )
        display_data = EntityDisplayData(entity_status_data=status_data)
        self.assertEqual(display_data.entity, entity)
        self.assertEqual(len(display_data.state_status_data_list), 2)
        self.assertEqual(set(display_data.state_status_data_by_role.keys()),
                         {'on_off', 'movement'})

    def test_entity_status_data_supports_optional_display_icon(self):
        """Test entity status data with optional SVG icon for display."""
        entity = Entity.objects.create(
            name='Icon Entity',
            entity_type_str='CAMERA'
        )
        
        svg_icon = Mock(spec=SvgIconItem)
        svg_icon.icon_name = 'camera-icon'
        
        status_data = EntityStatusData(
            entity=entity,
            entity_state_status_data_list=[],
            display_only_svg_icon_item=svg_icon
        )
        
        # Should store and provide access to display icon
        self.assertEqual(status_data.display_only_svg_icon_item.icon_name, 'camera-icon')

    def test_entity_status_data_handles_entity_without_states(self):
        """Test entity status data for entities with no configured states."""
        entity = Entity.objects.create(
            name='Simple Entity',
            entity_type_str='DISPLAY_ONLY'
        )
        
        status_data = EntityStatusData(
            entity=entity,
            entity_state_status_data_list=[]
        )
        
        # Should handle entities with no states gracefully
        self.assertEqual(status_data.entity, entity)
        self.assertEqual(len(status_data.entity_state_status_data_list), 0)
        self.assertIsNone(status_data.display_only_svg_icon_item)
        
        # Display wrapper still exposes the entity and an empty state list.
        display_data = EntityDisplayData(entity_status_data=status_data)
        self.assertEqual(display_data.entity, entity)
        self.assertEqual(len(display_data.state_status_data_list), 0)

    def test_entity_status_data_aggregates_multiple_state_types(self):
        """Test entity status data aggregation across different state types."""
        entity = Entity.objects.create(
            name='Multi-Function Device',
            entity_type_str='CAMERA'
        )
        
        # Mock different types of entity state status data
        power_status = Mock(spec=EntityStateStatusData)
        power_status.entity_state = Mock()
        power_status.entity_state.entity_state_type_str = 'ON_OFF'
        power_status.latest_sensor_response = Mock()
        power_status.latest_sensor_response.value = 'ON'
        
        motion_status = Mock(spec=EntityStateStatusData)
        motion_status.entity_state = Mock()
        motion_status.entity_state.entity_state_type_str = 'MOTION'
        motion_status.latest_sensor_response = Mock()
        motion_status.latest_sensor_response.value = 'DETECTED'
        
        recording_status = Mock(spec=EntityStateStatusData)
        recording_status.entity_state = Mock()
        recording_status.entity_state.entity_state_type_str = 'RECORDING'
        recording_status.latest_sensor_response = Mock()
        recording_status.latest_sensor_response.value = 'ACTIVE'
        
        status_data = EntityStatusData(
            entity=entity,
            entity_state_status_data_list=[power_status, motion_status, recording_status]
        )
        
        # Should aggregate all state types for comprehensive entity status
        self.assertEqual(len(status_data.entity_state_status_data_list), 3)
        
        state_types = [
            state.entity_state.entity_state_type_str 
            for state in status_data.entity_state_status_data_list
        ]
        self.assertIn('ON_OFF', state_types)
        self.assertIn('MOTION', state_types)
        self.assertIn('RECORDING', state_types)


class TestStateStatusDataByRole(BaseTestCase):
    """``EntityDisplayData.state_status_data_by_role`` indexes the
    state-status entries by the lowercase EntityStateRole name so
    panel templates can pull a specific state by semantic role."""

    def test_keys_are_lowercase_role_names(self):
        from hi.apps.entity.enums import EntityStateRole, EntityType
        from hi.apps.entity.models import EntityState

        entity = Entity.objects.create(
            name='Smoke Test',
            entity_type_str=str(EntityType.SMOKE_DETECTOR),
        )
        smoke_state = EntityState.objects.create(
            entity=entity, name='Smoke',
            entity_state_type_str='SMOKE',
            role_str=str(EntityStateRole.SMOKE),
        )
        battery_state = EntityState.objects.create(
            entity=entity, name='Battery',
            entity_state_type_str='BATTERY_LEVEL',
            role_str=str(EntityStateRole.BATTERY_LEVEL),
        )

        status_data = EntityStatusData(
            entity=entity,
            entity_state_status_data_list=[
                EntityStateStatusData(
                    entity_state=smoke_state,
                    sensor_response_list=[], controller_data_list=[],
                ),
                EntityStateStatusData(
                    entity_state=battery_state,
                    sensor_response_list=[], controller_data_list=[],
                ),
            ],
        )
        display_data = EntityDisplayData(entity_status_data=status_data)

        by_role = display_data.state_status_data_by_role
        self.assertIn('smoke', by_role)
        self.assertIn('battery_level', by_role)
        self.assertEqual(by_role['smoke'].entity_state, smoke_state)
        self.assertEqual(by_role['battery_level'].entity_state, battery_state)

    def test_empty_when_no_states(self):
        entity = Entity.objects.create(
            name='Empty', entity_type_str='OTHER',
        )
        status_data = EntityStatusData(
            entity=entity, entity_state_status_data_list=[],
        )
        display_data = EntityDisplayData(entity_status_data=status_data)
        self.assertEqual(display_data.state_status_data_by_role, {})

    def test_by_role_map_is_dict(self):
        entity = Entity.objects.create(
            name='Ctx Test', entity_type_str='OTHER',
        )
        status_data = EntityStatusData(
            entity=entity, entity_state_status_data_list=[],
        )
        display_data = EntityDisplayData(entity_status_data=status_data)
        self.assertIsInstance(display_data.state_status_data_by_role, dict)