Add methods for sending individual mock component data messages in tests (#483)

With this PR, there will be no remaining test dependencies on the flaky
automatic raw-data streaming functionality of `MockMicrogrid`. The
benchmarks for the data sourcing actor still depends on this, but that
can be dealt with later.

This PR also allows for the tests for the power distributing actor to
use `MockMicrogrid`, because that would make it easy for the tests to be
run on many different component graph configs, rather than the single
config it uses now.

Author: daniel-zullo-frequenz

tests/timeseries/_battery_pool/test_battery_pool.py

@@ -440,24 +440,24 @@ async def test_battery_pool_power(mocker: MockerFixture) -> None:
     """Test `BatteryPool.{,production,consumption}_power` methods."""
     mockgrid = MockMicrogrid(grid_side_meter=True)
     mockgrid.add_batteries(2)
-    await mockgrid.start_mock_datapipeline(mocker)
+    await mockgrid.start(mocker)
 
     battery_pool = microgrid.battery_pool()
     power_receiver = battery_pool.power.new_receiver()
     consumption_receiver = battery_pool.consumption_power.new_receiver()
     production_receiver = battery_pool.production_power.new_receiver()
 
-    await mockgrid.mock_data.send_bat_inverter_power([2.0, 3.0])
+    await mockgrid.mock_resampler.send_bat_inverter_power([2.0, 3.0])
     assert (await power_receiver.receive()).value == Power.from_watts(5.0)
     assert (await consumption_receiver.receive()).value == Power.from_watts(5.0)
     assert (await production_receiver.receive()).value == Power.from_watts(0.0)
 
-    await mockgrid.mock_data.send_bat_inverter_power([-2.0, -5.0])
+    await mockgrid.mock_resampler.send_bat_inverter_power([-2.0, -5.0])
     assert (await power_receiver.receive()).value == Power.from_watts(-7.0)
     assert (await consumption_receiver.receive()).value == Power.from_watts(0.0)
     assert (await production_receiver.receive()).value == Power.from_watts(7.0)
 
-    await mockgrid.mock_data.send_bat_inverter_power([2.0, -5.0])
+    await mockgrid.mock_resampler.send_bat_inverter_power([2.0, -5.0])
     assert (await power_receiver.receive()).value == Power.from_watts(-3.0)
     assert (await consumption_receiver.receive()).value == Power.from_watts(0.0)
     assert (await production_receiver.receive()).value == Power.from_watts(3.0)

tests/timeseries/_formula_engine/test_formula_composition.py

@@ -27,7 +27,7 @@ async def test_formula_composition(  # pylint: disable=too-many-locals
         mockgrid = MockMicrogrid(grid_side_meter=False)
         mockgrid.add_batteries(3)
         mockgrid.add_solar_inverters(2)
-        await mockgrid.start_mock_datapipeline(mocker)
+        await mockgrid.start(mocker)
 
         logical_meter = microgrid.logical_meter()
         battery_pool = microgrid.battery_pool()
@@ -44,8 +44,8 @@ async def test_formula_composition(  # pylint: disable=too-many-locals
         engine = (logical_meter.pv_power + battery_pool.power).build("inv_power")
         inv_calc_recv = engine.new_receiver()
 
-        await mockgrid.mock_data.send_bat_inverter_power([10.0, 12.0, 14.0])
-        await mockgrid.mock_data.send_meter_power(
+        await mockgrid.mock_resampler.send_bat_inverter_power([10.0, 12.0, 14.0])
+        await mockgrid.mock_resampler.send_meter_power(
             [100.0, 10.0, 12.0, 14.0, -100.0, -200.0]
         )
 
@@ -99,7 +99,7 @@ async def test_formula_composition_missing_pv(self, mocker: MockerFixture) -> No
         """Test the composition of formulas with missing PV power data."""
         mockgrid = MockMicrogrid(grid_side_meter=False)
         mockgrid.add_batteries(3)
-        await mockgrid.start_mock_datapipeline(mocker)
+        await mockgrid.start(mocker)
         battery_pool = microgrid.battery_pool()
         logical_meter = microgrid.logical_meter()
 
@@ -110,10 +110,10 @@ async def test_formula_composition_missing_pv(self, mocker: MockerFixture) -> No
 
         count = 0
         for _ in range(10):
-            await mockgrid.mock_data.send_bat_inverter_power(
+            await mockgrid.mock_resampler.send_bat_inverter_power(
                 [10.0 + count, 12.0 + count, 14.0 + count]
             )
-            await mockgrid.mock_data.send_non_existing_component_value()
+            await mockgrid.mock_resampler.send_non_existing_component_value()
 
             bat_pow = await battery_power_recv.receive()
             pv_pow = await pv_power_recv.receive()
@@ -137,7 +137,7 @@ async def test_formula_composition_missing_bat(self, mocker: MockerFixture) -> N
         """Test the composition of formulas with missing battery power data."""
         mockgrid = MockMicrogrid(grid_side_meter=False)
         mockgrid.add_solar_inverters(2)
-        await mockgrid.start_mock_datapipeline(mocker)
+        await mockgrid.start(mocker)
         battery_pool = microgrid.battery_pool()
         logical_meter = microgrid.logical_meter()
 
@@ -148,10 +148,10 @@ async def test_formula_composition_missing_bat(self, mocker: MockerFixture) -> N
 
         count = 0
         for _ in range(10):
-            await mockgrid.mock_data.send_meter_power(
+            await mockgrid.mock_resampler.send_meter_power(
                 [10.0 + count, 12.0 + count, 14.0 + count]
             )
-            await mockgrid.mock_data.send_non_existing_component_value()
+            await mockgrid.mock_resampler.send_non_existing_component_value()
             bat_pow = await battery_power_recv.receive()
             pv_pow = await pv_power_recv.receive()
             inv_pow = await inv_calc_recv.receive()
@@ -177,7 +177,7 @@ async def test_3_phase_formulas(self, mocker: MockerFixture) -> None:
         )
         mockgrid.add_batteries(3)
         mockgrid.add_ev_chargers(1)
-        await mockgrid.start_mock_datapipeline(mocker)
+        await mockgrid.start(mocker)
         logical_meter = microgrid.logical_meter()
         ev_pool = microgrid.ev_charger_pool()
 
@@ -190,15 +190,15 @@ async def test_3_phase_formulas(self, mocker: MockerFixture) -> None:
         count = 0
 
         for _ in range(10):
-            await mockgrid.mock_data.send_meter_current(
+            await mockgrid.mock_resampler.send_meter_current(
                 [
                     [10.0, 12.0, 14.0],
                     [10.0, 12.0, 14.0],
                     [10.0, 12.0, 14.0],
                     [10.0, 12.0, 14.0],
                 ]
             )
-            await mockgrid.mock_data.send_evc_current(
+            await mockgrid.mock_resampler.send_evc_current(
                 [[10.0 + count, 12.0 + count, 14.0 + count]]
             )
 

tests/timeseries/mock_microgrid.py

@@ -33,7 +33,7 @@
     InverterDataWrapper,
     MeterDataWrapper,
 )
-from .mock_datapipeline import MockDataPipeline
+from .mock_resampler import MockResampler
 
 
 class MockMicrogrid:  # pylint: disable=too-many-instance-attributes
@@ -49,7 +49,7 @@ class MockMicrogrid:  # pylint: disable=too-many-instance-attributes
     battery_id_suffix = 9
 
     _microgrid: MockMicrogridClient
-    mock_data: MockDataPipeline
+    mock_resampler: MockResampler
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -105,10 +105,10 @@ def __init__(  # pylint: disable=too-many-arguments
         self._streaming_tasks: list[asyncio.Task[None]] = []
         self._start_meter_streaming(4)
 
-    async def start_mock_datapipeline(self, mocker: MockerFixture) -> None:
-        """Start the MockDataPipeline."""
+    async def start(self, mocker: MockerFixture) -> None:
+        """Init the mock microgrid client and start the mock resampler."""
         self.init_mock_client(lambda mock_client: mock_client.initialize(mocker))
-        self.mock_data = MockDataPipeline(
+        self.mock_resampler = MockResampler(
             mocker,
             ResamplerConfig(timedelta(seconds=self._sample_rate_s)),
             bat_inverter_ids=self.battery_inverter_ids,
@@ -148,24 +148,6 @@ def start_mock_client(
         ]
         return self._microgrid
 
-    async def start(self, mocker: MockerFixture) -> None:
-        """Start the MockServer, and the data source and resampling actors."""
-        self.start_mock_client(lambda mock_client: mock_client.initialize(mocker))
-        await asyncio.sleep(self._sample_rate_s / 2)
-
-        # pylint: disable=protected-access
-        _data_pipeline._DATA_PIPELINE = _data_pipeline._DataPipeline(
-            ResamplerConfig(
-                resampling_period=timedelta(seconds=self._sample_rate_s),
-                # Align to the time the resampler is created to avoid flakiness
-                # in the tests, it seems test using the mock microgrid assume
-                # that the resampling window is aligned to the start of the
-                # test.
-                align_to=None,
-            )
-        )
-        # pylint: enable=protected-access
-
     async def _comp_data_send_task(
         self, comp_id: int, make_comp_data: Callable[[int, datetime], ComponentData]
     ) -> None:
@@ -363,12 +345,104 @@ def add_ev_chargers(self, count: int) -> None:
             self._start_ev_charger_streaming(evc_id)
             self._connections.add(Connection(self._connect_to, evc_id))
 
+    async def send_meter_data(self, values: list[float]) -> None:
+        """Send raw meter data from the mock microgrid.
+
+        Args:
+            values: list of active power values for each meter.
+        """
+        assert len(values) == len(self.meter_ids)
+        timestamp = datetime.now(tz=timezone.utc)
+        for comp_id, value in zip(self.meter_ids, values):
+            await self._microgrid.send(
+                MeterDataWrapper(
+                    component_id=comp_id,
+                    timestamp=timestamp,
+                    active_power=value,
+                    current_per_phase=(
+                        value + 100.0,
+                        value + 101.0,
+                        value + 102.0,
+                    ),
+                )
+            )
+
+    async def send_battery_data(self, socs: list[float]) -> None:
+        """Send raw battery data from the mock microgrid.
+
+        Args:
+            values: list of soc values for each battery.
+        """
+        assert len(socs) == len(self.battery_ids)
+        timestamp = datetime.now(tz=timezone.utc)
+        for comp_id, value in zip(self.battery_ids, socs):
+            await self._microgrid.send(
+                BatteryDataWrapper(component_id=comp_id, timestamp=timestamp, soc=value)
+            )
+
+    async def send_battery_inverter_data(self, values: list[float]) -> None:
+        """Send raw battery inverter data from the mock microgrid.
+
+        Args:
+            values: list of active power values for each battery inverter.
+        """
+        assert len(values) == len(self.battery_inverter_ids)
+        timestamp = datetime.now(tz=timezone.utc)
+        for comp_id, value in zip(self.battery_inverter_ids, values):
+            await self._microgrid.send(
+                InverterDataWrapper(
+                    component_id=comp_id, timestamp=timestamp, active_power=value
+                )
+            )
+
+    async def send_pv_inverter_data(self, values: list[float]) -> None:
+        """Send raw pv inverter data from the mock microgrid.
+
+        Args:
+            values: list of active power values for each pv inverter.
+        """
+        assert len(values) == len(self.pv_inverter_ids)
+        timestamp = datetime.now(tz=timezone.utc)
+        for comp_id, value in zip(self.pv_inverter_ids, values):
+            await self._microgrid.send(
+                InverterDataWrapper(
+                    component_id=comp_id, timestamp=timestamp, active_power=value
+                )
+            )
+
+    async def send_ev_charger_data(self, values: list[float]) -> None:
+        """Send raw ev charger data from the mock microgrid.
+
+        Args:
+            values: list of active power values for each ev charger.
+        """
+        assert len(values) == len(self.evc_ids)
+        timestamp = datetime.now(tz=timezone.utc)
+        for comp_id, value in zip(self.evc_ids, values):
+            await self._microgrid.send(
+                EvChargerDataWrapper(
+                    component_id=comp_id,
+                    timestamp=timestamp,
+                    active_power=value,
+                    current_per_phase=(
+                        value + 100.0,
+                        value + 101.0,
+                        value + 102.0,
+                    ),
+                    component_state=self.evc_component_states[comp_id],
+                    cable_state=self.evc_cable_states[comp_id],
+                )
+            )
+
     async def cleanup(self) -> None:
         """Clean up after a test."""
         # pylint: disable=protected-access
         if _data_pipeline._DATA_PIPELINE:
             await _data_pipeline._DATA_PIPELINE._stop()
 
+        for coro in self._streaming_coros:
+            coro.close()
+
         for task in self._streaming_tasks:
             await cancel_and_await(task)
         microgrid.connection_manager._CONNECTION_MANAGER = None

tests/timeseries/mock_datapipeline.py tests/timeseries/mock_resampler.pytests/timeseries/mock_datapipeline.py renamed to tests/timeseries/mock_resampler.py

@@ -23,8 +23,8 @@
 # pylint: disable=too-many-instance-attributes
 
 
-class MockDataPipeline:
-    """Mock data_pipeline."""
+class MockResampler:
+    """Mock resampler."""
 
     def __init__(  # pylint: disable=too-many-arguments
         self,