From cfa58f0f971e5c1de729942e4e647c95dfbc149d Mon Sep 17 00:00:00 2001 From: Shiyas Mohammed <83513144+shiyasmohd@users.noreply.github.com> Date: Mon, 3 Feb 2025 17:08:52 +0530 Subject: [PATCH] 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. --- transports/quic/Cargo.toml | 5 +- transports/quic/src/transport.rs | 6 +- transports/quic/tests/smoke.rs | 68 +++++++++++----------- transports/quic/tests/stream_compliance.rs | 16 ++--- 4 files changed, 47 insertions(+), 48 deletions(-) diff --git a/transports/quic/Cargo.toml b/transports/quic/Cargo.toml index 8c416858c91..f6f95800193 100644 --- a/transports/quic/Cargo.toml +++ b/transports/quic/Cargo.toml @@ -35,11 +35,10 @@ 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"] } @@ -47,7 +46,7 @@ tracing-subscriber = { workspace = true, features = ["env-filter"] } [[test]] name = "stream_compliance" -required-features = ["async-std"] +required-features = ["tokio"] [lints] workspace = true diff --git a/transports/quic/src/transport.rs b/transports/quic/src/transport.rs index 63a65ce99cc..84aaba8b672 100644 --- a/transports/quic/src/transport.rs +++ b/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()); diff --git a/transports/quic/tests/smoke.rs b/transports/quic/tests/smoke.rs index 5fbef84649e..6be4796612a 100644 --- a/transports/quic/tests/smoke.rs +++ b/transports/quic/tests/smoke.rs @@ -41,10 +41,10 @@ async fn tokio_smoke() { smoke::().await } -#[cfg(feature = "async-std")] -#[async_std::test] +#[cfg(feature = "tokio")] +#[tokio::test] async fn async_std_smoke() { - smoke::().await + smoke::().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::(); - let (b_peer_id, mut b_transport) = create_default_transport::(); + let (a_peer_id, mut a_transport) = create_default_transport::(); + let (b_peer_id, mut b_transport) = create_default_transport::(); 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::(); + let (a_peer_id, mut a_transport) = create_default_transport::(); let (b_peer_id, mut b_transport) = { - let (id, transport) = create_default_transport::(); + let (id, transport) = create_default_transport::(); (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::(); - let (b_peer_id, mut b_transport) = create_default_transport::(); + let (a_peer_id, mut a_transport) = create_default_transport::(); + let (b_peer_id, mut b_transport) = create_default_transport::(); 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::().await; + let (mut stream_a, mut stream_b) = build_streams::().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::().await; + let (mut stream_a, mut stream_b) = build_streams::().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::().await; + let (stream_a, mut stream_b) = build_streams::().await; drop(stream_a); futures_timer::Delay::new(Duration::from_millis(100)).await; diff --git a/transports/quic/tests/stream_compliance.rs b/transports/quic/tests/stream_compliance.rs index 13c29f2caa0..225ea1e4936 100644 --- a/transports/quic/tests/stream_compliance.rs +++ b/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) }