refactor: use fixtures in test_connection_utils, snapshot mutable list in test_connection_manager

Extract mock_ws_client and coordinator_request fixtures to reduce
duplication. Snapshot migrating_from_list per attempt to avoid
mutable reference aliasing in assertions.

Author: aliev

tests/test_connection_manager.py

@@ -55,7 +55,9 @@ async def test_retries_on_sfu_join_error_and_passes_failed_sfus(
         async def mock_connect_internal(migrating_from_list=None, **kwargs):
             nonlocal call_count
             call_count += 1
-            received_migrating_from_list.append(migrating_from_list)
+            received_migrating_from_list.append(
+                list(migrating_from_list) if migrating_from_list else None
+            )
 
             if call_count <= 2:
                 mock_join_response = MagicMock()
@@ -76,7 +78,7 @@ async def mock_connect_internal(migrating_from_list=None, **kwargs):
 
         assert call_count == 3
         assert received_migrating_from_list[0] is None
-        assert "sfu-node-1" in received_migrating_from_list[1]
+        assert received_migrating_from_list[1] == ["sfu-node-1"]
         assert received_migrating_from_list[2] == ["sfu-node-1", "sfu-node-2"]
 
     @pytest.mark.asyncio

tests/test_connection_utils.py

@@ -5,146 +5,127 @@
     connect_websocket,
     ConnectionOptions,
     SfuConnectionError,
+    SfuJoinError,
     join_call_coordinator_request,
 )
 from getstream.video.rtc.signaling import SignalingError
 from getstream.video.rtc.pb.stream.video.sfu.models import models_pb2
 
 
+@pytest.fixture
+def mock_ws_client():
+    """Patch WebSocketClient and yield the mock instance."""
+    with patch("getstream.video.rtc.connection_utils.WebSocketClient") as mock_ws_cls:
+        mock_ws = AsyncMock()
+        mock_ws_cls.return_value = mock_ws
+        yield mock_ws
+
+
+@pytest.fixture
+def coordinator_request():
+    """Set up a mock coordinator client that captures the request body."""
+    mock_call = AsyncMock()
+    mock_call.call_type = "default"
+    mock_call.id = "test_call"
+    mock_call.client.stream.api_key = "key"
+    mock_call.client.stream.api_secret = "secret"
+    mock_call.client.stream.base_url = "https://test.url"
+
+    captured_body = {}
+
+    with patch("getstream.video.rtc.connection_utils.user_client") as mock_user_client:
+        mock_client = AsyncMock()
+
+        async def capture_post(*args, **kwargs):
+            captured_body.update(kwargs.get("json", {}))
+            return AsyncMock()
+
+        mock_client.post = capture_post
+        mock_user_client.return_value = mock_client
+        yield mock_call, captured_body
+
+
 class TestConnectWebsocket:
     @pytest.mark.asyncio
-    async def test_raises_sfu_join_error_on_sfu_full(self):
+    async def test_raises_sfu_join_error_on_sfu_full(self, mock_ws_client):
         """connect_websocket should raise SfuJoinError when SFU is full."""
-        from getstream.video.rtc.connection_utils import SfuJoinError
-
-        # Create a models_pb2.Error with SFU_FULL code
         sfu_error = models_pb2.Error(
             code=models_pb2.ERROR_CODE_SFU_FULL,
             message="server is full",
             should_retry=True,
         )
-        signaling_error = SignalingError(
-            "Connection failed: server is full", error=sfu_error
+        mock_ws_client.connect = AsyncMock(
+            side_effect=SignalingError(
+                "Connection failed: server is full", error=sfu_error
+            )
         )
 
-        with patch(
-            "getstream.video.rtc.connection_utils.WebSocketClient"
-        ) as mock_ws_cls:
-            mock_ws = AsyncMock()
-            mock_ws.connect = AsyncMock(side_effect=signaling_error)
-            mock_ws_cls.return_value = mock_ws
-
-            with pytest.raises(SfuJoinError) as exc_info:
-                await connect_websocket(
-                    token="test_token",
-                    ws_url="wss://test.url",
-                    session_id="test_session",
-                    options=ConnectionOptions(),
-                )
-
-            assert exc_info.value.error_code == models_pb2.ERROR_CODE_SFU_FULL
-            assert exc_info.value.should_retry is True
-            # SfuJoinError should be a subclass of SfuConnectionError
-            assert isinstance(exc_info.value, SfuConnectionError)
+        with pytest.raises(SfuJoinError) as exc_info:
+            await connect_websocket(
+                token="test_token",
+                ws_url="wss://test.url",
+                session_id="test_session",
+                options=ConnectionOptions(),
+            )
+
+        assert exc_info.value.error_code == models_pb2.ERROR_CODE_SFU_FULL
+        assert exc_info.value.should_retry is True
+        assert isinstance(exc_info.value, SfuConnectionError)
 
     @pytest.mark.asyncio
-    async def test_non_retryable_error_propagates_as_signaling_error(self):
+    async def test_non_retryable_error_propagates_as_signaling_error(
+        self, mock_ws_client
+    ):
         """Non-retryable SignalingError should not become SfuJoinError."""
-        from getstream.video.rtc.connection_utils import SfuJoinError
-
-        # Error with non-retryable code (e.g. permission denied)
         sfu_error = models_pb2.Error(
             code=models_pb2.ERROR_CODE_PERMISSION_DENIED,
             message="permission denied",
             should_retry=False,
         )
-        signaling_error = SignalingError(
-            "Connection failed: permission denied", error=sfu_error
+        mock_ws_client.connect = AsyncMock(
+            side_effect=SignalingError(
+                "Connection failed: permission denied", error=sfu_error
+            )
         )
 
-        with patch(
-            "getstream.video.rtc.connection_utils.WebSocketClient"
-        ) as mock_ws_cls:
-            mock_ws = AsyncMock()
-            mock_ws.connect = AsyncMock(side_effect=signaling_error)
-            mock_ws_cls.return_value = mock_ws
-
-            with pytest.raises(SignalingError) as exc_info:
-                await connect_websocket(
-                    token="test_token",
-                    ws_url="wss://test.url",
-                    session_id="test_session",
-                    options=ConnectionOptions(),
-                )
+        with pytest.raises(SignalingError) as exc_info:
+            await connect_websocket(
+                token="test_token",
+                ws_url="wss://test.url",
+                session_id="test_session",
+                options=ConnectionOptions(),
+            )
 
-            assert not isinstance(exc_info.value, SfuJoinError)
+        assert not isinstance(exc_info.value, SfuJoinError)
 
 
 class TestJoinCallCoordinatorRequest:
     @pytest.mark.asyncio
-    async def test_includes_migrating_from_in_body(self):
+    async def test_includes_migrating_from_in_body(self, coordinator_request):
         """migrating_from and migrating_from_list should be included in the request body."""
-        mock_call = AsyncMock()
-        mock_call.call_type = "default"
-        mock_call.id = "test_call"
-        mock_call.client.stream.api_key = "key"
-        mock_call.client.stream.api_secret = "secret"
-        mock_call.client.stream.base_url = "https://test.url"
-
-        captured_body = {}
-
-        with patch(
-            "getstream.video.rtc.connection_utils.user_client"
-        ) as mock_user_client:
-            mock_client = AsyncMock()
-
-            async def capture_post(*args, **kwargs):
-                captured_body.update(kwargs.get("json", {}))
-                return AsyncMock()
-
-            mock_client.post = capture_post
-            mock_user_client.return_value = mock_client
-
-            await join_call_coordinator_request(
-                call=mock_call,
-                user_id="user1",
-                location="auto",
-                migrating_from="sfu-london-1",
-                migrating_from_list=["sfu-london-1", "sfu-paris-2"],
-            )
+        mock_call, captured_body = coordinator_request
+
+        await join_call_coordinator_request(
+            call=mock_call,
+            user_id="user1",
+            location="auto",
+            migrating_from="sfu-london-1",
+            migrating_from_list=["sfu-london-1", "sfu-paris-2"],
+        )
 
         assert captured_body["migrating_from"] == "sfu-london-1"
         assert captured_body["migrating_from_list"] == ["sfu-london-1", "sfu-paris-2"]
 
     @pytest.mark.asyncio
-    async def test_omits_migrating_from_when_not_provided(self):
+    async def test_omits_migrating_from_when_not_provided(self, coordinator_request):
         """migrating_from should not appear in body when not provided."""
-        mock_call = AsyncMock()
-        mock_call.call_type = "default"
-        mock_call.id = "test_call"
-        mock_call.client.stream.api_key = "key"
-        mock_call.client.stream.api_secret = "secret"
-        mock_call.client.stream.base_url = "https://test.url"
-
-        captured_body = {}
-
-        with patch(
-            "getstream.video.rtc.connection_utils.user_client"
-        ) as mock_user_client:
-            mock_client = AsyncMock()
-
-            async def capture_post(*args, **kwargs):
-                captured_body.update(kwargs.get("json", {}))
-                return AsyncMock()
-
-            mock_client.post = capture_post
-            mock_user_client.return_value = mock_client
-
-            await join_call_coordinator_request(
-                call=mock_call,
-                user_id="user1",
-                location="auto",
-            )
+        mock_call, captured_body = coordinator_request
+
+        await join_call_coordinator_request(
+            call=mock_call,
+            user_id="user1",
+            location="auto",
+        )
 
         assert "migrating_from" not in captured_body
         assert "migrating_from_list" not in captured_body