Home Information - Your home, your data, organized.
Python
import logging
from threading import Lock
import threading
import time
from hi.apps.config.models import Subsystem, SubsystemAttribute
from hi.apps.config.settings_manager import SettingsManager
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)
class TestSetting(SettingEnum):
TEST_SETTING = SettingDefinition(
label='Test Setting',
description='A test setting',
value_type=AttributeValueType.TEXT,
value_range=None,
is_editable=True,
is_required=True,
initial_value='test_initial',
)
class TestSettingsManager(BaseTestCase):
def setUp(self):
super().setUp()
# Reset SettingsManager singleton for proper test isolation
SettingsManager._instance = None
def test_singleton_behavior(self):
"""Test SettingsManager singleton pattern - critical for system consistency."""
manager1 = SettingsManager()
manager2 = SettingsManager()
self.assertIs(manager1, manager2)
return
def test_initialization_lifecycle(self):
"""Test complete initialization lifecycle."""
manager = SettingsManager()
# Ensure manager is initialized (it may already be from other tests)
manager.ensure_initialized()
self.assertTrue(manager._was_initialized)
# Subsystems should be loaded
subsystems = manager.get_subsystems()
self.assertIsInstance(subsystems, list)
return
def test_setting_value_management_workflow(self):
"""Test complete workflow of setting value management."""
manager = SettingsManager()
manager.ensure_initialized()
# Create test subsystem and attribute
subsystem = Subsystem.objects.create(
name='Test Subsystem',
subsystem_key='test_workflow',
)
test_key = TestSetting.TEST_SETTING.key
attribute = SubsystemAttribute.objects.create(
subsystem=subsystem,
setting_key=test_key,
value_type=AttributeValueType.TEXT,
value='initial_workflow_value',
)
# Reload subsystems and attributes to pick up new data
manager._subsystem_list = manager._load_settings()
manager.reload()
# Test getting setting value
initial_value = manager.get_setting_value(TestSetting.TEST_SETTING)
self.assertEqual(initial_value, 'initial_workflow_value')
# Test updating setting value
manager.set_setting_value(TestSetting.TEST_SETTING, 'updated_workflow_value')
# Verify update was applied
updated_value = manager.get_setting_value(TestSetting.TEST_SETTING)
self.assertEqual(updated_value, 'updated_workflow_value')
# Verify database persistence
attribute.refresh_from_db()
self.assertEqual(attribute.value, 'updated_workflow_value')
return
def test_setting_value_error_scenarios(self):
"""Test error handling in setting value operations."""
manager = SettingsManager()
manager.ensure_initialized()
# Test KeyError for non-existent setting
with self.assertRaises(KeyError):
manager.set_setting_value(TestSetting.TEST_SETTING, 'any_value')
# Test None return for non-existent setting
value = manager.get_setting_value(TestSetting.TEST_SETTING)
self.assertIsNone(value)
return
def test_change_listener_notification_system(self):
"""Test change listener system with real callbacks."""
manager = SettingsManager()
# Track notifications with simple state
notification_count = [0] # Use list for mutable reference
listener_called = [False]
def test_callback():
notification_count[0] += 1
listener_called[0] = True
manager.register_change_listener(test_callback)
# Create test data to trigger reload
Subsystem.objects.create(
name='Listener Test Subsystem',
subsystem_key='listener_test',
)
# Initialize and reload to trigger notifications
manager.ensure_initialized()
initial_count = notification_count[0]
manager.reload()
# Verify callback was invoked
self.assertTrue(listener_called[0])
self.assertGreater(notification_count[0], initial_count)
return
def test_change_listener_resilience(self):
"""Test system resilience when change listeners fail."""
manager = SettingsManager()
# Track successful callback execution
successful_callback_executed = [False]
def failing_callback():
raise ValueError("Simulated callback failure")
def successful_callback():
successful_callback_executed[0] = True
# Register both callbacks
manager.register_change_listener(failing_callback)
manager.register_change_listener(successful_callback)
# Create test data
Subsystem.objects.create(
name='Resilience Test Subsystem',
subsystem_key='resilience_test',
)
# Reload should not fail despite exception in first callback
manager.ensure_initialized()
successful_callback_executed[0] = False # Reset flag
manager.reload()
# Successful callback should still execute
self.assertTrue(successful_callback_executed[0])
return
def test_database_synchronization(self):
"""Test manager stays synchronized with database changes."""
manager = SettingsManager()
manager.ensure_initialized()
# Create initial test data
subsystem = Subsystem.objects.create(
name='Sync Test Subsystem',
subsystem_key='sync_test',
)
test_key = 'test.sync.setting'
attribute = SubsystemAttribute.objects.create(
subsystem=subsystem,
setting_key=test_key,
value_type=AttributeValueType.TEXT,
value='sync_initial_value',
)
# Reload subsystems and attributes to pick up new data
manager._subsystem_list = manager._load_settings()
manager.reload()
# Verify initial state
initial_value = manager.get_setting_value(
type('MockSetting', (), {'key': test_key})()
)
self.assertEqual(initial_value, 'sync_initial_value')
# Modify database directly
attribute.value = 'sync_modified_value'
attribute.save()
# Reload should pick up changes
manager.reload()
updated_value = manager.get_setting_value(
type('MockSetting', (), {'key': test_key})()
)
self.assertEqual(updated_value, 'sync_modified_value')
return
def test_subsystem_management(self):
"""Test subsystem management functionality."""
manager = SettingsManager()
manager.ensure_initialized()
# Create test subsystems
Subsystem.objects.create(
name='Management Test 1',
subsystem_key='mgmt_test_1',
)
Subsystem.objects.create(
name='Management Test 2',
subsystem_key='mgmt_test_2',
)
# Reload subsystems to pick up new subsystems
manager._subsystem_list = manager._load_settings()
manager.reload()
# Test subsystem retrieval - just verify the new ones are present
updated_subsystems = manager.get_subsystems()
subsystem_keys = [s.subsystem_key for s in updated_subsystems]
self.assertIn('mgmt_test_1', subsystem_keys)
self.assertIn('mgmt_test_2', subsystem_keys)
# Verify subsystems can be retrieved individually
mgmt_subsystems = [s for s in updated_subsystems if s.subsystem_key.startswith('mgmt_test_')]
self.assertEqual(len(mgmt_subsystems), 2)
return
def test_server_startup_tracking(self):
"""Test server startup datetime tracking."""
manager = SettingsManager()
startup_time = manager.get_server_start_datetime()
self.assertIsNotNone(startup_time)
# Should be consistent across calls
startup_time2 = manager.get_server_start_datetime()
self.assertEqual(startup_time, startup_time2)
return
def test_thread_safety_infrastructure(self):
"""Test thread safety infrastructure is properly configured."""
manager = SettingsManager()
# Verify locks exist and are proper lock types
lock_types = (type(Lock()), type(threading.Lock()), type(threading.RLock()))
self.assertIsInstance(manager._subsystems_lock, lock_types)
self.assertIsInstance(manager._attributes_lock, lock_types)
# Test that locks can be acquired and released
with manager._subsystems_lock:
self.assertTrue(True) # Lock acquisition succeeded
with manager._attributes_lock:
self.assertTrue(True) # Lock acquisition succeeded
def test_no_deadlock_on_setting_save(self):
"""Test that setting a value doesn't cause deadlock from signal-triggered reload.
The background reload via ``_settings_processor`` is scheduled
from ``transaction.on_commit``, which doesn't fire under
``TestCase`` (the wrapping transaction rolls back), so this
test only asserts the synchronous no-deadlock contract."""
manager = SettingsManager()
manager.ensure_initialized()
subsystem = Subsystem.objects.create(
name='Deadlock Test Subsystem',
subsystem_key='deadlock_test',
)
test_key = TestSetting.TEST_SETTING.key
_ = SubsystemAttribute.objects.create(
subsystem=subsystem,
setting_key=test_key,
value_type=AttributeValueType.TEXT,
value='deadlock_initial_value',
)
manager.reload()
# This operation previously caused deadlock: the signal handler
# tried to reload while the manager's lock was held.
start_time = time.time()
manager.set_setting_value(TestSetting.TEST_SETTING, 'deadlock_test_value')
elapsed = time.time() - start_time
self.assertLess(elapsed, 1.0, "set_setting_value took too long, possible deadlock")
# The in-memory map is updated synchronously by set_setting_value,
# so it reflects the new value regardless of whether the
# background reload eventually runs.
self.assertEqual(manager.get_setting_value(TestSetting.TEST_SETTING), 'deadlock_test_value')
return