chore(test-utils): revert #5725, with it we cannot publish the crates…

… using test-utils

Cargo.toml

@@ -30,7 +30,6 @@ members = [
     "misc/quickcheck-ext",
     "misc/rw-stream-sink",
     "misc/server",
-    "misc/test-utils",
     "misc/webrtc-utils",
     "muxers/mplex",
     "muxers/test-harness",
@@ -114,7 +113,6 @@ libp2p-websocket = { version = "0.44.1", path = "transports/websocket" }
 libp2p-websocket-websys = { version = "0.4.1", path = "transports/websocket-websys" }
 libp2p-webtransport-websys = { version = "0.4.1", path = "transports/webtransport-websys" }
 libp2p-yamux = { version = "0.46.0", path = "muxers/yamux" }
-libp2p-test-utils = { version = "0.1.0", path = "misc/test-utils" }
 
 # External dependencies
 async-std-resolver = { version = "0.25.0-alpha.4", default-features = false }

misc/multistream-select/Cargo.toml

@@ -23,7 +23,7 @@ async-std = { version = "1.6.2", features = ["attributes"] }
 futures_ringbuf = "0.4.0"
 quickcheck = { workspace = true }
 rw-stream-sink = { workspace = true }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 # Passing arguments to the docsrs builder in order to properly document cfg's.
 # More information: https://docs.rs/about/builds#cross-compiling

misc/multistream-select/src/dialer_select.rs

@@ -214,9 +214,9 @@ mod tests {
         future::timeout,
         net::{TcpListener, TcpStream},
     };
-    use libp2p_test_utils::EnvFilter;
     use quickcheck::{Arbitrary, Gen, GenRange};
     use tracing::metadata::LevelFilter;
+    use tracing_subscriber::EnvFilter;
 
     use super::*;
     use crate::listener_select_proto;
@@ -275,11 +275,13 @@ mod tests {
             ListenerProtos(listen_protos): ListenerProtos,
             DialPayload(dial_payload): DialPayload,
         ) {
-            libp2p_test_utils::with_env_filter(
-                EnvFilter::builder()
-                    .with_default_directive(LevelFilter::DEBUG.into())
-                    .from_env_lossy(),
-            );
+            let _ = tracing_subscriber::fmt()
+                .with_env_filter(
+                    EnvFilter::builder()
+                        .with_default_directive(LevelFilter::DEBUG.into())
+                        .from_env_lossy(),
+                )
+                .try_init();
 
             async_std::task::block_on(async move {
                 let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();

muxers/mplex/Cargo.toml

@@ -32,7 +32,7 @@ libp2p-muxer-test-harness = { path = "../test-harness" }
 libp2p-plaintext = { workspace = true }
 libp2p-tcp = { workspace = true, features = ["async-io"] }
 quickcheck = { workspace = true }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 [[bench]]
 name = "split_send_size"

muxers/mplex/benches/split_send_size.rs

@@ -38,6 +38,7 @@ use libp2p_identity as identity;
 use libp2p_identity::PeerId;
 use libp2p_mplex as mplex;
 use libp2p_plaintext as plaintext;
+use tracing_subscriber::EnvFilter;
 
 type BenchTransport = transport::Boxed<(PeerId, muxing::StreamMuxerBox)>;
 
@@ -54,7 +55,9 @@ const BENCH_SIZES: [usize; 8] = [
 ];
 
 fn prepare(c: &mut Criterion) {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let payload: Vec<u8> = vec![1; 1024 * 1024];
 

muxers/mplex/src/io.rs

@@ -1231,7 +1231,10 @@ mod tests {
 
     #[test]
     fn max_buffer_behaviour() {
-        libp2p_test_utils::with_default_env_filter();
+        use tracing_subscriber::EnvFilter;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
 
         fn prop(cfg: MplexConfig, overflow: NonZeroU8) {
             let mut r_buf = BytesMut::new();
@@ -1366,7 +1369,10 @@ mod tests {
 
     #[test]
     fn close_on_error() {
-        libp2p_test_utils::with_default_env_filter();
+        use tracing_subscriber::EnvFilter;
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .try_init();
 
         fn prop(cfg: MplexConfig, num_streams: NonZeroU8) {
             let num_streams = cmp::min(cfg.max_substreams, num_streams.get() as usize);

protocols/autonat/Cargo.toml

@@ -37,7 +37,7 @@ thiserror = { workspace = true, optional = true }
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt", "sync"] }
 libp2p-swarm-test = { path = "../../swarm-test" }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 libp2p-identify = { workspace = true }
 libp2p-swarm = { workspace = true, features = ["macros"] }
 

protocols/autonat/tests/autonatv2.rs

@@ -11,10 +11,13 @@ use libp2p_swarm::{
 use libp2p_swarm_test::SwarmExt;
 use rand_core::OsRng;
 use tokio::sync::oneshot;
+use tracing_subscriber::EnvFilter;
 
 #[tokio::test]
 async fn confirm_successful() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
     let (mut alice, mut bob) = start_and_connect().await;
 
     let cor_server_peer = *alice.local_peer_id();
@@ -125,7 +128,9 @@ async fn confirm_successful() {
 
 #[tokio::test]
 async fn dial_back_to_unsupported_protocol() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
     let (mut alice, mut bob) = bootstrap().await;
 
     let alice_peer_id = *alice.local_peer_id();
@@ -221,7 +226,9 @@ async fn dial_back_to_unsupported_protocol() {
 
 #[tokio::test]
 async fn dial_back_to_non_libp2p() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
     let (mut alice, mut bob) = bootstrap().await;
     let alice_peer_id = *alice.local_peer_id();
 
@@ -307,7 +314,9 @@ async fn dial_back_to_non_libp2p() {
 
 #[tokio::test]
 async fn dial_back_to_not_supporting() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let (mut alice, mut bob) = bootstrap().await;
     let alice_peer_id = *alice.local_peer_id();

protocols/dcutr/Cargo.toml

@@ -34,7 +34,7 @@ libp2p-swarm = { workspace = true, features = ["macros"] }
 libp2p-swarm-test = { path = "../../swarm-test" }
 libp2p-tcp = { workspace = true, features = ["async-io"] }
 libp2p-yamux = { workspace = true }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
 tokio = { workspace = true, features = ["rt", "macros"] }
 
 # Passing arguments to the docsrs builder in order to properly document cfg's.

protocols/dcutr/tests/lib.rs

@@ -32,10 +32,13 @@ use libp2p_plaintext as plaintext;
 use libp2p_relay as relay;
 use libp2p_swarm::{Config, NetworkBehaviour, Swarm, SwarmEvent};
 use libp2p_swarm_test::SwarmExt as _;
+use tracing_subscriber::EnvFilter;
 
 #[tokio::test]
 async fn connect() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut relay = build_relay();
     let mut dst = build_client();

protocols/gossipsub/Cargo.toml

@@ -45,7 +45,7 @@ prometheus-client = { workspace = true }
 libp2p-core = { workspace = true }
 libp2p-swarm-test = { path = "../../swarm-test" }
 quickcheck = { workspace = true }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
 tokio = { workspace = true, features = ["rt", "rt-multi-thread", "time", "macros"] }
 
 # Passing arguments to the docsrs builder in order to properly document cfg's.

protocols/gossipsub/src/behaviour/tests.rs

@@ -4766,7 +4766,10 @@ fn test_limit_number_of_message_ids_inside_ihave() {
 
 #[test]
 fn test_iwant_penalties() {
-    libp2p_test_utils::with_default_env_filter();
+    // use tracing_subscriber::EnvFilter;
+    // let _ = tracing_subscriber::fmt()
+    // .with_env_filter(EnvFilter::from_default_env())
+    // .try_init();
     let config = ConfigBuilder::default()
         .iwant_followup_time(Duration::from_secs(4))
         .build()

protocols/gossipsub/tests/smoke.rs

@@ -31,6 +31,7 @@ use libp2p_swarm_test::SwarmExt as _;
 use quickcheck::{QuickCheck, TestResult};
 use rand::{seq::SliceRandom, SeedableRng};
 use tokio::{runtime::Runtime, time};
+use tracing_subscriber::EnvFilter;
 
 struct Graph {
     nodes: SelectAll<Swarm<gossipsub::Behaviour>>,
@@ -131,7 +132,9 @@ async fn build_node() -> Swarm<gossipsub::Behaviour> {
 
 #[test]
 fn multi_hop_propagation() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     fn prop(num_nodes: u8, seed: u64) -> TestResult {
         if !(2..=50).contains(&num_nodes) {

protocols/identify/Cargo.toml

@@ -29,7 +29,7 @@ either = "1.12.0"
 async-std = { version = "1.6.2", features = ["attributes"] }
 libp2p-swarm-test = { path = "../../swarm-test" }
 libp2p-swarm = { workspace = true, features = ["macros"] }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 # Passing arguments to the docsrs builder in order to properly document cfg's.
 # More information: https://docs.rs/about/builds#cross-compiling

protocols/identify/tests/smoke.rs

@@ -9,10 +9,13 @@ use libp2p_identify as identify;
 use libp2p_identity::Keypair;
 use libp2p_swarm::{Swarm, SwarmEvent};
 use libp2p_swarm_test::SwarmExt;
+use tracing_subscriber::EnvFilter;
 
 #[async_std::test]
 async fn periodic_identify() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut swarm1 = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(
@@ -81,7 +84,9 @@ async fn periodic_identify() {
 }
 #[async_std::test]
 async fn only_emits_address_candidate_once_per_connection() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut swarm1 = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(
@@ -151,7 +156,9 @@ async fn only_emits_address_candidate_once_per_connection() {
 
 #[async_std::test]
 async fn emits_unique_listen_addresses() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut swarm1 = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(
@@ -221,7 +228,9 @@ async fn emits_unique_listen_addresses() {
 
 #[async_std::test]
 async fn hides_listen_addresses() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut swarm1 = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(
@@ -290,7 +299,9 @@ async fn hides_listen_addresses() {
 
 #[async_std::test]
 async fn identify_push() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut swarm1 = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(identify::Config::new("a".to_string(), identity.public()))
@@ -340,7 +351,9 @@ async fn identify_push() {
 
 #[async_std::test]
 async fn discover_peer_after_disconnect() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut swarm1 = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(identify::Config::new("a".to_string(), identity.public()))
@@ -391,7 +404,9 @@ async fn discover_peer_after_disconnect() {
 
 #[async_std::test]
 async fn configured_interval_starts_after_first_identify() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let identify_interval = Duration::from_secs(5);
 
@@ -429,7 +444,9 @@ async fn configured_interval_starts_after_first_identify() {
 
 #[async_std::test]
 async fn reject_mismatched_public_key() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .try_init();
 
     let mut honest_swarm = Swarm::new_ephemeral(|identity| {
         identify::Behaviour::new(

protocols/kad/Cargo.toml

@@ -41,7 +41,7 @@ libp2p-swarm = { path = "../../swarm", features = ["macros"] }
 libp2p-swarm-test = { path = "../../swarm-test" }
 libp2p-yamux = { workspace = true }
 quickcheck = { workspace = true }
-libp2p-test-utils = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 [features]
 serde = ["dep:serde", "bytes/serde"]

protocols/kad/src/behaviour/test.rs

@@ -323,7 +323,9 @@ fn query_iter() {
 
 #[test]
 fn unresponsive_not_returned_direct() {
-    libp2p_test_utils::with_default_env_filter();
+    let _ = tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .try_init();
     // Build one node. It contains fake addresses to non-existing nodes. We ask it to find a
     // random peer. We make sure that no fake address is returned.