Move repeated Receiver tests to test_receiver.py

There is no need to test the methods that are implemented in `Receiver`
itself for every channel or receiver implementation.

We also add a couple of extra trivial tests.

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

Author: llucax

tests/test_anycast.py

@@ -162,58 +162,3 @@ async def test_anycast_none_messages() -> None:
 
     await sender.send(10)
     assert await receiver.receive() == 10
-
-
-async def test_anycast_async_iterator() -> None:
-    """Check that the anycast receiver works as an async iterator."""
-    acast: Anycast[str] = Anycast(name="test")
-
-    sender = acast.new_sender()
-    receiver = acast.new_receiver()
-
-    async def send_messages() -> None:
-        for val in ["one", "two", "three", "four", "five"]:
-            await sender.send(val)
-        await acast.close()
-
-    sender_task = asyncio.create_task(send_messages())
-
-    received = []
-    async for recv in receiver:
-        received.append(recv)
-
-    assert received == ["one", "two", "three", "four", "five"]
-
-    await sender_task
-
-
-async def test_anycast_map() -> None:
-    """Ensure map runs on all incoming messages."""
-    chan: Anycast[int] = Anycast(name="test")
-    sender = chan.new_sender()
-
-    # transform int receiver into bool receiver.
-    receiver: Receiver[bool] = chan.new_receiver().map(lambda num: num > 10)
-
-    await sender.send(8)
-    await sender.send(12)
-
-    assert (await receiver.receive()) is False
-    assert (await receiver.receive()) is True
-
-
-async def test_anycast_filter() -> None:
-    """Ensure filter keeps only the messages that pass the filter."""
-    chan = Anycast[int](name="input-chan")
-    sender = chan.new_sender()
-
-    # filter out all numbers less than 10.
-    receiver: Receiver[int] = chan.new_receiver().filter(lambda num: num > 10)
-
-    await sender.send(8)
-    await sender.send(12)
-    await sender.send(5)
-    await sender.send(15)
-
-    assert (await receiver.receive()) == 12
-    assert (await receiver.receive()) == 15

tests/test_broadcast.py

@@ -6,7 +6,6 @@
 
 import asyncio
 from dataclasses import dataclass
-from typing import TypeGuard, assert_never
 
 import pytest
 
@@ -194,86 +193,6 @@ async def test_broadcast_no_resend_latest() -> None:
     assert await new_recv.receive() == 100
 
 
-async def test_broadcast_async_iterator() -> None:
-    """Check that the broadcast receiver works as an async iterator."""
-    bcast: Broadcast[int] = Broadcast(name="iter_test")
-
-    sender = bcast.new_sender()
-    receiver = bcast.new_receiver()
-
-    async def send_messages() -> None:
-        for val in range(0, 10):
-            await sender.send(val)
-        await bcast.close()
-
-    sender_task = asyncio.create_task(send_messages())
-
-    received = []
-    async for recv in receiver:
-        received.append(recv)
-
-    assert received == list(range(0, 10))
-
-    await sender_task
-
-
-async def test_broadcast_map() -> None:
-    """Ensure map runs on all incoming messages."""
-    chan = Broadcast[int](name="input-chan")
-    sender = chan.new_sender()
-
-    # transform int receiver into bool receiver.
-    receiver: Receiver[bool] = chan.new_receiver().map(lambda num: num > 10)
-
-    await sender.send(8)
-    await sender.send(12)
-
-    assert (await receiver.receive()) is False
-    assert (await receiver.receive()) is True
-
-
-async def test_broadcast_filter() -> None:
-    """Ensure filter keeps only the messages that pass the filter."""
-    chan = Broadcast[int](name="input-chan")
-    sender = chan.new_sender()
-
-    # filter out all numbers less than 10.
-    receiver: Receiver[int] = chan.new_receiver().filter(lambda num: num > 10)
-
-    await sender.send(8)
-    await sender.send(12)
-    await sender.send(5)
-    await sender.send(15)
-
-    assert (await receiver.receive()) == 12
-    assert (await receiver.receive()) == 15
-
-
-async def test_broadcast_filter_type_guard() -> None:
-    """Ensure filter type guard works."""
-    chan = Broadcast[int | str](name="input-chan")
-    sender = chan.new_sender()
-
-    def _is_int(num: int | str) -> TypeGuard[int]:
-        return isinstance(num, int)
-
-    # filter out objects that are not integers.
-    receiver = chan.new_receiver().filter(_is_int)
-
-    await sender.send("hello")
-    await sender.send(8)
-
-    message = await receiver.receive()
-    assert message == 8
-    is_int = False
-    match message:
-        case int():
-            is_int = True
-        case unexpected:
-            assert_never(unexpected)
-    assert is_int
-
-
 async def test_broadcast_receiver_drop() -> None:
     """Ensure deleted receivers get cleaned up."""
     chan = Broadcast[int](name="input-chan")

tests/test_receiver.py

@@ -6,6 +6,7 @@
 import asyncio
 from collections.abc import Sequence
 from typing import TypeGuard, assert_type
+from unittest.mock import MagicMock
 
 import pytest
 from typing_extensions import override
@@ -85,3 +86,61 @@ async def test_receiver_drop_while() -> None:
 
         with pytest.raises(ReceiverStoppedError):
             await filtered_receiver.receive()
+
+
+async def test_receiver_async_iteration() -> None:
+    """Test async iteration over the receiver."""
+    receiver = _MockReceiver([1, 2])
+
+    received = []
+    async with asyncio.timeout(1):
+        async for message in receiver:
+            received.append(message)
+
+    assert received == [1, 2]
+
+
+async def test_receiver_map() -> None:
+    """Test mapping a function over the receiver's messages."""
+    receiver = _MockReceiver([1, 2])
+
+    mapped_receiver = receiver.map(lambda x: f"{x} + 1")
+    assert await mapped_receiver.receive() == "1 + 1"
+    assert await mapped_receiver.receive() == "2 + 1"
+
+
+async def test_receiver_filter() -> None:
+    """Test filtering the receiver's messages."""
+    receiver = _MockReceiver([1, 2, 3, 4, 5])
+
+    filtered_receiver = receiver.filter(lambda x: x % 2 == 0)
+    async with asyncio.timeout(1):
+        assert await filtered_receiver.receive() == 2
+        assert await filtered_receiver.receive() == 4
+
+        with pytest.raises(ReceiverStoppedError):
+            await filtered_receiver.receive()
+
+
+async def test_receiver_triggered() -> None:
+    """Test the triggered method."""
+    receiver = _MockReceiver()
+    selected = MagicMock()
+    selected._recv = receiver  # pylint: disable=protected-access
+
+    assert receiver.triggered(selected)
+    assert selected._handled  # pylint: disable=protected-access
+
+
+async def test_receiver_error_handling() -> None:
+    """Test error handling in the receiver."""
+    receiver = _MockReceiver([1])
+    receiver.stop()
+
+    async with asyncio.timeout(1):
+        with pytest.raises(ReceiverStoppedError):
+            await receiver.receive()
+
+        receiver = _MockReceiver()
+        with pytest.raises(ReceiverError):
+            await receiver.receive()