rs_connections/
lib.rs

1mod base;
2mod builder;
3mod conn;
4mod error;
5mod inner_tcp;
6mod inner_udp;
7mod inner_websocket;
8
9pub use error::ConnectError;
10pub use rs_event_emitter::{EventHandler, Handle};
11
12pub use base::{
13    ConnectionInterface, Emitter, Protocol, ConnectionBaseInterface, CLOSE_EVENT, CONNECTED_EVENT, CONNECTING_EVENT,
14    DISCONNECT_EVENT, ERROR_EVENT, MESSAGE_EVENT, RECONNECT_EVENT,
15};
16
17pub use builder::{ConnBuilder, ConnBuilderConfig};
18
19pub use conn::Conn;
20
21pub const HEARTBEAT_INTERVAL: u64 = 10 * 1000;
22
23#[cfg(test)]
24mod tests {
25    use std::sync::Arc;
26
27    use crate::{
28        base::{
29            ConnectionInterface, Emitter, Protocol, CLOSE_EVENT, CONNECTED_EVENT, CONNECTING_EVENT,
30            DISCONNECT_EVENT, ERROR_EVENT, MESSAGE_EVENT, RECONNECT_EVENT,
31        },
32        builder::{ConnBuilder, ConnBuilderConfig},
33    };
34
35    use super::*;
36
37    #[tokio::test]
38    async fn it_test_connect() {
39        let connect_opt = ConnBuilderConfig {
40            host: "127.0.0.1".to_string(),
41            port: 9673,
42            heartbeat_time: Some(HEARTBEAT_INTERVAL),
43            protocol: Protocol::WEBSOCKET,
44        };
45
46        let mut conn = ConnBuilder::new(connect_opt).build();
47
48        conn.connect().await.unwrap();
49        // conn.send(data.as_bytes()).await.unwrap();
50        loop {
51            match conn.receive().await {
52                Ok(_) => {
53                    println!("receive");
54                }
55                Err(_) => {
56                    println!("receive err");
57                }
58            }
59        }
60    }
61
62    #[tokio::test]
63    async fn it_test_event() {
64        let connect_opt = ConnBuilderConfig {
65            host: "127.0.0.1".to_string(),
66            port: 9673,
67            heartbeat_time: Some(HEARTBEAT_INTERVAL),
68            protocol: Protocol::WEBSOCKET,
69        };
70
71        let mut conn = ConnBuilder::new(connect_opt).build();
72
73        let handle_connecting = EventHandler::new(Box::new(|data: &str| {
74            println!("event connecting: {}", data);
75        }));
76
77        let handle_connected = EventHandler::new(Box::new(|data: &str| {
78            println!("event connected: {}", data);
79        }));
80
81        let handle_close = EventHandler::new(Box::new(|data: String| {
82            println!("event close: {}", data);
83        }));
84
85        let handle_disconnect = EventHandler::new(Box::new(|data: &str| {
86            println!("event disconnect: {}", data);
87        }));
88
89        let handle_error = EventHandler::new(Box::new(|data: ConnectError| {
90            println!("event error: {}", data);
91        }));
92
93        let handle_test_message = EventHandler::new(Box::new(|data: String| {
94            println!("event message: {}", data);
95        }));
96
97        let handle_binary_message = EventHandler::new(Box::new(|data: Vec<u8>| {
98            println!("event binary message: {:?}", data);
99        }));
100
101        let handle_reconnect = EventHandler::new(Box::new(|data: String| {
102            println!("event reconnect: {}", data);
103        }));
104
105        conn.on(CONNECTING_EVENT, Arc::new(handle_connecting.clone()));
106        conn.on(CONNECTED_EVENT, Arc::new(handle_connected.clone()));
107        conn.on(CLOSE_EVENT, Arc::new(handle_close.clone()));
108        conn.on(DISCONNECT_EVENT, Arc::new(handle_disconnect.clone()));
109        conn.on(ERROR_EVENT, Arc::new(handle_error.clone()));
110        conn.on(MESSAGE_EVENT, Arc::new(handle_test_message.clone()));
111        conn.on(MESSAGE_EVENT, Arc::new(handle_binary_message.clone()));
112        conn.on(RECONNECT_EVENT, Arc::new(handle_reconnect.clone()));
113
114        conn.connect().await.unwrap();
115
116        loop {
117            match conn.receive().await {
118                Ok(_) => {
119                    println!("receive");
120                }
121                Err(_) => {
122                    println!("receive err");
123                }
124            }
125        }
126    }
127}