Skip to content

Home Information - Your home, your data, organized.

Python
13.2 KB
Raw Blame
import logging
from types import ModuleType

from hi.apps.config.models import Subsystem, SubsystemAttribute
from hi.apps.config.settings_manager import SettingsManager
from hi.apps.config.app_settings import AppSettings
from hi.apps.config.setting_enums import SettingEnum, SettingDefinition
from hi.apps.attribute.enums import AttributeValueType
from hi.testing.base_test_case import BaseTestCase

logging.disable(logging.CRITICAL)


# Create test settings for integration testing
class IntegrationTestSettings(SettingEnum):
    TEST_WORKFLOW_SETTING = SettingDefinition(
        label='Test Workflow Setting',
        description='Setting for testing complete workflows',
        value_type=AttributeValueType.TEXT,
        value_range=None,
        is_editable=True,
        is_required=True,
        initial_value='workflow_default',
    )
    NOTIFICATION_SETTING = SettingDefinition(
        label='Notification Setting',
        description='Setting for testing change notifications',
        value_type=AttributeValueType.BOOLEAN,
        value_range=None,
        is_editable=True,
        is_required=False,
        initial_value='true',
    )


class TestConfigIntegration(BaseTestCase):
    """Integration tests for config module components working together in real workflows."""

    def setUp(self):
        super().setUp()
        # Reset SettingsManager singleton for proper test isolation
        SettingsManager._instance = None

    def test_complete_settings_discovery_workflow(self):
        """Test complete workflow from module discovery to setting value access."""
        # Create test module with settings
        test_module = ModuleType('integration_test_module')
        test_module.IntegrationTestSettings = IntegrationTestSettings
        
        # Test app settings discovery
        app_settings = AppSettings(
            app_name='test.integration.module',
            app_module=test_module,
        )
        
        # Verify settings were discovered correctly
        self.assertEqual(len(app_settings), 1)
        all_definitions = app_settings.all_setting_definitions()
        self.assertEqual(len(all_definitions), 2)
        
        # Verify specific settings are present
        workflow_key = IntegrationTestSettings.TEST_WORKFLOW_SETTING.key
        notification_key = IntegrationTestSettings.NOTIFICATION_SETTING.key
        
        self.assertIn(workflow_key, all_definitions)
        self.assertIn(notification_key, all_definitions)
        
        # Verify setting properties are preserved
        workflow_def = all_definitions[workflow_key]
        self.assertEqual(workflow_def.label, 'Test Workflow Setting')
        self.assertEqual(workflow_def.value_type, AttributeValueType.TEXT)
        self.assertTrue(workflow_def.is_editable)
        return

    def test_settings_manager_integration_with_real_enums(self):
        """Test SettingsManager integration with actual SettingEnum instances."""
        manager = SettingsManager()
        
        # Create subsystem and attribute with real enum key
        subsystem = Subsystem.objects.create(
            name='Integration Test Subsystem',
            subsystem_key='integration_test',
        )
        
        workflow_key = IntegrationTestSettings.TEST_WORKFLOW_SETTING.key
        attribute = SubsystemAttribute.objects.create(
            subsystem=subsystem,
            setting_key=workflow_key,
            value_type=AttributeValueType.TEXT,
            value='integration_initial_value',
        )
        
        manager.ensure_initialized()
        
        # Reload subsystems and attributes to pick up new data
        manager._subsystem_list = manager._load_settings()
        manager.reload()
        
        # Test getting value using real enum
        initial_value = manager.get_setting_value(IntegrationTestSettings.TEST_WORKFLOW_SETTING)
        self.assertEqual(initial_value, 'integration_initial_value')
        
        # Test setting value using real enum
        manager.set_setting_value(
            IntegrationTestSettings.TEST_WORKFLOW_SETTING,
            'integration_updated_value'
        )
        
        # Verify update worked
        updated_value = manager.get_setting_value(IntegrationTestSettings.TEST_WORKFLOW_SETTING)
        self.assertEqual(updated_value, 'integration_updated_value')
        
        # Verify persistence
        attribute.refresh_from_db()
        self.assertEqual(attribute.value, 'integration_updated_value')
        return

    def test_change_notification_workflow(self):
        """Test complete change notification workflow across components."""
        manager = SettingsManager()
        
        # Track notifications through the workflow
        notification_log = []
        
        def workflow_change_listener():
            notification_log.append('workflow_change_detected')
        
        def secondary_change_listener():
            notification_log.append('secondary_change_detected')
        
        # Register listeners
        manager.register_change_listener(workflow_change_listener)
        manager.register_change_listener(secondary_change_listener)
        
        # Create test subsystem and setting
        subsystem = Subsystem.objects.create(
            name='Notification Test Subsystem',
            subsystem_key='notification_test',
        )
        
        notification_key = IntegrationTestSettings.NOTIFICATION_SETTING.key
        SubsystemAttribute.objects.create(
            subsystem=subsystem,
            setting_key=notification_key,
            value_type=AttributeValueType.BOOLEAN,
            value='false',
        )
        
        # Initialize manager
        manager.ensure_initialized()
        initial_log_length = len(notification_log)
        
        # Trigger reload to test notification workflow
        manager.reload()
        
        # Verify notifications were sent
        self.assertGreater(len(notification_log), initial_log_length)
        self.assertIn('workflow_change_detected', notification_log)
        self.assertIn('secondary_change_detected', notification_log)
        return

    def test_cross_component_value_type_handling(self):
        """Test value type handling across all config components."""
        manager = SettingsManager()
        
        # Create subsystem for testing
        subsystem = Subsystem.objects.create(
            name='Value Type Test Subsystem',
            subsystem_key='value_type_test',
        )
        
        # Test various value types through complete workflow
        value_type_tests = [
            (AttributeValueType.TEXT, 'text_workflow_value'),
            (AttributeValueType.INTEGER, '42'),
            (AttributeValueType.FLOAT, '3.14159'),
            (AttributeValueType.BOOLEAN, 'true'),
            (AttributeValueType.ENUM, 'WORKFLOW_OPTION'),
        ]
        
        created_attributes = []
        setting_keys = []
        
        for i, (value_type, test_value) in enumerate(value_type_tests):
            setting_key = f'workflow.{value_type.name.lower()}.setting.{i}'
            setting_keys.append(setting_key)
            
            attr = SubsystemAttribute.objects.create(
                subsystem=subsystem,
                setting_key=setting_key,
                value_type=value_type,
                value=test_value,
            )
            created_attributes.append(attr)
        
        manager.ensure_initialized()
        
        # Reload subsystems and attributes to pick up new data
        manager._subsystem_list = manager._load_settings()
        manager.reload()
        
        # Verify all value types are accessible through manager
        for setting_key, (value_type, expected_value) in zip(setting_keys, value_type_tests):
            with self.subTest(value_type=value_type):
                # Create mock setting enum for access
                mock_setting = type('MockSetting', (), {'key': setting_key})()
                actual_value = manager.get_setting_value(mock_setting)
                self.assertEqual(actual_value, expected_value)
        
        # Test updating different value types
        for setting_key, (value_type, _) in zip(setting_keys, value_type_tests):
            mock_setting = type('MockSetting', (), {'key': setting_key})()
            new_value = f'updated_{value_type.name.lower()}_value'
            
            manager.set_setting_value(mock_setting, new_value)
            updated_value = manager.get_setting_value(mock_setting)
            self.assertEqual(updated_value, new_value)
        return

    def test_system_stability_across_component_interactions(self):
        """Test system stability when all components interact in realistic scenarios."""
        manager = SettingsManager()
        
        # Create multiple subsystems to simulate real system
        subsystems = []
        for i in range(3):
            subsystem = Subsystem.objects.create(
                name=f'Stability Test Subsystem {i}',
                subsystem_key=f'stability_test_{i}',
            )
            subsystems.append(subsystem)
        
        # Create multiple settings across subsystems
        all_setting_keys = []
        for i, subsystem in enumerate(subsystems):
            for j in range(2):
                setting_key = f'stability.subsystem_{i}.setting_{j}'
                all_setting_keys.append(setting_key)
                
                SubsystemAttribute.objects.create(
                    subsystem=subsystem,
                    setting_key=setting_key,
                    value_type=AttributeValueType.TEXT,
                    value=f'stability_value_{i}_{j}',
                )
        
        manager.ensure_initialized()
        
        # Reload subsystems and attributes to pick up new data
        manager._subsystem_list = manager._load_settings()
        manager.reload()
        
        # Test multiple operations in sequence (simulating real usage)
        operations_performed = 0
        
        # Multiple reloads
        for _ in range(3):
            manager.reload()
            operations_performed += 1
        
        # Multiple setting accesses
        for setting_key in all_setting_keys:
            mock_setting = type('MockSetting', (), {'key': setting_key})()
            value = manager.get_setting_value(mock_setting)
            self.assertIsNotNone(value)
            operations_performed += 1
        
        # Multiple setting updates
        for i, setting_key in enumerate(all_setting_keys[:3]):  # Update subset
            mock_setting = type('MockSetting', (), {'key': setting_key})()
            manager.set_setting_value(mock_setting, f'stability_updated_{i}')
            operations_performed += 1
        
        # Verify system maintained stability
        self.assertGreater(operations_performed, 10)  # Multiple operations completed
        
        # Verify all subsystems still accessible
        current_subsystems = manager.get_subsystems()
        self.assertGreaterEqual(len(current_subsystems), 3)
        
        # Verify settings still accessible after all operations
        final_reload_successful = True
        try:
            manager.reload()
        except Exception:
            final_reload_successful = False
        
        self.assertTrue(final_reload_successful)
        return

    def test_error_recovery_across_component_boundaries(self):
        """Test system recovery from errors that cross component boundaries."""
        manager = SettingsManager()
        
        # Create valid subsystem and setting
        subsystem = Subsystem.objects.create(
            name='Error Recovery Test Subsystem',
            subsystem_key='error_recovery_test',
        )
        
        valid_setting_key = 'error.recovery.valid.setting'
        SubsystemAttribute.objects.create(
            subsystem=subsystem,
            setting_key=valid_setting_key,
            value_type=AttributeValueType.TEXT,
            value='valid_value',
        )
        
        manager.ensure_initialized()
        
        # Reload subsystems and attributes to pick up new data
        manager._subsystem_list = manager._load_settings()
        manager.reload()
        
        # Verify normal operation works
        mock_valid_setting = type('MockSetting', (), {'key': valid_setting_key})()
        initial_value = manager.get_setting_value(mock_valid_setting)
        self.assertEqual(initial_value, 'valid_value')
        
        # Test error handling for non-existent setting
        mock_invalid_setting = type('MockSetting', (), {
            'key': 'non.existent.setting',
            'name': 'NON_EXISTENT_SETTING'
        })()
        
        # Should handle gracefully without crashing
        non_existent_value = manager.get_setting_value(mock_invalid_setting)
        self.assertIsNone(non_existent_value)
        
        # Should raise appropriate error for set operation
        with self.assertRaises(KeyError):
            manager.set_setting_value(mock_invalid_setting, 'any_value')
        
        # Verify valid operations still work after errors
        updated_value = manager.get_setting_value(mock_valid_setting)
        self.assertEqual(updated_value, 'valid_value')
        
        # System should still be able to reload successfully
        manager.reload()
        post_error_value = manager.get_setting_value(mock_valid_setting)
        self.assertEqual(post_error_value, 'valid_value')
        return