| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586 |
- """Nozzle-aware printer pick for "Any <model>" queue items (#3536).
- Before #3536 the model-based pick looked at model, filament and state but not
- at the nozzle: a file sliced for 0.6 mm could be assigned to a printer with a
- 0.4 mm nozzle and then fail in ``_start_print``. These tests cover the pieces
- of the fix in order: the sliced diameter carried on each candidate, then the
- printer filter built on it.
- """
- from contextlib import ExitStack
- from types import SimpleNamespace
- from unittest.mock import AsyncMock, MagicMock, patch
- import pytest
- from sqlalchemy import select
- from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
- from sqlalchemy.orm import selectinload
- import backend.app.models # noqa: F401 - populate Base.metadata
- from backend.app.core.database import Base
- from backend.app.core.printer_scope import ALL_PRINTERS
- from backend.app.models.library import LibraryFile
- from backend.app.models.print_queue import PrintQueueItem
- from backend.app.models.printer import Printer
- from backend.app.services.print_scheduler import (
- PrintScheduler,
- _asks_nothing_new,
- _candidates_for,
- _ModelCandidate,
- _sliced_nozzle,
- _wrong_nozzle_label,
- )
- from backend.tests.unit.test_scheduler_dispatch_order_2915 import PRINTERS as ORDER_PRINTERS, _farm
- # --- Sliced diameter per candidate -------------------------------------------
- def _item(*, variants=None, archive=None, library_file=None):
- return SimpleNamespace(
- variants=variants or [],
- archive=archive,
- archive_id=1 if archive is not None else None,
- library_file=library_file,
- library_file_id=2 if library_file is not None else None,
- target_model="A1",
- required_filament_types=None,
- filament_overrides=None,
- )
- def _variant(vid, nozzle):
- return SimpleNamespace(
- id=vid,
- position=vid,
- attempt_count=0,
- target_model="A1",
- required_filament_types=None,
- filament_overrides=None,
- library_file=SimpleNamespace(deleted_at=None, file_metadata={"nozzle_diameter": nozzle}),
- )
- def test_sliced_nozzle_from_archive():
- assert _sliced_nozzle(SimpleNamespace(nozzle_diameter=0.6), None) == 0.6
- def test_sliced_nozzle_from_library_metadata():
- assert _sliced_nozzle(None, SimpleNamespace(file_metadata={"nozzle_diameter": 0.6})) == 0.6
- def test_sliced_nozzle_unknown():
- assert _sliced_nozzle(None, SimpleNamespace(file_metadata=None)) is None
- assert _sliced_nozzle(None, SimpleNamespace(file_metadata={})) is None
- assert _sliced_nozzle(None, None) is None
- def test_sliced_nozzle_rejects_garbage_and_non_positive():
- assert _sliced_nozzle(SimpleNamespace(nozzle_diameter=0), None) is None
- assert _sliced_nozzle(SimpleNamespace(nozzle_diameter=-0.4), None) is None
- assert _sliced_nozzle(None, SimpleNamespace(file_metadata={"nozzle_diameter": "abc"})) is None
- assert _sliced_nozzle(None, SimpleNamespace(file_metadata={"nozzle_diameter": [0.4]})) is None
- assert _sliced_nozzle(None, SimpleNamespace(file_metadata={"nozzle_diameter": "0.6"})) == 0.6
- def test_sliced_nozzle_is_read_without_rounding():
- # The tolerance lives in _nozzle_mismatch_message, not here.
- meta = SimpleNamespace(file_metadata={"nozzle_diameter": "0.6000001"})
- assert _sliced_nozzle(None, meta) == 0.6000001
- def test_candidates_carry_their_own_nozzle():
- single = _item(library_file=SimpleNamespace(file_metadata={"nozzle_diameter": 0.6}))
- assert [c.sliced_nozzle for c in _candidates_for(single)] == [0.6]
- multi = _item(variants=[_variant(1, 0.4), _variant(2, 0.6)])
- assert sorted(c.sliced_nozzle for c in _candidates_for(multi)) == [0.4, 0.6]
- # --- Does this nozzle fit? ---------------------------------------------------
- def _state(*diameters: str):
- """PrinterState-shaped namespace with the given nozzle diameter strings."""
- return SimpleNamespace(nozzles=[SimpleNamespace(nozzle_diameter=d) for d in diameters])
- def _h2c(*rack: tuple[int, str], mounted: str = "0.4"):
- """H2C-shaped state: one mounted hotend plus docked nozzles (#2885 shape)."""
- info = [{"id": 0, "diameter": mounted, "wear": 0, "max_temp": 350, "serial_number": "SN0"}]
- info += [
- {"id": nozzle_id, "diameter": d, "wear": 0, "max_temp": 350, "serial_number": f"SN{nozzle_id}"}
- for nozzle_id, d in rack
- ]
- return SimpleNamespace(nozzles=[SimpleNamespace(nozzle_diameter=mounted)], nozzle_rack=info)
- def test_wrong_nozzle_label_single_and_dual():
- assert _wrong_nozzle_label("A1-1", _state("0.4"), 0.6) == "A1-1 (0.4mm)"
- assert _wrong_nozzle_label("A1-1", _state("0.6"), 0.6) is None
- assert _wrong_nozzle_label("H2D-1", _state("0.4", "0.4"), 0.6) == "H2D-1 (0.4mm)"
- assert _wrong_nozzle_label("H2D-1", _state("0.4", "0.6"), 0.6) is None
- def test_wrong_nozzle_label_unknown_fits():
- assert _wrong_nozzle_label("A1-1", _state("0.4"), None) is None
- assert _wrong_nozzle_label("A1-1", _state("0.4"), 0) is None
- assert _wrong_nozzle_label("A1-1", None, 0.6) is None
- assert _wrong_nozzle_label("A1-1", _state(""), 0.6) is None # nothing reported
- def test_wrong_nozzle_label_rack():
- assert _wrong_nozzle_label("H2C-1", _h2c((16, "0.6")), 0.6) is None
- assert _wrong_nozzle_label("H2C-1", _h2c((16, "0.2"), (18, "0.8")), 0.6) == "H2C-1 (0.4mm, rack 0.2mm / 0.8mm)"
- def test_wrong_nozzle_label_rack_without_mounted_nozzle():
- status = SimpleNamespace(
- nozzles=[SimpleNamespace(nozzle_diameter="")],
- nozzle_rack=[{"id": 16, "diameter": "0.2", "max_temp": 350, "serial_number": "SN16"}],
- )
- assert _wrong_nozzle_label("H2C-1", status, 0.6) == "H2C-1 (no nozzle mounted, rack 0.2mm)"
- SIZES = ["0.2", "0.4", "0.6", "0.8"]
- @pytest.mark.parametrize("sliced", SIZES)
- @pytest.mark.parametrize("installed", SIZES)
- def test_only_the_same_size_fits(sliced, installed):
- # Same size fits, every other (also the neighbouring one) never does.
- label = _wrong_nozzle_label("A1-1", _state(installed), float(sliced))
- if sliced == installed:
- assert label is None
- else:
- assert label == f"A1-1 ({installed}mm)"
- def test_float_noise_from_metadata_still_fits():
- assert _wrong_nozzle_label("A1-1", _state("0.6"), 0.6000001) is None
- assert _wrong_nozzle_label("A1-1", _state("0.4"), 0.6000001) == "A1-1 (0.4mm)"
- # --- Matcher: passes over a printer with the wrong nozzle --------------------
- @pytest.fixture
- async def a1_farm():
- """Two A1s in "Workshop"; A1-1 is the one with fewer print hours."""
- engine = create_async_engine("sqlite+aiosqlite:///:memory:", echo=False)
- async with engine.begin() as conn:
- await conn.run_sync(Base.metadata.create_all)
- session_maker = async_sessionmaker(engine, expire_on_commit=False)
- async with session_maker() as db:
- db.add_all(
- [
- Printer(
- id=pid,
- name=f"A1-{pid}",
- serial_number=f"A1000{pid}",
- ip_address=f"192.0.2.{pid}",
- access_code="x",
- model="A1",
- is_active=True,
- location="Workshop",
- runtime_seconds=pid * 3600,
- )
- for pid in (1, 2)
- ]
- )
- await db.commit()
- try:
- yield SimpleNamespace(session_maker=session_maker)
- finally:
- await engine.dispose()
- async def _find(ctx, scheduler, states, *, model="A1", exclude=frozenset(), connected=True, idle=None, **kwargs):
- """Run the matcher; ``states`` maps printer id to its reported state (or None)."""
- idle = idle or {}
- with (
- patch("backend.app.services.print_scheduler.printer_manager.get_status", lambda pid: states.get(pid)),
- patch(
- "backend.app.services.print_scheduler.printer_manager.is_connected",
- lambda pid: connected if not callable(connected) else connected(pid),
- ),
- patch.object(scheduler, "_is_printer_idle", lambda pid, *_a, **_k: idle.get(pid, True)),
- ):
- async with ctx.session_maker() as db:
- return await scheduler._find_idle_printer_for_model(db, model, set(exclude), **kwargs)
- class TestMatcherNozzle:
- @pytest.mark.asyncio
- async def test_skips_the_printer_with_the_wrong_nozzle(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.6")}
- assert await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=0.6) == (2, None)
- @pytest.mark.asyncio
- async def test_no_printer_fits_names_every_nozzle(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.4")}
- assert await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=0.6) == (
- None,
- "No A1 has a 0.6mm nozzle: A1-1 (0.4mm), A1-2 (0.4mm)",
- )
- @pytest.mark.asyncio
- async def test_reason_names_the_location(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.4")}
- _, reason = await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=0.6, target_location="Workshop")
- assert reason.startswith("No A1 in Workshop has a 0.6mm nozzle: ")
- @pytest.mark.asyncio
- async def test_float_noise_in_the_sliced_size_is_not_shown(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.4")}
- _, reason = await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=0.6000001)
- assert reason.startswith("No A1 has a 0.6mm nozzle: ")
- @pytest.mark.asyncio
- async def test_unknown_sliced_nozzle_behaves_as_before(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.6")}
- assert await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=None) == (1, None)
- @pytest.mark.asyncio
- async def test_printer_without_status_fits(self, a1_farm):
- states = {1: None, 2: _state("0.4")}
- assert await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=0.6) == (1, None)
- @pytest.mark.asyncio
- async def test_wrong_nozzle_printer_does_not_hide_a_busy_matching_one(self, a1_farm):
- """The only printer that fits is busy: the job just waits, silently."""
- states = {1: _state("0.4"), 2: _state("0.6")}
- pick, reason = await _find(a1_farm, PrintScheduler(), states, exclude={2}, sliced_nozzle=0.6)
- assert pick is None
- assert reason == "Busy: A1-2"
- assert PrintScheduler._is_busy_only(reason) is True
- @pytest.mark.asyncio
- async def test_busy_or_offline_wrong_nozzle_printers_read_as_nozzle_not_busy(self, a1_farm):
- """A1-1 is printing, A1-2 offline, both 0.4: waiting would never help."""
- states = {1: _state("0.4"), 2: _state("0.4")}
- pick, reason = await _find(
- a1_farm,
- PrintScheduler(),
- states,
- connected=lambda pid: pid == 1,
- idle={1: False},
- sliced_nozzle=0.6,
- )
- assert pick is None
- assert reason == "No A1 has a 0.6mm nozzle: A1-1 (0.4mm), A1-2 (0.4mm)"
- @pytest.mark.asyncio
- async def test_excluded_wrong_nozzle_printer_is_not_listed_as_busy(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.4")}
- _, reason = await _find(a1_farm, PrintScheduler(), states, exclude={1, 2}, sliced_nozzle=0.6)
- assert reason.startswith("No A1 has a 0.6mm nozzle: ")
- @pytest.mark.asyncio
- async def test_nozzle_reason_is_not_busy_only_and_asks_something(self, a1_farm):
- states = {1: _state("0.4"), 2: _state("0.4")}
- _, reason = await _find(a1_farm, PrintScheduler(), states, sliced_nozzle=0.6)
- assert PrintScheduler._is_busy_only(reason) is False
- assert _asks_nothing_new(reason) is False
- @pytest.mark.asyncio
- async def test_missing_filament_and_wrong_nozzle_mixed(self, a1_farm):
- """A1-1 has the wrong nozzle, A1-2 fits but lacks PETG: only the filament is named."""
- scheduler = PrintScheduler()
- states = {1: _state("0.4"), 2: _state("0.6")}
- with patch.object(
- scheduler, "_get_missing_filament_types", lambda pid, _types, *_a, **_k: ["PETG"] if pid == 2 else []
- ):
- pick, reason = await _find(a1_farm, scheduler, states, sliced_nozzle=0.6, required_filament_types=["PETG"])
- assert pick is None
- assert reason == "Waiting for filament: A1-2 (needs PETG)"
- # --- Wake path: does not power on a printer with the wrong nozzle ------------
- class TestWakeNozzle:
- async def _wake(self, ctx, sliced_nozzle):
- scheduler = PrintScheduler()
- plug = SimpleNamespace(id=1, auto_on=True, enabled=True, controls_printer_power=True)
- power_on = AsyncMock(return_value=True)
- # Both printers are off but keep their last status (A1-1 0.4, A1-2 0.6).
- states = {1: _state("0.4"), 2: _state("0.6")}
- with (
- patch("backend.app.services.print_scheduler.printer_manager.is_connected", MagicMock(return_value=False)),
- patch(
- "backend.app.services.print_scheduler.printer_manager.is_awaiting_plate_clear",
- MagicMock(return_value=False),
- ),
- patch("backend.app.services.print_scheduler.printer_manager.get_status", lambda pid: states.get(pid)),
- patch.object(scheduler, "_cached_filament_shortfall", MagicMock(return_value=[])),
- patch.object(scheduler, "_get_smart_plugs", AsyncMock(return_value=[plug])),
- patch.object(scheduler, "_power_on_and_wait", power_on),
- ):
- async with ctx.session_maker() as db:
- return await scheduler._wake_printer_for_model(
- db,
- [
- _ModelCandidate(
- target_model="A1",
- sliced_for=None,
- required_filament_types=None,
- filament_overrides=None,
- sliced_nozzle=sliced_nozzle,
- )
- ],
- None,
- set(),
- {1, 2},
- require_plate_clear=False,
- )
- @pytest.mark.asyncio
- async def test_wakes_the_printer_whose_nozzle_fits(self, a1_farm):
- assert await self._wake(a1_farm, 0.6) == (2, 2)
- @pytest.mark.asyncio
- async def test_unknown_sliced_nozzle_wakes_the_least_worn_as_before(self, a1_farm):
- assert await self._wake(a1_farm, None) == (1, 1)
- # --- Queue pass: end to end ---------------------------------------------------
- async def _add_any_a1(ctx, nozzle, **fields):
- async with ctx.session_maker() as db:
- lib = LibraryFile(
- filename="part-a.gcode.3mf",
- file_path="/library/part-a.gcode.3mf",
- file_size=10,
- file_type="gcode.3mf",
- file_metadata={"nozzle_diameter": nozzle},
- )
- db.add(lib)
- await db.flush()
- values = {"status": "pending", "position": 1, "target_model": "A1", "library_file_id": lib.id}
- values.update(fields)
- item = PrintQueueItem(**values)
- db.add(item)
- await db.commit()
- return item.id
- async def _load(db, item_id):
- return (
- await db.execute(
- select(PrintQueueItem)
- .where(PrintQueueItem.id == item_id)
- .options(
- selectinload(PrintQueueItem.library_file),
- selectinload(PrintQueueItem.archive),
- selectinload(PrintQueueItem.variants),
- )
- )
- ).scalar_one()
- async def _get_item(ctx, item_id):
- async with ctx.session_maker() as db:
- return await _load(db, item_id)
- class TestQueuePassNozzle:
- async def _pass(self, ctx, states):
- scheduler = PrintScheduler()
- launched = MagicMock()
- dispatched = AsyncMock()
- patches = [
- patch("backend.app.services.print_scheduler.async_session", ctx.session_maker),
- patch("backend.app.core.database.async_session", ctx.session_maker),
- patch("backend.app.services.print_scheduler.printer_manager.is_connected", MagicMock(return_value=True)),
- patch("backend.app.services.print_scheduler.printer_manager.get_status", lambda pid: states.get(pid)),
- patch(
- "backend.app.services.print_scheduler.ha_sensor_manager.blocked_printers",
- AsyncMock(return_value={}),
- ),
- patch(
- "backend.app.services.notification_service.notification_service.on_queue_job_waiting",
- AsyncMock(),
- ),
- patch(
- "backend.app.services.notification_service.notification_service.on_queue_job_assigned",
- AsyncMock(),
- ),
- patch("backend.app.services.print_scheduler.compute_deficit_for_queue_item", AsyncMock(return_value=[])),
- patch.object(scheduler, "_filament_short_on", AsyncMock(return_value=False)),
- patch.object(scheduler, "_is_printer_idle", MagicMock(return_value=True)),
- patch.object(scheduler, "_check_auto_drying", AsyncMock()),
- patch.object(scheduler, "_ensure_ams_mapping", AsyncMock(return_value=None)),
- patch.object(scheduler, "_block_on_unmatched_filament", AsyncMock(return_value=False)),
- patch.object(scheduler, "_unmatched_on", AsyncMock(return_value=[])),
- patch.object(scheduler, "_launch_uploads", launched),
- patch.object(scheduler, "_dispatch_one", dispatched),
- ]
- with ExitStack() as stack:
- for p in patches:
- stack.enter_context(p)
- await scheduler.check_queue()
- return launched, dispatched
- @pytest.mark.asyncio
- async def test_waits_with_the_nozzle_reason_when_no_printer_fits(self, a1_farm):
- item_id = await _add_any_a1(a1_farm, 0.6)
- launched, dispatched = await self._pass(a1_farm, {1: _state("0.4"), 2: _state("0.4")})
- item = await _get_item(a1_farm, item_id)
- assert item.status == "pending"
- assert item.printer_id is None
- assert item.waiting_reason == "No A1 has a 0.6mm nozzle: A1-1 (0.4mm), A1-2 (0.4mm)"
- launched.assert_not_called()
- dispatched.assert_not_called()
- @pytest.mark.asyncio
- async def test_goes_to_the_printer_whose_nozzle_fits(self, a1_farm):
- item_id = await _add_any_a1(a1_farm, 0.6)
- launched, _ = await self._pass(a1_farm, {1: _state("0.4"), 2: _state("0.6")})
- launched.assert_called_once()
- assert launched.call_args[0][0] == [item_id]
- assert launched.call_args[0][1] == {item_id: 2}
- assert (await _get_item(a1_farm, item_id)).printer_id == 2
- # --- Low-filament hold release -----------------------------------------------
- class TestShortHoldNozzle:
- """A job held for low filament on A1-1 only moves to a printer whose nozzle fits.
- Without the nozzle the move would pin it on a 0.4 mm A1, where the
- dispatch guard (#1899) then fails it.
- """
- async def _release(self, ctx, states):
- item_id = await _add_any_a1(ctx, 0.6, printer_id=1, manual_start=True, filament_short=True)
- scheduler = PrintScheduler()
- async def short_on(db, item, printer_id, *, require_known=False):
- return printer_id == 1 # A1-2 has enough filament
- with (
- patch("backend.app.services.print_scheduler.printer_manager.is_connected", MagicMock(return_value=True)),
- patch("backend.app.services.print_scheduler.printer_manager.get_status", lambda pid: states.get(pid)),
- patch.object(scheduler, "_filament_short_on", AsyncMock(side_effect=short_on)),
- patch.object(scheduler, "_unmatched_on", AsyncMock(return_value=[])),
- patch.object(scheduler, "_is_printer_idle", MagicMock(return_value=True)),
- ):
- async with ctx.session_maker() as db:
- item = await _load(db, item_id)
- moved = await scheduler._release_short_model_hold(db, item, set(), False, ALL_PRINTERS)
- return moved, item.printer_id
- @pytest.mark.asyncio
- async def test_not_moved_to_a_printer_with_the_wrong_nozzle(self, a1_farm):
- assert await self._release(a1_farm, {1: _state("0.6"), 2: _state("0.4")}) == (False, 1)
- @pytest.mark.asyncio
- async def test_moved_to_a_printer_whose_nozzle_fits(self, a1_farm):
- assert await self._release(a1_farm, {1: _state("0.6"), 2: _state("0.6")}) == (True, 2)
- # --- Auto-drying: which printers an "Any model" job counts for ---------------
- class TestDryingPrinterIds:
- """An "Any A1" job that no 0.4 mm A1 can print must not block or trigger drying there."""
- async def _ids(self, ctx, nozzle, states):
- item_id = await _add_any_a1(ctx, nozzle)
- with patch("backend.app.services.print_scheduler.printer_manager.get_status", lambda pid: states.get(pid)):
- async with ctx.session_maker() as db:
- item = await _load(db, item_id)
- return await PrintScheduler()._model_job_printer_ids(db, item, ALL_PRINTERS, {})
- @pytest.mark.asyncio
- async def test_only_printers_whose_nozzle_fits_count(self, a1_farm):
- assert await self._ids(a1_farm, 0.6, {1: _state("0.4"), 2: _state("0.6")}) == {2}
- @pytest.mark.asyncio
- async def test_unknown_sliced_nozzle_counts_every_printer(self, a1_farm):
- assert await self._ids(a1_farm, None, {1: _state("0.4"), 2: _state("0.6")}) == {1, 2}
- # --- Chosen pick order (#2915) plus nozzle ------------------------------------
- class TestPickOrderNozzle:
- """The nozzle check passes a printer over whatever order the setting picks in.
- Farm from the #2915 tests: X1C-1 most worn (priority 2), X1C-2 priority 1,
- X1C-3 fewest hours (no priority).
- """
- async def _pick(self, setting, nozzles, sliced_nozzle=0.6):
- engine, ctx = await _farm(setting, **ORDER_PRINTERS)
- try:
- states = {pid: _state(d) for pid, d in nozzles.items()}
- return await _find(ctx, PrintScheduler(), states, model="X1C", sliced_nozzle=sliced_nozzle)
- finally:
- await engine.dispose()
- @pytest.mark.asyncio
- @pytest.mark.parametrize(
- ("setting", "nozzles", "expected"),
- [
- ("priority", {1: "0.6", 2: "0.4", 3: "0.6"}, 1), # priority 1 has the wrong nozzle
- ("priority", {1: "0.4", 2: "0.4", 3: "0.6"}, 3), # only the one without priority fits
- ("most_hours", {1: "0.4", 2: "0.6", 3: "0.6"}, 2), # the most worn has the wrong nozzle
- ("fewest_hours", {1: "0.6", 2: "0.6", 3: "0.4"}, 2), # the least worn has the wrong nozzle
- ],
- )
- async def test_the_next_printer_in_the_chosen_order_whose_nozzle_fits(self, setting, nozzles, expected):
- assert await self._pick(setting, nozzles) == (expected, None)
- @pytest.mark.asyncio
- async def test_the_reason_names_the_printers_in_the_chosen_order(self):
- assert await self._pick("priority", {1: "0.4", 2: "0.4", 3: "0.4"}) == (
- None,
- "No X1C has a 0.6mm nozzle: X1C-2 (0.4mm), X1C-1 (0.4mm), X1C-3 (0.4mm)",
- )
- @pytest.mark.asyncio
- async def test_the_wake_step_passes_over_the_first_in_order_with_the_wrong_nozzle(self):
- """All off; X1C-2 (priority 1) last reported 0.4, so X1C-1 is woken instead."""
- engine, ctx = await _farm("priority", **ORDER_PRINTERS)
- scheduler = PrintScheduler()
- plug = SimpleNamespace(id=1, auto_on=True, enabled=True, controls_printer_power=True)
- states = {1: _state("0.6"), 2: _state("0.4"), 3: _state("0.6")}
- try:
- with (
- patch(
- "backend.app.services.print_scheduler.printer_manager.is_connected", MagicMock(return_value=False)
- ),
- patch(
- "backend.app.services.print_scheduler.printer_manager.is_awaiting_plate_clear",
- MagicMock(return_value=False),
- ),
- patch("backend.app.services.print_scheduler.printer_manager.get_status", lambda pid: states.get(pid)),
- patch.object(scheduler, "_cached_filament_shortfall", MagicMock(return_value=[])),
- patch.object(scheduler, "_get_smart_plugs", AsyncMock(return_value=[plug])),
- patch.object(scheduler, "_power_on_and_wait", AsyncMock(return_value=True)),
- ):
- async with ctx.session_maker() as db:
- woken = await scheduler._wake_printer_for_model(
- db,
- [
- _ModelCandidate(
- target_model="X1C",
- sliced_for=None,
- required_filament_types=None,
- filament_overrides=None,
- sliced_nozzle=0.6,
- )
- ],
- None,
- set(),
- {1, 2, 3},
- require_plate_clear=False,
- )
- finally:
- await engine.dispose()
- assert woken == (1, 1)
|