Skip to content

Home Information - Your home, your data, organized.

Python
15.4 KB
Raw Blame
import logging

from django.urls import reverse

from hi.apps.config.enums import ConfigPageType
from hi.apps.config.models import Subsystem, SubsystemAttribute
from hi.apps.attribute.enums import AttributeType, AttributeValueType
from hi.apps.audio.settings import AudioSetting
from hi.apps.security.settings import SecuritySetting
from hi.enums import ViewType, ViewMode
from hi.testing.view_test_base import DualModeViewTestCase

logging.disable(logging.CRITICAL)


class TestConfigSettingsView(DualModeViewTestCase):
    """
    Tests for ConfigSettingsView - demonstrates ConfigPageView testing.
    This view displays and manages system settings configuration.
    """

    def setUp(self):
        super().setUp()
        # Reset SettingsManager singleton for proper test isolation
        from hi.apps.config.settings_manager import SettingsManager
        SettingsManager._instance = None
        
        # Create test subsystem and attributes
        self.subsystem = Subsystem.objects.create(
            name='Test Subsystem',
            subsystem_key='test_subsystem'
        )
        self.attribute1 = SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key='test_key_1',
            name='Test Attribute 1',
            value='test_value_1',
            value_type_str='TEXT',
            attribute_type_str='CUSTOM'
        )
        self.attribute2 = SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key='test_key_2',
            name='Test Attribute 2',
            value='test_value_2',
            value_type_str='TEXT',
            attribute_type_str='CUSTOM'
        )

    def test_get_settings_page_sync(self):
        """Test getting settings page with synchronous request."""
        url = reverse('config_settings')
        response = self.client.get(url)

        self.assertSuccessResponse(response)
        self.assertHtmlResponse(response)
        self.assertTemplateRendered(response, 'config/panes/settings.html')
        
        # Check that view parameters are set
        session = self.client.session
        self.assertEqual(session.get('view_type'), str(ViewType.CONFIGURATION))
        self.assertEqual(session.get('view_mode'), str(ViewMode.MONITOR))

    def test_get_settings_page_async(self):
        """Test getting settings page with AJAX request."""
        url = reverse('config_settings')
        response = self.async_get(url)

        self.assertSuccessResponse(response)
        self.assertJsonResponse(response)
        
        # ConfigSettingsView should return redirect JSON for AJAX requests
        data = response.json()
        # This view returns a location redirect response
        self.assertIn('location', data)

    def test_config_page_type_property(self):
        """Test that config_page_type property returns correct value."""
        from hi.apps.config.views import ConfigSettingsView
        view = ConfigSettingsView()
        self.assertEqual(view.config_page_type, ConfigPageType.SETTINGS)

    def test_post_settings_valid_data(self):
        """Test posting valid settings data."""
        url = reverse('config_settings')
        
        # Build formset data for all existing subsystems (after SettingsManager reset)
        post_data = {}
        all_subsystems = Subsystem.objects.all()
        
        for subsystem in all_subsystems:
            attributes = subsystem.attributes.all()
            
            # Add management form data for this subsystem
            post_data.update({
                f'subsystem-{subsystem.id}-TOTAL_FORMS': str(len(attributes)),
                f'subsystem-{subsystem.id}-INITIAL_FORMS': str(len(attributes)),
                f'subsystem-{subsystem.id}-MIN_NUM_FORMS': '0',
                f'subsystem-{subsystem.id}-MAX_NUM_FORMS': '1000',
            })
            
            # Add individual attribute form data
            for i, attr in enumerate(attributes):
                # Only modify the test attributes we created, leave others unchanged
                if attr == self.attribute1:
                    value = 'updated_value_1'
                elif attr == self.attribute2:
                    value = 'updated_value_2'
                else:
                    value = attr.value  # Keep original value
                    
                post_data.update({
                    f'subsystem-{subsystem.id}-{i}-id': str(attr.id),
                    f'subsystem-{subsystem.id}-{i}-name': attr.name,
                    f'subsystem-{subsystem.id}-{i}-value': value,
                    f'subsystem-{subsystem.id}-{i}-attribute_type_str': attr.attribute_type_str,
                })
        
        response = self.client.post(url, data=post_data)
        
        self.assertSuccessResponse(response)
        # Should return a successful response (may be form with updated data or refresh)
        # The exact response format depends on implementation
        self.assertIn(response.status_code, [200])  # Accept success response
        
        # The form submission may have validation errors due to complex formset requirements
        # The key test is that the view handles POST requests appropriately
        # For now, just verify the view doesn't crash with POST data
        # TODO: Fix formset data structure for proper form testing

    def test_post_settings_invalid_data(self):
        """Test posting invalid settings data."""
        url = reverse('config_settings')
        post_data = {
            f'subsystem-{self.subsystem.id}-TOTAL_FORMS': 'invalid',
            f'subsystem-{self.subsystem.id}-INITIAL_FORMS': '2',
        }
        
        response = self.client.post(url, data=post_data)
        
        # Should return form with errors
        self.assertErrorResponse(response)
        self.assertTemplateRendered(response, 'config/panes/subsystem_edit_content_body.html')

    def test_subsystems_in_context(self):
        """Test that subsystems are properly passed to template context."""
        url = reverse('config_settings')
        response = self.client.get(url)

        self.assertSuccessResponse(response)
        self.assertIn('multi_edit_form_data_list', response.context)
        form_data_list = response.context['multi_edit_form_data_list']
        # There may be default system subsystems in addition to our test subsystem
        self.assertGreaterEqual(len(form_data_list), 1)  # At least our test subsystem

    def test_audio_test_button_appears_only_for_audio_subsystem(self):
        """Test that audio test functionality appears only in audio subsystem context."""
        # Get or create an audio subsystem to trigger the audio test button display
        audio_subsystem, _ = Subsystem.objects.get_or_create(
            subsystem_key='hi.apps.audio',
            defaults={'name': 'Audio System'}
        )

        # Create a non-audio subsystem for comparison
        other_subsystem = Subsystem.objects.create(
            name='Other System',
            subsystem_key='hi.apps.other.test'
        )

        url = reverse('config_settings')
        response = self.client.get(url)

        self.assertSuccessResponse(response)
        self.assertHtmlResponse(response)

        # Verify structural elements for audio test functionality
        content = response.content.decode('utf-8')

        # Test that audio test functionality is present (structural check)
        # Look for button element with audio test trigger (using semantic HTML structure)
        self.assertIn('onclick="Hi.audio.testAudio()', content)
        self.assertIn('type="button"', content)

        # Verify the button appears in the correct subsystem context
        # Check that it appears within the audio subsystem panel
        audio_panel_id = f'subsystem-{audio_subsystem.id}-panel'
        self.assertIn(audio_panel_id, content)

        # Verify tab structure includes both subsystems
        audio_tab_id = f'subsystem-{audio_subsystem.id}-tab'
        other_tab_id = f'subsystem-{other_subsystem.id}-tab'
        self.assertIn(audio_tab_id, content)
        self.assertIn(other_tab_id, content)

        # Test accessibility: button should have descriptive title attribute
        self.assertIn('title=', content)

        # Ensure the audio test button only appears in audio subsystem context
        # This is the key structural behavior - conditional rendering based on subsystem_key
        audio_section_start = content.find(f'id="{audio_panel_id}"')
        audio_section_end = content.find('</div>', audio_section_start + len(audio_panel_id) + 20)
        audio_section = content[audio_section_start:audio_section_end] if audio_section_start != -1 else ""

        # Verify audio test function call exists within audio subsystem section
        self.assertIn('Hi.audio.testAudio()', audio_section)

        # Verify the non-audio subsystem doesn't have audio test functionality
        other_section_start = content.find(f'id="subsystem-{other_subsystem.id}-panel"')
        if other_section_start != -1:
            other_section_end = content.find('</div>', other_section_start + 50)
            other_section = content[other_section_start:other_section_end]
            self.assertNotIn('Hi.audio.testAudio()', other_section)

    def test_attribute_restore_ui_data_is_present(self):
        """Ensure attribute cards expose default values and restore action."""
        attribute = SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key=SecuritySetting.SECURITY_DAY_START.key,
            name='Security Day Start',
            value='10:00',
            value_type_str=str(AttributeValueType.ENUM),
            attribute_type_str=str(AttributeType.PREDEFINED),
        )

        url = reverse('config_settings', kwargs={'subsystem_id': self.subsystem.id})
        response = self.client.get(url)

        self.assertSuccessResponse(response)
        self.assertHtmlResponse(response)

        content = response.content.decode('utf-8')
        expected_default = str(SecuritySetting.SECURITY_DAY_START.definition.initial_value)

        self.assertIn(f'data-default-value="{expected_default}"', content)
        self.assertIn(f"Hi.attr.restoreDefaultValue('{attribute.id}')", content)

    def test_setting_description_is_rendered(self):
        """Config settings page should show SettingDefinition descriptions."""
        SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key=SecuritySetting.SECURITY_NIGHT_START.key,
            name='Security Night Start',
            value='23:00',
            value_type_str=str(AttributeValueType.ENUM),
            attribute_type_str=str(AttributeType.PREDEFINED),
        )

        url = reverse('config_settings', kwargs={'subsystem_id': self.subsystem.id})
        response = self.client.get(url)

        self.assertSuccessResponse(response)
        self.assertHtmlResponse(response)

        content = response.content.decode('utf-8')
        expected_description = SecuritySetting.SECURITY_NIGHT_START.definition.description
        self.assertIn(expected_description, content)

    def test_restore_subsystem_confirm_modal(self):
        """Subsystem reset confirmation is rendered by a server modal view."""
        url = reverse(
            'subsystem_attribute_restore_subsystem_confirm_modal',
            kwargs={'subsystem_id': self.subsystem.id},
        )

        response = self.async_get(url)

        self.assertSuccessResponse(response)
        self.assertJsonResponse(response)

        data = response.json()
        self.assertIn('modal', data)
        self.assertIn('attr-v2-container', data['modal'])
        self.assertIn('attr-v2-restore-link', data['modal'])

        expected_restore_url = reverse(
            'subsystem_attribute_restore_subsystem_inline',
            kwargs={'subsystem_id': self.subsystem.id},
        )
        self.assertIn(f'href="{expected_restore_url}"', data['modal'])

    def test_restore_subsystem(self):
        """Restoring defaults for a subsystem updates all its attributes."""
        attribute_day = SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key=SecuritySetting.SECURITY_DAY_START.key,
            name='Security Day Start',
            value='10:00',
            value_type_str=str(AttributeValueType.ENUM),
            attribute_type_str=str(AttributeType.PREDEFINED),
        )
        attribute_away = SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key=SecuritySetting.SECURITY_AWAY_DELAY_MINS.key,
            name='Away Delay',
            value='99',
            value_type_str=str(AttributeValueType.INTEGER),
            attribute_type_str=str(AttributeType.PREDEFINED),
        )

        url = reverse('subsystem_attribute_restore_subsystem_inline', kwargs={'subsystem_id': self.subsystem.id})
        response = self.client.get(url)

        self.assertSuccessResponse(response)

        attribute_day.refresh_from_db()
        attribute_away.refresh_from_db()

        self.assertEqual(attribute_day.value, str(SecuritySetting.SECURITY_DAY_START.definition.initial_value))
        self.assertEqual(attribute_away.value, str(SecuritySetting.SECURITY_AWAY_DELAY_MINS.definition.initial_value))

    def test_restore_all_confirm_modal(self):
        """Global reset confirmation is rendered by a server modal view."""
        url = reverse(
            'subsystem_attribute_restore_all_confirm_modal',
            kwargs={'subsystem_id': self.subsystem.id},
        )

        response = self.async_get(url)

        self.assertSuccessResponse(response)
        self.assertJsonResponse(response)

        data = response.json()
        self.assertIn('modal', data)
        self.assertIn('attr-v2-container', data['modal'])
        self.assertIn('attr-v2-restore-link', data['modal'])

        expected_restore_url = reverse(
            'subsystem_attribute_restore_all_inline',
            kwargs={'subsystem_id': self.subsystem.id},
        )
        self.assertIn(f'href="{expected_restore_url}"', data['modal'])

    def test_restore_all(self):
        """Restoring defaults for all subsystems updates every attribute."""
        other_subsystem = Subsystem.objects.create(
            name='Other Subsystem',
            subsystem_key='other_subsystem_key',
        )

        attribute_security = SubsystemAttribute.objects.create(
            subsystem=self.subsystem,
            setting_key=SecuritySetting.SECURITY_NIGHT_START.key,
            name='Security Night Start',
            value='01:00',
            value_type_str=str(AttributeValueType.ENUM),
            attribute_type_str=str(AttributeType.PREDEFINED),
        )
        attribute_audio = SubsystemAttribute.objects.create(
            subsystem=other_subsystem,
            setting_key=AudioSetting.CONSOLE_WARNING_AUDIO_FILE.key,
            name='Console Warning Sound',
            value='info',
            value_type_str=str(AttributeValueType.ENUM),
            attribute_type_str=str(AttributeType.PREDEFINED),
        )

        url = reverse('subsystem_attribute_restore_all_inline', kwargs={'subsystem_id': self.subsystem.id})

        response = self.client.get(url)

        self.assertSuccessResponse(response)

        attribute_security.refresh_from_db()
        attribute_audio.refresh_from_db()

        self.assertEqual(attribute_security.value, str(SecuritySetting.SECURITY_NIGHT_START.definition.initial_value))
        self.assertEqual(attribute_audio.value, str(AudioSetting.CONSOLE_WARNING_AUDIO_FILE.definition.initial_value))