test_plate_clear_mqtt_notification.py 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  1. """Tests for the plate-clear gate reaching MQTT and notifications (#2525).
  2. ``awaiting_plate_clear`` is a Bambuddy-side flag (#961) — the printer's own MQTT
  3. push only ever reports RUNNING/PAUSE/FAILED/FINISH/IDLE, so an external
  4. automation had no way to tell "finished" from "finished and still waiting for
  5. someone to clear the bed". It now rides along on the retained per-printer status
  6. topic, gets its own retained topic on every transition, and can raise a
  7. notification on the rising edge.
  8. """
  9. from types import SimpleNamespace
  10. from unittest.mock import AsyncMock, MagicMock, patch
  11. import pytest
  12. from backend.app.services.bambu_mqtt import PrinterState
  13. from backend.app.services.mqtt_relay import MQTTRelayService
  14. from backend.app.services.printer_manager import PrinterManager
  15. def _relay() -> MQTTRelayService:
  16. relay = MQTTRelayService()
  17. relay.enabled = True
  18. relay.connected = True
  19. relay.client = MagicMock()
  20. return relay
  21. def _state() -> PrinterState:
  22. return PrinterState(
  23. connected=True,
  24. state="FINISH",
  25. progress=100,
  26. remaining_time=0,
  27. layer_num=250,
  28. total_layers=250,
  29. current_print="benchy.gcode.3mf",
  30. subtask_name="benchy",
  31. gcode_file="benchy.gcode",
  32. temperatures={"nozzle": 40, "bed": 30},
  33. wifi_signal="-50dBm",
  34. chamber_light="off",
  35. speed_level=2,
  36. cooling_fan_speed=0,
  37. big_fan1_speed=0,
  38. big_fan2_speed=0,
  39. heatbreak_fan_speed=0,
  40. left_aux_fan_speed=None,
  41. exhaust_fan_present=False,
  42. )
  43. def _published(relay: MQTTRelayService) -> list[tuple[str, dict, bool]]:
  44. """Decode every publish as (topic, payload, retain)."""
  45. import json
  46. calls = []
  47. for call in relay.client.publish.call_args_list:
  48. topic = call.args[0]
  49. payload = json.loads(call.args[1])
  50. calls.append((topic, payload, call.kwargs.get("retain", False)))
  51. return calls
  52. class TestStatusPayload:
  53. @pytest.mark.asyncio
  54. async def test_status_payload_carries_awaiting_plate_clear(self):
  55. relay = _relay()
  56. await relay.on_printer_status(1, _state(), "X1C", "01P00A000000001", True)
  57. topic, payload, retain = _published(relay)[0]
  58. assert topic == "bambuddy/printers/01P00A000000001/status"
  59. assert payload["awaiting_plate_clear"] is True
  60. assert retain is True
  61. @pytest.mark.asyncio
  62. async def test_status_payload_defaults_to_not_awaiting(self):
  63. relay = _relay()
  64. await relay.on_printer_status(1, _state(), "X1C", "01P00A000000001")
  65. _, payload, _ = _published(relay)[0]
  66. assert payload["awaiting_plate_clear"] is False
  67. # The pre-existing telemetry fields must survive the addition.
  68. assert payload["state"] == "FINISH"
  69. assert payload["progress"] == 100
  70. class TestPlateClearTopic:
  71. @pytest.mark.asyncio
  72. async def test_publishes_retained_state_on_its_own_topic(self):
  73. relay = _relay()
  74. await relay.on_plate_clear_state(3, "P1S", "01S00C000000003", True)
  75. topic, payload, retain = _published(relay)[0]
  76. assert topic == "bambuddy/printers/01S00C000000003/plate_clear"
  77. assert payload["awaiting"] is True
  78. assert payload["printer_id"] == 3
  79. assert payload["printer_name"] == "P1S"
  80. assert payload["printer_serial"] == "01S00C000000003"
  81. # Retained so a subscriber that connects later learns the current state
  82. # instead of waiting for the next transition.
  83. assert retain is True
  84. @pytest.mark.asyncio
  85. async def test_honours_the_configured_topic_prefix(self):
  86. relay = _relay()
  87. relay.topic_prefix = "farm/bambuddy"
  88. await relay.on_plate_clear_state(3, "P1S", "01S00C000000003", False)
  89. topic, payload, _ = _published(relay)[0]
  90. assert topic == "farm/bambuddy/printers/01S00C000000003/plate_clear"
  91. assert payload["awaiting"] is False
  92. @pytest.mark.asyncio
  93. async def test_silent_when_relay_is_disabled(self):
  94. relay = _relay()
  95. relay.enabled = False
  96. await relay.on_plate_clear_state(3, "P1S", "01S00C000000003", True)
  97. relay.client.publish.assert_not_called()
  98. class TestEdgeTriggering:
  99. """The setter is re-asserted routinely (the queue clears the gate on every
  100. dispatch), so outward-facing emissions must fire on transitions only."""
  101. def _manager(self) -> PrinterManager:
  102. manager = PrinterManager()
  103. loop = MagicMock()
  104. loop.is_running.return_value = True
  105. manager._loop = loop
  106. return manager
  107. def test_emits_on_the_rising_edge(self):
  108. manager = self._manager()
  109. with patch.object(manager, "_schedule_async") as scheduled:
  110. manager.set_awaiting_plate_clear(7, True)
  111. emitted = [c for c in scheduled.call_args_list if "_emit_plate_clear_change" in repr(c.args[0])]
  112. assert len(emitted) == 1
  113. for call in scheduled.call_args_list:
  114. call.args[0].close()
  115. def test_does_not_re_emit_when_already_awaiting(self):
  116. manager = self._manager()
  117. manager._awaiting_plate_clear.add(7)
  118. with patch.object(manager, "_schedule_async") as scheduled:
  119. manager.set_awaiting_plate_clear(7, True)
  120. emitted = [c for c in scheduled.call_args_list if "_emit_plate_clear_change" in repr(c.args[0])]
  121. assert emitted == []
  122. # Persistence and the WebSocket broadcast are idempotent and stay unconditional.
  123. assert len(scheduled.call_args_list) == 2
  124. for call in scheduled.call_args_list:
  125. call.args[0].close()
  126. def test_does_not_emit_when_clearing_a_gate_that_was_never_up(self):
  127. manager = self._manager()
  128. with patch.object(manager, "_schedule_async") as scheduled:
  129. manager.set_awaiting_plate_clear(7, False)
  130. emitted = [c for c in scheduled.call_args_list if "_emit_plate_clear_change" in repr(c.args[0])]
  131. assert emitted == []
  132. for call in scheduled.call_args_list:
  133. call.args[0].close()
  134. def test_emits_on_the_falling_edge(self):
  135. manager = self._manager()
  136. manager._awaiting_plate_clear.add(7)
  137. with patch.object(manager, "_schedule_async") as scheduled:
  138. manager.set_awaiting_plate_clear(7, False)
  139. emitted = [c for c in scheduled.call_args_list if "_emit_plate_clear_change" in repr(c.args[0])]
  140. assert len(emitted) == 1
  141. for call in scheduled.call_args_list:
  142. call.args[0].close()
  143. class TestEmitFanOut:
  144. @pytest.mark.asyncio
  145. async def test_rising_edge_publishes_and_notifies(self):
  146. manager = PrinterManager()
  147. manager._printer_info[7] = SimpleNamespace(name="X1C", serial_number="01P00A000000001")
  148. publish = AsyncMock()
  149. notify = AsyncMock()
  150. with (
  151. patch("backend.app.services.mqtt_relay.mqtt_relay.on_plate_clear_state", publish),
  152. patch(
  153. "backend.app.services.notification_service.notification_service.on_plate_clear_required",
  154. notify,
  155. ),
  156. ):
  157. await manager._emit_plate_clear_change(7, True)
  158. publish.assert_awaited_once_with(7, "X1C", "01P00A000000001", True)
  159. assert notify.await_count == 1
  160. assert notify.await_args.args[:2] == (7, "X1C")
  161. @pytest.mark.asyncio
  162. async def test_falling_edge_publishes_but_does_not_notify(self):
  163. manager = PrinterManager()
  164. manager._printer_info[7] = SimpleNamespace(name="X1C", serial_number="01P00A000000001")
  165. publish = AsyncMock()
  166. notify = AsyncMock()
  167. with (
  168. patch("backend.app.services.mqtt_relay.mqtt_relay.on_plate_clear_state", publish),
  169. patch(
  170. "backend.app.services.notification_service.notification_service.on_plate_clear_required",
  171. notify,
  172. ),
  173. ):
  174. await manager._emit_plate_clear_change(7, False)
  175. publish.assert_awaited_once_with(7, "X1C", "01P00A000000001", False)
  176. notify.assert_not_awaited()
  177. @pytest.mark.asyncio
  178. async def test_unknown_printer_is_a_no_op(self):
  179. manager = PrinterManager()
  180. publish = AsyncMock()
  181. with patch("backend.app.services.mqtt_relay.mqtt_relay.on_plate_clear_state", publish):
  182. await manager._emit_plate_clear_change(999, True)
  183. publish.assert_not_awaited()
  184. @pytest.mark.asyncio
  185. async def test_falls_back_to_the_db_when_no_client_is_registered(self):
  186. """A printer disconnected outright has no cached info, but the gate can
  187. still be released through the API (#2864) — the retained topic must not
  188. be left asserting a state that is no longer true."""
  189. manager = PrinterManager()
  190. publish = AsyncMock()
  191. with (
  192. patch("backend.app.services.mqtt_relay.mqtt_relay.on_plate_clear_state", publish),
  193. patch.object(
  194. PrinterManager,
  195. "_printer_info_from_db",
  196. AsyncMock(return_value=SimpleNamespace(name="Powered-off X1C", serial_number="01P00A000000009")),
  197. ),
  198. ):
  199. await manager._emit_plate_clear_change(9, False)
  200. publish.assert_awaited_once_with(9, "Powered-off X1C", "01P00A000000009", False)
  201. @pytest.mark.asyncio
  202. async def test_mqtt_failure_does_not_block_the_notification(self):
  203. manager = PrinterManager()
  204. manager._printer_info[7] = SimpleNamespace(name="X1C", serial_number="01P00A000000001")
  205. notify = AsyncMock()
  206. with (
  207. patch(
  208. "backend.app.services.mqtt_relay.mqtt_relay.on_plate_clear_state",
  209. AsyncMock(side_effect=RuntimeError("broker down")),
  210. ),
  211. patch(
  212. "backend.app.services.notification_service.notification_service.on_plate_clear_required",
  213. notify,
  214. ),
  215. ):
  216. await manager._emit_plate_clear_change(7, True)
  217. assert notify.await_count == 1