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 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}