fix remaining test issues

Author: lukasIO

livekit-rtc/tests/test_e2e.py

@@ -21,12 +21,12 @@
 import asyncio
 import os
 import uuid
-from typing import Callable, TypeVar
+from typing import Any, Callable, Dict, List, TypeVar
 import numpy as np
-import pytest
+import pytest  # type: ignore[import-not-found]
 
 from livekit import rtc, api
-from livekit.rtc.utils import sine_wave_generator
+from livekit.rtc.utils import sine_wave_generator  # type: ignore[attr-defined]
 
 
 SAMPLE_RATE = 48000
@@ -55,7 +55,7 @@ async def assert_eventually(
     raise AssertionError(f"{message} (last result: {last_result})")
 
 
-def skip_if_no_credentials():
+def skip_if_no_credentials() -> Any:
     required_vars = ["LIVEKIT_URL", "LIVEKIT_API_KEY", "LIVEKIT_API_SECRET"]
     missing = [var for var in required_vars if not os.getenv(var)]
     return pytest.mark.skipif(
@@ -82,12 +82,13 @@ def unique_room_name(base: str) -> str:
     return f"{base}-{uuid.uuid4().hex[:8]}"
 
 
-@pytest.mark.asyncio
-@skip_if_no_credentials()
-async def test_publish_track():
+@pytest.mark.asyncio  # type: ignore[misc]
+@skip_if_no_credentials()  # type: ignore[misc]
+async def test_publish_track() -> None:
     """Test that a published track can be subscribed by another participant"""
     room_name = unique_room_name("test-publish-track")
     url = os.getenv("LIVEKIT_URL")
+    assert url is not None
 
     publisher_room = rtc.Room()
     subscriber_room = rtc.Room()
@@ -102,15 +103,15 @@ async def test_publish_track():
     @subscriber_room.on("track_published")
     def on_track_published(
         publication: rtc.RemoteTrackPublication, participant: rtc.RemoteParticipant
-    ):
+    ) -> None:
         track_published_event.set()
 
     @subscriber_room.on("track_subscribed")
     def on_track_subscribed(
         track: rtc.Track,
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
-    ):
+    ) -> None:
         nonlocal subscribed_track
         if track.kind == rtc.TrackKind.KIND_AUDIO:
             subscribed_track = track
@@ -140,12 +141,13 @@ def on_track_subscribed(
         await subscriber_room.disconnect()
 
 
-@pytest.mark.asyncio
-@skip_if_no_credentials()
-async def test_audio_stream_subscribe():
+@pytest.mark.asyncio  # type: ignore[misc]
+@skip_if_no_credentials()  # type: ignore[misc]
+async def test_audio_stream_subscribe() -> None:
     """Test that published audio can be consumed and has similar energy levels"""
     room_name = unique_room_name("test-audio-stream")
     url = os.getenv("LIVEKIT_URL")
+    assert url is not None
 
     publisher_room = rtc.Room()
     subscriber_room = rtc.Room()
@@ -161,7 +163,7 @@ def on_track_subscribed(
         track: rtc.Track,
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
-    ):
+    ) -> None:
         nonlocal subscribed_track
         if track.kind == rtc.TrackKind.KIND_AUDIO:
             subscribed_track = track
@@ -178,9 +180,9 @@ def on_track_subscribed(
         await publisher_room.local_participant.publish_track(track, options)
         target_duration = 5.0
 
-        published_energy = []
+        published_energy: List[Any] = []
 
-        async def publish_audio():
+        async def publish_audio() -> None:
             async for frame in sine_wave_generator(440, target_duration, SAMPLE_RATE):
                 data = np.frombuffer(frame.data.tobytes(), dtype=np.int16)
                 energy = np.mean(np.abs(data.astype(np.float32)))
@@ -235,20 +237,21 @@ async def publish_audio():
         await subscriber_room.disconnect()
 
 
-@pytest.mark.asyncio
-@skip_if_no_credentials()
-async def test_room_lifecycle_events():
+@pytest.mark.asyncio  # type: ignore[misc]
+@skip_if_no_credentials()  # type: ignore[misc]
+async def test_room_lifecycle_events() -> None:
     """Test that room lifecycle and track events are fired properly"""
     room_name = unique_room_name("test-lifecycle-events")
     url = os.getenv("LIVEKIT_URL")
+    assert url is not None
 
     room1 = rtc.Room()
     room2 = rtc.Room()
 
     token1 = create_token("participant-1", room_name)
     token2 = create_token("participant-2", room_name)
 
-    events = {
+    events: Dict[str, List[str]] = {
         "disconnected": [],
         "participant_connected": [],
         "participant_disconnected": [],
@@ -263,51 +266,51 @@ async def test_room_lifecycle_events():
     }
 
     @room1.on("disconnected")
-    def on_room1_disconnected(reason):
+    def on_room1_disconnected(reason: Any) -> None:
         events["disconnected"].append("room1")
 
     @room1.on("participant_connected")
-    def on_room1_participant_connected(participant: rtc.RemoteParticipant):
+    def on_room1_participant_connected(participant: rtc.RemoteParticipant) -> None:
         events["participant_connected"].append(f"room1-{participant.identity}")
 
     @room1.on("participant_disconnected")
-    def on_room1_participant_disconnected(participant: rtc.RemoteParticipant):
+    def on_room1_participant_disconnected(participant: rtc.RemoteParticipant) -> None:
         events["participant_disconnected"].append(f"room1-{participant.identity}")
 
     @room1.on("local_track_published")
-    def on_room1_local_track_published(publication: rtc.LocalTrackPublication, track):
+    def on_room1_local_track_published(publication: rtc.LocalTrackPublication, track: Any) -> None:
         events["local_track_published"].append(f"room1-{publication.sid}")
 
     @room1.on("local_track_unpublished")
-    def on_room1_local_track_unpublished(publication: rtc.LocalTrackPublication):
+    def on_room1_local_track_unpublished(publication: rtc.LocalTrackPublication) -> None:
         events["local_track_unpublished"].append(f"room1-{publication.sid}")
 
     @room1.on("room_updated")
-    def on_room1_room_updated():
+    def on_room1_room_updated() -> None:
         events["room_updated"].append("room1")
 
     @room1.on("connection_state_changed")
-    def on_room1_connection_state_changed(state: rtc.ConnectionState):
+    def on_room1_connection_state_changed(state: rtc.ConnectionState) -> None:
         events["connection_state_changed"].append(f"room1-{state}")
 
     @room2.on("track_published")
     def on_room2_track_published(
         publication: rtc.RemoteTrackPublication, participant: rtc.RemoteParticipant
-    ):
+    ) -> None:
         events["track_published"].append(f"room2-{publication.sid}")
 
     @room2.on("track_subscribed")
     def on_room2_track_subscribed(
         track: rtc.Track,
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
-    ):
+    ) -> None:
         events["track_subscribed"].append(f"room2-{publication.sid}")
 
     @room2.on("track_unpublished")
     def on_room2_track_unpublished(
         publication: rtc.RemoteTrackPublication, participant: rtc.RemoteParticipant
-    ):
+    ) -> None:
         events["track_unpublished"].append(f"room2-{publication.sid}")
 
     try:
@@ -388,20 +391,21 @@ def on_room2_track_unpublished(
             await room2.disconnect()
 
 
-@pytest.mark.asyncio
-@skip_if_no_credentials()
-async def test_connection_state_transitions():
+@pytest.mark.asyncio  # type: ignore[misc]
+@skip_if_no_credentials()  # type: ignore[misc]
+async def test_connection_state_transitions() -> None:
     """Test that connection state transitions work correctly"""
     room_name = unique_room_name("test-connection-state")
     url = os.getenv("LIVEKIT_URL")
+    assert url is not None
 
     room = rtc.Room()
     token = create_token("state-test", room_name)
 
-    states = []
+    states: List[rtc.ConnectionState] = []
 
     @room.on("connection_state_changed")
-    def on_state_changed(state: rtc.ConnectionState):
+    def on_state_changed(state: rtc.ConnectionState) -> None:
         states.append(state)
 
     try:
@@ -414,7 +418,7 @@ def on_state_changed(state: rtc.ConnectionState):
             message="Room did not reach CONN_CONNECTED state",
         )
         await assert_eventually(
-            lambda: rtc.ConnectionState.CONN_CONNECTED in states,
+            lambda: rtc.ConnectionState.CONN_CONNECTED in states,  # type: ignore[comparison-overlap]
             message="CONN_CONNECTED state not in state change events",
         )
 

livekit-rtc/tests/test_emitter.py

@@ -1,16 +1,16 @@
 from livekit.rtc import EventEmitter
-from typing import Literal
-import pytest
+from typing import Any, Literal
+import pytest  # type: ignore[import-not-found]
 
 
-def test_events():
+def test_events() -> None:
     EventTypes = Literal["connected", "reconnected", "disconnected"]
     emitter = EventEmitter[EventTypes]()
 
     connected_calls = []
 
     @emitter.once("connected")
-    def on_connected():
+    def on_connected() -> None:
         connected_calls.append(True)
 
     emitter.emit("connected")
@@ -22,7 +22,7 @@ def on_connected():
     reconnected_calls = []
 
     @emitter.on("reconnected")
-    def on_reconnected():
+    def on_reconnected() -> None:
         reconnected_calls.append(True)
 
     emitter.emit("reconnected")
@@ -32,11 +32,11 @@ def on_reconnected():
     disconnected_calls = []
 
     @emitter.on("disconnected")
-    def on_disconnected():
+    def on_disconnected() -> None:
         disconnected_calls.append(True)
 
     @emitter.on("disconnected")
-    def on_disconnected_another():
+    def on_disconnected_another() -> None:
         disconnected_calls.append(True)
 
     emitter.emit("disconnected")
@@ -46,15 +46,15 @@ def on_disconnected_another():
     assert len(disconnected_calls) == 5
 
 
-def test_args():
+def test_args() -> None:
     EventTypes = Literal["whatever"]
 
     emitter = EventEmitter[EventTypes]()
 
     calls = []
 
     @emitter.on("whatever")
-    def on_whatever(first, second, third):
+    def on_whatever(first: Any, second: Any, third: Any) -> None:
         calls.append((first, second, third))
 
     emitter.emit("whatever", 1, 2, 3)
@@ -66,15 +66,15 @@ def on_whatever(first, second, third):
         emitter.emit("whatever", 1, 2)
 
 
-def test_varargs():
+def test_varargs() -> None:
     EventTypes = Literal["whatever"]
 
     emitter = EventEmitter[EventTypes]()
 
     calls = []
 
     @emitter.on("whatever")
-    def on_whatever_varargs(*args):
+    def on_whatever_varargs(*args: Any) -> None:
         calls.append(args)
 
     emitter.emit("whatever", 1, 2, 3, 4, 5)
@@ -83,20 +83,20 @@ def on_whatever_varargs(*args):
     assert calls == [(1, 2, 3, 4, 5), (1, 2)]
 
 
-def test_throw():
+def test_throw() -> None:
     EventTypes = Literal["error"]
 
     emitter = EventEmitter[EventTypes]()
 
     calls = []
 
     @emitter.on("error")
-    def on_error():
+    def on_error() -> None:
         calls.append(True)
         raise ValueError("error")
 
     @emitter.on("error")
-    def on_error_another():
+    def on_error_another() -> None:
         calls.append(True)
 
     emitter.emit("error")