Fix frequency sending Quantity (#804)

- Move frequency() tests into own file
- Fix frequency() sending `Quantities` instead of `Frequency`

Author: Marenz

RELEASE_NOTES.md

@@ -57,3 +57,4 @@
 ## Bug Fixes
 
 - 0W power requests are now not adjusted to exclusion bounds by the `PowerManager` and `PowerDistributor`, and are sent over to the microgrid API directly.
+- Fixed that `microgrid.frequency()` was sending `Quantity` objects instead of `Frequency`.

src/frequenz/sdk/timeseries/_grid_frequency.py

@@ -93,7 +93,11 @@ def new_receiver(self) -> Receiver[Sample[Frequency]]:
                 "Grid frequency request already sent: %s", self._source_component
             )
 
-        return receiver
+        return receiver.map(
+            lambda sample: Sample(
+                sample.timestamp, Frequency.from_hertz(sample.value.base_value)
+            )
+        )
 
     async def _send_request(self) -> None:
         """Send the request for grid frequency."""

tests/timeseries/test_frequency_streaming.py

@@ -0,0 +1,165 @@
+# License: MIT
+# Copyright © 2022 Frequenz Energy-as-a-Service GmbH
+
+"""Tests for the logical meter."""
+
+
+import asyncio
+from datetime import datetime, timezone
+
+from pytest_mock import MockerFixture
+
+from frequenz.sdk import microgrid
+from frequenz.sdk.timeseries._quantities import Frequency
+from tests.utils import component_data_wrapper
+
+from ._formula_engine.utils import equal_float_lists
+from .mock_microgrid import MockMicrogrid
+
+# pylint: disable=protected-access
+
+
+async def test_grid_frequency_1(mocker: MockerFixture) -> None:
+    """Test the grid frequency formula."""
+    mockgrid = MockMicrogrid(grid_meter=True)
+    mockgrid.add_batteries(2)
+    mockgrid.add_solar_inverters(1)
+    await mockgrid.start(mocker)
+
+    grid_freq = microgrid.frequency()
+    grid_freq_recv = grid_freq.new_receiver()
+
+    assert grid_freq._task is not None
+    # We have to wait for the metric request to be sent
+    await grid_freq._task
+    # And consumed
+    await asyncio.sleep(0)
+
+    results = []
+    grid_meter_data = []
+    for count in range(10):
+        freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
+        await mockgrid.mock_client.send(
+            component_data_wrapper.MeterDataWrapper(
+                mockgrid.meter_ids[0], datetime.now(tz=timezone.utc), frequency=freq
+            )
+        )
+
+        grid_meter_data.append(Frequency.from_hertz(freq))
+        val = await grid_freq_recv.receive()
+        assert val is not None and val.value is not None
+        assert val.value.as_hertz() == freq
+        results.append(val.value)
+    await mockgrid.cleanup()
+    assert equal_float_lists(results, grid_meter_data)
+
+
+async def test_grid_frequency_no_grid_meter_no_consumer_meter(
+    mocker: MockerFixture,
+) -> None:
+    """Test the grid frequency formula without a grid side meter."""
+    mockgrid = MockMicrogrid(grid_meter=False)
+    mockgrid.add_consumer_meters()
+    mockgrid.add_batteries(1, no_meter=False)
+    mockgrid.add_batteries(1, no_meter=False)
+    await mockgrid.start(mocker)
+    grid_freq = microgrid.frequency()
+
+    grid_freq_recv = grid_freq.new_receiver()
+    # We have to wait for the metric request to be sent
+    assert grid_freq._task is not None
+    await grid_freq._task
+    # And consumed
+    await asyncio.sleep(0)
+
+    results = []
+    meter_data = []
+    for count in range(10):
+        freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
+        await mockgrid.mock_client.send(
+            component_data_wrapper.MeterDataWrapper(
+                mockgrid.meter_ids[0], datetime.now(tz=timezone.utc), frequency=freq
+            )
+        )
+        meter_data.append(Frequency.from_hertz(freq))
+
+        val = await grid_freq_recv.receive()
+        assert val is not None and val.value is not None
+        assert val.value.as_hertz() == freq
+        results.append(val.value)
+    await mockgrid.cleanup()
+    assert equal_float_lists(results, meter_data)
+
+
+async def test_grid_frequency_no_grid_meter(
+    mocker: MockerFixture,
+) -> None:
+    """Test the grid frequency formula without a grid side meter."""
+    mockgrid = MockMicrogrid(grid_meter=False)
+    mockgrid.add_batteries(1, no_meter=False)
+    mockgrid.add_batteries(1, no_meter=True)
+    await mockgrid.start(mocker)
+    grid_freq = microgrid.frequency()
+
+    grid_freq_recv = grid_freq.new_receiver()
+    # We have to wait for the metric request to be sent
+    assert grid_freq._task is not None
+    await grid_freq._task
+    # And consumed
+    await asyncio.sleep(0)
+
+    results = []
+    meter_data = []
+    for count in range(10):
+        freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
+        await mockgrid.mock_client.send(
+            component_data_wrapper.MeterDataWrapper(
+                mockgrid.meter_ids[0], datetime.now(tz=timezone.utc), frequency=freq
+            )
+        )
+        meter_data.append(Frequency.from_hertz(freq))
+
+        val = await grid_freq_recv.receive()
+        assert val is not None and val.value is not None
+        assert val.value.as_hertz() == freq
+        results.append(val.value)
+    await mockgrid.cleanup()
+    assert equal_float_lists(results, meter_data)
+
+
+async def test_grid_frequency_only_inverter(
+    mocker: MockerFixture,
+) -> None:
+    """Test the grid frequency formula without any meter but only inverters."""
+    mockgrid = MockMicrogrid(grid_meter=False)
+    mockgrid.add_batteries(2, no_meter=True)
+    await mockgrid.start(mocker)
+
+    grid_freq = microgrid.frequency()
+    grid_freq_recv = grid_freq.new_receiver()
+    # We have to wait for the metric request to be sent
+    assert grid_freq._task is not None
+    await grid_freq._task
+    # And consumed
+    await asyncio.sleep(0)
+
+    results = []
+    meter_data = []
+    for count in range(10):
+        freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
+
+        await mockgrid.mock_client.send(
+            component_data_wrapper.InverterDataWrapper(
+                mockgrid.battery_inverter_ids[0],
+                datetime.now(tz=timezone.utc),
+                frequency=freq,
+            )
+        )
+
+        meter_data.append(Frequency.from_hertz(freq))
+        val = await grid_freq_recv.receive()
+        assert val is not None and val.value is not None
+        assert val.value.as_hertz() == freq
+        results.append(val.value)
+    await mockgrid.cleanup()
+    assert equal_float_lists(results, meter_data)

tests/timeseries/test_logical_meter.py

@@ -4,16 +4,11 @@
 """Tests for the logical meter."""
 
 
-import asyncio
-from datetime import datetime, timezone
-
 from pytest_mock import MockerFixture
 
 from frequenz.sdk import microgrid
-from frequenz.sdk.timeseries._quantities import Frequency, Power
-from tests.utils import component_data_wrapper
+from frequenz.sdk.timeseries._quantities import Power
 
-from ._formula_engine.utils import equal_float_lists
 from .mock_microgrid import MockMicrogrid
 
 # pylint: disable=too-many-locals
@@ -23,147 +18,6 @@
 class TestLogicalMeter:  # pylint: disable=too-many-public-methods
     """Tests for the logical meter."""
 
-    async def test_grid_frequency_1(self, mocker: MockerFixture) -> None:
-        """Test the grid frequency formula."""
-        mockgrid = MockMicrogrid(grid_meter=True)
-        mockgrid.add_batteries(2)
-        mockgrid.add_solar_inverters(1)
-        await mockgrid.start(mocker)
-
-        grid_freq = microgrid.frequency()
-        grid_freq_recv = grid_freq.new_receiver()
-
-        assert grid_freq._task is not None
-        # We have to wait for the metric request to be sent
-        await grid_freq._task
-        # And consumed
-        await asyncio.sleep(0)
-
-        results = []
-        grid_meter_data = []
-        for count in range(10):
-            freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
-            await mockgrid.mock_client.send(
-                component_data_wrapper.MeterDataWrapper(
-                    mockgrid.meter_ids[0], datetime.now(tz=timezone.utc), frequency=freq
-                )
-            )
-
-            grid_meter_data.append(Frequency.from_hertz(freq))
-            val = await grid_freq_recv.receive()
-            assert val is not None and val.value is not None
-            results.append(val.value)
-        await mockgrid.cleanup()
-        assert equal_float_lists(results, grid_meter_data)
-
-    async def test_grid_frequency_no_grid_meter_no_consumer_meter(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """Test the grid frequency formula without a grid side meter."""
-        mockgrid = MockMicrogrid(grid_meter=False)
-        mockgrid.add_consumer_meters()
-        mockgrid.add_batteries(1, no_meter=False)
-        mockgrid.add_batteries(1, no_meter=False)
-        await mockgrid.start(mocker)
-        grid_freq = microgrid.frequency()
-
-        grid_freq_recv = grid_freq.new_receiver()
-        # We have to wait for the metric request to be sent
-        assert grid_freq._task is not None
-        await grid_freq._task
-        # And consumed
-        await asyncio.sleep(0)
-
-        results = []
-        meter_data = []
-        for count in range(10):
-            freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
-            await mockgrid.mock_client.send(
-                component_data_wrapper.MeterDataWrapper(
-                    mockgrid.meter_ids[0], datetime.now(tz=timezone.utc), frequency=freq
-                )
-            )
-            meter_data.append(Frequency.from_hertz(freq))
-
-            val = await grid_freq_recv.receive()
-            assert val is not None and val.value is not None
-            results.append(val.value)
-        await mockgrid.cleanup()
-        assert equal_float_lists(results, meter_data)
-
-    async def test_grid_frequency_no_grid_meter(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """Test the grid frequency formula without a grid side meter."""
-        mockgrid = MockMicrogrid(grid_meter=False)
-        mockgrid.add_batteries(1, no_meter=False)
-        mockgrid.add_batteries(1, no_meter=True)
-        await mockgrid.start(mocker)
-        grid_freq = microgrid.frequency()
-
-        grid_freq_recv = grid_freq.new_receiver()
-        # We have to wait for the metric request to be sent
-        assert grid_freq._task is not None
-        await grid_freq._task
-        # And consumed
-        await asyncio.sleep(0)
-
-        results = []
-        meter_data = []
-        for count in range(10):
-            freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
-            await mockgrid.mock_client.send(
-                component_data_wrapper.MeterDataWrapper(
-                    mockgrid.meter_ids[0], datetime.now(tz=timezone.utc), frequency=freq
-                )
-            )
-            meter_data.append(Frequency.from_hertz(freq))
-
-            val = await grid_freq_recv.receive()
-            assert val is not None and val.value is not None
-            results.append(val.value)
-        await mockgrid.cleanup()
-        assert equal_float_lists(results, meter_data)
-
-    async def test_grid_frequency_only_inverter(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """Test the grid frequency formula without any meter but only inverters."""
-        mockgrid = MockMicrogrid(grid_meter=False)
-        mockgrid.add_batteries(2, no_meter=True)
-        await mockgrid.start(mocker)
-
-        grid_freq = microgrid.frequency()
-        grid_freq_recv = grid_freq.new_receiver()
-        # We have to wait for the metric request to be sent
-        assert grid_freq._task is not None
-        await grid_freq._task
-        # And consumed
-        await asyncio.sleep(0)
-
-        results = []
-        meter_data = []
-        for count in range(10):
-            freq = float(50.0 + (1 if count % 2 == 0 else -1) * 0.01)
-
-            await mockgrid.mock_client.send(
-                component_data_wrapper.InverterDataWrapper(
-                    mockgrid.battery_inverter_ids[0],
-                    datetime.now(tz=timezone.utc),
-                    frequency=freq,
-                )
-            )
-
-            meter_data.append(Frequency.from_hertz(freq))
-            val = await grid_freq_recv.receive()
-            assert val is not None and val.value is not None
-            results.append(val.value)
-        await mockgrid.cleanup()
-        assert equal_float_lists(results, meter_data)
-
     async def test_chp_power(self, mocker: MockerFixture) -> None:
         """Test the chp power formula."""
         mockgrid = MockMicrogrid(grid_meter=False)