WIP: Add tests and fix some bugs

Author: llucax

noxfile.py

@@ -28,14 +28,28 @@ def formatting(session: nox.Session) -> None:
 @nox.session
 def pylint(session: nox.Session) -> None:
     """Run pylint to do lint checks."""
-    session.install("-e", ".[docs]", "pylint", "pytest", "nox")
+    session.install(
+        "-e",
+        ".[docs]",
+        "pylint",
+        "pytest",
+        "nox",
+        "async-solipsism",
+    )
     session.run("pylint", *check_dirs, *check_files)
 
 
 @nox.session
 def mypy(session: nox.Session) -> None:
     """Run mypy to check type hints."""
-    session.install("-e", ".[docs]", "pytest", "nox", "mypy")
+    session.install(
+        "-e",
+        ".[docs]",
+        "pytest",
+        "nox",
+        "mypy",
+        "async-solipsism",
+    )
 
     common_args = [
         "--namespace-packages",
@@ -72,7 +86,13 @@ def docstrings(session: nox.Session) -> None:
 @nox.session
 def pytest(session: nox.Session) -> None:
     """Run all tests using pytest."""
-    session.install("pytest", "pytest-cov", "pytest-mock", "pytest-asyncio")
+    session.install(
+        "pytest",
+        "pytest-cov",
+        "pytest-mock",
+        "pytest-asyncio",
+        "async-solipsism",
+    )
     session.install("-e", ".")
     session.run(
         "pytest",

src/frequenz/channels/util/_periodic_timer.py

@@ -80,7 +80,7 @@ class PeriodicTimer(Receiver[timedelta]):
     as the timer uses `asyncio`s loop monotonic clock.
 
     If the timer is delayed too much (see `delay_tolerance`), then the timer
-    will behave according to the `missed_ticks_behaviour`. Missing ticks might
+    will behave according to the `missed_tick_behavior`. Missing ticks might
     or might not trigger a message and the drift could be accumulated or not.
 
     The timer accepts an optional `loop`, which will be used to track the time.
@@ -130,7 +130,7 @@ class PeriodicTimer(Receiver[timedelta]):
         ```python
         timer = PeriodicTimer(timedelta(seconds=1.0),
             auto_start=False,
-            missed_ticks_behaviour=MissedTickBehavior.SKIP_AND_DRIFT,
+            missed_tick_behavior=MissedTickBehavior.SKIP_AND_DRIFT,
             delay_tolerance=timedelta(0),
         )
         select = Select(bat_1=receiver1, heavy_process=receiver2, timeout=timer)
@@ -161,7 +161,7 @@ def __init__(
         interval: timedelta,
         *,
         auto_start: bool = True,
-        missed_ticks_behaviour: MissedTickBehavior = MissedTickBehavior.TRIGGER_ALL,
+        missed_tick_behavior: MissedTickBehavior = MissedTickBehavior.TRIGGER_ALL,
         delay_tolerance: timedelta | None = None,
         loop: asyncio.AbstractEventLoop | None = None,
     ) -> None:
@@ -175,11 +175,11 @@ def __init__(
                 instance is created. This can only be `True` if there is
                 already a running loop or an explicit `loop` that is running
                 was passed.
-            missed_ticks_behaviour: The behaviour of the timer when it misses
+            missed_tick_behavior: The behavior of the timer when it misses
                 a tick. See the documentation of `MissedTickBehavior` for
                 details.
             delay_tolerance: The maximum delay that is tolerated before
-                adjusting ticks according to `missed_ticks_behaviour`.  If
+                adjusting ticks according to `missed_tick_behavior`.  If
                 a tick is delayed less than this, then it is not considered
                 a missed tick. By default this is set to 1% of the interval.
                 Bear in mind that some `MissedTickBehavior`s ignore this value.
@@ -193,16 +193,16 @@ def __init__(
         self._interval: timedelta = interval
         """The time to between timer ticks."""
 
-        self._missed_ticks_behaviour: MissedTickBehavior = missed_ticks_behaviour
-        """The behaviour of the timer when it misses a tick.
+        self._missed_tick_behavior: MissedTickBehavior = missed_tick_behavior
+        """The behavior of the timer when it misses a tick.
 
         See the documentation of `MissedTickBehavior` for details.
         """
 
         self._delay_tolerance: timedelta = (
             (interval / 100) if delay_tolerance is None else delay_tolerance
         )
-        """The maximum allowed delay before triggering `missed_ticks_behaviour`.
+        """The maximum allowed delay before triggering `missed_tick_behavior`.
 
         If a tick is delayed less than this, then it is not considered a missed
         tick. Bear in mind that some `MissedTickBehavior`s ignore this value.
@@ -213,24 +213,28 @@ def __init__(
         )
         """The event loop to use to track time."""
 
-        self._stopped: bool = False
+        self._stopped: bool = True
         """Wether the timer was requested to stop.
 
-        If there is no request to stop, any receiving method will start it by
-        calling `reset()`. If this is True, receiving methods will raise
-        a `ReceiverStoppedError`.
+        If this is `False`, then the timer is running.
+
+        If this is `True`, then it is stopped or there is a request to stop it
+        or it was not started yet:
+
+        * If `_next_msg_time` is `None`, it means it wasn't started yet (it was
+          created with `auto_start=False`).  Any receiving method will start
+          it by calling `reset()` in this case.
 
-        When the timer is not `auto_start`ed, this will be `False`, but
-        `_next_msg_time` will be `None`, indicating receiving methods that they
-        should start the timer.
+        * If `_next_msg_time` is not `None`, it means there was a request to
+          stop it.  In this case receiving methods will raise
+          a `ReceiverClosedError`.
         """
 
         self._next_tick_time: float | None = None
         """The absolute (monotonic) time when the timer should trigger.
 
-        If this is `None`, it means the timer either didn't started (if
-        `_stopped` is `False`) or was explicitly stopped (if `_stopped` is
-        `True`).
+        If this is `None`, it means the timer didn't start yet, but it should
+        be started as soon as it is used.
         """
 
         self._current_drift: timedelta | None = None
@@ -255,21 +259,21 @@ def interval(self) -> timedelta:
         return self._interval
 
     @property
-    def missed_ticks_behaviour(self) -> MissedTickBehavior:
-        """The behaviour of the timer when it misses a tick.
+    def missed_tick_behavior(self) -> MissedTickBehavior:
+        """The behavior of the timer when it misses a tick.
 
         Returns:
-            The behaviour of the timer when it misses a tick.
+            The behavior of the timer when it misses a tick.
         """
-        return self._missed_ticks_behaviour
+        return self._missed_tick_behavior
 
     @property
     def delay_tolerance(self) -> timedelta:
-        """The maximum allowed delay before triggering `missed_ticks_behaviour`.
+        """The maximum allowed delay before triggering `missed_tick_behavior`.
 
         Returns:
             The maximum allowed delay before triggering
-                `missed_ticks_behaviour`.
+                `missed_tick_behavior`.
         """
         return self._delay_tolerance
 
@@ -318,7 +322,7 @@ def stop(self) -> None:
         You can restart the timer with `reset()`.
         """
         self._stopped = True
-        self._next_tick_time = None
+        self._next_tick_time = -1.0
 
     async def ready(self) -> bool:
         """Wait until the timer interval passed.
@@ -340,18 +344,18 @@ async def ready(self) -> bool:
         if self._current_drift is not None:
             return True
 
-        # If a stop was explicitly requested, we bail out.
-        if self._stopped:
-            return False
-
-        # If there is no stop requested but we don't have a time for the next
-        # message, then we reset() (so we start the timer as of now).
+        # If `_next_tick_time` is `None`, it means it was created with
+        # `auto_start=False` and should be started.
         if self._next_tick_time is None:
             self.reset()
             assert (
                 self._next_tick_time is not None
             ), "This should be assigned by reset()"
 
+        # If a stop was explicitly requested, we bail out.
+        if self._stopped:
+            return False
+
         now = self._loop.time()
         time_to_next_tick = self._next_tick_time - now
         # If we didn't reach the tick yet, sleep until we do.
@@ -365,18 +369,18 @@ async def ready(self) -> bool:
         # calculate the next tick time and return.
         if (
             self._current_drift <= self._delay_tolerance
-            or self._missed_ticks_behaviour is MissedTickBehavior.TRIGGER_ALL
+            or self._missed_tick_behavior is MissedTickBehavior.TRIGGER_ALL
         ):
             self._next_tick_time = self._next_tick_time + self._interval.total_seconds()
             return True
 
         # At this point we have a considerable delay and need to skip ticks
 
-        if self._missed_ticks_behaviour is MissedTickBehavior.SKIP_AND_DRIFT:
+        if self._missed_tick_behavior is MissedTickBehavior.SKIP_AND_DRIFT:
             self.reset()
             return True
 
-        if self._missed_ticks_behaviour is MissedTickBehavior.SKIP_AND_RESYNC:
+        if self._missed_tick_behavior is MissedTickBehavior.SKIP_AND_RESYNC:
             # We need to resync (align) the next tick time to the current time
             total_missed, reminder = divmod(self._current_drift, self._interval)
             delta_to_next_tick = self._interval * (total_missed + 1) - reminder
@@ -399,7 +403,9 @@ def consume(self) -> timedelta:
         Raises:
             ReceiverStoppedError: if the timer was stopped via `stop()`.
         """
-        if self._stopped:
+        # If it was stopped and there it no pending result, we raise
+        # (if there is a pending result, then we still want to return it first)
+        if self._stopped and self._current_drift is None:
             raise ReceiverStoppedError(self)
 
         assert (