Add unit tests for the traffic watcher services (#27)

proto/client-api/src/stats.rs

@@ -1486,6 +1486,18 @@ impl From<HighResTimeStamp> for SystemTime {
     }
 }
 
+impl From<SystemTime> for HighResTimeStamp {
+    #[allow(clippy::cast_precision_loss)]
+    #[inline]
+    fn from(time: SystemTime) -> Self {
+        HighResTimeStamp(
+            time.duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_millis() as f64,
+        )
+    }
+}
+
 /// Hashing string representation.
 ///
 /// Some people believe that such behavior is incorrect (but in some programming

src/api/control/refs/fid.rs

@@ -117,7 +117,7 @@ impl TryFrom<String> for StatefulFid {
                 member_id
             }
         } else {
-            return Ok(Fid::<ToRoom>::new(room_id.to_string().into()).into());
+            return Ok(Fid::<ToRoom>::new(room_id.into()).into());
         };
 
         let endpoint_id = if let Some(endpoint_id) = splitted.next() {

src/media/peer.rs

@@ -463,3 +463,66 @@ impl Peer<Stable> {
         Ok(mids)
     }
 }
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    /// Returns [`PeerStateMachine`] with provided count of the `MediaTrack`s
+    /// media types.
+    pub fn test_peer_from_peer_tracks(
+        send_audio: u32,
+        send_video: u32,
+        recv_audio: u32,
+        recv_video: u32,
+    ) -> PeerStateMachine {
+        let mut peer = Peer {
+            state: Stable {},
+            context: Context {
+                id: Id(1),
+                sdp_offer: None,
+                sdp_answer: None,
+                senders: HashMap::new(),
+                receivers: HashMap::new(),
+                member_id: MemberId::from("test-member"),
+                is_force_relayed: false,
+                partner_peer: Id(2),
+                ice_user: None,
+                endpoints: Vec::new(),
+                partner_member: MemberId::from("partner-member"),
+            },
+        };
+
+        let mut track_id_counter = Counter::default();
+
+        for _ in 0..send_audio {
+            let track_id = track_id_counter.next_id();
+            let track =
+                MediaTrack::new(track_id, MediaType::Audio(AudioSettings {}));
+            peer.context.senders.insert(track_id, Rc::new(track));
+        }
+
+        for _ in 0..send_video {
+            let track_id = track_id_counter.next_id();
+            let track =
+                MediaTrack::new(track_id, MediaType::Video(VideoSettings {}));
+            peer.context.senders.insert(track_id, Rc::new(track));
+        }
+
+        for _ in 0..recv_audio {
+            let track_id = track_id_counter.next_id();
+            let track =
+                MediaTrack::new(track_id, MediaType::Audio(AudioSettings {}));
+            peer.context.receivers.insert(track_id, Rc::new(track));
+        }
+
+        for _ in 0..recv_video {
+            let track_id = track_id_counter.next_id();
+            let track =
+                MediaTrack::new(track_id, MediaType::Video(VideoSettings {}));
+            peer.context.receivers.insert(track_id, Rc::new(track));
+        }
+
+        peer.into()
+    }
+}

src/signalling/peers/media_traffic_state.rs

@@ -251,6 +251,20 @@ mod tracks_state_tests {
             get_diff_added(state_before, state_after).unwrap(),
             MediaType::Video
         );
+
+        let state_before = MediaTrafficState::with_media_type(MediaType::Audio);
+        let state_after = MediaTrafficState::with_media_type(MediaType::Both);
+        assert_eq!(
+            get_diff_added(state_before, state_after).unwrap(),
+            MediaType::Video,
+        );
+
+        let state_before = MediaTrafficState::with_media_type(MediaType::Video);
+        let state_after = MediaTrafficState::with_media_type(MediaType::Both);
+        assert_eq!(
+            get_diff_added(state_before, state_after).unwrap(),
+            MediaType::Audio,
+        );
     }
 
     #[test]
@@ -278,5 +292,13 @@ mod tracks_state_tests {
         let before = MediaTrafficState::new();
         let after = MediaTrafficState::with_media_type(MediaType::Both);
         assert!(get_diff_removed(before, after).is_none());
+
+        let before = MediaTrafficState::with_media_type(MediaType::Both);
+        let after = MediaTrafficState::with_media_type(MediaType::Audio);
+        assert_eq!(get_diff_removed(before, after).unwrap(), MediaType::Video);
+
+        let before = MediaTrafficState::with_media_type(MediaType::Both);
+        let after = MediaTrafficState::with_media_type(MediaType::Video);
+        assert_eq!(get_diff_removed(before, after).unwrap(), MediaType::Audio);
     }
 }