optimize unit test.

Author: jjeffcaii

examples/echo/main.rs

@@ -7,7 +7,7 @@ use std::env;
 use std::error::Error;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     env_logger::builder().format_timestamp_millis().init();
     let addr = env::args()
         .nth(1)

examples/proxy/main.rs

@@ -10,7 +10,7 @@ use rsocket_rust::prelude::*;
 use std::error::Error;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     env_logger::builder().format_timestamp_millis().init();
 
     RSocketFactory::receive()

src/x/client.rs

@@ -94,7 +94,8 @@ impl ClientBuilder {
         self.responder = Some(acceptor);
         self
     }
-    pub async fn start(self) -> Result<Client, Box<dyn Error>> {
+
+    pub async fn start(self) -> Result<Client, Box<dyn Error + Send + Sync>> {
         // TODO: process error
         let uri = self.uri.unwrap();
         match URI::parse(&uri) {
@@ -111,7 +112,7 @@ impl ClientBuilder {
         addr: SocketAddr,
         responder: Option<fn() -> Box<dyn RSocket>>,
         sb: SetupPayloadBuilder,
-    ) -> Result<Client, Box<dyn Error>> {
+    ) -> Result<Client, Box<dyn Error + Send + Sync>> {
         let socket = transport::tcp::connect(&addr);
         let (rcv_tx, rcv_rx) = mpsc::unbounded_channel::<Frame>();
         let (snd_tx, snd_rx) = mpsc::unbounded_channel::<Frame>();

src/x/server.rs

@@ -49,7 +49,7 @@ impl ServerBuilder {
         self
     }
 
-    pub async fn serve(self) -> Result<(), Box<dyn Error>> {
+    pub async fn serve(self) -> Result<(), Box<dyn Error + Send + Sync>> {
         // TODO: process error
         let s = self.uri.unwrap();
         match URI::parse(&s) {
@@ -66,7 +66,7 @@ impl ServerBuilder {
         addr: SocketAddr,
         on_setup: FnAcceptorWithSetup,
         on_start: Option<FnStart>,
-    ) -> Result<(), Box<dyn Error>> {
+    ) -> Result<(), Box<dyn Error + Send + Sync>> {
         let mut listener = TcpListener::bind(&addr).await.unwrap();
         debug!("listening on: {}", addr);
         if let Some(it) = on_start {

src/x/uri.rs

@@ -15,15 +15,15 @@ pub(crate) enum URI {
 }
 
 impl URI {
-    pub(crate) fn parse(s: &str) -> Result<URI, Box<dyn Error>> {
+    pub(crate) fn parse(s: &str) -> Result<URI, Box<dyn Error + Send + Sync>> {
         match Url::parse(s) {
             Ok(u) => Self::from_url(u),
             Err(e) => Err(Box::new(e)),
         }
     }
 
     #[inline]
-    fn from_url(u: Url) -> Result<URI, Box<dyn Error>> {
+    fn from_url(u: Url) -> Result<URI, Box<dyn Error + Send + Sync>> {
         let domain = u.domain().unwrap_or("0.0.0.0");
         let schema = u.scheme();
         match schema.to_lowercase().as_ref() {

tests/clients.rs

@@ -3,27 +3,57 @@ extern crate log;
 
 use futures::stream;
 use rsocket_rust::prelude::*;
+use std::thread::sleep;
+use std::time::Duration;
+use tokio::runtime::Runtime;
+
+fn init() {
+    let _ = env_logger::builder()
+        .format_timestamp_millis()
+        .is_test(true)
+        .try_init();
+}
 
-#[tokio::main]
 #[test]
-#[ignore]
-async fn test_client() {
-    env_logger::builder().init();
-    let cli = RSocketFactory::connect()
-        .acceptor(|| Box::new(EchoRSocket))
-        .transport("tcp://127.0.0.1:7878")
-        .setup(Payload::from("READY!"))
-        .mime_type("text/plain", "text/plain")
-        .start()
-        .await
-        .unwrap();
+fn test_client() {
+    init();
+
+    let server_runtime = Runtime::new().unwrap();
+
+    // spawn a server
+    server_runtime.spawn(async move {
+        RSocketFactory::receive()
+            .transport("tcp://127.0.0.1:7878")
+            .acceptor(|setup, _socket| {
+                info!("accept setup: {:?}", setup);
+                Ok(Box::new(EchoRSocket))
+            })
+            .on_start(|| info!("+++++++ echo server started! +++++++"))
+            .serve()
+            .await
+    });
+
+    sleep(Duration::from_millis(500));
+
+    let mut client_runtime = Runtime::new().unwrap();
+
+    client_runtime.block_on(async {
+        let cli = RSocketFactory::connect()
+            .acceptor(|| Box::new(EchoRSocket))
+            .transport("tcp://127.0.0.1:7878")
+            .setup(Payload::from("READY!"))
+            .mime_type("text/plain", "text/plain")
+            .start()
+            .await
+            .unwrap();
 
-    exec_metadata_push(&cli).await;
-    exec_fire_and_forget(&cli).await;
-    exec_request_response(&cli).await;
-    exec_request_stream(&cli).await;
-    exec_request_channel(&cli).await;
-    cli.close();
+        exec_metadata_push(&cli).await;
+        exec_fire_and_forget(&cli).await;
+        exec_request_response(&cli).await;
+        exec_request_stream(&cli).await;
+        exec_request_channel(&cli).await;
+        cli.close();
+    });
 }
 
 #[tokio::main]