fix(service): submit_print_job rollback + paused-jobs nicht persistieren

Adressiert C-1 (PAUSED als QUEUED in DB) und I-1 (kein Rollback).

C-1: on_tape_mismatch=queue Pfad ruft save_queued nicht mehr auf —
PAUSED-Jobs bleiben in-memory-only (Trade-off: Hub-Restart löscht sie,
Phase 3 wird PAUSED in JobState enum aufnehmen).

I-1: happy-path try/except um queue.submit_with_id ergänzt — bei
failure wird DB-Job via mark_failed auf FAILED gesetzt damit keine
stale QUEUED-Rows ohne Worker bleiben.

Refs #93

Author: strausmann

backend/app/services/print_service.py

@@ -72,6 +72,16 @@ async def _resolve_label_data(self, request: PrintRequest) -> LabelData:
         )
 
     async def submit_print_job(self, request: PrintRequest) -> UUID:
+        """Orchestrate template-load → preflight → render → persist → queue.submit.
+
+        Phase-2-Limitationen:
+        - on_tape_mismatch=queue: PAUSED-Jobs bleiben in-memory-only bis resume.
+          Hub-Restart während PAUSED löscht den Job — Phase-2-Trade-off.
+          Phase 3 (Issue #95 wenn erstellt) wird PAUSED in JobState enum aufnehmen
+          + DB-Migration für persistenten paused-state.
+        - tape_mismatch Metadaten (error_code, error_message, error_detail) werden
+          nur in-memory gehalten; keine DB-Row im PAUSED-Pfad.
+        """
         # 1. Load template — fail fast before any I/O if template is unknown.
         template = self._loader.get(request.template_id)
 
@@ -88,14 +98,17 @@ async def submit_print_job(self, request: PrintRequest) -> UUID:
             if request.on_tape_mismatch == "fail":
                 raise mismatch
 
-            # "queue" path: DB-Row anlegen BEVOR an Queue übergeben.
-            # Phase 2: Persist BEFORE queue.submit_paused_with_id so the job
-            # is durable even if the queue crashes before the worker picks it up.
+            # "queue" path: PAUSED-Jobs NICHT in DB persistieren.
+            # C-1-Fix: save_queued würde den Job als QUEUED in DB ablegen, aber
+            # PAUSED ist kein gültiger JobState-Wert. Nach Hub-Restart würde
+            # list_pending() den Job als QUEUED finden und sofort drucken —
+            # obwohl der User noch den Tape wechseln muss (Doppel-Druck-Risiko).
+            # Trade-off: Job geht bei Hub-Restart verloren, nichts wurde gedruckt.
             # R2-M3: PrintRequest hat KEINE api_key_id/source_ip Felder.
             # AuthContext-Integration folgt in einem späteren Task.
             label_data = await self._resolve_label_data(request)
             image = self._renderer.render(template, label_data)
-            db_job = Job(
+            paused_job_id = Job(  # noqa: F841  — id wird aus submit_paused_with_id geholt
                 printer_id=self._printer_id,
                 template_key=request.template_id,
                 payload={
@@ -109,24 +122,24 @@ async def submit_print_job(self, request: PrintRequest) -> UUID:
                 api_key_id=None,   # TODO: aus AuthContext wenn Endpoint-Layer angepasst
                 source_ip=None,    # TODO: aus AuthContext wenn Endpoint-Layer angepasst
             )
-            await self._store.save_queued(db_job)
+            # Keine save_queued() — Job bleibt in-memory-only bis resume.
             await self._queue.submit_paused_with_id(
-                db_job.id,
+                paused_job_id.id,
                 self._printer_id,
                 image,
                 tape_mm=template.tape_mm,
                 auto_cut=request.options.auto_cut,
                 high_resolution=request.options.high_resolution,
             )
             # Tape-mismatch Metadaten an den in-memory Job anhängen
-            in_memory_job = await self._queue.get(str(db_job.id))
+            in_memory_job = await self._queue.get(str(paused_job_id.id))
             in_memory_job.error_code = "tape_mismatch"
             in_memory_job.error_message = str(mismatch)
             in_memory_job.error_detail = {
                 "expected_mm": template.tape_mm,
                 "loaded_mm": preflight.loaded_tape_mm,
             }
-            return db_job.id
+            return paused_job_id.id
 
         # 4. Happy path: resolve label data, render, submit.
         # Phase 2: DB-Row anlegen BEVOR an Queue übergeben (Durability-Garantie).
@@ -149,12 +162,23 @@ async def submit_print_job(self, request: PrintRequest) -> UUID:
             source_ip=None,    # TODO: aus AuthContext wenn Endpoint-Layer angepasst
         )
         await self._store.save_queued(db_job)
-        await self._queue.submit_with_id(
-            db_job.id,
-            self._printer_id,
-            image,
-            tape_mm=template.tape_mm,
-            auto_cut=request.options.auto_cut,
-            high_resolution=request.options.high_resolution,
-        )
+        try:
+            await self._queue.submit_with_id(
+                db_job.id,
+                self._printer_id,
+                image,
+                tape_mm=template.tape_mm,
+                auto_cut=request.options.auto_cut,
+                high_resolution=request.options.high_resolution,
+            )
+        except Exception as exc:
+            # I-1-Fix: in-memory Submit fehlgeschlagen nach DB-Persist — Rollback.
+            # Ohne diesen Rollback bliebe eine stale QUEUED-Row in der DB ohne
+            # Worker-Gegenstück, die nach Hub-Restart fälschlicherweise re-enqueued
+            # würde. mark_failed markiert die Row als FAILED und verhindert das.
+            await self._store.mark_failed(
+                db_job.id,
+                f"submit_failed: {exc.__class__.__name__}: {exc}",
+            )
+            raise
         return db_job.id

backend/tests/unit/services/test_print_service.py

@@ -95,15 +95,18 @@ def backend():
 _PRINTER_ID = UUID("bbbbbbbb-0000-0000-0000-000000000001")
 
 
-def _service(loader, renderer, queue, lookup_service, backend):
-    return PrintService(
+def _service(loader, renderer, queue, lookup_service, backend, store=None):
+    kwargs = dict(
         template_loader=loader,
         renderer=renderer,
         print_queue=queue,
         lookup_service=lookup_service,
         printer_id=_PRINTER_ID,
         backend=backend,
     )
+    if store is not None:
+        kwargs["store"] = store
+    return PrintService(**kwargs)
 
 
 # ---------------------------------------------------------------------------
@@ -470,3 +473,87 @@ async def print_image(self, image, *, tape_mm, **kw):
     assert job.state == JobState.PAUSED, f"Expected PAUSED, got {job.state}"
     assert job.error_code == "tape_mismatch"
     assert job.error_detail == {"expected_mm": 24, "loaded_mm": 12}
+
+
+# ---------------------------------------------------------------------------
+# Fix C-1: PAUSED-Pfad ruft save_queued NICHT auf
+# ---------------------------------------------------------------------------
+
+
+async def test_tape_mismatch_queue_path_does_not_persist_db_job(
+    loader, renderer, queue, lookup_service, backend
+) -> None:
+    """C-1-Fix: on_tape_mismatch=queue → save_queued wird NICHT aufgerufen.
+
+    Vorher wurde der Job als QUEUED persistiert, obwohl er in PAUSED-State
+    versetzt wurde. Nach Hub-Restart würde list_pending() ihn als QUEUED
+    finden und sofort drucken — Doppel-Druck-Risiko.
+    Fix: PAUSED-Jobs bleiben in-memory-only, kein DB-Persist.
+    """
+    backend.preflight_check.return_value = PreflightStatus(
+        hr_printer_status="idle",
+        loaded_tape_mm=12,  # mismatch: template wants 24mm
+        error_flags=[],
+    )
+    job = Job(id="job-1", printer_id=_PRINTER_ID, image_payload=b"", tape_mm=24, options={})
+    from app.services.job_lifecycle import JobStateMachine
+
+    JobStateMachine.transition(job, JobState.PAUSED)
+    queue.submit_paused_with_id.return_value = _FAKE_JOB_UUID
+    queue.get.return_value = job
+
+    mock_store = AsyncMock()
+
+    svc = _service(loader, renderer, queue, lookup_service, backend, store=mock_store)
+    req = PrintRequest(
+        template_id="qr-only-24mm",
+        data=RawLabelData(title="T", primary_id="P", qr_payload="Q"),
+        on_tape_mismatch="queue",
+    )
+
+    job_id = await svc.submit_print_job(req)
+
+    assert isinstance(job_id, UUID)
+    # save_queued darf NICHT aufgerufen worden sein — kein DB-Persist für PAUSED
+    mock_store.save_queued.assert_not_awaited()
+    # submit_paused_with_id muss aber aufgerufen worden sein
+    queue.submit_paused_with_id.assert_awaited_once()
+
+
+# ---------------------------------------------------------------------------
+# Fix I-1: Rollback bei queue.submit_with_id Fehler
+# ---------------------------------------------------------------------------
+
+
+async def test_submit_with_failing_queue_marks_db_job_failed(
+    loader, renderer, queue, lookup_service, backend
+) -> None:
+    """I-1-Fix: Wenn queue.submit_with_id wirft, muss der DB-Job auf FAILED gesetzt werden.
+
+    Ohne Rollback bliebe eine stale QUEUED-Row in der DB ohne Worker-Gegenstück.
+    Nach Hub-Restart würde list_pending() sie finden und re-enqueuen — aber der
+    Job hat keinen gültigen Zustand mehr.
+    Fix: try/except um submit_with_id, bei Exception → mark_failed + re-raise.
+    """
+    submit_error = RuntimeError("asyncio.Queue voll oder andere Fehlerursache")
+    queue.submit_with_id.side_effect = submit_error
+
+    mock_store = AsyncMock()
+
+    svc = _service(loader, renderer, queue, lookup_service, backend, store=mock_store)
+    req = PrintRequest(
+        template_id="qr-only-24mm",
+        data=RawLabelData(title="T", primary_id="P", qr_payload="Q"),
+    )
+
+    with pytest.raises(RuntimeError):
+        await svc.submit_print_job(req)
+
+    # save_queued muss aufgerufen worden sein (DB-Persist vor submit)
+    mock_store.save_queued.assert_awaited_once()
+    # mark_failed muss aufgerufen worden sein mit passendem error-String
+    mock_store.mark_failed.assert_awaited_once()
+    call_args = mock_store.mark_failed.call_args
+    error_msg: str = call_args.args[1] if call_args.args else call_args.kwargs["error"]
+    assert "submit_failed" in error_msg
+    assert "RuntimeError" in error_msg