test_plate_clear_per_printer_2860.py 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223
  1. """A printer's own "Require plate-clear confirmation" (#2860).
  2. The app setting gated every printer the same way, so a printer with an
  3. automatic plate changer and one cleared by hand could not share a queue. A
  4. printer may now override it: on, off, or null to follow the setting. These
  5. tests cover the cache, every place the scheduler applies the gate, and WLED.
  6. """
  7. from types import SimpleNamespace
  8. from unittest.mock import AsyncMock, MagicMock, patch
  9. import pytest
  10. from backend.app.services import plate_clear
  11. from backend.app.services.print_scheduler import PrintScheduler, _ModelCandidate
  12. from backend.app.services.wled import WLEDManager
  13. A1 = 1 # clears its own plate
  14. P1S = 2 # cleared by hand
  15. @pytest.fixture(autouse=True)
  16. def overrides():
  17. plate_clear.load_overrides({})
  18. yield plate_clear
  19. plate_clear.load_overrides({})
  20. class TestCache:
  21. def test_no_override_follows_the_setting(self):
  22. assert plate_clear.applies(A1, True) is True
  23. assert plate_clear.applies(A1, False) is False
  24. def test_override_wins_over_the_setting(self, overrides):
  25. overrides.set_override(A1, False)
  26. overrides.set_override(P1S, True)
  27. assert plate_clear.applies(A1, True) is False
  28. assert plate_clear.applies(P1S, False) is True
  29. def test_none_removes_the_override(self, overrides):
  30. overrides.set_override(A1, False)
  31. overrides.set_override(A1, None)
  32. assert plate_clear.applies(A1, True) is True
  33. def test_load_replaces_every_override(self, overrides):
  34. overrides.set_override(A1, False)
  35. overrides.load_overrides({P1S: True, 3: None})
  36. assert plate_clear.applies(A1, True) is True
  37. assert plate_clear.applies(P1S, False) is True
  38. assert plate_clear.applies(3, False) is False
  39. def _awaiting_printer_manager():
  40. """Both printers connected, finished and awaiting plate-clear."""
  41. pm = MagicMock()
  42. pm.is_connected.return_value = True
  43. pm.get_status.return_value = MagicMock(state="FINISH")
  44. pm.is_awaiting_plate_clear.return_value = True
  45. return pm
  46. class TestIdleCheck:
  47. @pytest.fixture
  48. def scheduler(self):
  49. return PrintScheduler()
  50. def test_printer_turned_off_is_idle_with_the_setting_on(self, overrides, scheduler):
  51. overrides.set_override(A1, False)
  52. with patch("backend.app.services.print_scheduler.printer_manager", _awaiting_printer_manager()):
  53. assert scheduler._is_printer_idle(A1, True) is True
  54. assert scheduler._is_printer_idle(P1S, True) is False
  55. def test_printer_turned_on_is_held_with_the_setting_off(self, overrides, scheduler):
  56. overrides.set_override(P1S, True)
  57. with patch("backend.app.services.print_scheduler.printer_manager", _awaiting_printer_manager()):
  58. assert scheduler._is_printer_idle(P1S, False) is False
  59. assert scheduler._is_printer_idle(A1, False) is True
  60. def test_drying_ignores_a_printer_turned_on(self, overrides, scheduler):
  61. """Drying never waited for the plate (#2801); a printer's own setting
  62. must not start holding it."""
  63. overrides.set_override(P1S, True)
  64. with patch("backend.app.services.print_scheduler.printer_manager", _awaiting_printer_manager()):
  65. assert scheduler._is_printer_idle(P1S, False, ignore_plate_clear=True) is True
  66. assert scheduler._is_printer_idle(P1S, True, ignore_plate_clear=True) is True
  67. class TestPinnedHoldReason:
  68. def test_printer_turned_off_reads_busy(self, overrides):
  69. overrides.set_override(A1, False)
  70. with patch("backend.app.services.print_scheduler.printer_manager", _awaiting_printer_manager()):
  71. assert PrintScheduler._pinned_hold_reason(A1, "A1 mini", True) == "Busy: A1 mini"
  72. def test_printer_turned_on_waits_for_the_plate(self, overrides):
  73. overrides.set_override(P1S, True)
  74. with patch("backend.app.services.print_scheduler.printer_manager", _awaiting_printer_manager()):
  75. assert PrintScheduler._pinned_hold_reason(P1S, "P1S", False) == "Waiting for plate confirmation: P1S"
  76. class TestWake:
  77. """A printer the gate holds is not powered on for a job; one it does not
  78. hold is, though its flag is up."""
  79. @staticmethod
  80. async def _woken(require_plate_clear: bool) -> tuple[int | None, int | None]:
  81. scheduler = PrintScheduler()
  82. printer = SimpleNamespace(id=A1, name="A1 mini")
  83. plug = SimpleNamespace(id=1, auto_on=True, enabled=True, controls_printer_power=True)
  84. pm = MagicMock()
  85. pm.is_connected.return_value = False
  86. pm.is_awaiting_plate_clear.return_value = True
  87. pm.get_status.return_value = None
  88. with (
  89. patch("backend.app.services.print_scheduler.printer_manager", pm),
  90. patch.object(scheduler, "_printers_for_model", AsyncMock(return_value=[printer])),
  91. patch.object(scheduler, "_cached_filament_shortfall", MagicMock(return_value=[])),
  92. patch.object(scheduler, "_get_smart_plugs", AsyncMock(return_value=[plug])),
  93. patch.object(scheduler, "_power_on_and_wait", AsyncMock(return_value=True)),
  94. ):
  95. return await scheduler._wake_printer_for_model(
  96. AsyncMock(),
  97. [
  98. _ModelCandidate(
  99. target_model="A1M", sliced_for="A1M", required_filament_types=None, filament_overrides=None
  100. )
  101. ],
  102. None,
  103. set(),
  104. {A1},
  105. require_plate_clear,
  106. )
  107. @pytest.mark.asyncio
  108. async def test_printer_turned_off_is_woken_with_the_setting_on(self, overrides):
  109. overrides.set_override(A1, False)
  110. assert await self._woken(True) == (A1, A1)
  111. @pytest.mark.asyncio
  112. async def test_printer_turned_on_is_not_woken_with_the_setting_off(self, overrides):
  113. overrides.set_override(A1, True)
  114. assert await self._woken(False) == (None, None)
  115. class TestKeepWarm:
  116. """Keep-warm holds the bed while someone clears the plate, so it only
  117. runs on a printer the gate applies to."""
  118. @staticmethod
  119. async def _held(require_plate_clear: bool) -> set[int]:
  120. scheduler = PrintScheduler()
  121. items = [
  122. SimpleNamespace(
  123. id=pid,
  124. printer_id=pid,
  125. archive=SimpleNamespace(file_path=None, bed_temperature=60),
  126. preheat_chamber_target_override=60,
  127. )
  128. for pid in (A1, P1S)
  129. ]
  130. clients = {A1: MagicMock(), P1S: MagicMock()}
  131. pm = MagicMock()
  132. pm.get_status.return_value = SimpleNamespace(
  133. state="FINISH", temperatures={"bed_target": 0.0, "chamber": 55.0}, raw_data={}
  134. )
  135. pm.get_client.side_effect = clients.get
  136. settings = {"queue_keep_bed_warm": True, "preheat_enabled": True}
  137. with (
  138. patch("backend.app.services.print_scheduler.printer_manager", pm),
  139. patch.object(
  140. scheduler,
  141. "_get_bool_setting",
  142. AsyncMock(side_effect=lambda _db, key, default: settings.get(key, default)),
  143. ),
  144. patch.object(scheduler, "_get_int_setting", AsyncMock(side_effect=lambda _db, key, default=0: default)),
  145. ):
  146. await scheduler._apply_keep_warm(AsyncMock(), items, [], {A1, P1S}, require_plate_clear)
  147. return {pid for pid, client in clients.items() if client.set_bed_temperature.called}
  148. @pytest.mark.asyncio
  149. async def test_printer_turned_off_is_not_held_with_the_setting_on(self, overrides):
  150. overrides.set_override(A1, False)
  151. assert await self._held(True) == {P1S}
  152. @pytest.mark.asyncio
  153. async def test_printer_turned_on_is_held_with_the_setting_off(self, overrides):
  154. overrides.set_override(P1S, True)
  155. assert await self._held(False) == {P1S}
  156. @pytest.mark.asyncio
  157. async def test_nothing_held_with_the_setting_off_and_no_override(self):
  158. assert await self._held(False) == set()
  159. class TestWled:
  160. """The "queue waiting" preset shows only where the gate holds the queue."""
  161. @staticmethod
  162. def _status(printer_id: int, require_plate_clear: bool) -> str | None:
  163. from backend.app.schemas.printer import WLEDConfig
  164. manager = WLEDManager(client=MagicMock())
  165. manager.require_plate_clear = require_plate_clear
  166. manager._configs[printer_id] = WLEDConfig.model_validate(
  167. {"enabled": True, "base_url": "http://wled.local", "presets": {"queue_waiting": 5, "finished": 6}}
  168. )
  169. sent = []
  170. with patch.object(manager, "_apply_status", lambda pid, config, status, preset: sent.append(status)):
  171. manager.handle_status(
  172. printer_id,
  173. SimpleNamespace(connected=True, state="FINISH", stg_cur=0, hms_errors=[]),
  174. awaiting_plate_clear=True,
  175. )
  176. return sent[0]
  177. def test_printer_turned_off_shows_finished_with_the_setting_on(self, overrides):
  178. overrides.set_override(A1, False)
  179. assert self._status(A1, True) == "finished"
  180. assert self._status(P1S, True) == "queue_waiting"
  181. def test_printer_turned_on_shows_queue_waiting_with_the_setting_off(self, overrides):
  182. overrides.set_override(P1S, True)
  183. assert self._status(P1S, False) == "queue_waiting"
  184. assert self._status(A1, False) == "finished"