Implement test stubs

crates/live_kit_client/src/test.rs

@@ -67,7 +67,7 @@ impl TestServer {
         }
     }
 
-    async fn create_room(&self, room: String) -> Result<()> {
+    pub async fn create_room(&self, room: String) -> Result<()> {
         self.background.simulate_random_delay().await;
         let mut server_rooms = self.rooms.lock();
         if server_rooms.contains_key(&room) {
@@ -104,7 +104,7 @@ impl TestServer {
                 room_name
             ))
         } else {
-            for track in &room.tracks {
+            for track in &room.video_tracks {
                 client_room
                     .0
                     .lock()
@@ -182,7 +182,7 @@ impl TestServer {
             frames_rx: local_track.frames_rx.clone(),
         });
 
-        room.tracks.push(track.clone());
+        room.video_tracks.push(track.clone());
 
         for (id, client_room) in &room.client_rooms {
             if *id != identity {
@@ -199,6 +199,43 @@ impl TestServer {
         Ok(())
     }
 
+    async fn publish_audio_track(
+        &self,
+        token: String,
+        _local_track: &LocalAudioTrack,
+    ) -> Result<()> {
+        self.background.simulate_random_delay().await;
+        let claims = live_kit_server::token::validate(&token, &self.secret_key)?;
+        let identity = claims.sub.unwrap().to_string();
+        let room_name = claims.video.room.unwrap();
+
+        let mut server_rooms = self.rooms.lock();
+        let room = server_rooms
+            .get_mut(&*room_name)
+            .ok_or_else(|| anyhow!("room {} does not exist", room_name))?;
+
+        let track = Arc::new(RemoteAudioTrack {
+            sid: nanoid::nanoid!(17),
+            publisher_id: identity.clone(),
+        });
+
+        room.audio_tracks.push(track.clone());
+
+        for (id, client_room) in &room.client_rooms {
+            if *id != identity {
+                let _ = client_room
+                    .0
+                    .lock()
+                    .audio_track_updates
+                    .0
+                    .try_broadcast(RemoteAudioTrackUpdate::Subscribed(track.clone()))
+                    .unwrap();
+            }
+        }
+
+        Ok(())
+    }
+
     fn video_tracks(&self, token: String) -> Result<Vec<Arc<RemoteVideoTrack>>> {
         let claims = live_kit_server::token::validate(&token, &self.secret_key)?;
         let room_name = claims.video.room.unwrap();
@@ -207,18 +244,26 @@ impl TestServer {
         let room = server_rooms
             .get_mut(&*room_name)
             .ok_or_else(|| anyhow!("room {} does not exist", room_name))?;
-        Ok(room.tracks.clone())
+        Ok(room.video_tracks.clone())
     }
 
-    async fn publish_audio_track(&self, _token: String, _local_track: &LocalAudioTrack) -> Result<()> {
-        todo!()
+    fn audio_tracks(&self, token: String) -> Result<Vec<Arc<RemoteAudioTrack>>> {
+        let claims = live_kit_server::token::validate(&token, &self.secret_key)?;
+        let room_name = claims.video.room.unwrap();
+
+        let mut server_rooms = self.rooms.lock();
+        let room = server_rooms
+            .get_mut(&*room_name)
+            .ok_or_else(|| anyhow!("room {} does not exist", room_name))?;
+        Ok(room.audio_tracks.clone())
     }
 }
 
 #[derive(Default)]
 struct TestServerRoom {
     client_rooms: HashMap<Sid, Arc<Room>>,
-    tracks: Vec<Arc<RemoteVideoTrack>>,
+    video_tracks: Vec<Arc<RemoteVideoTrack>>,
+    audio_tracks: Vec<Arc<RemoteAudioTrack>>,
 }
 
 impl TestServerRoom {}
@@ -350,10 +395,19 @@ impl Room {
         }
     }
 
-    pub fn unpublish_track(&self, _: LocalTrackPublication) {}
+    pub fn unpublish_track(&self, _publication: LocalTrackPublication) {}
 
-    pub fn remote_audio_tracks(&self, _publisher_id: &str) -> Vec<Arc<RemoteAudioTrack>> {
-       todo!()
+    pub fn remote_audio_tracks(&self, publisher_id: &str) -> Vec<Arc<RemoteAudioTrack>> {
+        if !self.is_connected() {
+            return Vec::new();
+        }
+
+        self.test_server()
+            .audio_tracks(self.token())
+            .unwrap()
+            .into_iter()
+            .filter(|track| track.publisher_id() == publisher_id)
+            .collect()
     }
 
     pub fn remote_video_tracks(&self, publisher_id: &str) -> Vec<Arc<RemoteVideoTrack>> {
@@ -476,10 +530,6 @@ impl RemoteAudioTrack {
     pub fn publisher_id(&self) -> &str {
         &self.publisher_id
     }
-
-    pub fn start(&self)  -> futures::channel::oneshot::Receiver<bool> {
-        todo!();
-    }
 }
 
 #[derive(Clone)]