feat(queue): PrintQueue ruft JobStore bei jeder State-Transition (Phase 2)

QUEUED -> PRINTING -> DONE/FAILED wird synchron in der DB persistiert.
Konstruktor bekommt store: JobStore als optionalen Parameter (Default:
MemoryJobStore für Rückwärtskompatibilität). Worker bridget dataclass.id
(str) via UUID(job.id) an den Store. Skip-Check bleibt vor mark_printing.
_jobs dict bleibt für laufende Drucke mit image_payload erhalten.

Refs #93

Author: strausmann

backend/app/services/print_queue.py

@@ -40,6 +40,7 @@
     JobState,
     JobStateMachine,
 )
+from app.services.job_store import JobStore, MemoryJobStore
 
 
 # Callback type: called after each state transition.  The optional queue_depth
@@ -134,8 +135,10 @@ def __init__(
         self,
         printers: list[_PrinterLike],
         on_state_change: _StateChangeCallback | None = None,
+        store: JobStore | None = None,
     ) -> None:
         self._on_state_change = on_state_change
+        self._store: JobStore = store if store is not None else MemoryJobStore()
         self._printers: dict[UUID, _PrinterLike] = {p.id: p for p in printers}
         # Queue type is Job | None — None is the sentinel used by stop() to wake
         # workers that are blocked at queue.get().
@@ -513,6 +516,9 @@ async def _worker(self, printer_id: UUID) -> None:
             if job.state != JobState.QUEUED:
                 continue
 
+            # Phase 2: DB-State QUEUED->PRINTING persistieren (bridge: dataclass.id ist str)
+            await self._store.mark_printing(UUID(job.id))
+
             try:
                 _from = job.state
                 JobStateMachine.transition(job, JobState.PRINTING)
@@ -532,6 +538,7 @@ async def _worker(self, printer_id: UUID) -> None:
                 await printer.print_image(image, tape_mm=job.tape_mm, **job.options)
                 _from = job.state
                 JobStateMachine.transition(job, JobState.COMPLETED)
+                await self._store.mark_done(UUID(job.id))  # Phase 2: DB-State persistieren
                 self._notify_state_change(
                     job,
                     _from,
@@ -564,6 +571,8 @@ async def _worker(self, printer_id: UUID) -> None:
                         job.state,
                         exc,
                     )
+                # Phase 2: DB-State persistieren (auch wenn Transition fehlschlug)
+                await self._store.mark_failed(UUID(job.id), f"{code}: {msg}")
                 logger.exception("Job %s failed on %s (printer error)", job.id, printer_id)
                 if isinstance(exc, _RECOVERABLE_PRINTER_ERRORS):
                     # Halt the whole printer queue — user must change tape /
@@ -589,4 +598,6 @@ async def _worker(self, printer_id: UUID) -> None:
                         job.state,
                         exc,
                     )
+                # Phase 2: DB-State persistieren (auch wenn Transition fehlschlug)
+                await self._store.mark_failed(UUID(job.id), str(exc))
                 logger.exception("Job %s failed on %s", job.id, printer_id)

backend/tests/unit/services/test_print_queue_persistence.py

@@ -0,0 +1,95 @@
+"""PrintQueue muss store.mark_* bei jeder State-Transition aufrufen.
+
+Tests verwenden die echte PrintQueue-Signatur:
+    PrintQueue(printers=[...], on_state_change=None, store=store)
+
+Der Worker bridget dataclass-Job.id (str) via UUID(job.id) an den Store.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+from uuid import UUID, uuid4
+
+import pytest
+from PIL import Image
+
+from app.services.job_store import MemoryJobStore
+from app.services.print_queue import PrintQueue
+
+# Stabile Printer-UUID für alle Tests in diesem Modul
+_PRINTER_ID = UUID("cccccccc-0000-0000-0000-000000000001")
+
+
+def _make_printer(printer_id: UUID = _PRINTER_ID) -> MagicMock:
+    """Erstellt einen schnellen Fake-Printer der print_image sofort beendet."""
+    printer = MagicMock()
+    printer.id = printer_id
+    printer.print_image = AsyncMock(return_value=None)
+    return printer
+
+
+def _sample_image() -> Image.Image:
+    return Image.new("1", (300, 76))
+
+
+@pytest.mark.asyncio
+async def test_printqueue_constructor_accepts_store() -> None:
+    """PrintQueue.__init__ muss store=JobStore annehmen und in _store ablegen."""
+    store = MemoryJobStore()
+    queue = PrintQueue(
+        printers=[_make_printer()],
+        store=store,
+    )
+    assert queue._store is store
+
+
+@pytest.mark.asyncio
+async def test_printqueue_calls_mark_printing_then_mark_done() -> None:
+    """Worker muss store.mark_printing dann store.mark_done bei Erfolg aufrufen."""
+    store = AsyncMock(spec=MemoryJobStore)
+    printer = _make_printer()
+    queue = PrintQueue(
+        printers=[printer],
+        store=store,
+    )
+    await queue.start()
+    try:
+        job_id = await queue.submit(_PRINTER_ID, _sample_image(), tape_mm=12)
+        await queue.wait_for_job(job_id, timeout_s=5)
+    finally:
+        await queue.stop()
+
+    # job.id ist str — Store-Calls bekommen UUID(job_id)
+    expected_uuid = UUID(job_id)
+    store.mark_printing.assert_awaited_once_with(expected_uuid)
+    store.mark_done.assert_awaited_once_with(expected_uuid)
+    store.mark_failed.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_printqueue_calls_mark_failed_on_printer_error() -> None:
+    """Worker muss store.mark_failed aufrufen wenn printer.print_image wirft."""
+    from app.printer_backends.exceptions import PrinterError
+
+    store = AsyncMock(spec=MemoryJobStore)
+    printer = _make_printer()
+    printer.print_image = AsyncMock(side_effect=PrinterError("tape_empty"))
+    queue = PrintQueue(
+        printers=[printer],
+        store=store,
+    )
+    await queue.start()
+    try:
+        job_id = await queue.submit(_PRINTER_ID, _sample_image(), tape_mm=12)
+        await queue.wait_for_job(job_id, timeout_s=5)
+    finally:
+        await queue.stop()
+
+    expected_uuid = UUID(job_id)
+    store.mark_printing.assert_awaited_once_with(expected_uuid)
+    store.mark_failed.assert_awaited_once()
+    # erstes Argument des einzigen Calls muss die richtige UUID sein
+    actual_uuid = store.mark_failed.call_args.args[0]
+    assert actual_uuid == expected_uuid
+    store.mark_done.assert_not_awaited()