Home Information - Your home, your data, organized.
Python
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)