Fix a few tests warnings

Fix some deprecation warnings while overriding the event loop and for
`test_timer_intergration` we also use async-solipsism properly,
before we were not replacing the loop policy appropriately.

Signed-off-by: Leandro Lucarella <[email protected]>

Author: llucax

tests/test_select_integration.py

@@ -9,7 +9,7 @@ class at a time.
 """
 
 import asyncio
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator
 from typing import Any
 
 import async_solipsism
@@ -33,17 +33,11 @@ class TestSelect:
     recv1: Event
     recv2: Event
     recv3: Event
-    loop: async_solipsism.EventLoop
 
     @pytest.fixture(autouse=True)
-    def event_loop(
-        self, request: pytest.FixtureRequest
-    ) -> Iterator[async_solipsism.EventLoop]:
-        """Replace the loop with one that doesn't interact with the outside world."""
-        loop = async_solipsism.EventLoop()
-        request.cls.loop = loop
-        yield loop
-        loop.close()
+    def event_loop_policy(self) -> async_solipsism.EventLoopPolicy:
+        """Return an event loop policy that uses the async solipsism event loop."""
+        return async_solipsism.EventLoopPolicy()
 
     @pytest.fixture()
     async def start_run_ordered_sequence(self) -> AsyncIterator[asyncio.Task[None]]:
@@ -92,10 +86,16 @@ def assert_received_from(
         assert selected.exception is None
         assert not selected.was_stopped
         if expected_pending_tasks > 0:
-            assert len(asyncio.all_tasks(self.loop)) == expected_pending_tasks
+            assert (
+                len(asyncio.all_tasks(asyncio.get_event_loop()))
+                == expected_pending_tasks
+            )
         elif expected_pending_tasks < 0:
-            assert len(asyncio.all_tasks(self.loop)) > expected_pending_tasks
-        assert self.loop.time() == at_time
+            assert (
+                len(asyncio.all_tasks(asyncio.get_event_loop()))
+                > expected_pending_tasks
+            )
+        assert asyncio.get_event_loop().time() == at_time
 
     def assert_receiver_stopped(
         self,
@@ -125,10 +125,16 @@ def assert_receiver_stopped(
         assert isinstance(selected.exception, ReceiverStoppedError)
         assert selected.exception.receiver is receiver
         if expected_pending_tasks > 0:
-            assert len(asyncio.all_tasks(self.loop)) == expected_pending_tasks
+            assert (
+                len(asyncio.all_tasks(asyncio.get_event_loop()))
+                == expected_pending_tasks
+            )
         elif expected_pending_tasks < 0:
-            assert len(asyncio.all_tasks(self.loop)) > expected_pending_tasks
-        assert self.loop.time() == at_time
+            assert (
+                len(asyncio.all_tasks(asyncio.get_event_loop()))
+                > expected_pending_tasks
+            )
+        assert asyncio.get_event_loop().time() == at_time
 
     # We use the loop time (and the sleeps in the run_ordered_sequence method) mainly to
     # ensure we are processing the events in the correct order and we are really
@@ -362,11 +368,11 @@ async def test_multiple_ready(
         Also test that the loop waits forever if there are no more receivers ready.
         """
         received: set[str] = set()
-        last_time: float = self.loop.time()
+        last_time: float = asyncio.get_event_loop().time()
         try:
             async with asyncio.timeout(15):
                 async for selected in select(self.recv1, self.recv2, self.recv3):
-                    now = self.loop.time()
+                    now = asyncio.get_event_loop().time()
                     if now != last_time:  # Only check when there was a jump in time
                         match now:
                             case 1:
@@ -401,7 +407,7 @@ async def test_multiple_ready(
                     else:
                         assert False, "Should not reach this point"
         except asyncio.TimeoutError:
-            assert self.loop.time() == 15
+            assert asyncio.get_event_loop().time() == 15
             # This happened after time == 3, but the loop never resumes because
             # there is nothing ready, so we need to check it after the timeout.
             assert received == {

tests/test_timer.py

@@ -252,11 +252,14 @@ async def test_timer_construction_defaults() -> None:
 def test_timer_construction_no_async() -> None:
     """Test the construction outside of async (using a custom loop)."""
     loop = async_solipsism.EventLoop()
-    timer = Timer(timedelta(seconds=1.0), TriggerAllMissed(), loop=loop)
-    assert timer.interval == timedelta(seconds=1.0)
-    assert isinstance(timer.missed_tick_policy, TriggerAllMissed)
-    assert timer.loop is loop
-    assert timer.is_running is True
+    try:
+        timer = Timer(timedelta(seconds=1.0), TriggerAllMissed(), loop=loop)
+        assert timer.interval == timedelta(seconds=1.0)
+        assert isinstance(timer.missed_tick_policy, TriggerAllMissed)
+        assert timer.loop is loop
+        assert timer.is_running is True
+    finally:
+        loop.close()
 
 
 def test_timer_construction_no_event_loop() -> None:

tests/test_timer_integration.py

@@ -13,11 +13,17 @@
 from frequenz.channels.timer import SkipMissedAndDrift, Timer
 
 
+@pytest.fixture(autouse=True)
+def event_loop_policy() -> async_solipsism.EventLoopPolicy:
+    """Return an event loop policy that uses the async solipsism event loop."""
+    return async_solipsism.EventLoopPolicy()
+
+
 @pytest.mark.integration
-async def test_timer_timeout_reset(
-    event_loop: async_solipsism.EventLoop,  # pylint: disable=redefined-outer-name
-) -> None:
+@pytest.mark.asyncio(loop_scope="function")
+async def test_timer_timeout_reset() -> None:
     """Test that the receiving is properly adjusted after a reset."""
+    event_loop = asyncio.get_running_loop()
 
     async def timer_wait(timer: Timer) -> None:
         await timer.receive()