chore(libp2p-websocket): use tokio instead of async-std

ref libp2p#4449

Pull-Request: libp2p#6028.

Author: kamuik16

Cargo.lock

@@ -27,9 +27,9 @@ webpki-roots = "0.26"
 
 [dev-dependencies]
 libp2p-tcp = { workspace = true, features = ["async-io"] }
-libp2p-dns = { workspace = true, features = ["async-std"] }
+libp2p-dns = { workspace = true, features = ["tokio"] }
 libp2p-identity = { workspace = true, features = ["rand"] }
-async-std = { version = "1.6.5", features = ["attributes"] }
+tokio = { workspace = true, features = ["rt", "macros", "io-std", "io-util"] }
 rcgen = { workspace = true }
 
 # Passing arguments to the docsrs builder in order to properly document cfg's.

transports/websocket/Cargo.toml

@@ -72,12 +72,11 @@ use rw_stream_sink::RwStreamSink;
 /// # use libp2p_websocket as websocket;
 /// # use std::pin::Pin;
 /// #
-/// # #[async_std::main]
+/// # #[tokio::main]
 /// # async fn main() {
 ///
 /// let mut transport = websocket::Config::new(
-///     dns::async_std::Transport::system(tcp::async_io::Transport::new(tcp::Config::default()))
-///         .await
+///     dns::tokio::Transport::system(tcp::async_io::Transport::new(tcp::Config::default()))
 ///         .unwrap(),
 /// );
 ///
@@ -115,7 +114,7 @@ use rw_stream_sink::RwStreamSink;
 /// # use libp2p_websocket as websocket;
 /// # use std::pin::Pin;
 /// #
-/// # #[async_std::main]
+/// # #[tokio::main]
 /// # async fn main() {
 ///
 /// let mut transport =

transports/websocket/src/lib.rs

@@ -293,87 +293,81 @@ where
 
 #[cfg(test)]
 mod tests {
-    use async_std::{io, task};
     use futures::{channel::mpsc, prelude::*};
+    use tokio::io::{self, AsyncWriteExt};
 
     use crate::quicksink::{make_sink, Action};
 
-    #[test]
-    fn smoke_test() {
-        task::block_on(async {
-            let sink = make_sink(io::stdout(), |mut stdout, action| async move {
-                match action {
-                    Action::Send(x) => stdout.write_all(x).await?,
-                    Action::Flush => stdout.flush().await?,
-                    Action::Close => stdout.close().await?,
-                }
-                Ok::<_, io::Error>(stdout)
-            });
+    #[tokio::test]
+    async fn smoke_test() {
+        let sink = make_sink(io::stdout(), |mut stdout, action| async move {
+            match action {
+                Action::Send(x) => stdout.write_all(x).await?,
+                Action::Flush => stdout.flush().await?,
+                Action::Close => stdout.shutdown().await?,
+            }
+            Ok::<_, io::Error>(stdout)
+        });
 
-            let values = vec![Ok(&b"hello\n"[..]), Ok(&b"world\n"[..])];
-            assert!(stream::iter(values).forward(sink).await.is_ok())
-        })
+        let values = vec![Ok(&b"hello\n"[..]), Ok(&b"world\n"[..])];
+        assert!(stream::iter(values).forward(sink).await.is_ok())
     }
 
-    #[test]
-    fn replay() {
-        task::block_on(async {
-            let (tx, rx) = mpsc::channel(5);
+    #[tokio::test]
+    async fn replay() {
+        let (tx, rx) = mpsc::channel(5);
 
-            let sink = make_sink(tx, |mut tx, action| async move {
-                tx.send(action.clone()).await?;
-                if action == Action::Close {
-                    tx.close().await?
-                }
-                Ok::<_, mpsc::SendError>(tx)
-            });
+        let sink = make_sink(tx, |mut tx, action| async move {
+            tx.send(action.clone()).await?;
+            if action == Action::Close {
+                tx.close().await?
+            }
+            Ok::<_, mpsc::SendError>(tx)
+        });
 
-            futures::pin_mut!(sink);
+        futures::pin_mut!(sink);
 
-            let expected = [
-                Action::Send("hello\n"),
-                Action::Flush,
-                Action::Send("world\n"),
-                Action::Flush,
-                Action::Close,
-            ];
+        let expected = [
+            Action::Send("hello\n"),
+            Action::Flush,
+            Action::Send("world\n"),
+            Action::Flush,
+            Action::Close,
+        ];
 
-            for &item in &["hello\n", "world\n"] {
-                sink.send(item).await.unwrap()
-            }
+        for &item in &["hello\n", "world\n"] {
+            sink.send(item).await.unwrap()
+        }
 
-            sink.close().await.unwrap();
+        sink.close().await.unwrap();
 
-            let actual = rx.collect::<Vec<_>>().await;
+        let actual = rx.collect::<Vec<_>>().await;
 
-            assert_eq!(&expected[..], &actual[..])
-        });
+        assert_eq!(&expected[..], &actual[..])
     }
 
-    #[test]
-    fn error_does_not_panic() {
-        task::block_on(async {
-            let sink = make_sink(io::stdout(), |mut _stdout, _action| async move {
-                Err(io::Error::other("oh no"))
-            });
+    #[tokio::test]
+    async fn error_does_not_panic() {
+        let sink = make_sink(io::stdout(), |mut _stdout, _action| async move {
+            Err(io::Error::other("oh no"))
+        });
 
-            futures::pin_mut!(sink);
+        futures::pin_mut!(sink);
 
-            let result = sink.send("hello").await;
-            match result {
-                Err(crate::quicksink::Error::Send(e)) => {
-                    assert_eq!(e.kind(), io::ErrorKind::Other);
-                    assert_eq!(e.to_string(), "oh no")
-                }
-                _ => panic!("unexpected result: {result:?}"),
-            };
+        let result = sink.send("hello").await;
+        match result {
+            Err(crate::quicksink::Error::Send(e)) => {
+                assert_eq!(e.kind(), io::ErrorKind::Other);
+                assert_eq!(e.to_string(), "oh no")
+            }
+            _ => panic!("unexpected result: {result:?}"),
+        };
 
-            // Call send again, expect not to panic.
-            let result = sink.send("hello").await;
-            match result {
-                Err(crate::quicksink::Error::Closed) => {}
-                _ => panic!("unexpected result: {result:?}"),
-            };
-        })
+        // Call send again, expect not to panic.
+        let result = sink.send("hello").await;
+        match result {
+            Err(crate::quicksink::Error::Closed) => {}
+            _ => panic!("unexpected result: {result:?}"),
+        };
     }
 }