Rename variable in battery status

Rename request_result variable to set_power_result.

Signed-off-by: ela-kotulska-frequenz <[email protected]>

Author: ela-kotulska-frequenz

src/frequenz/sdk/actor/power_distributing/_battery_pool_status.py

@@ -94,8 +94,8 @@ def __init__(
         self._current_status = BatteryStatus(working=set(), uncertain=set())
 
         # Channel for sending results of requests to the batteries
-        request_result_channel = Broadcast[SetPowerResult]("battery_request_status")
-        self._request_result_sender = request_result_channel.new_sender()
+        set_power_result_channel = Broadcast[SetPowerResult]("battery_request_status")
+        self._set_power_result_sender = set_power_result_channel.new_sender()
 
         self._batteries: Dict[str, BatteryStatusTracker] = {}
 
@@ -112,7 +112,7 @@ def __init__(
                 max_data_age_sec=max_data_age_sec,
                 max_blocking_duration_sec=max_blocking_duration_sec,
                 status_sender=channel.sender,
-                request_result_receiver=request_result_channel.new_receiver(
+                set_power_result_receiver=set_power_result_channel.new_receiver(
                     f"battery_{battery_id}_request_status"
                 ),
             )
@@ -189,7 +189,7 @@ async def update_status(
             succeed_batteries: Batteries that succeed request
             failed_batteries: Batteries that failed request
         """
-        await self._request_result_sender.send(
+        await self._set_power_result_sender.send(
             SetPowerResult(succeed_batteries, failed_batteries)
         )
 

src/frequenz/sdk/actor/power_distributing/_battery_status.py

@@ -164,7 +164,7 @@ def __init__(  # pylint: disable=too-many-arguments
         max_data_age_sec: float,
         max_blocking_duration_sec: float,
         status_sender: Sender[Status],
-        request_result_receiver: Receiver[SetPowerResult],
+        set_power_result_receiver: Receiver[SetPowerResult],
     ) -> None:
         """Create class instance.
 
@@ -177,7 +177,7 @@ def __init__(  # pylint: disable=too-many-arguments
             max_blocking_duration_sec: This value tell what should be the maximum
                 timeout used for blocking failing component.
             status_sender: Channel to send status updates.
-            request_result_receiver: Channel to receive results of the requests to the
+            set_power_result_receiver: Channel to receive results of the requests to the
                 components.
 
         Raises:
@@ -204,7 +204,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self._select = None
 
         self._task = asyncio.create_task(
-            self._run(status_sender, request_result_receiver)
+            self._run(status_sender, set_power_result_receiver)
         )
 
     @property
@@ -226,15 +226,15 @@ async def stop(self) -> None:
     async def _run(
         self,
         status_sender: Sender[Status],
-        request_result_receiver: Receiver[SetPowerResult],
+        set_power_result_receiver: Receiver[SetPowerResult],
     ) -> None:
-        """Process data from the components and request_result_receiver.
+        """Process data from the components and set_power_result_receiver.
 
         New status is send only when it change.
 
         Args:
             status_sender: Channel to send status updates.
-            request_result_receiver: Channel to receive results of the requests to the
+            set_power_result_receiver: Channel to receive results of the requests to the
                 components.
         """
         api_client = get_microgrid().api_client
@@ -247,7 +247,7 @@ async def _run(
             battery_timer=self._battery.data_recv_timer,
             inverter_timer=self._inverter.data_recv_timer,
             inverter=inverter_receiver,
-            request_result=request_result_receiver,
+            set_power_result=set_power_result_receiver,
         )
 
         while True:
@@ -280,7 +280,7 @@ def _update_status(self, select: Select) -> Optional[Status]:
             self._inverter.last_msg_timestamp = msg.inner.timestamp
             self._inverter.data_recv_timer.reset()
 
-        elif msg := select.request_result:
+        elif msg := select.set_power_result:
             result: SetPowerResult = msg.inner
             if self.battery_id in result.succeed:
                 self._blocking_status.unblock()

tests/actor/test_battery_status.py

@@ -195,7 +195,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self,
         battery: Optional[BatteryData] = None,
         inverter: Optional[InverterData] = None,
-        request_result: Optional[SetPowerResult] = None,
+        set_power_result: Optional[SetPowerResult] = None,
         battery_timer_flag: bool = False,
         inverter_timer_flag: bool = False,
     ) -> None:
@@ -208,14 +208,14 @@ def __init__(  # pylint: disable=too-many-arguments
                 that no messages have been received for a while.
             inverter_timer_flag: If true the inverter data timer will be set to indicate
                 that no messages have been received for a while.
-            request_result: Expected SetPowerResult message. Defaults to None.
+            set_power_result: Expected SetPowerResult message. Defaults to None.
         """
         self.battery = None if battery is None else Message(battery)
         self.inverter = None if inverter is None else Message(inverter)
         self.inverter_timer = inverter_timer_flag
         self.battery_timer = battery_timer_flag
-        self.request_result = (
-            None if request_result is None else Message(request_result)
+        self.set_power_result = (
+            None if set_power_result is None else Message(set_power_result)
         )
 
 
@@ -255,14 +255,14 @@ async def test_sync_update_status_with_messages(
             mock_microgrid: mock_microgrid fixture
         """
         status_channel = Broadcast[Status]("battery_status")
-        request_result_channel = Broadcast[SetPowerResult]("request_result")
+        set_power_result_channel = Broadcast[SetPowerResult]("set_power_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
             max_data_age_sec=5,
             max_blocking_duration_sec=30,
             status_sender=status_channel.new_sender(),
-            request_result_receiver=request_result_channel.new_receiver(),
+            set_power_result_receiver=set_power_result_channel.new_receiver(),
         )
 
         assert tracker.battery_id == BATTERY_ID
@@ -402,7 +402,7 @@ async def test_sync_blocking_feature(
         """
 
         status_channel = Broadcast[Status]("battery_status")
-        request_result_channel = Broadcast[SetPowerResult]("request_result")
+        set_power_result_channel = Broadcast[SetPowerResult]("set_power_result")
 
         # increase max_data_age_sec for blocking tests.
         # Otherwise it will block blocking.
@@ -411,7 +411,7 @@ async def test_sync_blocking_feature(
             max_data_age_sec=500,
             max_blocking_duration_sec=30,
             status_sender=status_channel.new_sender(),
-            request_result_receiver=request_result_channel.new_receiver(),
+            set_power_result_receiver=set_power_result_channel.new_receiver(),
         )
 
         with time_machine.travel("2022-01-01 00:00 UTC", tick=False) as time:
@@ -428,7 +428,7 @@ async def test_sync_blocking_feature(
 
             # message is not correct, component should not block.
             select = FakeSelect(
-                request_result=SetPowerResult(succeed={1}, failed={106})
+                set_power_result=SetPowerResult(succeed={1}, failed={106})
             )
             assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
@@ -440,15 +440,15 @@ async def test_sync_blocking_feature(
             for timeout in expected_blocking_timeout:
                 # message is not correct, component should not block.
                 select = FakeSelect(
-                    request_result=SetPowerResult(succeed={1}, failed={106})
+                    set_power_result=SetPowerResult(succeed={1}, failed={106})
                 )
                 status = tracker._update_status(select)  # type: ignore[arg-type]
                 assert status is Status.UNCERTAIN
 
                 # Battery should be still blocked, nothing should happen
                 time.shift(timeout - 1)
                 select = FakeSelect(
-                    request_result=SetPowerResult(succeed={1}, failed={106})
+                    set_power_result=SetPowerResult(succeed={1}, failed={106})
                 )
                 assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
@@ -462,7 +462,7 @@ async def test_sync_blocking_feature(
 
             # should block for 30 sec
             select = FakeSelect(
-                request_result=SetPowerResult(succeed={1}, failed={106})
+                set_power_result=SetPowerResult(succeed={1}, failed={106})
             )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is Status.UNCERTAIN
@@ -484,15 +484,15 @@ async def test_sync_blocking_feature(
 
             # should block for 30 sec
             select = FakeSelect(
-                request_result=SetPowerResult(succeed={1}, failed={106})
+                set_power_result=SetPowerResult(succeed={1}, failed={106})
             )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is Status.UNCERTAIN
             time.shift(28)
 
             # If battery succeed, then it should unblock.
             select = FakeSelect(
-                request_result=SetPowerResult(succeed={106}, failed={206})
+                set_power_result=SetPowerResult(succeed={106}, failed={206})
             )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is Status.WORKING
@@ -512,14 +512,14 @@ async def test_sync_blocking_interrupted_with_with_max_data(
         """
 
         status_channel = Broadcast[Status]("battery_status")
-        request_result_channel = Broadcast[SetPowerResult]("request_result")
+        set_power_result_channel = Broadcast[SetPowerResult]("set_power_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
             max_data_age_sec=5,
             max_blocking_duration_sec=30,
             status_sender=status_channel.new_sender(),
-            request_result_receiver=request_result_channel.new_receiver(),
+            set_power_result_receiver=set_power_result_channel.new_receiver(),
         )
 
         with time_machine.travel("2022-01-01 00:00 UTC", tick=False) as time:
@@ -531,7 +531,7 @@ async def test_sync_blocking_interrupted_with_with_max_data(
             assert status is Status.WORKING
 
             select = FakeSelect(
-                request_result=SetPowerResult(succeed={1}, failed={106})
+                set_power_result=SetPowerResult(succeed={1}, failed={106})
             )
             status = tracker._update_status(select)  # type: ignore[arg-type]
             assert status is Status.UNCERTAIN
@@ -540,7 +540,7 @@ async def test_sync_blocking_interrupted_with_with_max_data(
             for timeout in expected_blocking_timeout:
                 # message is not correct, component should not block.
                 select = FakeSelect(
-                    request_result=SetPowerResult(succeed={1}, failed={106})
+                    set_power_result=SetPowerResult(succeed={1}, failed={106})
                 )
                 assert tracker._update_status(select) is None  # type: ignore[arg-type]
                 time.shift(timeout)
@@ -561,14 +561,14 @@ async def test_sync_blocking_interrupted_with_invalid_message(
         """
 
         status_channel = Broadcast[Status]("battery_status")
-        request_result_channel = Broadcast[SetPowerResult]("request_result")
+        set_power_result_channel = Broadcast[SetPowerResult]("set_power_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
             max_data_age_sec=5,
             max_blocking_duration_sec=30,
             status_sender=status_channel.new_sender(),
-            request_result_receiver=request_result_channel.new_receiver(),
+            set_power_result_receiver=set_power_result_channel.new_receiver(),
         )
 
         select = FakeSelect(inverter=inverter_data(component_id=INVERTER_ID))
@@ -577,7 +577,7 @@ async def test_sync_blocking_interrupted_with_invalid_message(
         select = FakeSelect(battery=battery_data(component_id=BATTERY_ID))
         assert tracker._update_status(select) is Status.WORKING  # type: ignore[arg-type]
 
-        select = FakeSelect(request_result=SetPowerResult(succeed={1}, failed={106}))
+        select = FakeSelect(set_power_result=SetPowerResult(succeed={1}, failed={106}))
         assert tracker._update_status(select) is Status.UNCERTAIN  # type: ignore[arg-type]
 
         select = FakeSelect(
@@ -588,10 +588,10 @@ async def test_sync_blocking_interrupted_with_invalid_message(
         )
         assert tracker._update_status(select) is Status.NOT_WORKING  # type: ignore[arg-type]
 
-        select = FakeSelect(request_result=SetPowerResult(succeed={1}, failed={106}))
+        select = FakeSelect(set_power_result=SetPowerResult(succeed={1}, failed={106}))
         assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
-        select = FakeSelect(request_result=SetPowerResult(succeed={106}, failed={}))
+        select = FakeSelect(set_power_result=SetPowerResult(succeed={106}, failed={}))
         assert tracker._update_status(select) is None  # type: ignore[arg-type]
 
         select = FakeSelect(inverter=inverter_data(component_id=INVERTER_ID))
@@ -613,14 +613,14 @@ async def test_timers(
             mocker: pytest mocker instance
         """
         status_channel = Broadcast[Status]("battery_status")
-        request_result_channel = Broadcast[SetPowerResult]("request_result")
+        set_power_result_channel = Broadcast[SetPowerResult]("set_power_result")
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
             max_data_age_sec=5,
             max_blocking_duration_sec=30,
             status_sender=status_channel.new_sender(),
-            request_result_receiver=request_result_channel.new_receiver(),
+            set_power_result_receiver=set_power_result_channel.new_receiver(),
         )
 
         battery_timer_spy = mocker.spy(tracker._battery.data_recv_timer, "reset")
@@ -673,17 +673,17 @@ async def test_async_battery_status(
         """
 
         status_channel = Broadcast[Status]("battery_status")
-        request_result_channel = Broadcast[SetPowerResult]("request_result")
+        set_power_result_channel = Broadcast[SetPowerResult]("set_power_result")
 
         status_receiver = status_channel.new_receiver()
-        request_result_sender = request_result_channel.new_sender()
+        set_power_result_sender = set_power_result_channel.new_sender()
 
         tracker = BatteryStatusTracker(
             BATTERY_ID,
             max_data_age_sec=5,
             max_blocking_duration_sec=30,
             status_sender=status_channel.new_sender(),
-            request_result_receiver=request_result_channel.new_receiver(),
+            set_power_result_receiver=set_power_result_channel.new_receiver(),
         )
         await asyncio.sleep(0.01)
 
@@ -693,7 +693,7 @@ async def test_async_battery_status(
             status = await asyncio.wait_for(status_receiver.receive(), timeout=0.1)
             assert status is Status.WORKING
 
-            assert await request_result_sender.send(
+            assert await set_power_result_sender.send(
                 SetPowerResult(succeed={}, failed={BATTERY_ID})
             )
             status = await asyncio.wait_for(status_receiver.receive(), timeout=0.1)
@@ -714,7 +714,7 @@ async def test_async_battery_status(
             status = await asyncio.wait_for(status_receiver.receive(), timeout=0.1)
             assert status is Status.NOT_WORKING
 
-            assert await request_result_sender.send(
+            assert await set_power_result_sender.send(
                 SetPowerResult(succeed={}, failed={BATTERY_ID})
             )
             await asyncio.sleep(0.3)