384 lines
8.4 KiB
Python
384 lines
8.4 KiB
Python
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()) |