Skip to content

Home Information - Your home, your data, organized.

Python
10.2 KB
Raw Blame
import json
import logging
from datetime import datetime

from django.db import IntegrityError
from django.utils import timezone

from hi.apps.sense.models import Sensor, SensorHistory
from hi.apps.sense.enums import SensorType
from hi.apps.entity.models import Entity, EntityState
from hi.testing.base_test_case import BaseTestCase

logging.disable(logging.CRITICAL)


class TestSensor(BaseTestCase):

    def test_sensor_sensor_type_property_conversion(self):
        """Test sensor_type property enum conversion - custom business logic."""
        entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='CAMERA'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        sensor = Sensor.objects.create(
            name='Test Sensor',
            entity_state=entity_state,
            sensor_type_str='DEFAULT',
            integration_id='test_id',
            integration_name='test_integration'
        )
        
        # Test getter converts string to enum
        self.assertEqual(sensor.sensor_type, SensorType.DEFAULT)
        
        # Test setter converts enum to string
        sensor.sensor_type = SensorType.DEFAULT
        self.assertEqual(sensor.sensor_type_str, 'default')

    def test_sensor_integration_key_inheritance(self):
        """Test Sensor integration key inheritance - critical for integration system."""
        entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='CAMERA'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        sensor = Sensor.objects.create(
            name='Test Sensor',
            entity_state=entity_state,
            sensor_type_str='DEFAULT',
            integration_id='sensor_123',
            integration_name='test_integration'
        )
        
        # Should inherit integration key fields from IntegrationDetailsModel
        self.assertEqual(sensor.integration_id, 'sensor_123')
        self.assertEqual(sensor.integration_name, 'test_integration')

    def test_sensor_unique_constraint_enforced(self):
        """Test integration key uniqueness constraint - critical for data integrity."""
        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 first sensor
        Sensor.objects.create(
            name='First Sensor',
            entity_state=entity_state,
            sensor_type_str='DEFAULT',
            integration_id='duplicate_id',
            integration_name='test_integration'
        )
        
        # Attempt to create second sensor with same integration key should fail
        with self.assertRaises(IntegrityError):
            Sensor.objects.create(
                name='Second Sensor',
                entity_state=entity_state,
                sensor_type_str='DEFAULT',
                integration_id='duplicate_id',
                integration_name='test_integration'
            )

    def test_sensor_str_representation_includes_key_fields(self):
        """Test string representation includes essential identification fields."""
        entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='LIGHT'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        sensor = Sensor.objects.create(
            name='Test Sensor',
            entity_state=entity_state,
            sensor_type_str='DEFAULT',
            integration_id='sensor_123',
            integration_name='test_integration'
        )
        
        str_repr = str(sensor)
        self.assertIn('Test Sensor', str_repr)
        self.assertIn('sensor_123', str_repr)
        self.assertIn(str(sensor.id), str_repr)

    def test_sensor_css_class_property_generation(self):
        """Test CSS class property generates correctly for UI integration."""
        entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='LIGHT'
        )
        entity_state = EntityState.objects.create(
            entity=entity,
            entity_state_type_str='ON_OFF'
        )
        
        sensor = Sensor.objects.create(
            name='Test Sensor',
            entity_state=entity_state,
            sensor_type_str='DEFAULT',
            integration_id='sensor_123',
            integration_name='test_integration'
        )
        
        expected_css_class = f'hi-sensor-{sensor.id}'
        self.assertEqual(sensor.css_class, expected_css_class)


class TestSensorHistory(BaseTestCase):
    """SensorHistory model: default ordering, JSON details parsing,
    index-backed query correctness, and related-name access."""

    def setUp(self):
        self.entity = Entity.objects.create(
            name='Test Entity',
            entity_type_str='LIGHT'
        )
        self.entity_state = EntityState.objects.create(
            entity=self.entity,
            entity_state_type_str='ON_OFF'
        )
        self.sensor = Sensor.objects.create(
            name='Test Sensor',
            entity_state=self.entity_state,
            sensor_type_str='DEFAULT',
            integration_id='sensor_123',
            integration_name='test_integration'
        )

    def test_sensor_history_ordering_by_timestamp(self):
        """Test default ordering by response_datetime descending."""
        from django.utils import timezone
        # Create history records with different timestamps
        history1 = SensorHistory.objects.create(
            sensor=self.sensor,
            value='value1',
            response_datetime=timezone.make_aware(datetime(2023, 1, 1, 12, 0, 0))
        )
        history2 = SensorHistory.objects.create(
            sensor=self.sensor,
            value='value2',
            response_datetime=timezone.make_aware(datetime(2023, 1, 1, 13, 0, 0))
        )
        history3 = SensorHistory.objects.create(
            sensor=self.sensor,
            value='value3',
            response_datetime=timezone.make_aware(datetime(2023, 1, 1, 11, 0, 0))
        )
        
        # Query should return in descending timestamp order
        history_list = list(SensorHistory.objects.filter(sensor=self.sensor))
        
        self.assertEqual(history_list[0], history2)  # Most recent
        self.assertEqual(history_list[1], history1)
        self.assertEqual(history_list[2], history3)  # Oldest

    def test_sensor_history_detail_attrs_property_json_parsing(self):
        """Test detail_attrs property correctly parses JSON details field."""
        test_details = {'key1': 'value1', 'key2': 'value2'}
        
        history = SensorHistory.objects.create(
            sensor=self.sensor,
            value='test_value',
            response_datetime=timezone.now(),
            details=json.dumps(test_details)
        )
        
        self.assertEqual(history.detail_attrs, test_details)

    def test_sensor_history_detail_attrs_property_handles_empty_details(self):
        """Test detail_attrs property returns empty dict for null/empty details."""
        history = SensorHistory.objects.create(
            sensor=self.sensor,
            value='test_value',
            response_datetime=timezone.now(),
            details=None
        )
        
        self.assertEqual(history.detail_attrs, {})

    def test_sensor_history_database_indexes_exist(self):
        """Test database indexes are properly configured for query performance."""
        from django.utils import timezone
        # Create multiple history records to test index usage
        for i in range(59):  # Keep within valid minute range
            SensorHistory.objects.create(
                sensor=self.sensor,
                value=f'value_{i}',
                response_datetime=timezone.make_aware(datetime(2023, 1, 1, 12, i, 0))
            )
        
        # Test that queries use indexes efficiently
        from django.db import connection
        
        with connection.cursor() as cursor:
            # Query that should use sensor + timestamp index
            cursor.execute("""
                SELECT COUNT(*) FROM sense_sensorhistory 
                WHERE sensor_id = %s AND response_datetime > %s
            """, [self.sensor.id, timezone.make_aware(datetime(2023, 1, 1, 12, 50, 0))])
            
            result = cursor.fetchone()
            self.assertEqual(result[0], 8)  # Should find records efficiently (range 50-58 = 8 records)

    def test_sensor_history_value_field_max_length(self):
        """Test value field respects maximum length constraint."""
        long_value = 'x' * 300  # Exceeds 255 character limit
        
        history = SensorHistory.objects.create(
            sensor=self.sensor,
            value=long_value,
            response_datetime=timezone.now()
        )
        
        # Django/SQLite may store full value but CharField has max_length=255
        # Test that the model field constraint is defined correctly
        field_max_length = SensorHistory._meta.get_field('value').max_length
        self.assertEqual(field_max_length, 255)
        
        # For actual truncation behavior, check if database enforces it
        saved_history = SensorHistory.objects.get(id=history.id)
        # SQLite may not enforce CharField length, so we test the model constraint exists
        self.assertIsNotNone(saved_history.value)

    def test_sensor_history_related_name_access(self):
        """Test related name allows access from sensor to history."""
        history1 = SensorHistory.objects.create(
            sensor=self.sensor,
            value='value1',
            response_datetime=timezone.now()
        )
        history2 = SensorHistory.objects.create(
            sensor=self.sensor,
            value='value2',
            response_datetime=timezone.now()
        )
        
        # Access history through sensor's related name
        sensor_history = self.sensor.history.all()
        self.assertEqual(len(sensor_history), 2)
        self.assertIn(history1, sensor_history)
        self.assertIn(history2, sensor_history)