import asyncio from types import SimpleNamespace import app.api as api class FakeTionState: def __init__(self): # Физическое состояние Tion. # # Специально ставим техническую уставку 30, # чтобы проверить, что API её не покажет. self.heater = False self.heating = False self.target_temp = 30 self.in_temp = 14 self.fan_speed = 2 def to_dict(self): return { "heater": self.heater, "heating": self.heating, "target_temp": self.target_temp, "in_temp": self.in_temp, "fan_speed": self.fan_speed, } class FakeTionService: def __init__(self): self.state = FakeTionState() self.online = True self.running = True self.last_seen = None self.last_error = None self.execute_calls = [] async def execute(self, operation): # При активном расписании температурные команды # НЕ должны идти напрямую сюда. self.execute_calls.append(operation) class FakeSchedule: def __init__(self): self.running = True self.paused = False self.config = SimpleNamespace( enabled=True, ) self.override_active = False self.override_settings = SimpleNamespace( heater=None, target_temp=None, speed=None, ) self.apply_override_calls = [] def resolve(self): return SimpleNamespace( enabled=True, scheduled_settings=SimpleNamespace( heater=True, target_temp=24, ), auto_active=False, auto_target_temp=None, ) async def apply_override(self, settings): self.apply_override_calls.append( settings ) if settings.heater is not None: self.override_settings.heater = ( settings.heater ) if settings.target_temp is not None: self.override_settings.target_temp = ( settings.target_temp ) self.override_active = True async def clear_override(self): self.override_active = False self.override_settings = SimpleNamespace( heater=None, target_temp=None, speed=None, ) async def pause(self): self.paused = True async def resume(self): self.paused = False class FakeAutoController: def __init__(self, schedule): self.schedule = schedule self.manual_heater_enabled = None self.manual_target_temperature = None self.reconcile_calls = 0 def effective_temperature_config(self): if self.schedule.paused: return SimpleNamespace( heater_enabled=( self.manual_heater_enabled ), target_temp=( self.manual_target_temperature ), ) heater = True target = 24 if self.schedule.override_active: override = ( self.schedule.override_settings ) if override.heater is not None: heater = override.heater if override.target_temp is not None: target = override.target_temp return SimpleNamespace( heater_enabled=heater, target_temp=target, ) def set_manual_heater_enabled( self, enabled, ): self.manual_heater_enabled = enabled def set_manual_target_temperature( self, temperature, ): self.manual_target_temperature = ( temperature ) def clear_manual_heater_control(self): self.manual_heater_enabled = None self.manual_target_temperature = None async def reconcile_temperature(self): self.reconcile_calls += 1 def status(self): return { "state": "test", } class FakeQingping: def status(self): return { "online": True, "temperature": 25.5, } def prepare(): schedule = FakeSchedule() auto = FakeAutoController(schedule) tion = FakeTionService() api.schedule_service = schedule api.auto_controller = auto api.service = tion api.qingping_service = FakeQingping() # Чтобы тест не зависел от Elica. api.get_elica_status = lambda: { "online": True, } # Нам здесь не нужна внутренняя структура # schedule-status. api.get_schedule_status = lambda: { "available": True, "paused": schedule.paused, } return schedule, auto, tion def test_status_uses_logical_temperature(): schedule, auto, tion = prepare() status = api.get_status() # Физически Tion: assert tion.state.target_temp == 30 assert tion.state.heater is False # Но пользователь должен видеть: assert status["tion"]["target_temp"] == 24 assert status["tion"]["heater"] is True # heating остаётся физическим. assert status["tion"]["heating"] is False async def test_temperature_creates_override(): schedule, auto, tion = prepare() await api.set_temperature(26) assert schedule.override_active is True assert ( schedule.override_settings.target_temp == 26 ) # Изменение только температуры # не должно само задавать heater. assert ( schedule.override_settings.heater is None ) # Tion напрямую не вызывается. assert tion.execute_calls == [] # Новый температурный контур # применяется сразу. assert auto.reconcile_calls == 1 async def test_heater_creates_override(): schedule, auto, tion = prepare() await api.set_heater("off") assert schedule.override_active is True assert ( schedule.override_settings.heater is False ) assert tion.execute_calls == [] assert auto.reconcile_calls == 1 async def test_pause_uses_logical_state(): schedule, auto, tion = prepare() # Физический heater выключен. assert tion.state.heater is False # Но логически отопление разрешено: config = ( auto.effective_temperature_config() ) assert config.heater_enabled is True assert config.target_temp == 24 await api.pause_schedule() assert schedule.paused is True # PAUSE должен запомнить ЛОГИЧЕСКОЕ # состояние, а не физический heater=False. assert ( auto.manual_heater_enabled is True ) assert ( auto.manual_target_temperature == 24 ) assert auto.reconcile_calls == 1 async def test_resume_clears_manual_state(): schedule, auto, tion = prepare() schedule.paused = True auto.manual_heater_enabled = True auto.manual_target_temperature = 25 await api.resume_schedule() assert schedule.paused is False assert ( auto.manual_heater_enabled is None ) assert ( auto.manual_target_temperature is None ) assert auto.reconcile_calls == 1 def test_temperature_routes(): paths = [ route.path for route in api.app.routes ] # increase мы решили удалить полностью. assert ( "/api/tion/temperature/increase" not in paths ) # Основной endpoint должен существовать # ровно один раз. assert ( paths.count( "/api/tion/temperature/{temperature}" ) == 1 ) async def main(): test_status_uses_logical_temperature() await test_temperature_creates_override() await test_heater_creates_override() await test_pause_uses_logical_state() await test_resume_clears_manual_state() test_temperature_routes() print( "ALL TEMPERATURE API TESTS PASSED" ) if __name__ == "__main__": asyncio.run(main())