tests: fixed operation tests after refactoring and added runtime state

tests/unit/daq/operations/face_detection/test_face_detection_service.py

@@ -4,12 +4,17 @@ import pytest
 
 from aare.common.coordinate import Coordinate, SmargonCoordinate
 from aare.common.models import BoundingBoxModel, MLBoxModel, MLBoxType, ZoomModeEnum
+from aare.daq.operations.common import runtime
 from aare.daq.operations.face_detection.models import (
     FaceDetectionContext,
     FaceDetectionResult,
 )
 from aare.daq.operations.face_detection.service import FaceDetectionService
-
+from aare.daq.operations.common.runtime import (
+    DAQRuntimeState,
+    SampleProvider,
+    StatusProvider,
+    FaceDetectionProgressEmitter)
 
 class DummyGeometry:
     def __init__(self):
@@ -47,6 +52,19 @@ def context():
 
     cfg = types.SimpleNamespace(zoom_mode=ZoomModeEnum.User)
 
+    def emit_progress(payload):
+        progress_events.append(payload)
+
+    runtime_state = DAQRuntimeState(
+        sample_provider=types.SimpleNamespace(sample=None),
+        sample_geometry_provider=types.SimpleNamespace(sample_geometry=DummyGeometry()),
+        status_provider=types.SimpleNamespace(status=None),
+    )
+
+    progress_emitter = FaceDetectionProgressEmitter(
+        reporter=types.SimpleNamespace(emit_progress=emit_progress)
+    )
+
     ctx = FaceDetectionContext(
         cfg=cfg,
         devs=devs,
@@ -55,10 +73,10 @@ def context():
                 box=None,
                 target_point=None,
                 focus=None,
-            )
+            ),
         ),
-        sample_geometry_provider=lambda: DummyGeometry(),
-        emit_progress=lambda payload: progress_events.append(payload),
+        runtime=runtime_state,
+        progress_emitter=progress_emitter
     )
     ctx._progress_events = progress_events
     return ctx

tests/unit/daq/operations/loop_centering/test_loop_centering_analyzer.py

@@ -5,6 +5,7 @@ import pytest
 from aare.common.coordinate import Coordinate, SmargonCoordinate
 from aare.common.models import MLBoxType, MLOutputModel
 from aare.daq.mlbox import MLBoxPredictionsResult
+from aare.daq.operations.common.runtime import DAQRuntimeState, TraceWriter, PredictionProvider, OperationServices
 from aare.daq.operations.loop_centering.analyzer import LoopCenteringAnalyzer
 from aare.daq.operations.loop_centering.models import (
     LoopCenteringContext,
@@ -35,19 +36,35 @@ def _coord_target(x: float, y: float, z: float = 0.0) -> SmargonCoordinate:
 
 @pytest.fixture
 def analyzer(mock_logger):
+    runtime_state = DAQRuntimeState(
+        sample_provider=types.SimpleNamespace(sample=None),
+        sample_geometry_provider=types.SimpleNamespace(sample_geometry=DummyGeometry()),
+        status_provider=types.SimpleNamespace(status=None),
+    )
+
     ctx = LoopCenteringContext(
         cfg=types.SimpleNamespace(),
         devs=types.SimpleNamespace(),
         mlbox=DummyMlBox(),
         settings=LoopCenteringSettings(),
-        sample_geometry_provider=lambda: DummyGeometry(),
-        save_screenshot_db=lambda *args, **kwargs: None,
-        append_smargon_trace=lambda *args, **kwargs: None,
-        get_predictions=lambda: MLBoxPredictionsResult(
-            predictions=None,
-            image=None,
-            target_point=None,
-            focus=None,
+        runtime=runtime_state,
+        services=OperationServices(
+            screenshots=types.SimpleNamespace(
+                save_to_db=lambda *args, **kwargs: None
+            )
+        ),
+        trace_writer=TraceWriter(
+            appender=types.SimpleNamespace(append_smargon_trace=lambda *args, **kwargs: None)
+        ),
+        prediction_provider=PredictionProvider(
+            getter=types.SimpleNamespace(
+                get_predictions=lambda: MLBoxPredictionsResult(
+                    predictions=None,
+                    image=None,
+                    target_point=None,
+                    focus=None,
+                )
+            )
         ),
     )
     return LoopCenteringAnalyzer(context=ctx, logger=mock_logger)
@@ -125,7 +142,7 @@ def test_analyze_angle_with_crystal_prediction_returns_valid_target(analyzer):
     boxes = MLOutputModel()
     boxes.add_box(MLBoxType.CRYSTAL, (10, 20, 30, 40), conf=0.9)
 
-    analyzer.ctx.get_predictions = lambda: MLBoxPredictionsResult(
+    analyzer.ctx.prediction_provider.getter.get_predictions = lambda: MLBoxPredictionsResult(
         predictions=boxes,
         image=None,
         target_point=(25.0, 30.0),

tests/unit/daq/operations/loop_centering/test_loop_centering_service.py

@@ -3,6 +3,7 @@ import types
 import pytest
 
 from aare.common.models import LoopCenteringResult
+from aare.daq.operations.common.runtime import DAQRuntimeState, OperationServices, TraceWriter, PredictionProvider
 from aare.daq.operations.loop_centering.models import (
     AngleAnalysis,
     LoopCenteringContext,
@@ -23,15 +24,31 @@ def context():
     screenshots = []
     traces = []
 
+    runtime_state = DAQRuntimeState(
+        sample_provider=types.SimpleNamespace(sample=None),
+        sample_geometry_provider=types.SimpleNamespace(sample_geometry=types.SimpleNamespace()),
+        status_provider=types.SimpleNamespace(status=None),
+    )
+
     ctx = LoopCenteringContext(
         cfg=types.SimpleNamespace(),
         devs=devs,
         mlbox=types.SimpleNamespace(),
         settings=LoopCenteringSettings(),
-        sample_geometry_provider=lambda: types.SimpleNamespace(),
-        save_screenshot_db=lambda sample_id, filename, wait=0.0: screenshots.append((sample_id, filename, wait)),
-        append_smargon_trace=lambda **kwargs: traces.append(kwargs),
-        get_predictions=lambda: None,
+        runtime=runtime_state,
+        services=OperationServices(
+            screenshots=types.SimpleNamespace(
+                save_to_db=lambda sample_id, filename, wait=0.0: screenshots.append((sample_id, filename, wait))
+            )
+        ),
+        trace_writer=TraceWriter(
+            appender=types.SimpleNamespace(
+                append_smargon_trace=lambda **kwargs: traces.append(kwargs)
+            )
+        ),
+        prediction_provider=PredictionProvider(
+            getter=types.SimpleNamespace(get_predictions=lambda: None)
+        ),
     )
     ctx._screenshots = screenshots
     ctx._traces = traces

tests/unit/daq/operations/mounting/test_mounting_service.py

@@ -122,7 +122,7 @@ def test_dry_unmounts_current_sample_before_drying(mock_logger):
     ctx.devs.tell.dry = lambda **kwargs: dry_calls.append(kwargs)
 
     service = MountingService(context=ctx, logger=mock_logger)
-    service.dry(park=True)
+    service.dry(park=True, unmount=True)
 
     assert len(unmount_calls) == 1
     assert ctx.cfg.current_sample is None