test_monitor_only_plugs_3583.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285
  1. """#3583: monitor-only MQTT plugs are never switched by automation.
  2. Bambuddy subscribes to an MQTT plug and never publishes, so it can be neither
  3. turned on nor off. Its auto on / auto off default to on and the UI hides both,
  4. yet every automation path tried to switch it -- through the Tasmota service,
  5. with no IP. Linked beside a plug that can switch, it could take the queue's
  6. power-on and hold the job, and every auto-off logged a failed turn-off.
  7. """
  8. from datetime import datetime, timezone
  9. from types import SimpleNamespace
  10. from unittest.mock import AsyncMock, MagicMock, patch
  11. import pytest
  12. from backend.app.models.smart_plug import SmartPlug
  13. from backend.app.services.print_scheduler import PrintScheduler
  14. from backend.app.services.smart_plug_manager import SmartPlugManager, can_turn_off, is_monitor_only
  15. from backend.tests.unit.test_scheduler_class_target_smart_plug_2786 import ( # noqa: F401 - fixture
  16. _add_item,
  17. _get_item,
  18. _run,
  19. queue_db,
  20. )
  21. def _plug(plug_id, plug_type="tasmota", **kw):
  22. fields = {
  23. "id": plug_id,
  24. "name": f"{plug_type} {plug_id}",
  25. "plug_type": plug_type,
  26. "ip_address": None if plug_type == "mqtt" else f"10.0.1.{plug_id}",
  27. "username": None,
  28. "password": None,
  29. "ha_entity_id": None,
  30. "enabled": True,
  31. "auto_on": True,
  32. "auto_off": True,
  33. "auto_off_after_drying": True,
  34. "off_delay_after_drying_minutes": 10,
  35. "off_delay_mode": "time",
  36. "off_delay_minutes": 5,
  37. "off_temp_threshold": 70,
  38. "printer_id": 1,
  39. "controls_printer_power": True,
  40. "auto_off_executed": False,
  41. "auto_off_pending": False,
  42. "auto_off_pending_since": None,
  43. "schedule_enabled": True,
  44. "schedule_on_time": "08:00",
  45. "schedule_off_time": "22:00",
  46. "last_state": "OFF",
  47. }
  48. fields.update(kw)
  49. plug = MagicMock()
  50. for key, value in fields.items():
  51. setattr(plug, key, value)
  52. return plug
  53. class TestCapability:
  54. def test_mqtt_is_monitor_only(self):
  55. assert is_monitor_only(SimpleNamespace(plug_type="mqtt"))
  56. assert not is_monitor_only(SimpleNamespace(plug_type="rest"))
  57. @pytest.mark.parametrize(
  58. ("plug_type", "entity", "expected"),
  59. [
  60. ("tasmota", None, True),
  61. ("rest", None, True),
  62. ("homeassistant", "switch.printer", True),
  63. ("homeassistant", "script.printer_off", False),
  64. ("mqtt", None, False),
  65. ],
  66. )
  67. def test_can_turn_off(self, plug_type, entity, expected):
  68. assert can_turn_off(SimpleNamespace(plug_type=plug_type, ha_entity_id=entity)) is expected
  69. def test_auto_on_plugs_leave_out_mqtt(self):
  70. mqtt, rest = _plug(1, "mqtt"), _plug(2, "rest")
  71. assert PrintScheduler._auto_on_plugs([mqtt, rest]) == [rest]
  72. class TestPrintCycle:
  73. @pytest.mark.asyncio
  74. async def test_print_start_does_not_switch_on_an_mqtt_plug(self):
  75. manager = SmartPlugManager()
  76. mqtt, tasmota = _plug(1, "mqtt"), _plug(2)
  77. with (
  78. patch.object(manager, "_get_plugs_for_printer", AsyncMock(return_value=[mqtt, tasmota])),
  79. patch("backend.app.services.smart_plug_manager.tasmota_service") as service,
  80. ):
  81. service.turn_on = AsyncMock(return_value=True)
  82. await manager.on_print_start(printer_id=1, db=AsyncMock())
  83. service.turn_on.assert_awaited_once_with(tasmota)
  84. @pytest.mark.asyncio
  85. async def test_print_start_still_runs_a_linked_script(self):
  86. """Turning on is narrower than switching: a script is run on purpose."""
  87. manager = SmartPlugManager()
  88. script = _plug(3, "homeassistant", ha_entity_id="script.printer_on")
  89. with (
  90. patch.object(manager, "_get_plugs_for_printer", AsyncMock(return_value=[script])),
  91. patch.object(manager, "_configure_ha_service", AsyncMock()),
  92. patch("backend.app.services.smart_plug_manager.homeassistant_service") as service,
  93. ):
  94. service.turn_on = AsyncMock(return_value=True)
  95. await manager.on_print_start(printer_id=1, db=AsyncMock())
  96. service.turn_on.assert_awaited_once_with(script)
  97. @pytest.mark.asyncio
  98. async def test_print_end_schedules_no_off_for_an_mqtt_plug(self):
  99. manager = SmartPlugManager()
  100. mqtt, tasmota = _plug(1, "mqtt"), _plug(2)
  101. with (
  102. patch.object(manager, "_get_plugs_for_printer", AsyncMock(return_value=[mqtt, tasmota])),
  103. patch.object(manager, "_schedule_delayed_off") as schedule,
  104. ):
  105. await manager.on_print_complete(printer_id=1, status="completed", db=AsyncMock())
  106. assert [c.args[0] for c in schedule.call_args_list] == [tasmota]
  107. @pytest.mark.asyncio
  108. async def test_auto_off_after_a_queue_job_skips_an_mqtt_plug(self):
  109. manager = SmartPlugManager()
  110. mqtt, tasmota = _plug(1, "mqtt"), _plug(2)
  111. with (
  112. patch.object(manager, "_get_plugs_for_printer", AsyncMock(return_value=[mqtt, tasmota])),
  113. patch.object(manager, "_schedule_off_per_mode") as schedule,
  114. ):
  115. await manager.schedule_off_after_queue_job(printer_id=1, db=AsyncMock())
  116. assert [c.args[0] for c in schedule.call_args_list] == [tasmota]
  117. @pytest.mark.asyncio
  118. async def test_drying_auto_off_skips_an_mqtt_plug(self):
  119. manager = SmartPlugManager()
  120. mqtt, tasmota = _plug(1, "mqtt"), _plug(2)
  121. with (
  122. patch.object(manager, "_get_plugs_for_printer", AsyncMock(return_value=[mqtt, tasmota])),
  123. patch.object(manager, "_schedule_delayed_off") as schedule,
  124. ):
  125. await manager.on_drying_complete(printer_id=1, db=AsyncMock())
  126. assert [c.args[0] for c in schedule.call_args_list] == [tasmota]
  127. def _session_returning(plugs):
  128. db = AsyncMock()
  129. result = MagicMock()
  130. result.scalars.return_value.all.return_value = plugs
  131. db.execute = AsyncMock(return_value=result)
  132. session = MagicMock()
  133. session.return_value.__aenter__ = AsyncMock(return_value=db)
  134. session.return_value.__aexit__ = AsyncMock()
  135. return session, db
  136. class TestSchedulesAndRestart:
  137. @pytest.mark.asyncio
  138. async def test_a_schedule_does_not_switch_an_mqtt_plug(self):
  139. manager = SmartPlugManager()
  140. mqtt = _plug(1, "mqtt")
  141. session, _db = _session_returning([mqtt])
  142. now = MagicMock()
  143. now.strftime.return_value = "08:00"
  144. with (
  145. patch("backend.app.services.smart_plug_manager.datetime") as clock,
  146. patch("backend.app.core.database.async_session", session),
  147. patch("backend.app.services.smart_plug_manager.tasmota_service") as service,
  148. ):
  149. clock.now.return_value = now
  150. clock.utcnow.return_value = datetime.now(timezone.utc)
  151. service.turn_on = AsyncMock(return_value=True)
  152. await manager._check_schedules()
  153. service.turn_on.assert_not_awaited()
  154. @pytest.mark.asyncio
  155. async def test_a_pending_off_left_on_an_mqtt_plug_is_cleared(self):
  156. manager = SmartPlugManager()
  157. mqtt = _plug(1, "mqtt", auto_off_pending=True, auto_off_pending_since=datetime.now(timezone.utc))
  158. session, db = _session_returning([mqtt])
  159. with (
  160. patch("backend.app.core.database.async_session", session),
  161. patch.object(manager, "_schedule_delayed_off") as delayed,
  162. patch.object(manager, "_schedule_temp_based_off") as temp,
  163. patch("backend.app.services.smart_plug_manager.tasmota_service") as service,
  164. ):
  165. service.turn_off = AsyncMock(return_value=True)
  166. await manager.resume_pending_auto_offs()
  167. service.turn_off.assert_not_awaited()
  168. delayed.assert_not_called()
  169. temp.assert_not_called()
  170. assert mqtt.auto_off_pending is False
  171. db.commit.assert_awaited()
  172. class TestObicoPowerOff:
  173. @pytest.mark.asyncio
  174. async def test_failure_power_off_skips_an_mqtt_plug(self):
  175. from backend.app.services import obico_actions
  176. mqtt, tasmota = _plug(1, "mqtt"), _plug(2)
  177. session, _db = _session_returning([])
  178. with (
  179. patch("backend.app.services.obico_actions.async_session", session),
  180. patch(
  181. "backend.app.services.smart_plug_manager.smart_plug_manager._get_plugs_for_printer",
  182. AsyncMock(return_value=[mqtt, tasmota]),
  183. ),
  184. patch("backend.app.services.smart_plug_manager.tasmota_service") as service,
  185. patch("backend.app.services.smart_plug_manager.publish_plug_state", AsyncMock()),
  186. patch(
  187. "backend.app.services.smart_plug_manager.run_linked_scripts_after_automatic_switch",
  188. AsyncMock(),
  189. ),
  190. ):
  191. service.turn_off = AsyncMock(return_value=True)
  192. await obico_actions._turn_off_linked_plugs(1)
  193. service.turn_off.assert_awaited_once_with(tasmota)
  194. async def _add_typed_plug(ctx, printer_id, plug_type, *, controls_printer_power=True):
  195. async with ctx.session_maker() as db:
  196. fields = {"ip_address": f"10.0.1.{printer_id}"} if plug_type != "mqtt" else {"mqtt_topic": "tele/p/SENSOR"}
  197. if plug_type == "rest":
  198. fields = {"rest_on_url": "http://plug.example/on", "rest_off_url": "http://plug.example/off"}
  199. plug = SmartPlug(
  200. name=f"{plug_type} {printer_id}",
  201. plug_type=plug_type,
  202. printer_id=printer_id,
  203. enabled=True,
  204. auto_on=True,
  205. controls_printer_power=controls_printer_power,
  206. **fields,
  207. )
  208. db.add(plug)
  209. await db.commit()
  210. return plug.id
  211. def _powered_plug_types(power_on):
  212. return [call.args[0].plug_type for call in power_on.await_args_list]
  213. class TestQueuePowerOn:
  214. @pytest.mark.asyncio
  215. async def test_a_job_on_a_printer_powers_on_with_the_plug_that_can_switch(self, queue_db):
  216. """The bug: the MQTT plug came first and was picked, and the job held."""
  217. await _add_typed_plug(queue_db, 1, "mqtt")
  218. await _add_typed_plug(queue_db, 1, "rest")
  219. await _add_item(queue_db, printer_id=1)
  220. power_on = await _run(queue_db, PrintScheduler(), power_on=AsyncMock(return_value=False))
  221. assert _powered_plug_types(power_on) == ["rest"]
  222. @pytest.mark.asyncio
  223. async def test_an_any_model_job_wakes_with_the_plug_that_can_switch(self, queue_db):
  224. await _add_typed_plug(queue_db, 1, "mqtt")
  225. await _add_typed_plug(queue_db, 1, "rest")
  226. await _add_item(queue_db, target_model="X1C")
  227. power_on = await _run(queue_db, PrintScheduler(), power_on=AsyncMock(return_value=True))
  228. assert _powered_plug_types(power_on) == ["rest"]
  229. @pytest.mark.asyncio
  230. async def test_a_printer_with_only_an_mqtt_plug_is_not_woken(self, queue_db):
  231. """And says why: it has no plug that can switch it on."""
  232. await _add_typed_plug(queue_db, 1, "mqtt")
  233. await _add_typed_plug(queue_db, 2, "mqtt")
  234. item_id = await _add_item(queue_db, target_model="X1C")
  235. power_on = await _run(queue_db, PrintScheduler(), power_on=AsyncMock(return_value=True))
  236. power_on.assert_not_awaited()
  237. item = await _get_item(queue_db, item_id)
  238. assert "no Auto On smart plug" in (item.waiting_reason or "")