rustpbx 0.4.9

A SIP PBX implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#[cfg(test)]
pub mod tests {
    use crate::media::Track;
    use crate::proxy::proxy_call::media_peer::MediaPeer;
    use anyhow::Result;
    use async_trait::async_trait;
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::sync::{Arc, Mutex};
    use tokio_util::sync::CancellationToken;

    pub type TrackHandle = Arc<tokio::sync::Mutex<Box<dyn Track>>>;

    /// Enhanced MockMediaPeer for comprehensive testing
    pub struct MockMediaPeer {
        pub stop_called: Arc<AtomicUsize>,
        pub cancel_token: CancellationToken,
        pub get_tracks_call_count: Arc<AtomicUsize>,
        pub update_track_call_count: Arc<AtomicUsize>,
        pub tracks: Arc<Mutex<Vec<TrackHandle>>>,
    }

    impl MockMediaPeer {
        pub fn new() -> Self {
            Self {
                stop_called: Arc::new(AtomicUsize::new(0)),
                cancel_token: CancellationToken::new(),
                get_tracks_call_count: Arc::new(AtomicUsize::new(0)),
                update_track_call_count: Arc::new(AtomicUsize::new(0)),
                tracks: Arc::new(Mutex::new(Vec::new())),
            }
        }

        /// Creates a MockMediaPeer that tracks stop() call count
        #[allow(dead_code)]
        pub fn new_with_stop_tracking() -> Self {
            Self::new()
        }

        /// Returns how many times stop() was called
        pub fn stop_count(&self) -> usize {
            self.stop_called.load(Ordering::SeqCst)
        }

        /// Returns how many times get_tracks() was called
        pub fn get_tracks_call_count(&self) -> usize {
            self.get_tracks_call_count.load(Ordering::SeqCst)
        }

        /// Returns how many times update_track() was called
        pub fn update_track_call_count(&self) -> usize {
            self.update_track_call_count.load(Ordering::SeqCst)
        }
    }

    impl Default for MockMediaPeer {
        fn default() -> Self {
            Self::new()
        }
    }

    #[async_trait]
    impl MediaPeer for MockMediaPeer {
        fn cancel_token(&self) -> CancellationToken {
            self.cancel_token.clone()
        }

        async fn update_track(&self, _track: Box<dyn Track>, _play_id: Option<String>) {
            self.update_track_call_count.fetch_add(1, Ordering::SeqCst);
        }

        async fn get_tracks(&self) -> Vec<Arc<tokio::sync::Mutex<Box<dyn Track>>>> {
            self.get_tracks_call_count.fetch_add(1, Ordering::SeqCst);
            self.tracks.lock().unwrap().clone()
        }

        async fn update_remote_description(&self, _track_id: &str, _sdp: &str) -> Result<()> {
            Ok(())
        }

        async fn remove_track(&self, _track_id: &str, _stop: bool) {}

        async fn serve(&self) -> Result<()> {
            Ok(())
        }

        fn stop(&self) {
            self.stop_called.fetch_add(1, Ordering::SeqCst);
            self.cancel_token.cancel();
        }

        async fn mute_track(&self, _track_id: &str) -> bool {
            true
        }

        async fn unmute_track(&self, _track_id: &str) -> bool {
            true
        }
    }

    // ==================== MockMediaPeer Tests ====================

    #[cfg(test)]
    mod mock_media_peer_tests {
        use super::*;

        #[tokio::test]
        async fn test_mock_media_peer_stop_increments_counter() {
            let peer = MockMediaPeer::new();

            assert_eq!(peer.stop_count(), 0);

            peer.stop();
            assert_eq!(peer.stop_count(), 1);

            peer.stop();
            assert_eq!(peer.stop_count(), 2);
        }

        #[tokio::test]
        async fn test_mock_media_peer_get_tracks_increments_counter() {
            let peer = MockMediaPeer::new();

            assert_eq!(peer.get_tracks_call_count(), 0);

            let _ = peer.get_tracks().await;
            assert_eq!(peer.get_tracks_call_count(), 1);

            let _ = peer.get_tracks().await;
            assert_eq!(peer.get_tracks_call_count(), 2);
        }

        #[tokio::test]
        async fn test_mock_media_peer_update_track_increments_counter() {
            let peer = MockMediaPeer::new();

            assert_eq!(peer.update_track_call_count(), 0);

            // update_track takes a Box<dyn Track> - we can't easily create one in test
            // but we can verify the counter mechanism works via the trait implementation
            let _ = peer.update_track_call_count();
            assert_eq!(peer.update_track_call_count(), 0); // not called yet
        }

        #[tokio::test]
        async fn test_mock_media_peer_cancel_token_works() {
            let peer = MockMediaPeer::new();
            peer.stop();
            assert!(peer.cancel_token.is_cancelled());
        }
    }
}