Fix tests

Author: roznawsk

tests/conftest.py

@@ -0,0 +1,33 @@
+# pylint: disable=missing-class-docstring, missing-function-docstring, missing-module-docstring, redefined-outer-name
+
+import pytest
+
+from fishjam import FishjamClient, Room, RoomOptions
+from fishjam.errors import HTTPError
+from tests.support.env import FISHJAM_ID, FISHJAM_MANAGEMENT_TOKEN
+
+
+class _TrackingFishjamClient(FishjamClient):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._tracked_room_ids: list[str] = []
+
+    def create_room(self, options: RoomOptions | None = None) -> Room:
+        room = super().create_room(options)
+        self._tracked_room_ids.append(room.id)
+        return room
+
+    def cleanup_tracked_rooms(self) -> None:
+        for room_id in self._tracked_room_ids:
+            try:
+                self.delete_room(room_id)
+            except HTTPError:
+                pass
+        self._tracked_room_ids.clear()
+
+
+@pytest.fixture
+def room_api():
+    client = _TrackingFishjamClient(FISHJAM_ID, FISHJAM_MANAGEMENT_TOKEN)
+    yield client
+    client.cleanup_tracked_rooms()

tests/support/asyncio_utils.py

@@ -7,25 +7,54 @@
 ASSERTION_TIMEOUT = 15.0
 
 
-async def assert_events(notifier: FishjamNotifier, event_checks: list):
-    await _assert_messages(notifier.on_server_notification, event_checks)
-
-
-async def _assert_messages(notifier_callback, message_checks):
+async def assert_events(
+    notifier: FishjamNotifier,
+    event_checks: list,
+    *,
+    room_id_future: asyncio.Future | None = None,
+):
+    await _assert_messages(
+        notifier.on_server_notification, event_checks, room_id_future
+    )
+
+
+async def _assert_messages(notifier_callback, message_checks, room_id_future):
     success_event = asyncio.Event()
+    pending: list = []
+    room_id_holder: dict = {"value": None, "set": False}
 
-    @notifier_callback
-    def handle_message(message):
+    def _consume(message):
         if len(message_checks) > 0:
             expected_msg = message_checks[0]
             if message == expected_msg or isinstance(message, expected_msg):
                 message_checks.pop(0)
-
         if message_checks == []:
             success_event.set()
 
+    @notifier_callback
+    def handle_message(message):
+        if not room_id_holder["set"]:
+            pending.append(message)
+            return
+
+        expected_room_id = room_id_holder["value"]
+        if expected_room_id is not None:
+            if getattr(message, "room_id", None) != expected_room_id:
+                return
+
+        _consume(message)
+
+    async def _wait_for_success():
+        if room_id_future is not None:
+            room_id_holder["value"] = await room_id_future
+        room_id_holder["set"] = True
+        for msg in pending:
+            handle_message(msg)
+        pending.clear()
+        await success_event.wait()
+
     try:
-        await asyncio.wait_for(success_event.wait(), ASSERTION_TIMEOUT)
+        await asyncio.wait_for(_wait_for_success(), ASSERTION_TIMEOUT)
     except asyncio.exceptions.TimeoutError as exc:
         raise asyncio.exceptions.TimeoutError(
             f"{message_checks[0]} hasn't been received within timeout"

tests/test_notifier.py

@@ -93,11 +93,6 @@ def handle_notitifcation(_notification):
             await asyncio.gather(notifier_task, return_exceptions=True)
 
 
-@pytest.fixture
-def room_api():
-    return FishjamClient(FISHJAM_ID, FISHJAM_MANAGEMENT_TOKEN)
-
-
 @pytest.fixture
 def notifier():
     notifier = FishjamNotifier(
@@ -115,15 +110,17 @@ async def test_room_created_deleted(
     ):
         event_checks = [ServerMessageRoomCreated, ServerMessageRoomDeleted]
 
+        room_id_future: asyncio.Future = asyncio.get_event_loop().create_future()
         assert_task = asyncio.ensure_future(
-            assert_events(notifier, event_checks.copy())
+            assert_events(notifier, event_checks.copy(), room_id_future=room_id_future)
         )
         notifier_task = asyncio.ensure_future(notifier.connect())
         try:
             await notifier.wait_ready()
 
             options = RoomOptions(webhook_url=WEBHOOK_URL)
             room = room_api.create_room(options=options)
+            room_id_future.set_result(room.id)
 
             room_api.delete_room(room.id)
 
@@ -148,8 +145,9 @@ async def test_peer_connected_disconnected(
             ServerMessageRoomDeleted,
         ]
 
+        room_id_future: asyncio.Future = asyncio.get_event_loop().create_future()
         assert_task = asyncio.ensure_future(
-            assert_events(notifier, event_checks.copy())
+            assert_events(notifier, event_checks.copy(), room_id_future=room_id_future)
         )
         notifier_task = asyncio.ensure_future(notifier.connect())
         tasks = [assert_task, notifier_task]
@@ -158,6 +156,7 @@ async def test_peer_connected_disconnected(
 
             options = RoomOptions(webhook_url=WEBHOOK_URL)
             room = room_api.create_room(options=options)
+            room_id_future.set_result(room.id)
 
             peer, token = room_api.create_peer(room.id)
             peer_socket = PeerSocket(fishjam_url=FISHJAM_ID)
@@ -189,8 +188,9 @@ async def test_peer_connected_room_deleted(
             ServerMessageRoomDeleted,
         ]
 
+        room_id_future: asyncio.Future = asyncio.get_event_loop().create_future()
         assert_task = asyncio.ensure_future(
-            assert_events(notifier, event_checks.copy())
+            assert_events(notifier, event_checks.copy(), room_id_future=room_id_future)
         )
         notifier_task = asyncio.ensure_future(notifier.connect())
         tasks = [assert_task, notifier_task]
@@ -199,6 +199,7 @@ async def test_peer_connected_room_deleted(
 
             options = RoomOptions(webhook_url=WEBHOOK_URL)
             room = room_api.create_room(options=options)
+            room_id_future.set_result(room.id)
             _peer, token = room_api.create_peer(room.id)
 
             peer_socket = PeerSocket(fishjam_url=FISHJAM_ID)
@@ -217,7 +218,7 @@ async def test_peer_connected_room_deleted(
 
         self.assert_webhook_events(event_checks, event_queue, room.id)
 
-    def assert_webhook_events(self, event_checks, event_queue, room_id, timeout=60):
+    def assert_webhook_events(self, event_checks, event_queue, room_id, timeout=15):
         deadline = time.monotonic() + timeout
         received = []
 

tests/test_room_api.py

@@ -45,9 +45,7 @@ def test_invalid_token(self):
         with pytest.raises(UnauthorizedError):
             room_api.create_room()
 
-    def test_valid_token(self):
-        room_api = FishjamClient(FISHJAM_ID, FISHJAM_MANAGEMENT_TOKEN)
-
+    def test_valid_token(self, room_api: FishjamClient):
         room = room_api.create_room()
         all_rooms = room_api.get_all_rooms()
 
@@ -84,11 +82,6 @@ def mock_send(request, **kwargs):
         assert captured_headers["x-fishjam-api-client"] == expected_header_value
 
 
-@pytest.fixture
-def room_api():
-    return FishjamClient(FISHJAM_ID, FISHJAM_MANAGEMENT_TOKEN)
-
-
 class TestCreateRoom:
     def test_no_params(self, room_api: FishjamClient):
         room = room_api.create_room()