Add tests for 3-phase power metrics

Signed-off-by: Daniel Zullo <[email protected]>

Author: daniel-zullo-frequenz

tests/microgrid/test_component_data.py

@@ -53,14 +53,17 @@ def test_inverter_data() -> None:
                     phase_1=electrical_pb2.AC.ACPhase(
                         current=metrics_pb2.Metric(value=12.3),
                         voltage=metrics_pb2.Metric(value=229.8),
+                        power_active=metrics_pb2.Metric(value=33.1),
                     ),
                     phase_2=electrical_pb2.AC.ACPhase(
                         current=metrics_pb2.Metric(value=23.4),
                         voltage=metrics_pb2.Metric(value=230.0),
+                        power_active=metrics_pb2.Metric(value=33.3),
                     ),
                     phase_3=electrical_pb2.AC.ACPhase(
                         current=metrics_pb2.Metric(value=34.5),
                         voltage=metrics_pb2.Metric(value=230.2),
+                        power_active=metrics_pb2.Metric(value=33.8),
                     ),
                 ),
             ),
@@ -78,6 +81,7 @@ def test_inverter_data() -> None:
     ]
     assert inv_data.frequency == pytest.approx(50.1)
     assert inv_data.active_power == pytest.approx(100.2)
+    assert inv_data.active_power_per_phase == pytest.approx((33.1, 33.3, 33.8))
     assert inv_data.current_per_phase == pytest.approx((12.3, 23.4, 34.5))
     assert inv_data.voltage_per_phase == pytest.approx((229.8, 230.0, 230.2))
     assert inv_data.active_power_inclusion_lower_bound == pytest.approx(-51_000.0)

tests/microgrid/test_grid.py

@@ -202,6 +202,75 @@ async def test_grid_power_2(mocker: MockerFixture) -> None:
     assert equal_float_lists(results, meter_sums)
 
 
+async def test_grid_power_3_phase_side_meter(mocker: MockerFixture) -> None:
+    """Test the grid 3-phase power with a grid side meter."""
+    mockgrid = MockMicrogrid(grid_meter=True, mocker=mocker)
+    mockgrid.add_batteries(1, no_meter=True)
+    mockgrid.add_batteries(1, no_meter=False)
+
+    async with mockgrid, AsyncExitStack() as stack:
+        grid = microgrid.grid()
+        assert grid, "Grid is not initialized"
+        stack.push_async_callback(grid.stop)
+
+        grid_power_3_phase_recv = (
+            grid._power_3_phase.new_receiver()  # pylint: disable=protected-access
+        )
+
+        for count in range(10):
+            watts_delta = 1 if count % 2 == 0 else -1
+            watts_phases: list[float | None] = [
+                220.0 * watts_delta,
+                219.8 * watts_delta,
+                220.2 * watts_delta,
+            ]
+
+            await mockgrid.mock_resampler.send_meter_power_3_phase(
+                [watts_phases, watts_phases]
+            )
+
+            val = await grid_power_3_phase_recv.receive()
+            assert val is not None
+            assert val.value_p1 and val.value_p2 and val.value_p3
+            assert val.value_p1.as_watts() == watts_phases[0]
+            assert val.value_p2.as_watts() == watts_phases[1]
+            assert val.value_p3.as_watts() == watts_phases[2]
+
+
+async def test_grid_power_3_phase_none_values(mocker: MockerFixture) -> None:
+    """Test the grid 3-phase power with None values."""
+    mockgrid = MockMicrogrid(grid_meter=True, mocker=mocker)
+    mockgrid.add_batteries(2, no_meter=False)
+
+    async with mockgrid, AsyncExitStack() as stack:
+        grid = microgrid.grid()
+        assert grid, "Grid is not initialized"
+        stack.push_async_callback(grid.stop)
+
+        grid_power_3_phase_recv = (
+            grid._power_3_phase.new_receiver()  # pylint: disable=protected-access
+        )
+
+        for count in range(10):
+            watts_delta = 1 if count % 2 == 0 else -1
+            watts_phases: list[float | None] = [
+                220.0 * watts_delta,
+                219.8 * watts_delta,
+                220.2 * watts_delta,
+            ]
+
+            await mockgrid.mock_resampler.send_meter_power_3_phase(
+                [watts_phases, [None, None, None], [None, 219.8, 220.2]]
+            )
+
+            val = await grid_power_3_phase_recv.receive()
+            assert val is not None
+            assert val.value_p1 and val.value_p2 and val.value_p3
+            assert val.value_p1.as_watts() == watts_phases[0]
+            assert val.value_p2.as_watts() == watts_phases[1]
+            assert val.value_p3.as_watts() == watts_phases[2]
+
+
 async def test_grid_production_consumption_power_consumer_meter(
     mocker: MockerFixture,
 ) -> None:

tests/timeseries/mock_resampler.py

@@ -21,7 +21,7 @@
     NON_EXISTING_COMPONENT_ID,
 )
 
-# pylint: disable=too-many-instance-attributes
+# pylint: disable=too-many-instance-attributes disable=too-many-locals
 
 
 class MockResampler:
@@ -159,13 +159,26 @@ def voltage_senders(ids: list[int]) -> list[list[Sender[Sample[Quantity]]]]:
                 ),
             )
 
+        def power_3_phase_senders(
+            ids: list[int],
+        ) -> list[list[Sender[Sample[Quantity]]]]:
+            return multi_phase_senders(
+                ids,
+                (
+                    ComponentMetricId.ACTIVE_POWER_PHASE_1,
+                    ComponentMetricId.ACTIVE_POWER_PHASE_2,
+                    ComponentMetricId.ACTIVE_POWER_PHASE_3,
+                ),
+            )
+
         self._bat_inverter_current_senders = current_senders(bat_inverter_ids)
         self._pv_inverter_current_senders = current_senders(pv_inverter_ids)
         self._ev_current_senders = current_senders(evc_ids)
         self._chp_current_senders = current_senders(chp_ids)
         self._meter_current_senders = current_senders(meter_ids)
 
         self._meter_voltage_senders = voltage_senders(meter_ids)
+        self._meter_power_3_phase_senders = power_3_phase_senders(meter_ids)
 
         self._next_ts = datetime.now()
 
@@ -325,3 +338,12 @@ async def send_meter_voltage(self, values: list[list[float | None]]) -> None:
             for phase, value in enumerate(meter_values):
                 sample = self.make_sample(value)
                 await chan[phase].send(sample)
+
+    async def send_meter_power_3_phase(self, values: list[list[float | None]]) -> None:
+        """Send the given values as resampler output for meter active power."""
+        assert len(values) == len(self._meter_power_3_phase_senders)
+        for chan, meter_values in zip(self._meter_power_3_phase_senders, values):
+            assert len(meter_values) == 3  # 3 values for phases
+            for phase, value in enumerate(meter_values):
+                sample = self.make_sample(value)
+                await chan[phase].send(sample)

tests/utils/component_data_wrapper.py

@@ -101,6 +101,11 @@ def __init__(  # pylint: disable=too-many-arguments
         component_id: int,
         timestamp: datetime,
         active_power: float = math.nan,
+        active_power_per_phase: tuple[float, float, float] = (
+            math.nan,
+            math.nan,
+            math.nan,
+        ),
         current_per_phase: tuple[float, float, float] = (math.nan, math.nan, math.nan),
         voltage_per_phase: tuple[float, float, float] = (math.nan, math.nan, math.nan),
         active_power_inclusion_lower_bound: float = math.nan,
@@ -122,6 +127,7 @@ def __init__(  # pylint: disable=too-many-arguments
             component_id=component_id,
             timestamp=timestamp,
             active_power=active_power,
+            active_power_per_phase=active_power_per_phase,
             current_per_phase=current_per_phase,
             voltage_per_phase=voltage_per_phase,
             active_power_inclusion_lower_bound=active_power_inclusion_lower_bound,
@@ -157,6 +163,11 @@ def __init__(  # pylint: disable=too-many-arguments
         component_id: int,
         timestamp: datetime,
         active_power: float = math.nan,
+        active_power_per_phase: tuple[float, float, float] = (
+            math.nan,
+            math.nan,
+            math.nan,
+        ),
         current_per_phase: tuple[float, float, float] = (math.nan, math.nan, math.nan),
         voltage_per_phase: tuple[float, float, float] = (math.nan, math.nan, math.nan),
         active_power_inclusion_lower_bound: float = math.nan,
@@ -176,6 +187,7 @@ def __init__(  # pylint: disable=too-many-arguments
             component_id=component_id,
             timestamp=timestamp,
             active_power=active_power,
+            active_power_per_phase=active_power_per_phase,
             current_per_phase=current_per_phase,
             voltage_per_phase=voltage_per_phase,
             active_power_inclusion_lower_bound=active_power_inclusion_lower_bound,
@@ -211,6 +223,11 @@ def __init__(  # pylint: disable=too-many-arguments
         component_id: int,
         timestamp: datetime,
         active_power: float = math.nan,
+        active_power_per_phase: tuple[float, float, float] = (
+            math.nan,
+            math.nan,
+            math.nan,
+        ),
         current_per_phase: tuple[float, float, float] = (math.nan, math.nan, math.nan),
         voltage_per_phase: tuple[float, float, float] = (math.nan, math.nan, math.nan),
         frequency: float = math.nan,
@@ -224,6 +241,7 @@ def __init__(  # pylint: disable=too-many-arguments
             component_id=component_id,
             timestamp=timestamp,
             active_power=active_power,
+            active_power_per_phase=active_power_per_phase,
             current_per_phase=current_per_phase,
             voltage_per_phase=voltage_per_phase,
             frequency=frequency,