fix the README and make the tests run with localhost, as it will fallback to V0

Author: xianshijing-lk

livekit/src/room/mod.rs

@@ -1062,13 +1062,11 @@ impl RoomSession {
 
         let (participant_sid, stream_id) = lk_stream_id.unwrap();
         let mut track_id = track.id();
-        if stream_id.starts_with("TR") {
-            track_id = stream_id.into();
-        }
 
-        // In single PC mode, try to resolve track ID from mid_to_track_id mapping
+        // Resolve track ID based on signaling mode
         let session = self.rtc_engine.session();
-        if session.is_single_pc_mode() && !track_id.starts_with("TR") {
+        if session.is_single_pc_mode() {
+            // In single PC mode, resolve track ID from mid_to_track_id mapping
             if let Some(mid) = transceiver.mid() {
                 if let Some(resolved_track_id) = session.get_track_id_for_mid(&mid) {
                     log::debug!(
@@ -1079,12 +1077,15 @@ impl RoomSession {
                     track_id = resolved_track_id.into();
                 } else {
                     log::warn!(
-                        "could not resolve track_id for mid={}, using stream_id={}",
+                        "could not resolve track_id for mid={}, using track.id()={}",
                         mid,
                         track_id
                     );
                 }
             }
+        } else if stream_id.starts_with("TR") {
+            // In dual PC mode, use stream_id if it's a valid track ID
+            track_id = stream_id.into();
         }
 
         if !track_id.starts_with("TR") {
@@ -1188,29 +1189,29 @@ impl RoomSession {
         // In dual PC mode, use subscriber's offer/answer
         let (offer, answer) = if single_pc_mode {
             let pub_pc = session.publisher().peer_connection();
-            let local_desc = pub_pc.current_local_description();
-            let remote_desc = pub_pc.current_remote_description();
-            if local_desc.is_none() {
+            let Some(local_desc) = pub_pc.current_local_description() else {
                 log::warn!("skipping sendSyncState, no publisher offer");
                 return;
-            }
+            };
+            let remote_desc = pub_pc.current_remote_description();
             // In single PC mode: offer is local (publisher initiates), answer is remote
-            (local_desc.unwrap(), remote_desc)
+            (local_desc, remote_desc)
         } else {
-            let sub_pc = session.subscriber();
-            if sub_pc.is_none() {
+            let Some(sub_pc) = session.subscriber() else {
                 log::warn!("skipping sendSyncState, no subscriber");
                 return;
-            }
-            let sub_pc = sub_pc.unwrap().peer_connection();
-            let local_desc = sub_pc.current_local_description();
-            let remote_desc = sub_pc.current_remote_description();
-            if local_desc.is_none() {
+            };
+            let sub_pc = sub_pc.peer_connection();
+            let Some(local_desc) = sub_pc.current_local_description() else {
                 log::warn!("skipping sendSyncState, no subscriber answer");
                 return;
-            }
+            };
+            let Some(remote_desc) = sub_pc.current_remote_description() else {
+                log::warn!("skipping sendSyncState, no subscriber offer");
+                return;
+            };
             // In dual PC mode: answer is local, offer is remote
-            (remote_desc.unwrap(), Some(local_desc.unwrap()))
+            (remote_desc, Some(local_desc))
         };
 
         let mut track_sids = Vec::new();

livekit/tests/README.md

@@ -15,42 +15,52 @@ cargo test --features default,__lk-e2e-test -- --nocapture
 
 The `peer_connection_signaling_test.rs` tests verify both V0 (dual peer connection) and V1 (single peer connection) signaling modes.
 
-### V0 Tests (Dual PC - works on localhost)
+### V0 Tests (Dual Peer Connection)
 
-V0 tests can run against a local LiveKit server:
+V0 tests work on localhost with the default LiveKit development server:
 
 ```sh
 # Start local server
 livekit-server --dev
 
-# Run V0 tests only (uses localhost by default)
+# Run V0 tests
 cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test v0_ -- --nocapture
 ```
 
-### V1 Tests (Single PC - requires LiveKit Cloud)
+Default localhost configuration:
+- URL: `ws://localhost:7880`
+- API Key: `devkey`
+- API Secret: `secret`
 
-V1 (single peer connection) mode requires a LiveKit Cloud server or a server that supports the `/rtc/v1` endpoint. Local development servers typically don't support V1 signaling.
+### V1 Tests (Single Peer Connection)
 
-Set the following environment variables:
+**Important:** V1 (single peer connection) mode requires a LiveKit Cloud server or a server that supports the `/rtc/v1` endpoint.
+
+⚠️ **V1 tests will fall back to V0 signaling on localhost**, so to truly test V1 functionality, you **must** set the cloud environment variables:
 
 ```sh
 export LIVEKIT_URL="wss://your-project.livekit.cloud"
 export LIVEKIT_API_KEY="your-api-key"
 export LIVEKIT_API_SECRET="your-api-secret"
+
+# Run V1 tests
+cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test v1_ -- --nocapture
 ```
 
-Then run:
+### Running All Tests
 
 ```sh
-# Run V1 tests only
-cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test v1_ -- --nocapture
+# On localhost (V0 will work, V1 falls back to V0)
+livekit-server --dev
+cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test -- --nocapture
 
-# Run all signaling tests (both V0 and V1)
+# On LiveKit Cloud (both V0 and V1 work correctly)
+export LIVEKIT_URL="wss://your-project.livekit.cloud"
+export LIVEKIT_API_KEY="your-api-key"
+export LIVEKIT_API_SECRET="your-api-secret"
 cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test -- --nocapture
 ```
 
-**Note:** V1 tests will be skipped if the environment variables are not set.
-
 ## VS Code Integration
 
 If you are using Rust Analyzer in Visual Studio Code, you can enable the E2E test feature to get code completion for these tests. Add the following setting to *.vscode/settings.json*:

livekit/tests/peer_connection_signaling_test.rs

@@ -18,23 +18,25 @@
 //! signaling modes work correctly.
 //!
 //! V0 (Dual PC): Traditional mode with separate publisher and subscriber peer connections
-//!               Can run on localhost with `livekit-server --dev`
+//!               Works on localhost with `livekit-server --dev`
 //!
 //! V1 (Single PC): New mode with a single peer connection for both publish and subscribe
-//!                 Requires LiveKit Cloud or a server supporting /rtc/v1 endpoint
+//!                 Requires LiveKit Cloud or a server that supports /rtc/v1 endpoint.
+//!                 NOTE: V1 tests will fall back to V0 on localhost, so to truly test V1,
+//!                 you must set the cloud environment variables.
 //!
-//! Environment variables (required for V1, optional for V0):
-//! - LIVEKIT_URL: The LiveKit server URL (V0 defaults to ws://localhost:7880)
-//! - LIVEKIT_API_KEY: The API key (V0 defaults to "devkey")
-//! - LIVEKIT_API_SECRET: The API secret (V0 defaults to "secret")
+//! Environment variables:
+//! - LIVEKIT_URL: The LiveKit server URL (defaults to ws://localhost:7880)
+//! - LIVEKIT_API_KEY: The API key (defaults to "devkey")
+//! - LIVEKIT_API_SECRET: The API secret (defaults to "secret")
 //!
 //! Run all tests:
 //!   cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test -- --nocapture
 //!
-//! Run only V0 tests (works on localhost):
+//! Run only V0 tests:
 //!   cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test v0_ -- --nocapture
 //!
-//! Run only V1 tests (requires cloud):
+//! Run only V1 tests (set cloud env vars first):
 //!   cargo test -p livekit --features "__lk-e2e-test,native-tls" --test peer_connection_signaling_test v1_ -- --nocapture
 
 mod common;
@@ -78,55 +80,20 @@ mod signaling_tests {
         }
     }
 
-    /// Default localhost configuration for V0 tests
+    /// Default localhost configuration
     const DEFAULT_LOCALHOST_URL: &str = "ws://localhost:7880";
     const DEFAULT_API_KEY: &str = "devkey";
     const DEFAULT_API_SECRET: &str = "secret";
 
-    /// Get environment variables for V0 tests (uses localhost defaults)
-    fn get_v0_env() -> (String, String, String) {
+    /// Get environment for tests (uses localhost defaults if env vars not set)
+    fn get_env_for_mode(_mode: SignalingMode) -> (String, String, String) {
         let url = env::var("LIVEKIT_URL").unwrap_or_else(|_| DEFAULT_LOCALHOST_URL.to_string());
         let api_key = env::var("LIVEKIT_API_KEY").unwrap_or_else(|_| DEFAULT_API_KEY.to_string());
         let api_secret =
             env::var("LIVEKIT_API_SECRET").unwrap_or_else(|_| DEFAULT_API_SECRET.to_string());
         (url, api_key, api_secret)
     }
 
-    /// Check if cloud environment variables are set (required for V1 tests)
-    fn check_cloud_env_vars() -> Option<(String, String, String)> {
-        let url = env::var("LIVEKIT_URL").ok()?;
-        let api_key = env::var("LIVEKIT_API_KEY").ok()?;
-        let api_secret = env::var("LIVEKIT_API_SECRET").ok()?;
-        Some((url, api_key, api_secret))
-    }
-
-    /// Get environment for the given signaling mode
-    /// V0: Uses localhost defaults if env vars not set
-    /// V1: Requires env vars to be set, returns None if not
-    fn get_env_for_mode(mode: SignalingMode) -> Option<(String, String, String)> {
-        match mode {
-            SignalingMode::DualPC => Some(get_v0_env()),
-            SignalingMode::SinglePC => check_cloud_env_vars(),
-        }
-    }
-
-    /// Macro to get environment for the given mode, skipping if V1 and no cloud env
-    macro_rules! require_env_for_mode {
-        ($mode:expr) => {
-            match get_env_for_mode($mode) {
-                Some(env) => env,
-                None => {
-                    log::warn!(
-                        "Skipping {} test: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET not set. \
-                         V1 tests require LiveKit Cloud or a server supporting /rtc/v1 endpoint.",
-                        $mode.name()
-                    );
-                    return Ok(());
-                }
-            }
-        };
-    }
-
     /// Create a token for testing
     fn create_token(
         api_key: &str,
@@ -251,7 +218,7 @@ mod signaling_tests {
 
     /// Test basic connection
     async fn test_connect_impl(mode: SignalingMode) -> Result<()> {
-        let (url, api_key, api_secret) = require_env_for_mode!(mode);
+        let (url, api_key, api_secret) = get_env_for_mode(mode);
         let room_name = format!("test_{:?}_{}", mode, create_random_uuid());
         let token = create_token(&api_key, &api_secret, &room_name, "test_participant")?;
 
@@ -278,7 +245,7 @@ mod signaling_tests {
 
     /// Test two participants connecting
     async fn test_two_participants_impl(mode: SignalingMode) -> Result<()> {
-        let (url, api_key, api_secret) = require_env_for_mode!(mode);
+        let (url, api_key, api_secret) = get_env_for_mode(mode);
         let room_name = format!("test_{:?}_2p_{}", mode, create_random_uuid());
 
         let token1 = create_token(&api_key, &api_secret, &room_name, "participant_1")?;
@@ -312,7 +279,7 @@ mod signaling_tests {
 
     /// Test publishing and receiving audio tracks
     async fn test_audio_track_impl(mode: SignalingMode) -> Result<()> {
-        let (url, api_key, api_secret) = require_env_for_mode!(mode);
+        let (url, api_key, api_secret) = get_env_for_mode(mode);
         let room_name = format!("test_{:?}_audio_{}", mode, create_random_uuid());
 
         let token_pub = create_token(&api_key, &api_secret, &room_name, "publisher")?;
@@ -383,7 +350,7 @@ mod signaling_tests {
 
     /// Test reconnection - verifies tracks are restored
     async fn test_reconnect_impl(mode: SignalingMode) -> Result<()> {
-        let (url, api_key, api_secret) = require_env_for_mode!(mode);
+        let (url, api_key, api_secret) = get_env_for_mode(mode);
         let room_name = format!("test_{:?}_reconnect_{}", mode, create_random_uuid());
 
         let token_pub = create_token(&api_key, &api_secret, &room_name, "publisher")?;
@@ -491,7 +458,7 @@ mod signaling_tests {
 
     /// Test data channel
     async fn test_data_channel_impl(mode: SignalingMode) -> Result<()> {
-        let (url, api_key, api_secret) = require_env_for_mode!(mode);
+        let (url, api_key, api_secret) = get_env_for_mode(mode);
         let room_name = format!("test_{:?}_data_{}", mode, create_random_uuid());
 
         let token1 = create_token(&api_key, &api_secret, &room_name, "participant_1")?;
@@ -559,7 +526,7 @@ mod signaling_tests {
 
     /// Test node failure reconnection scenario
     async fn test_node_failure_impl(mode: SignalingMode) -> Result<()> {
-        let (url, api_key, api_secret) = require_env_for_mode!(mode);
+        let (url, api_key, api_secret) = get_env_for_mode(mode);
         let room_name = format!("test_{:?}_node_fail_{}", mode, create_random_uuid());
 
         let token = create_token(&api_key, &api_secret, &room_name, "test_participant")?;