Home Information - Your home, your data, organized.
Python
import logging
from unittest.mock import Mock, patch
import asyncio
from hi.apps.control.controller_manager import ControllerManager
from hi.apps.control.controller_history_manager import ControllerHistoryManager
from hi.apps.control.models import Controller
from hi.apps.control.transient_models import ControllerOutcome
from hi.apps.entity.models import Entity, EntityState
from hi.integrations.transient_models import IntegrationControlResult
from hi.testing.base_test_case import BaseTestCase
logging.disable(logging.CRITICAL)
class TestControllerManager(BaseTestCase):
def test_controller_manager_singleton_behavior(self):
"""Test ControllerManager singleton pattern - critical for system consistency."""
manager1 = ControllerManager()
manager2 = ControllerManager()
# Should be the same instance
self.assertIs(manager1, manager2)
return
def test_controller_manager_initialization_tracking(self):
"""Test initialization tracking - important for lazy loading."""
manager = ControllerManager()
# Should start uninitialized
self.assertFalse(manager._was_initialized)
# Should initialize once
manager.ensure_initialized()
self.assertTrue(manager._was_initialized)
# Should not reinitialize
manager.ensure_initialized()
self.assertTrue(manager._was_initialized)
return
@patch.object(ControllerManager, '_instance', None)
@patch('hi.apps.control.controller_manager.IntegrationManager')
def test_do_control_returns_integration_result(self, mock_integration_manager_class):
"""Test do_control returns actual control result from integration layer."""
# Create real controller with integration details
entity = Entity.objects.create(
name='Test Light',
entity_type_str='LIGHT'
)
entity_state = EntityState.objects.create(
entity=entity,
entity_state_type_str='ON_OFF'
)
controller = Controller.objects.create(
name='Living Room Light',
entity_state=entity_state,
controller_type_str='DEFAULT',
integration_id='home_assistant',
integration_name='Home Assistant'
)
# Mock only at integration boundary
mock_control_result = IntegrationControlResult(
new_value='on',
error_list=[]
)
mock_integration_controller = Mock()
mock_integration_controller.do_control.return_value = mock_control_result
mock_integration_gateway = Mock()
mock_integration_gateway.get_connector.return_value.get_controller.return_value = mock_integration_controller
mock_integration_manager = Mock()
mock_integration_manager.get_integration_gateway.return_value = mock_integration_gateway
mock_integration_manager_class.return_value = mock_integration_manager
# Test the control operation
manager = ControllerManager()
result = manager.do_control(controller=controller, control_value='on')
# Test actual return value and behavior
self.assertIsInstance(result, ControllerOutcome)
self.assertFalse(result.has_errors)
self.assertEqual(result.new_value, 'on')
self.assertEqual(result.error_list, [])
# Verify integration details passed correctly
call_args = mock_integration_controller.do_control.call_args
self.assertEqual(call_args.kwargs['hi_control_value'], 'on')
integration_details = call_args.kwargs['integration_details']
self.assertEqual(integration_details.key, controller.integration_key)
self.assertEqual(integration_details.payload, controller.integration_payload)
return
@patch.object(ControllerManager, '_instance', None)
@patch('hi.apps.control.controller_manager.IntegrationManager')
def test_do_control_handles_integration_errors(self, mock_integration_manager_class):
"""Test do_control properly handles and returns integration errors."""
entity = Entity.objects.create(
name='Test Switch',
entity_type_str='SWITCH'
)
entity_state = EntityState.objects.create(
entity=entity,
entity_state_type_str='ON_OFF'
)
controller = Controller.objects.create(
name='Broken Switch',
entity_state=entity_state,
controller_type_str='DEFAULT',
integration_id='unreliable_integration',
integration_name='Unreliable Integration'
)
# Mock integration failure
mock_control_result = IntegrationControlResult(
new_value='',
error_list=['Device is offline', 'Connection timeout']
)
mock_integration_controller = Mock()
mock_integration_controller.do_control.return_value = mock_control_result
mock_integration_gateway = Mock()
mock_integration_gateway.get_connector.return_value.get_controller.return_value = mock_integration_controller
mock_integration_manager = Mock()
mock_integration_manager.get_integration_gateway.return_value = mock_integration_gateway
mock_integration_manager_class.return_value = mock_integration_manager
# Test error handling
manager = ControllerManager()
result = manager.do_control(controller=controller, control_value='on')
# Test that error information is properly returned
self.assertIsInstance(result, ControllerOutcome)
self.assertTrue(result.has_errors)
self.assertEqual(result.error_list, ['Device is offline', 'Connection timeout'])
self.assertEqual(result.new_value, '')
return
@patch.object(ControllerManager, '_instance', None)
@patch.object(ControllerHistoryManager, '_instance', None)
@patch('hi.apps.control.controller_history_manager.ControllerHistory.objects.create')
@patch('hi.apps.control.controller_manager.IntegrationManager')
def test_do_control_async_returns_same_result_as_sync(self, mock_integration_manager_class, mock_history_create):
"""Test async control returns identical result to sync version."""
entity = Entity.objects.create(
name='Test Dimmer',
entity_type_str='LIGHT'
)
entity_state = EntityState.objects.create(
entity=entity,
entity_state_type_str='DISCRETE'
)
controller_sync = Controller.objects.create(
name='Bedroom Dimmer Sync',
entity_state=entity_state,
controller_type_str='DEFAULT',
integration_id='zigbee_integration',
integration_name='Zigbee Integration'
)
controller_async = Controller.objects.create(
name='Bedroom Dimmer Async',
entity_state=entity_state,
controller_type_str='DEFAULT',
integration_id='zigbee_integration',
integration_name='Zigbee Integration Async'
)
# Mock successful dimmer control
mock_control_result = IntegrationControlResult(
new_value='75',
error_list=[]
)
mock_integration_controller = Mock()
mock_integration_controller.do_control.return_value = mock_control_result
mock_integration_gateway = Mock()
mock_integration_gateway.get_connector.return_value.get_controller.return_value = mock_integration_controller
mock_integration_manager = Mock()
mock_integration_manager.get_integration_gateway.return_value = mock_integration_gateway
mock_integration_manager_class.return_value = mock_integration_manager
# Test both sync and async produce same result
manager = ControllerManager()
sync_result = manager.do_control(controller=controller_sync, control_value='75')
async def run_async_test():
return await manager.do_control_async(controller=controller_async, control_value='75')
async_result = asyncio.run(run_async_test())
# Both should return identical IntegrationControlResult objects
self.assertEqual(sync_result.has_errors, async_result.has_errors)
self.assertEqual(sync_result.error_list, async_result.error_list)
self.assertEqual(sync_result.new_value, async_result.new_value)
# Verify both called integration with same parameters
self.assertEqual(mock_integration_controller.do_control.call_count, 2)
for call in mock_integration_controller.do_control.call_args_list:
self.assertEqual(call.kwargs['hi_control_value'], '75')
return