test(process): use FakeProcessUnit test double

Author: olelod

tests/libecalc/process/process_solver/solvers/test_speed_solver.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from typing import Final
 
 import pytest
@@ -92,41 +93,43 @@ def speed_func(configuration: SpeedConfiguration):
     assert outlet_stream.pressure_bara == expected_pressure
 
 
-class FluidNotAchievableProcessUnit(ProcessUnit):
-    """Process unit that raises OutletFluidNotAchievableError based on speed.
-
-    Behaves like SpeedProcessUnit (pressure = inlet_pressure + speed) except when
-    the speed matches the failure condition. Supports two modes:
-    - fails_at_or_above: raises when speed >= threshold (for max-speed failure tests)
-    - fails_at_or_below: raises when speed <= threshold (for min-speed failure tests)
-    """
+class FakeProcessUnit(ProcessUnit):
+    """Test double whose propagate_stream is supplied as a callable."""
 
     def __init__(
         self,
-        shaft: Shaft,
-        fluid_service: FluidService,
-        *,
-        fails_at_or_above: float | None = None,
-        fails_at_or_below: float | None = None,
+        propagate_stream: Callable[[FluidStream], FluidStream],
         process_unit_id: ProcessUnitId | None = None,
     ):
         self._id: Final[ProcessUnitId] = process_unit_id or ProcessUnit._create_id()
-        self._shaft = shaft
-        self._fluid_service = fluid_service
-        self._fails_at_or_above = fails_at_or_above
-        self._fails_at_or_below = fails_at_or_below
+        self._propagate_stream = propagate_stream
 
     def get_id(self) -> ProcessUnitId:
         return self._id
 
     def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
-        speed = self._shaft.get_speed()
-        should_fail = (self._fails_at_or_above is not None and speed >= self._fails_at_or_above) or (
-            self._fails_at_or_below is not None and speed <= self._fails_at_or_below
+        return self._propagate_stream(inlet_stream)
+
+
+def _failing_speed_unit(
+    shaft: Shaft,
+    fluid_service: FluidService,
+    *,
+    fails_at_or_above: float | None = None,
+    fails_at_or_below: float | None = None,
+) -> FakeProcessUnit:
+    """Build a FakeProcessUnit that mirrors `pressure = inlet + speed` but raises
+    OutletFluidNotAchievableError when the shaft speed crosses the given threshold."""
+    unit_id = ProcessUnit._create_id()
+
+    def _propagate(inlet_stream: FluidStream) -> FluidStream:
+        speed = shaft.get_speed()
+        should_fail = (fails_at_or_above is not None and speed >= fails_at_or_above) or (
+            fails_at_or_below is not None and speed <= fails_at_or_below
         )
         if should_fail:
             raise OutletFluidNotAchievableError(
-                process_unit_id=self._id,
+                process_unit_id=unit_id,
                 unachievable_operating_point=CompressorOperatingPoint(
                     inlet_pressure_bara=inlet_stream.pressure_bara,
                     inlet_temperature_kelvin=inlet_stream.temperature_kelvin,
@@ -136,13 +139,15 @@ def propagate_stream(self, inlet_stream: FluidStream) -> FluidStream:
                     speed=speed,
                 ),
             )
-        return self._fluid_service.create_stream_from_standard_rate(
+        return fluid_service.create_stream_from_standard_rate(
             fluid_model=inlet_stream.fluid_model,
             pressure_bara=inlet_stream.pressure_bara + speed,
             standard_rate_m3_per_day=inlet_stream.standard_rate_sm3_per_day,
             temperature_kelvin=inlet_stream.temperature_kelvin,
         )
 
+    return FakeProcessUnit(propagate_stream=_propagate, process_unit_id=unit_id)
+
 
 def test_min_speed_fluid_not_achievable_target_achievable(
     search_strategy_factory,
@@ -152,7 +157,7 @@ def test_min_speed_fluid_not_achievable_target_achievable(
     fluid_service,
 ):
     """OutletFluidNotAchievableError at min speed: binary search finds higher effective min; target still reachable."""
-    unit = FluidNotAchievableProcessUnit(shaft=shaft, fluid_service=fluid_service, fails_at_or_below=300)
+    unit = _failing_speed_unit(shaft=shaft, fluid_service=fluid_service, fails_at_or_below=300)
     speed_solver = SpeedSolver(
         search_strategy=search_strategy_factory(),
         root_finding_strategy=root_finding_strategy,
@@ -179,7 +184,7 @@ def test_min_speed_fluid_not_achievable_target_not_achievable(
     fluid_service,
 ):
     """OutletFluidNotAchievableError at min speed: effective min too high → target below minimum achievable."""
-    unit = FluidNotAchievableProcessUnit(shaft=shaft, fluid_service=fluid_service, fails_at_or_below=400)
+    unit = _failing_speed_unit(shaft=shaft, fluid_service=fluid_service, fails_at_or_below=400)
     speed_solver = SpeedSolver(
         search_strategy=search_strategy_factory(),
         root_finding_strategy=root_finding_strategy,
@@ -209,7 +214,7 @@ def test_max_speed_fluid_not_achievable_target_achievable(
     fluid_service,
 ):
     """OutletFluidNotAchievableError at max speed: binary search finds lower effective max; target still reachable."""
-    unit = FluidNotAchievableProcessUnit(shaft=shaft, fluid_service=fluid_service, fails_at_or_above=500)
+    unit = _failing_speed_unit(shaft=shaft, fluid_service=fluid_service, fails_at_or_above=500)
     speed_solver = SpeedSolver(
         search_strategy=search_strategy_factory(),
         root_finding_strategy=root_finding_strategy,
@@ -236,7 +241,7 @@ def test_max_speed_fluid_not_achievable_target_not_achievable(
     fluid_service,
 ):
     """OutletFluidNotAchievableError at max speed: binary search finds lower effective max; target not reachable."""
-    unit = FluidNotAchievableProcessUnit(shaft=shaft, fluid_service=fluid_service, fails_at_or_above=300)
+    unit = _failing_speed_unit(shaft=shaft, fluid_service=fluid_service, fails_at_or_above=300)
     speed_solver = SpeedSolver(
         search_strategy=search_strategy_factory(),
         root_finding_strategy=root_finding_strategy,
@@ -266,7 +271,7 @@ def test_all_speeds_fluid_not_achievable_from_max(
     fluid_service,
 ):
     """All speeds fail EOS when searching from max: pre-check at boundary.min catches it immediately."""
-    unit = FluidNotAchievableProcessUnit(shaft=shaft, fluid_service=fluid_service, fails_at_or_above=0)
+    unit = _failing_speed_unit(shaft=shaft, fluid_service=fluid_service, fails_at_or_above=0)
     speed_solver = SpeedSolver(
         search_strategy=search_strategy_factory(),
         root_finding_strategy=root_finding_strategy,
@@ -293,7 +298,7 @@ def test_all_speeds_fluid_not_achievable_from_min(
     fluid_service,
 ):
     """All speeds fail EOS when searching from min: pre-check at boundary.max catches it immediately."""
-    unit = FluidNotAchievableProcessUnit(shaft=shaft, fluid_service=fluid_service, fails_at_or_below=600)
+    unit = _failing_speed_unit(shaft=shaft, fluid_service=fluid_service, fails_at_or_below=600)
     speed_solver = SpeedSolver(
         search_strategy=search_strategy_factory(),
         root_finding_strategy=root_finding_strategy,