connection 0.2.5

A TCP connection that can read and write serializable data
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

extern crate connection;

#[cfg(test)]
mod tests {
    use serde::{Deserialize, Serialize};

    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct TestMessage {
        id: u32,
        name: String,
        payload: Vec<u8>,
    }

    use super::*;
    use connection::Connection;
    use tokio::net::TcpListener;

    async fn setup() -> (TcpListener, Connection) {
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();
        let conn = Connection::dial(addr).await.unwrap();
        (listener, conn)
    }

    #[tokio::test]
    async fn write_and_read_message() {
        let (server_listener, mut client_connection) = setup().await;
        let message = TestMessage {
            id: 123,
            name: "Test Message".to_string(),
            payload: vec![1, 2, 3, 4, 5],
        };

        client_connection.write(&message).await.unwrap();

        let mut server_connection = Connection::new(server_listener.accept().await.unwrap().0);
        let parsed_message: TestMessage = server_connection.read().await.unwrap().unwrap();
        assert_eq!(message, parsed_message);
    }

    #[tokio::test]
    async fn send_and_receive_hello_world() {
        let (server_listener, mut client_connection) = setup().await;
        client_connection.write(&"Hello, world!").await.unwrap();
        let mut server_connection = Connection::new(server_listener.accept().await.unwrap().0);
        let parsed_message: String = server_connection.read().await.unwrap().unwrap();
        assert_eq!("Hello, world!", parsed_message);
    }
}