injoint 0.1.1

Injoint is a library for creating publish-subscribe APIs in minimalistic declarative way
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

#[cfg(test)]
mod tests {
    use super::*;
    use crate::connection::{SinkAdapter, StreamAdapter};
    use crate::message::{JointMessage, JointMessageMethod};
    use crate::response::Response;
    use async_trait::async_trait;
    use std::sync::{Arc, Mutex};

    struct MockSink {
        responses: Arc<Mutex<Vec<Response>>>,
    }

    #[async_trait]
    impl SinkAdapter for MockSink {
        async fn send(
            &mut self,
            response: Response,
        ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
            self.responses.lock().unwrap().push(response);
            Ok(())
        }
    }

    struct MockStream {
        messages: Vec<JointMessage>,
        index: usize,
    }

    #[async_trait]
    impl StreamAdapter for MockStream {
        async fn next(&mut self) -> Result<JointMessage, Box<dyn std::error::Error + Send + Sync>> {
            if self.index < self.messages.len() {
                let message = self.messages[self.index].clone();
                self.index += 1;
                Ok(message)
            } else {
                Err("End of stream".into())
            }
        }
    }

    #[tokio::test]
    async fn test_sink_adapter() {
        let responses = Arc::new(Mutex::new(Vec::new()));
        let mut sink = MockSink {
            responses: responses.clone(),
        };

        let response = Response::RoomCreated(123);
        let result = sink.send(response.clone()).await;
        assert!(result.is_ok());

        let stored_responses = responses.lock().unwrap();
        assert_eq!(stored_responses.len(), 1);

        match &stored_responses[0] {
            Response::RoomCreated(id) => assert_eq!(*id, 123),
            _ => panic!("Expected RoomCreated response"),
        }
    }

    #[tokio::test]
    async fn test_stream_adapter() {
        let messages = vec![
            JointMessage {
                client_token: "1".to_string(),
                message: JointMessageMethod::Create,
            },
            JointMessage {
                client_token: "1".to_string(),
                message: JointMessageMethod::Join(42),
            },
            JointMessage {
                client_token: "1".to_string(),
                message: JointMessageMethod::Leave,
            },
        ];

        let mut stream = MockStream {
            messages: messages.clone(),
            index: 0,
        };

        let message1 = stream.next().await.unwrap();
        assert!(matches!(message1.message, JointMessageMethod::Create));

        let message2 = stream.next().await.unwrap();
        if let JointMessageMethod::Join(room_id) = message2.message {
            assert_eq!(room_id, 42);
        } else {
            panic!("Expected Join message");
        }

        let message3 = stream.next().await.unwrap();
        assert!(matches!(message3.message, JointMessageMethod::Leave));

        let result = stream.next().await;
        assert!(result.is_err());
    }
}