Home Information - Your home, your data, organized.
Python
import logging
from unittest.mock import Mock, patch
from django.core.files.uploadedfile import SimpleUploadedFile
from django.db import transaction
from django.urls import reverse
from hi.apps.attribute.enums import AttributeValueType
from hi.apps.entity.enums import EntityType, EntityStateType
from hi.apps.entity.models import Entity, EntityAttribute
from hi.apps.location.models import Location, LocationView
from hi.apps.location.enums import LocationViewType
from hi.enums import ViewType
from hi.testing.view_test_base import SyncViewTestCase, DualModeViewTestCase
from .synthetic_data import EntityAttributeSyntheticData
logging.disable(logging.CRITICAL)
class TestEntityEditView(DualModeViewTestCase):
"""Enhanced tests for EntityEditView - comprehensive modal editing functionality.
Tests cover the full entity attribute editing system including:
- End-to-end form submission flows
- File upload with DOM fragment updates
- Entity type transition scenarios
- Form validation error handling
- HTMX response format validation
"""
def setUp(self):
super().setUp()
self.enterContext(self.in_memory_media_storage())
# Create test data using synthetic data helper
self.entity = EntityAttributeSyntheticData.create_test_entity(
name='Test Edit Entity',
entity_type_str=str(EntityType.LIGHT)
)
self.text_attr = EntityAttributeSyntheticData.create_test_text_attribute(
entity=self.entity,
name='brightness',
value='100'
)
self.file_attr = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='manual'
)
def test_get_modal_displays_entity_edit_form(self):
"""Test that GET request displays entity edit modal with forms."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertSuccessResponse(response)
self.assertHtmlResponse(response)
self.assertTemplateRendered(response, 'entity/modals/entity_edit.html')
# Verify context contains required forms and data
self.assertEqual(response.context['entity'], self.entity)
self.assertIn('entity_form', response.context)
self.assertIn('regular_attributes_formset', response.context)
self.assertIn('file_attributes', response.context)
def test_get_modal_ajax_request(self):
"""Test that AJAX GET request returns JSON modal response."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
response = self.async_get(url)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
self.assertTemplateRendered(response, 'entity/modals/entity_edit.html')
# HiModalView returns JSON with modal content for AJAX requests
data = response.json()
self.assertIn('modal', data)
def test_post_valid_entity_form_submission(self):
"""Test successful entity form submission with valid data."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
# Create form data for entity and attributes
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity,
name='Updated Entity Name',
entity_type_str=str(EntityType.WALL_SWITCH)
)
# Add formset data for existing attributes
attributes = list(self.entity.attributes.all())
formset_data = EntityAttributeSyntheticData.create_formset_data_for_attributes(
attributes, self.entity
)
form_data.update(formset_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
# Verify entity was updated
self.entity.refresh_from_db()
self.assertEqual(self.entity.name, 'Updated Entity Name')
self.assertEqual(self.entity.entity_type_str, str(EntityType.WALL_SWITCH))
def test_post_entity_type_change_returns_refresh_response(self):
"""Test EntityType changes return refresh response so location icons update."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity,
entity_type_str=str(EntityType.CAMERA),
)
attributes = list(self.entity.attributes.all())
formset_data = EntityAttributeSyntheticData.create_formset_data_for_attributes(
attributes, self.entity
)
form_data.update(formset_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
data = response.json()
self.assertIn('refresh', data)
self.assertTrue(data['refresh'])
def test_post_attribute_value_updates(self):
"""Test updating attribute values through formset."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Update attribute values in formset
attributes = list(self.entity.attributes.all())
formset_data = EntityAttributeSyntheticData.create_formset_data_for_attributes(
attributes, self.entity
)
# Modify attribute values
prefix = f'entity-{self.entity.id}'
for i, attr in enumerate(attributes):
if attr == self.text_attr:
formset_data[f'{prefix}-{i}-value'] = 'Updated brightness value'
form_data.update(formset_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
# Verify attribute was updated
self.text_attr.refresh_from_db()
self.assertEqual(self.text_attr.value, 'Updated brightness value')
def test_post_file_title_updates(self):
"""Test updating file attribute titles."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Add file title update data
file_attrs = [self.file_attr]
file_title_data = EntityAttributeSyntheticData.create_file_title_update_data(
entity=self.entity,
file_attributes=file_attrs
)
form_data.update(file_title_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
# Verify file title was updated
self.file_attr.refresh_from_db()
self.assertEqual(self.file_attr.value, 'Updated manual')
def test_post_file_deletions(self):
"""Test deleting file attributes."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Add file deletion data
file_deletion_data = EntityAttributeSyntheticData.create_file_deletion_data(
[self.file_attr]
)
form_data.update(file_deletion_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
# Verify file is hidden from active querysets
self.assertFalse(
EntityAttribute.objects.filter(id=self.file_attr.id).exists()
)
# Verify file attribute is soft-deleted and still recoverable
deleted_attr = EntityAttribute.all_objects.get(id=self.file_attr.id)
self.assertTrue(deleted_attr.is_deleted)
def test_restore_deleted_attribute_inline(self):
"""Test restoring a deleted attribute through inline restore endpoint."""
self.file_attr.delete()
self.assertFalse(EntityAttribute.objects.filter(id=self.file_attr.id).exists())
restore_url = reverse(
'entity_attribute_restore_deleted_inline',
kwargs={'entity_id': self.entity.id, 'attribute_id': self.file_attr.id},
)
response = self.client.get(restore_url)
self.assertSuccessResponse(response)
restored = EntityAttribute.objects.get(id=self.file_attr.id)
self.assertFalse(restored.is_deleted)
def test_post_invalid_form_returns_errors(self):
"""Test that invalid form submission returns error response with form errors."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
# Submit invalid form data (empty name)
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity,
name='' # Invalid - name is required
)
response = self.client.post(url, form_data)
# May return 200 with form errors or 400
self.assertIn(response.status_code, [200, 400])
# Verify entity was not updated
self.entity.refresh_from_db()
self.assertNotEqual(self.entity.name, '')
def test_post_html_response_format(self):
"""Test that POST responses use correct HTMX/antinode format."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity,
name='Test HTMX Response'
)
attributes = list(self.entity.attributes.all())
formset_data = EntityAttributeSyntheticData.create_formset_data_for_attributes(
attributes, self.entity
)
form_data.update(formset_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
self.assertTemplateRendered(response, 'attribute/components/file_card.html')
# Check antinode response structure
data = response.json()
self.assertTrue(
any(key in data for key in ['updates', 'message'])
)
def test_post_with_new_attribute_creation(self):
"""Test creating new attributes through the formset."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Create formset data with existing attributes plus new one using correct prefix
existing_attrs = list(self.entity.attributes.all())
prefix = f'entity-{self.entity.id}'
formset_data = {
f'{prefix}-TOTAL_FORMS': str(len(existing_attrs) + 2), # +1 existing +1 new
f'{prefix}-INITIAL_FORMS': str(len(existing_attrs)),
f'{prefix}-MIN_NUM_FORMS': '0',
f'{prefix}-MAX_NUM_FORMS': '1000',
}
# Add existing attributes
for i, attr in enumerate(existing_attrs):
formset_data.update({
f'{prefix}-{i}-id': str(attr.id),
f'{prefix}-{i}-name': attr.name,
f'{prefix}-{i}-value': attr.value,
f'{prefix}-{i}-attribute_type_str': attr.attribute_type_str,
})
# Add new attribute
new_idx = len(existing_attrs)
formset_data.update({
f'{prefix}-{new_idx}-name': 'new_property',
f'{prefix}-{new_idx}-value': 'new value',
f'{prefix}-{new_idx}-attribute_type_str': str(AttributeValueType.TEXT),
})
form_data.update(formset_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
# Verify new attribute was created
new_attr = self.entity.attributes.filter(name='new_property').first()
self.assertIsNotNone(new_attr)
self.assertEqual(new_attr.value, 'new value')
def test_get_hides_internal_attribute_section_when_entity_disallows_it(self):
"""When the entity has ``allow_internal_attributes`` False
(e.g., an integration-managed entity whose attribute data is
owned externally), the entire HI internal attribute section is
suppressed: Add File / Add Info buttons, the Files grid, the
Properties list, and the Deleted attributes list are all
omitted from the rendered surface.
"""
self.entity.allow_internal_attributes = False
self.entity.save(update_fields=['allow_internal_attributes'])
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
self.assertNotIn(f'attr-v2-add-attribute-btn-entity-{self.entity.id}', content)
self.assertNotIn('>Add File<', content)
self.assertNotIn('>Add Info<', content)
def test_entity_with_complex_attribute_mix(self):
"""Test editing entity with mixed attribute types (text, file, secret)."""
# Create entity with mixed attributes
complex_entity = EntityAttributeSyntheticData.create_entity_with_mixed_attributes(
name='Complex Test Entity'
)
url = reverse('entity_edit', kwargs={'entity_id': complex_entity.id})
# Test GET request
response = self.client.get(url)
self.assertSuccessResponse(response)
# Verify all attribute types are represented in context
file_attrs = response.context['file_attributes']
self.assertTrue(len(file_attrs) > 0)
# Test POST with updates to mixed attributes
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=complex_entity,
name='Updated Complex Entity'
)
attributes = list(complex_entity.attributes.exclude(value_type_str=str(AttributeValueType.FILE)))
formset_data = EntityAttributeSyntheticData.create_formset_data_for_attributes(
attributes, self.entity
)
form_data.update(formset_data)
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
# Verify entity was updated
complex_entity.refresh_from_db()
self.assertEqual(complex_entity.name, 'Updated Complex Entity')
def test_nonexistent_entity_returns_404(self):
"""Test that accessing nonexistent entity returns 404."""
url = reverse('entity_edit', kwargs={'entity_id': 99999})
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
response = self.client.post(url, {})
self.assertEqual(response.status_code, 404)
def test_database_transaction_handling(self):
"""Test that form submissions use proper database transactions."""
url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity,
name='Transaction Test Name'
)
attributes = list(self.entity.attributes.all())
formset_data = EntityAttributeSyntheticData.create_formset_data_for_attributes(
attributes, self.entity
)
form_data.update(formset_data)
with patch('django.db.transaction.atomic') as mock_atomic:
mock_atomic.return_value = transaction.atomic()
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
# Verify transaction.atomic was called
self.assertGreaterEqual(mock_atomic.call_count, 1)
# Verify update succeeded
self.entity.refresh_from_db()
self.assertEqual(self.entity.name, 'Transaction Test Name')
class TestEntityEditViewExternalViewData(DualModeViewTestCase):
"""Tests for the external-data view dispatch in
``EntityEditView.get()``. The external-data region renders only
when the entity's integration gateway returns a non-None
``ExternalViewData`` payload; everything else (native entities,
unknown integration_id, gateway returns None) suppresses it."""
def setUp(self):
super().setUp()
self.enterContext(self.in_memory_media_storage())
self.native_entity = EntityAttributeSyntheticData.create_test_entity(
name='Native Entity',
integration_id=None,
integration_name=None,
)
self.integration_entity = EntityAttributeSyntheticData.create_test_entity(
name='Integration Entity',
integration_id='ext_view_test',
integration_name='ext_view_test_name',
)
def _make_structured_view_data(self):
from hi.integrations.connector.external_view_data import (
NameValuePair, AttachmentRef, StructuredViewData,
)
return StructuredViewData(
deep_link_url='https://upstream.example/items/42',
attributes=[
NameValuePair(name='Manufacturer', value='Acme'),
NameValuePair(name='Model', value='WidgetPro'),
],
attachments=[
AttachmentRef(
id='att1',
title='Receipt',
mime_type='image/png',
thumbnail_url='https://upstream.example/thumb/att1',
open_url='https://upstream.example/open/att1',
),
],
)
def _make_minimal_view_data(self):
from hi.integrations.connector.external_view_data import MinimalViewData
return MinimalViewData(deep_link_url='https://upstream.example/items/99')
def test_native_entity_omits_section_and_skips_lookup(self):
"""A native entity (no integration_id) must NOT cause an
integration-gateway lookup and must render without the
external-view-data DOM marker."""
url = reverse('entity_edit', kwargs={'entity_id': self.native_entity.id})
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway'
) as mock_lookup:
response = self.client.get(url)
self.assertSuccessResponse(response)
self.assertIsNone(response.context['external_view_data'])
mock_lookup.assert_not_called()
self.assertNotIn('hi-attr-tab2-', response.content.decode('utf-8'))
def test_integration_entity_hook_returns_none_omits_section(self):
"""Integration entity whose gateway hook returns None: the
lookup happens but the section is suppressed."""
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = None
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
) as mock_lookup:
response = self.client.get(url)
self.assertSuccessResponse(response)
self.assertIsNone(response.context['external_view_data'])
mock_lookup.assert_called_with('ext_view_test')
# Confirm the gateway hook was invoked at least once with the
# right entity. EntityEditView.get() can be re-entered during
# render (e.g., when the status modal falls back to the edit
# view for an entity with no state data), so we don't pin the
# exact call count.
mock_gateway.get_connector.return_value.get_external_view_data.assert_called_with(self.integration_entity)
self.assertNotIn('hi-attr-tab2-', response.content.decode('utf-8'))
def test_integration_entity_structured_view_data_renders_section(self):
"""``StructuredViewData`` renders the structured partial with
attribute rows, attachments, and the deep link."""
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
structured = self._make_structured_view_data()
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = structured
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
):
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
self.assertIn('hi-attr-tab2-', content)
self.assertIn('attr-v2-external-structured', content)
self.assertIn('Manufacturer', content)
self.assertIn('Acme', content)
self.assertIn('WidgetPro', content)
self.assertIn('https://upstream.example/thumb/att1', content)
self.assertIn('https://upstream.example/items/42', content)
def test_integration_entity_minimal_view_data_renders_deep_link_only(self):
"""``MinimalViewData`` with only a deep link has no in-tab
content (its ``has_content`` returns False), so no External
tab is rendered. The deep link still reaches the operator
via the sticky-panel "Open in [integration]" action button."""
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
minimal = self._make_minimal_view_data()
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = minimal
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
):
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
self.assertNotIn('hi-attr-tab2-', content)
self.assertNotIn('attr-v2-external-minimal', content)
# Deep link surfaces via the additional-actions button.
self.assertIn('https://upstream.example/items/99', content)
def test_integration_entity_minimal_view_data_surfaces_error_message(self):
"""``MinimalViewData.error_message`` renders in the modal so
the operator sees the failure reason inline rather than only
in server logs."""
from hi.integrations.connector.external_view_data import MinimalViewData
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
minimal = MinimalViewData(
deep_link_url='https://upstream.example/items/99',
error_message='HomeBox upstream unavailable: Connection refused',
)
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = minimal
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
):
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
self.assertIn('attr-ext-minimal-error', content)
self.assertIn('HomeBox upstream unavailable: Connection refused', content)
# Deep link is still offered alongside the error.
self.assertIn('https://upstream.example/items/99', content)
def test_external_view_data_and_internal_attributes_coexist(self):
"""The external-data view and the internal attribute list are
independently gated: an integration entity with both internal
attributes AND an external view payload renders both."""
EntityAttributeSyntheticData.create_test_text_attribute(
entity=self.integration_entity,
name='internal_prop',
value='internal value',
)
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
structured = self._make_structured_view_data()
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = structured
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
):
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
# External-data view marker.
self.assertIn('attr-v2-external-structured', content)
# Internal attribute list marker: the internal attribute name
# appears in the rendered attribute list.
self.assertIn('internal_prop', content)
def test_connect_mode_renders_external_view_with_internal_attributes_suppressed(self):
"""``allow_internal_attributes=False`` plus a populated
``external_view_data`` payload: external-data view renders;
internal attribute list does not."""
self.integration_entity.allow_internal_attributes = False
self.integration_entity.save(update_fields=['allow_internal_attributes'])
EntityAttributeSyntheticData.create_test_text_attribute(
entity=self.integration_entity,
name='orphan_internal_prop',
value='should not render',
)
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
structured = self._make_structured_view_data()
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = structured
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
):
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
self.assertIn('hi-attr-tab2-', content)
self.assertIn('attr-v2-external-structured', content)
self.assertNotIn('orphan_internal_prop', content)
self.assertNotIn('>Add File<', content)
self.assertNotIn('>Add Info<', content)
def test_unknown_integration_id_omits_section(self):
"""If ``IntegrationManager.get_integration_gateway`` raises
``KeyError`` (e.g., the integration_id is stale or the
integration was never registered), the view catches the
exception and suppresses the external-data view — no error
escapes."""
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
side_effect=KeyError('Unknown integration id "ext_view_test".'),
):
response = self.client.get(url)
self.assertSuccessResponse(response)
self.assertIsNone(response.context['external_view_data'])
self.assertNotIn('hi-attr-tab2-', response.content.decode('utf-8'))
def test_custom_template_view_data_uses_instance_template_name(self):
"""``CustomTemplateViewData`` is the escape hatch: the
``template_name`` set on the instance drives the include. We
verify the include call site honors the instance attribute by
pointing at a template that emits a distinctive marker, then
asserting the marker appears in the rendered output."""
from hi.integrations.connector.external_view_data import CustomTemplateViewData
custom = CustomTemplateViewData(
template_name='integrations/external_data/entity/minimal.html',
deep_link_url='https://upstream.example/custom/1',
context={'unused': 'unused'},
)
mock_gateway = Mock()
mock_gateway.get_connector.return_value.get_external_view_data.return_value = custom
url = reverse('entity_edit', kwargs={'entity_id': self.integration_entity.id})
with patch(
'hi.integrations.integration_manager.IntegrationManager.get_integration_gateway',
return_value=mock_gateway,
):
response = self.client.get(url)
self.assertSuccessResponse(response)
content = response.content.decode('utf-8')
# The minimal partial is what we asked for via template_name,
# so its DOM marker must be present even though the instance
# is a CustomTemplateViewData.
self.assertIn('attr-v2-external-minimal', content)
self.assertIn('https://upstream.example/custom/1', content)
class TestEntityPropertiesEditView(SyncViewTestCase):
"""
Tests for EntityPropertiesEditView - handles entity properties (name, type) editing only.
This view is used by the sidebar in edit mode and only accepts POST requests.
"""
def setUp(self):
super().setUp()
# Create test entity
self.entity = Entity.objects.create(
integration_id='test.entity.props',
integration_name='test_integration',
name='Test Properties Entity',
entity_type_str=str(EntityType.LIGHT)
)
def test_post_valid_properties_edit(self):
"""Test successful entity properties edit."""
url = reverse('entity_properties_edit', kwargs={'entity_id': self.entity.id})
form_data = {
'name': 'Updated Properties Name',
'entity_type_str': str(EntityType.WALL_SWITCH),
}
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
# Verify entity was actually updated
self.entity.refresh_from_db()
self.assertEqual(self.entity.name, 'Updated Properties Name')
self.assertEqual(self.entity.entity_type_str, str(EntityType.WALL_SWITCH).lower())
def test_nonexistent_entity_returns_404(self):
"""Test that editing nonexistent entity returns 404."""
url = reverse('entity_properties_edit', kwargs={'entity_id': 99999})
response = self.client.post(url, {'name': 'Test', 'entity_type_str': str(EntityType.LIGHT)})
self.assertEqual(response.status_code, 404)
def test_get_not_allowed(self):
"""Test that GET requests are not allowed (only POST)."""
url = reverse('entity_properties_edit', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
def test_properties_edit_uses_edit_form_pane_not_add_form_pane(self):
"""Regression: the properties edit sidebar must include the
edit-specific form pane, not the bulk-add form pane. The two used
to share a single pane, which caused the add-only 'quantity' field
to render in the sidebar and silently ignore its value on save.
"""
url = reverse('entity_properties_edit', kwargs={'entity_id': self.entity.id})
form_data = {
'name': self.entity.name,
'entity_type_str': self.entity.entity_type_str,
}
response = self.client.post(url, form_data)
self.assertSuccessResponse(response)
self.assertTemplateRendered(response, 'entity/edit/panes/entity_properties_edit.html')
self.assertTemplateRendered(response, 'entity/edit/panes/entity_edit_form.html')
rendered_templates = [t.name for t in response.templates]
self.assertNotIn('entity/edit/panes/entity_add_form.html', rendered_templates)
class TestEntityAttributeUploadView(SyncViewTestCase):
"""
Tests for EntityAttributeUploadView - demonstrates file upload testing.
This view handles POST requests to upload entity attribute files.
"""
def setUp(self):
super().setUp()
self.enterContext(self.in_memory_media_storage())
# Create test entity
self.entity = Entity.objects.create(
integration_id='test.entity',
integration_name='test_integration',
name='Test Entity',
entity_type_str=str(EntityType.CAMERA)
)
def test_post_valid_file_upload(self):
"""Test successful file upload using real form."""
# Create test file
test_file = SimpleUploadedFile(
"test_image.jpg",
b"fake image content",
content_type="image/jpeg"
)
url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.post(url, {
'file_value': test_file
})
self.assertSuccessResponse(response)
# Verify that an EntityAttribute was created
self.assertTrue(self.entity.attributes.filter(file_value__isnull=False).exists())
def test_post_invalid_file_upload(self):
"""Test file upload with invalid form data."""
# Test with actually invalid data instead of mocking
# This tests real form validation behavior
url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.post(url, {
# Send completely empty data to trigger form validation errors
})
# The view should handle invalid forms appropriately
# (may return 200 with form errors, or 400, depending on implementation)
self.assertIn(response.status_code, [200, 400]) # Accept either valid response
@patch('hi.apps.attribute.edit_form_handler.transaction.atomic')
def test_upload_uses_transaction(self, mock_atomic):
"""Test that file upload uses database transaction."""
# Configure the mock to return the real transaction atomic context manager
mock_atomic.return_value = transaction.atomic()
test_file = SimpleUploadedFile(
"test.txt",
b"test content",
content_type="text/plain"
)
url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.post(url, {
'file_value': test_file
})
self.assertSuccessResponse(response)
# Verify that transaction.atomic was called (may be called multiple times due to nested transactions)
self.assertGreaterEqual(mock_atomic.call_count, 1)
# Verify that an EntityAttribute was created
self.assertTrue(self.entity.attributes.filter(file_value__isnull=False).exists())
def test_nonexistent_entity_returns_404(self):
"""Test that uploading to nonexistent entity returns 404."""
url = reverse('entity_attribute_upload', kwargs={'entity_id': 99999})
response = self.client.post(url, {})
self.assertEqual(response.status_code, 404)
def test_get_not_allowed(self):
"""Test that GET requests are not allowed."""
url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 405)
class TestEntityStatusView(DualModeViewTestCase):
"""
Tests for EntityStatusView - demonstrates view delegation testing.
This view shows entity status or delegates to edit view if no status available.
"""
def setUp(self):
super().setUp()
# Create test entity
self.entity = Entity.objects.create(
integration_id='test.entity',
integration_name='test_integration',
name='Test Entity',
entity_type_str=str(EntityType.MOTION_SENSOR)
)
# Create real EntityState data for StatusDisplayManager to process
from hi.apps.entity.models import EntityState
self.entity_state = EntityState.objects.create(
entity=self.entity,
entity_state_type_str=str(EntityStateType.ON_OFF),
name='Power State'
)
def test_get_status_with_data_sync(self):
"""Test getting entity status when status data exists."""
url = reverse('entity_status', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertSuccessResponse(response)
self.assertHtmlResponse(response)
# The real StatusDisplayManager should process our entity
# Since we don't have actual sensor data, it may delegate to edit view or show status
# Either is acceptable - we're testing that mocks are removed and real objects work
self.assertIn('entity', response.context)
self.assertEqual(response.context['entity'], self.entity)
def test_get_status_with_data_async(self):
"""Test getting entity status with AJAX request."""
url = reverse('entity_status', kwargs={'entity_id': self.entity.id})
response = self.async_get(url)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
# HiModalView returns JSON with modal content for AJAX requests
data = response.json()
self.assertIn('modal', data)
# The real StatusDisplayManager should process our entity
# Either edit or status modal content is acceptable behavior
def test_entity_with_no_status_data_shows_edit_interface(self):
"""Test that entity with no status data shows edit interface."""
# Create an entity without any EntityState (no status data)
from hi.apps.entity.models import Entity
entity_no_states = Entity.objects.create(
integration_id='test.no_states',
integration_name='test_integration',
name='Entity Without States',
entity_type_str=str(EntityType.MOTION_SENSOR)
)
url = reverse('entity_status', kwargs={'entity_id': entity_no_states.id})
response = self.client.get(url)
# Should return successful response with edit interface
self.assertSuccessResponse(response)
# When there's no status data, the real StatusDisplayManager should return empty data
# and the view should delegate to EntityEditView
self.assertIn('entity', response.context)
self.assertEqual(response.context['entity'], entity_no_states)
def test_nonexistent_entity_returns_404(self):
"""Test that accessing nonexistent entity returns 404."""
url = reverse('entity_status', kwargs={'entity_id': 99999})
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_post_not_allowed(self):
"""Test that POST requests are not allowed."""
url = reverse('entity_status', kwargs={'entity_id': self.entity.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
def test_type_specific_panel_falls_back_when_required_role_absent(self):
"""A typed panel whose required roles are missing on the entity
must fall back to the framework fallback panel rather than
render a misshapen typed view. Wires the resolver + view layer
end-to-end so a regression in dispatch routing surfaces here."""
from hi.apps.entity.models import Entity, EntityState
# THERMOSTAT panel requires THERMOSTAT_CURRENT_TEMPERATURE.
# Give the entity only an unrelated ON_OFF state so the typed
# panel is disqualified and the fallback wins.
thermostat_without_temp = Entity.objects.create(
integration_id='test.thermostat_no_temp',
integration_name='test_integration',
name='Misconfigured Thermostat',
entity_type_str=str(EntityType.THERMOSTAT),
)
EntityState.objects.create(
entity=thermostat_without_temp,
entity_state_type_str=str(EntityStateType.ON_OFF),
name='Some State',
)
url = reverse('entity_status', kwargs={'entity_id': thermostat_without_temp.id})
response = self.client.get(url)
self.assertSuccessResponse(response)
state_panel_data = response.context['state_panel_data']
self.assertEqual(state_panel_data.panel_template,
'entity/state_panels/fallback/modal.html')
class TestEntityHistoryView(DualModeViewTestCase):
"""EntityHistoryView is the per-entity overview modal showing
each state's most recent merged history rows."""
def setUp(self):
super().setUp()
self.entity = Entity.objects.create(
integration_id='test.entity',
integration_name='test_integration',
name='Test Entity',
entity_type_str=str(EntityType.THERMOSTAT),
)
def test_get_history_sync(self):
url = reverse('entity_history', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertSuccessResponse(response)
def test_get_history_async(self):
url = reverse('entity_history', kwargs={'entity_id': self.entity.id})
response = self.async_get(url)
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
data = response.json()
self.assertIn('modal', data)
def test_renders_one_block_per_state(self):
"""Each EntityState produces an entry in state_to_rows."""
from hi.apps.entity.models import EntityState
EntityState.objects.create(
entity=self.entity, name='temperature',
entity_state_type_str='TEMPERATURE',
)
EntityState.objects.create(
entity=self.entity, name='hvac_mode',
entity_state_type_str='DISCRETE',
)
url = reverse('entity_history', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
self.assertSuccessResponse(response)
state_to_rows = response.context['state_to_rows']
self.assertEqual(len(state_to_rows), 2)
def test_nonexistent_entity_returns_404(self):
url = reverse('entity_history', kwargs={'entity_id': 99999})
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_post_not_allowed(self):
url = reverse('entity_history', kwargs={'entity_id': self.entity.id})
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
class TestEntityEditModeView(SyncViewTestCase):
"""
Tests for EntityEditModeView - demonstrates HiSideView testing.
This view displays entity details in a side panel with location context.
"""
def setUp(self):
super().setUp()
# Create test entity
self.entity = Entity.objects.create(
integration_id='test.entity',
integration_name='test_integration',
name='Test Entity',
entity_type_str=str(EntityType.LIGHT)
)
# Create test location and location view
self.location = Location.objects.create(
name='Test Location',
svg_fragment_filename='test.svg',
svg_view_box_str='0 0 100 100'
)
self.location_view = LocationView.objects.create(
location=self.location,
name='Test View',
location_view_type_str=str(LocationViewType.DEFAULT), # MAIN doesn't exist, use DEFAULT
svg_view_box_str='0 0 100 100',
svg_rotate=0.0
)
def test_get_details_with_location_view(self):
"""Test getting entity details when in location view context."""
# Test with real entity and location view setup
# This tests actual view functionality without complex mocking
self.setSessionViewType(ViewType.LOCATION_VIEW)
url = reverse('entity_edit_mode', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
# The view should either succeed or fail gracefully
# Note: may return 500 if managers aren't properly initialized,
# but shouldn't crash
self.assertIn(response.status_code, [200, 500]) # Accept either for now
def test_get_details_without_location_view(self):
"""Test getting entity details when not in location view context."""
# Test with non-location view context
self.setSessionViewType(ViewType.CONFIGURATION)
url = reverse('entity_edit_mode', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
# The view should handle this case appropriately
self.assertIn(response.status_code, [200, 500]) # Accept either for now
def test_details_should_push_url(self):
"""Test that EntityEditModeView should push URL."""
# Test that the view responds to URL requests appropriately
# This tests the basic URL routing and view instantiation
url = reverse('entity_edit_mode', kwargs={'entity_id': self.entity.id})
response = self.client.get(url)
# View should respond (may be 500 due to manager initialization issues)
self.assertIn(response.status_code, [200, 500]) # Accept either for now
def test_nonexistent_entity_returns_404(self):
"""Test that accessing nonexistent entity returns 404."""
url = reverse('entity_edit_mode', kwargs={'entity_id': 99999})
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_post_not_allowed(self):
"""Test that POST requests are not allowed."""
url = reverse('entity_edit_mode', kwargs={'entity_id': self.entity.id})
response = self.client.post(url)
# May return 500 due to view processing issues before method check
# The key is that it shouldn't return 200 (success)
self.assertNotEqual(response.status_code, 200)
class TestEntityEditViewFileUploadIntegration(DualModeViewTestCase):
"""Integration tests for EntityEditView file upload flows.
These tests verify the complete file upload workflow including:
- File upload through EntityAttributeUploadView
- DOM fragment updates via antinode responses
- File management within EntityEditView
- Error handling for invalid files
"""
def setUp(self):
super().setUp()
self.enterContext(self.in_memory_media_storage())
self.entity = EntityAttributeSyntheticData.create_test_entity(
name='File Upload Test Entity',
entity_type_str=str(EntityType.CAMERA)
)
def test_file_upload_creates_attribute_and_updates_dom(self):
"""Test complete file upload flow from upload to DOM update."""
# First verify entity has no files
self.assertEqual(self.entity.attributes.filter(value_type_str=str(AttributeValueType.FILE)).count(), 0)
# Upload a file
test_file = EntityAttributeSyntheticData.create_test_image_file()
upload_url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.post(upload_url, {
'file_value': test_file
})
self.assertSuccessResponse(response)
self.assertJsonResponse(response)
self.assertTemplateRendered(response, 'attribute/components/file_card.html')
# Verify file attribute was created
file_attrs = self.entity.attributes.filter(value_type_str=str(AttributeValueType.FILE))
self.assertEqual(file_attrs.count(), 1)
file_attr = file_attrs.first()
self.assertEqual(file_attr.name, 'test_image.jpg')
self.assertEqual(file_attr.file_mime_type, 'image/jpeg')
# Verify DOM update response structure
data = response.json()
self.assertIn('updates', data)
def test_file_upload_error_handling(self):
"""Test file upload error handling and DOM error display."""
upload_url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
# Submit without file
response = self.client.post(upload_url, {})
# Should return error response
self.assertEqual(response.status_code, 400)
self.assertJsonResponse(response)
# Verify error DOM update structure
data = response.json()
self.assertIn('updates', data)
self.assertFalse(data['success'])
# Should have error update with replace mode
updates = data['updates']
self.assertTrue(len(updates) > 0)
self.assertEqual(updates[0]['mode'], 'replace')
# Verify no file was created
self.assertEqual(self.entity.attributes.filter(value_type_str=str(AttributeValueType.FILE)).count(), 0)
def test_entity_edit_view_shows_uploaded_files(self):
"""Test that EntityEditView properly displays uploaded files."""
# Create file attributes
file1 = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='document1'
)
file2 = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='image1',
file_value=EntityAttributeSyntheticData.create_test_image_file()
)
edit_url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
response = self.client.get(edit_url)
self.assertSuccessResponse(response)
# Verify file attributes are in context
file_attributes = response.context['file_attributes']
self.assertEqual(len(file_attributes), 2)
file_attr_ids = [attr.id for attr in file_attributes]
self.assertIn(file1.id, file_attr_ids)
self.assertIn(file2.id, file_attr_ids)
def test_file_deletion_through_entity_edit(self):
"""Test deleting files through EntityEditView."""
# Create file attribute
file_attr = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='test_delete_file'
)
edit_url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
# Submit deletion request
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Add file deletion data
form_data.update(
EntityAttributeSyntheticData.create_file_deletion_data([file_attr])
)
response = self.client.post(edit_url, form_data)
self.assertSuccessResponse(response)
# Verify file is hidden from active querysets
self.assertFalse(
EntityAttribute.objects.filter(id=file_attr.id).exists()
)
# Verify file attribute still exists as deleted for restore
self.assertTrue(
EntityAttribute.deleted_objects.filter(id=file_attr.id).exists()
)
def test_file_title_update_through_entity_edit(self):
"""Test updating file titles through EntityEditView."""
# Create file attribute
file_attr = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='original_file',
value='Original Title'
)
edit_url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
# Submit title update
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Add file title update data
form_data.update(
EntityAttributeSyntheticData.create_file_title_update_data(
entity=self.entity,
file_attributes=[file_attr]
)
)
response = self.client.post(edit_url, form_data)
self.assertSuccessResponse(response)
# Verify title was updated
file_attr.refresh_from_db()
self.assertEqual(file_attr.value, 'Updated original_file')
def test_multiple_file_operations_in_single_request(self):
"""Test handling multiple file operations in one EntityEditView submission."""
# Create test files
file_to_delete = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='delete_me'
)
file_to_update = EntityAttributeSyntheticData.create_test_file_attribute(
entity=self.entity,
name='update_me',
value='Old Title'
)
edit_url = reverse('entity_edit', kwargs={'entity_id': self.entity.id})
# Submit both deletion and title update
form_data = EntityAttributeSyntheticData.create_form_data_for_entity_edit(
entity=self.entity
)
# Add both operations
form_data.update(
EntityAttributeSyntheticData.create_file_deletion_data([file_to_delete])
)
form_data.update(
EntityAttributeSyntheticData.create_file_title_update_data(
entity=self.entity,
file_attributes=[file_to_update]
)
)
response = self.client.post(edit_url, form_data)
self.assertSuccessResponse(response)
# Verify deletion occurred
self.assertFalse(
EntityAttribute.objects.filter(id=file_to_delete.id).exists()
)
self.assertTrue(
EntityAttribute.deleted_objects.filter(id=file_to_delete.id).exists()
)
# Verify title update occurred
file_to_update.refresh_from_db()
self.assertEqual(file_to_update.value, 'Updated update_me')
def test_large_file_upload_handling(self):
"""Test handling of large file uploads."""
large_file = EntityAttributeSyntheticData.create_large_text_file()
upload_url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.post(upload_url, {
'file_value': large_file
})
self.assertSuccessResponse(response)
# Verify large file was handled correctly
file_attrs = self.entity.attributes.filter(value_type_str=str(AttributeValueType.FILE))
self.assertEqual(file_attrs.count(), 1)
file_attr = file_attrs.first()
self.assertEqual(file_attr.name, 'large_file.txt')
self.assertEqual(file_attr.file_mime_type, 'text/plain')
def test_pdf_file_upload_handling(self):
"""Test handling of PDF file uploads."""
pdf_file = EntityAttributeSyntheticData.create_test_pdf_file()
upload_url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
response = self.client.post(upload_url, {
'file_value': pdf_file
})
self.assertSuccessResponse(response)
# Verify PDF was handled correctly
file_attrs = self.entity.attributes.filter(value_type_str=str(AttributeValueType.FILE))
self.assertEqual(file_attrs.count(), 1)
file_attr = file_attrs.first()
self.assertEqual(file_attr.name, 'test_document.pdf')
self.assertEqual(file_attr.file_mime_type, 'application/pdf')
def test_file_upload_transaction_rollback_on_error(self):
"""Test that file upload transactions roll back properly on errors."""
upload_url = reverse('entity_attribute_upload', kwargs={'entity_id': self.entity.id})
# Create a scenario that might cause database errors
with patch('hi.apps.entity.models.EntityAttribute.save') as mock_save:
mock_save.side_effect = Exception("Simulated database error")
test_file = EntityAttributeSyntheticData.create_test_image_file()
# This should return an error response (500) but not raise an exception
response = self.client.post(upload_url, {
'file_value': test_file
})
# Should return server error due to the exception
self.assertEqual(response.status_code, 500)
# Verify no file attributes were created due to transaction rollback
self.assertEqual(self.entity.attributes.filter(value_type_str=str(AttributeValueType.FILE)).count(), 0)
class TestEntityStateHistoryView(DualModeViewTestCase):
"""The per-EntityState history modal renders observations and
unmatched intents through the ``render_state_value_text``
templatetag dispatch and supports next/prev cursor navigation."""
def setUp(self):
super().setUp()
import json
self.entity = Entity.objects.create(
name = 'Switch', entity_type_str = 'WALL_SWITCH',
)
from hi.apps.entity.models import EntityState
self.state = EntityState.objects.create(
entity = self.entity,
name = 'on_off',
entity_state_type_str = 'ON_OFF',
value_range_str = json.dumps([ 'on', 'off' ]),
)
from hi.apps.sense.models import Sensor, SensorHistory
from hi.apps.control.models import Controller, ControllerHistory
self.sensor = Sensor.objects.create(
entity_state = self.state, name = 'sw-sensor',
sensor_type_str = 'DEFAULT', integration_payload = '{}',
)
self.controller = Controller.objects.create(
entity_state = self.state, name = 'sw-ctrl',
controller_type_str = 'DEFAULT', integration_payload = '{}',
)
SensorHistory.objects.create(
sensor = self.sensor, value = 'on',
response_datetime = '2024-03-01T12:00:00Z',
)
ControllerHistory.objects.create(
controller = self.controller, value = 'off',
)
def test_renders_observation_with_human_readable_label(self):
"""The stored value 'on' renders as the EntityStateValue label 'On'."""
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': self.state.id },
)
response = self.client.get(url)
self.assertSuccessResponse(response)
body = response.content.decode()
self.assertIn( 'On', body )
def test_returns_404_for_unknown_entity_state(self):
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': 999999 },
)
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
def test_pagination_cursor_filters_older(self):
"""A `before` query param filters rows to those strictly
older than the given ISO timestamp."""
from hi.apps.sense.models import SensorHistory
SensorHistory.objects.all().delete()
for i in range(5):
SensorHistory.objects.create(
sensor = self.sensor, value = 'on',
response_datetime = f'2024-03-0{i+1}T12:00:00Z',
)
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': self.state.id },
)
# Cursor at 2024-03-04 should yield only rows from days 1-3.
response = self.client.get(url, { 'before': '2024-03-04T00:00:00+00:00' })
self.assertSuccessResponse(response)
rows = response.context['history_rows']
for row in rows:
self.assertLess( row.timestamp.isoformat(), '2024-03-04T00:00:00+00:00' )
def test_older_link_uses_url_encoded_cursor(self):
"""The HTML link for "Older" must URL-encode the ISO cursor;
an unencoded ``+`` becomes a space when re-parsed and the
next page falls back to most-recent."""
from hi.apps.sense.models import SensorHistory
for i in range(30):
SensorHistory.objects.create(
sensor = self.sensor, value = 'on',
response_datetime = f'2024-03-0{(i % 9) + 1}T12:00:00Z',
)
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': self.state.id },
)
response = self.client.get(url)
self.assertSuccessResponse(response)
body = response.content.decode()
# Encoded "+" is "%2B"; the cursor in the Older link must be
# encoded so the round-trip through the query parser preserves it.
self.assertIn( '%2B00%3A00', body )
def test_video_browse_affordance_rendered_for_video_stream_rows(self):
"""Rows whose underlying SensorHistory has_event_video_clip render a
click-through to the per-event video browser; rows without it
do not."""
from django.urls import reverse as _reverse
from hi.apps.sense.models import SensorHistory
SensorHistory.objects.all().delete()
video_obs = SensorHistory.objects.create(
sensor = self.sensor, value = 'on',
response_datetime = '2024-03-01T12:00:00Z',
has_event_video_clip = True,
)
expected_url = _reverse(
'console_entity_video_sensor_history_detail',
kwargs = {
'entity_id': self.entity.id,
'sensor_id': self.sensor.id,
'sensor_history_id': video_obs.id,
},
)
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': self.state.id },
)
response = self.client.get(url)
self.assertSuccessResponse(response)
body = response.content.decode()
self.assertIn( expected_url, body )
self.assertIn( 'hi-history-row-actions', body )
def test_details_affordance_rendered_for_rows_with_details(self):
"""Rows whose underlying SensorHistory has detail attributes
render a click-through to the per-event details modal."""
from django.urls import reverse as _reverse
from hi.apps.sense.models import SensorHistory
SensorHistory.objects.all().delete()
details_obs = SensorHistory.objects.create(
sensor = self.sensor, value = 'on',
response_datetime = '2024-03-01T12:00:00Z',
details = '{"trigger": "motion"}',
)
expected_url = _reverse(
'sense_sensor_history_details',
kwargs = { 'sensor_history_id': details_obs.id },
)
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': self.state.id },
)
response = self.client.get(url)
self.assertSuccessResponse(response)
body = response.content.decode()
self.assertIn( expected_url, body )
self.assertIn( 'hi-history-row-actions', body )
def test_no_affordances_rendered_for_plain_observation(self):
"""An observation with no video and no details has no
click-through icons in its row."""
from hi.apps.sense.models import SensorHistory
SensorHistory.objects.all().delete()
SensorHistory.objects.create(
sensor = self.sensor, value = 'on',
response_datetime = '2024-03-01T12:00:00Z',
)
url = reverse(
'entity_state_history',
kwargs = { 'entity_state_id': self.state.id },
)
response = self.client.get(url)
self.assertSuccessResponse(response)
body = response.content.decode()
# The history-row-actions wrapper only renders when at least
# one affordance applies. A plain observation should have no
# such wrapper.
self.assertNotIn( 'hi-history-row-actions', body )