chore(quic): migrate tests from async-std to tokio

Migrate tests from async-std to tokio in transports/quic as per #4449

Pull-Request: #5841.

Author: shiyasmohd

transports/quic/Cargo.toml

@@ -35,19 +35,18 @@ async-std = ["dep:async-std", "if-watch/smol", "quinn/runtime-async-std"]
 all-features = true
 
 [dev-dependencies]
-async-std = { version = "1.12.0", features = ["attributes"] }
 libp2p-identity = { workspace = true, features = ["rand"] }
 libp2p-muxer-test-harness = { path = "../../muxers/test-harness" }
 libp2p-noise = { workspace = true }
-libp2p-tcp = { workspace = true, features = ["async-io"] }
+libp2p-tcp = { workspace = true, features = ["tokio"] }
 libp2p-yamux = { workspace = true }
 quickcheck = "1"
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 [[test]]
 name = "stream_compliance"
-required-features = ["async-std"]
+required-features = ["tokio"]
 
 [lints]
 workspace = true

transports/quic/src/transport.rs

@@ -845,12 +845,12 @@ mod tests {
         );
     }
 
-    #[cfg(feature = "async-std")]
-    #[async_std::test]
+    #[cfg(feature = "tokio")]
+    #[tokio::test]
     async fn test_close_listener() {
         let keypair = libp2p_identity::Keypair::generate_ed25519();
         let config = Config::new(&keypair);
-        let mut transport = crate::async_std::Transport::new(config);
+        let mut transport = crate::tokio::Transport::new(config);
         assert!(poll_fn(|cx| Pin::new(&mut transport).as_mut().poll(cx))
             .now_or_never()
             .is_none());

transports/quic/tests/smoke.rs

@@ -41,10 +41,10 @@ async fn tokio_smoke() {
     smoke::<quic::tokio::Provider>().await
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn async_std_smoke() {
-    smoke::<quic::async_std::Provider>().await
+    smoke::<quic::tokio::Provider>().await
 }
 
 #[cfg(feature = "tokio")]
@@ -74,14 +74,14 @@ async fn endpoint_reuse() {
     assert_eq!(a_send_back_addr, a_addr);
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn ipv4_dial_ipv6() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
-    let (a_peer_id, mut a_transport) = create_default_transport::<quic::async_std::Provider>();
-    let (b_peer_id, mut b_transport) = create_default_transport::<quic::async_std::Provider>();
+    let (a_peer_id, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
+    let (b_peer_id, mut b_transport) = create_default_transport::<quic::tokio::Provider>();
 
     let a_addr = start_listening(&mut a_transport, "/ip6/::1/udp/0/quic-v1").await;
     let ((a_connected, _, _), (b_connected, _)) =
@@ -94,8 +94,8 @@ async fn ipv4_dial_ipv6() {
 /// Tests that a [`Transport::dial`] wakes up the task previously polling [`Transport::poll`].
 ///
 /// See https://github.com/libp2p/rust-libp2p/pull/3306 for context.
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn wrapped_with_delay() {
     use libp2p_core::transport::DialOpts;
 
@@ -161,15 +161,15 @@ async fn wrapped_with_delay() {
         }
     }
 
-    let (a_peer_id, mut a_transport) = create_default_transport::<quic::async_std::Provider>();
+    let (a_peer_id, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
     let (b_peer_id, mut b_transport) = {
-        let (id, transport) = create_default_transport::<quic::async_std::Provider>();
+        let (id, transport) = create_default_transport::<quic::tokio::Provider>();
         (id, DialDelay(Arc::new(Mutex::new(transport))).boxed())
     };
 
     // Spawn A
     let a_addr = start_listening(&mut a_transport, "/ip6/::1/udp/0/quic-v1").await;
-    let listener = async_std::task::spawn(async move {
+    let listener = tokio::spawn(async move {
         let (upgrade, _) = a_transport
             .select_next_some()
             .await
@@ -184,7 +184,7 @@ async fn wrapped_with_delay() {
     //
     // Note that the dial is spawned on a different task than the transport allowing the transport
     // task to poll the transport once and then suspend, waiting for the wakeup from the dial.
-    let dial = async_std::task::spawn({
+    let dial = tokio::spawn({
         let dial = b_transport
             .dial(
                 a_addr,
@@ -196,23 +196,23 @@ async fn wrapped_with_delay() {
             .unwrap();
         async { dial.await.unwrap().0 }
     });
-    async_std::task::spawn(async move { b_transport.next().await });
+    tokio::spawn(async move { b_transport.next().await });
 
     let (a_connected, b_connected) = future::join(listener, dial).await;
 
-    assert_eq!(a_connected, b_peer_id);
-    assert_eq!(b_connected, a_peer_id);
+    assert_eq!(a_connected.unwrap(), b_peer_id);
+    assert_eq!(b_connected.unwrap(), a_peer_id);
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 #[ignore] // Transport currently does not validate PeerId.
           // Enable once we make use of PeerId validation in rustls.
 async fn wrong_peerid() {
     use libp2p_identity::PeerId;
 
-    let (a_peer_id, mut a_transport) = create_default_transport::<quic::async_std::Provider>();
-    let (b_peer_id, mut b_transport) = create_default_transport::<quic::async_std::Provider>();
+    let (a_peer_id, mut a_transport) = create_default_transport::<quic::tokio::Provider>();
+    let (b_peer_id, mut b_transport) = create_default_transport::<quic::tokio::Provider>();
 
     let a_addr = start_listening(&mut a_transport, "/ip6/::1/udp/0/quic-v1").await;
     let a_addr_random_peer = a_addr.with(Protocol::P2p(PeerId::random()));
@@ -224,15 +224,15 @@ async fn wrong_peerid() {
     assert_eq!(b_connected, a_peer_id);
 }
 
-#[cfg(feature = "async-std")]
+#[cfg(feature = "tokio")]
 fn new_tcp_quic_transport() -> (PeerId, Boxed<(PeerId, StreamMuxerBox)>) {
     let keypair = generate_tls_keypair();
     let peer_id = keypair.public().to_peer_id();
     let mut config = quic::Config::new(&keypair);
     config.handshake_timeout = Duration::from_secs(1);
 
-    let quic_transport = quic::async_std::Transport::new(config);
-    let tcp_transport = tcp::async_io::Transport::new(tcp::Config::default())
+    let quic_transport = quic::tokio::Transport::new(config);
+    let tcp_transport = tcp::tokio::Transport::new(tcp::Config::default())
         .upgrade(upgrade::Version::V1)
         .authenticate(noise::Config::new(&keypair).unwrap())
         .multiplex(yamux::Config::default());
@@ -247,8 +247,8 @@ fn new_tcp_quic_transport() -> (PeerId, Boxed<(PeerId, StreamMuxerBox)>) {
     (peer_id, transport)
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn tcp_and_quic() {
     let (a_peer_id, mut a_transport) = new_tcp_quic_transport();
     let (b_peer_id, mut b_transport) = new_tcp_quic_transport();
@@ -377,15 +377,15 @@ async fn draft_29_support() {
     }
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn backpressure() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
     let max_stream_data = quic::Config::new(&generate_tls_keypair()).max_stream_data;
 
-    let (mut stream_a, mut stream_b) = build_streams::<quic::async_std::Provider>().await;
+    let (mut stream_a, mut stream_b) = build_streams::<quic::tokio::Provider>().await;
 
     let data = vec![0; max_stream_data as usize - 1];
 
@@ -403,13 +403,13 @@ async fn backpressure() {
     assert!(stream_a.write(&more_data).now_or_never().is_some());
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 async fn read_after_peer_dropped_stream() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
-    let (mut stream_a, mut stream_b) = build_streams::<quic::async_std::Provider>().await;
+    let (mut stream_a, mut stream_b) = build_streams::<quic::tokio::Provider>().await;
 
     let data = vec![0; 10];
 
@@ -424,14 +424,14 @@ async fn read_after_peer_dropped_stream() {
     assert_eq!(data, buf)
 }
 
-#[cfg(feature = "async-std")]
-#[async_std::test]
+#[cfg(feature = "tokio")]
+#[tokio::test]
 #[should_panic]
 async fn write_after_peer_dropped_stream() {
     let _ = tracing_subscriber::fmt()
         .with_env_filter(EnvFilter::from_default_env())
         .try_init();
-    let (stream_a, mut stream_b) = build_streams::<quic::async_std::Provider>().await;
+    let (stream_a, mut stream_b) = build_streams::<quic::tokio::Provider>().await;
     drop(stream_a);
     futures_timer::Delay::new(Duration::from_millis(100)).await;
 

transports/quic/tests/stream_compliance.rs

@@ -7,14 +7,14 @@ use libp2p_core::{
 };
 use libp2p_quic as quic;
 
-#[async_std::test]
+#[tokio::test]
 async fn close_implies_flush() {
     let (alice, bob) = connected_peers().await;
 
     libp2p_muxer_test_harness::close_implies_flush(alice, bob).await;
 }
 
-#[async_std::test]
+#[tokio::test]
 async fn read_after_close() {
     let (alice, bob) = connected_peers().await;
 
@@ -36,10 +36,10 @@ async fn connected_peers() -> (quic::Connection, quic::Connection) {
     let (dialer_conn_sender, dialer_conn_receiver) = oneshot::channel();
     let (listener_conn_sender, listener_conn_receiver) = oneshot::channel();
 
-    async_std::task::spawn(async move {
+    tokio::spawn(async move {
         let (upgrade, _) = listener.next().await.unwrap().into_incoming().unwrap();
 
-        async_std::task::spawn(async move {
+        tokio::spawn(async move {
             let (_, connection) = upgrade.await.unwrap();
 
             let _ = listener_conn_sender.send(connection);
@@ -58,13 +58,13 @@ async fn connected_peers() -> (quic::Connection, quic::Connection) {
             },
         )
         .unwrap();
-    async_std::task::spawn(async move {
+    tokio::spawn(async move {
         let connection = dial_fut.await.unwrap().1;
 
         let _ = dialer_conn_sender.send(connection);
     });
 
-    async_std::task::spawn(async move {
+    tokio::spawn(async move {
         loop {
             dialer.next().await;
         }
@@ -75,10 +75,10 @@ async fn connected_peers() -> (quic::Connection, quic::Connection) {
         .unwrap()
 }
 
-fn new_transport() -> quic::async_std::Transport {
+fn new_transport() -> quic::tokio::Transport {
     let keypair = libp2p_identity::Keypair::generate_ed25519();
     let mut config = quic::Config::new(&keypair);
     config.handshake_timeout = Duration::from_secs(1);
 
-    quic::async_std::Transport::new(config)
+    quic::tokio::Transport::new(config)
 }