test: re-enable test_small_network_get_failure with increased timeouts

apps/freenet-ping/app/Cargo.toml

@@ -25,6 +25,7 @@ humantime = "2.2.0"
 
 [dev-dependencies]
 freenet = { path = "../../../crates/core" }
+test-log = "0.2"
 testresult = { workspace = true }
 
 [lib]

apps/freenet-ping/app/tests/run_app.rs

@@ -17,7 +17,7 @@ use rand::SeedableRng;
 use testresult::TestResult;
 use tokio::{select, time::sleep, time::timeout};
 use tokio_tungstenite::connect_async;
-use tracing::{level_filters::LevelFilter, span, Instrument, Level};
+use tracing::{span, Instrument, Level};
 
 use common::{
     base_node_test_config, base_node_test_config_with_rng, gw_config_from_path,
@@ -171,10 +171,8 @@ async fn collect_node_diagnostics(
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 async fn test_node_diagnostics_query() -> TestResult {
-    freenet::config::set_logger(Some(LevelFilter::DEBUG), None);
-
     // Setup network sockets for the gateway and client node
     let network_socket_gw = TcpListener::bind("127.0.0.1:0")?;
     let ws_api_port_socket_gw = TcpListener::bind("127.0.0.1:0")?;
@@ -463,10 +461,8 @@ async fn test_node_diagnostics_query() -> TestResult {
 }
 
 #[ignore = "this test currently fails and we are workign on fixing it"]
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 async fn test_ping_multi_node() -> TestResult {
-    freenet::config::set_logger(Some(LevelFilter::DEBUG), None);
-
     // Setup network sockets for the gateway
     let network_socket_gw = TcpListener::bind("127.0.0.1:0")?;
 
@@ -1092,10 +1088,8 @@ async fn test_ping_multi_node() -> TestResult {
 }
 
 #[ignore = "this test currently fails and we are workign on fixing it"]
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 async fn test_ping_application_loop() -> TestResult {
-    freenet::config::set_logger(Some(LevelFilter::DEBUG), None);
-
     // Setup network sockets for the gateway
     let network_socket_gw = TcpListener::bind("127.0.0.1:0")?;
 
@@ -1519,7 +1513,7 @@ async fn test_ping_application_loop() -> TestResult {
     Ok(())
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[ignore = "Test has never worked - gateway nodes fail on startup with channel closed errors"]
 async fn test_ping_partially_connected_network() -> TestResult {
     /*
@@ -1551,8 +1545,6 @@ async fn test_ping_partially_connected_network() -> TestResult {
     const NUM_REGULAR_NODES: usize = 7;
     const CONNECTIVITY_RATIO: f64 = 0.5; // Controls connectivity between regular nodes
 
-    // Configure logging
-    freenet::config::set_logger(Some(LevelFilter::DEBUG), None);
     tracing::info!(
         "Starting test with {} gateways and {} regular nodes (connectivity ratio: {})",
         NUM_GATEWAYS,

apps/freenet-ping/app/tests/run_app_blocked_peers.rs

@@ -48,7 +48,7 @@ use common::{
     base_node_test_config, get_all_ping_states, gw_config_from_path, ping_states_equal, APP_TAG,
     PACKAGE_DIR, PATH_TO_CONTRACT,
 };
-use freenet::{config::set_logger, local_node::NodeConfig, server::serve_gateway};
+use freenet::{local_node::NodeConfig, server::serve_gateway};
 use freenet_ping_app::ping_client::{
     wait_for_get_response, wait_for_put_response, wait_for_subscribe_response,
 };
@@ -61,7 +61,7 @@ use futures::FutureExt;
 use testresult::TestResult;
 use tokio::{select, time::sleep};
 use tokio_tungstenite::connect_async;
-use tracing::{level_filters::LevelFilter, span, Instrument, Level};
+use tracing::{span, Instrument, Level};
 
 /// Configuration for blocked peers test variants
 #[derive(Debug, Clone)]
@@ -98,7 +98,6 @@ async fn run_blocked_peers_test(config: BlockedPeersConfig) -> TestResult {
             "debug,freenet::operations::subscribe=trace,freenet::contract=trace",
         );
     }
-    set_logger(Some(LevelFilter::DEBUG), None);
 
     tracing::info!("Starting {} blocked peers test...", config.test_name);
 
@@ -782,7 +781,7 @@ async fn run_blocked_peers_test(config: BlockedPeersConfig) -> TestResult {
 }
 
 /// Standard blocked peers test (baseline)
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[ignore]
 async fn test_ping_blocked_peers() -> TestResult {
     run_blocked_peers_test(BlockedPeersConfig {
@@ -802,7 +801,7 @@ async fn test_ping_blocked_peers() -> TestResult {
 }
 
 /// Simple blocked peers test
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[ignore]
 async fn test_ping_blocked_peers_simple() -> TestResult {
     run_blocked_peers_test(BlockedPeersConfig {
@@ -825,7 +824,7 @@ async fn test_ping_blocked_peers_simple() -> TestResult {
 // as they only varied in non-functional aspects like timeouts and logging
 
 /// Solution/reference implementation for blocked peers
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[ignore = "fix me"]
 async fn test_ping_blocked_peers_solution() -> TestResult {
     run_blocked_peers_test(BlockedPeersConfig {

apps/freenet-ping/app/tests/run_app_partially_connected_network.rs

@@ -28,14 +28,13 @@ use futures::FutureExt;
 use testresult::TestResult;
 use tokio::{select, time::timeout};
 use tokio_tungstenite::connect_async;
-use tracing::{level_filters::LevelFilter, span, Instrument, Level};
+use tracing::{span, Instrument, Level};
 
 use common::{base_node_test_config, gw_config_from_path, APP_TAG, PACKAGE_DIR, PATH_TO_CONTRACT};
 
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[ignore = "Test has never worked - nodes fail on startup with channel closed errors"]
 async fn test_ping_partially_connected_network() -> TestResult {
-    freenet::config::set_logger(Some(LevelFilter::DEBUG), None);
     /*
      * This test verifies how subscription propagation works in a partially connected network.
      *
@@ -68,8 +67,6 @@ async fn test_ping_partially_connected_network() -> TestResult {
     const NUM_REGULAR_NODES: usize = 7;
     const CONNECTIVITY_RATIO: f64 = 0.3; // Controls connectivity between regular nodes
 
-    // Configure logging
-    freenet::config::set_logger(Some(LevelFilter::DEBUG), None);
     println!(
         "Starting test with {NUM_GATEWAYS} gateways and {NUM_REGULAR_NODES} regular nodes (connectivity ratio: {CONNECTIVITY_RATIO})"
     );

apps/freenet-ping/app/tests/test_50_node_operations.rs

@@ -20,19 +20,16 @@ use std::{net::TcpListener, path::PathBuf, time::Duration};
 use testresult::TestResult;
 use tokio::{select, time::timeout};
 use tokio_tungstenite::connect_async;
-use tracing::level_filters::LevelFilter;
 
 use common::{base_node_test_config, gw_config_from_path, APP_TAG, PACKAGE_DIR, PATH_TO_CONTRACT};
 
 const NUM_GATEWAYS: usize = 3; // Multiple gateways to distribute load
 const NUM_REGULAR_NODES: usize = 47; // 3 + 47 = 50 total
 const CONNECTIVITY_RATIO: f64 = 0.1; // 10% connectivity to reduce network load
 
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 #[ignore = "large scale test - run manually"]
 async fn test_50_node_operations() -> TestResult {
-    freenet::config::set_logger(Some(LevelFilter::INFO), None);
-
     println!("🚀 Starting 50-node operations test");
     println!("   Gateway nodes: {NUM_GATEWAYS}");
     println!("   Regular nodes: {NUM_REGULAR_NODES}");

apps/freenet-ping/app/tests/test_connection_timing.rs

@@ -12,18 +12,12 @@ use futures::FutureExt;
 use testresult::TestResult;
 use tokio::{select, time::timeout};
 use tokio_tungstenite::connect_async;
-use tracing::{level_filters::LevelFilter, span, Instrument, Level};
+use tracing::{span, Instrument, Level};
 
 use common::{base_node_test_config, gw_config_from_path};
 
-#[tokio::test(flavor = "multi_thread")]
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
 async fn test_connection_timing() -> TestResult {
-    // Minimal logging to reduce noise
-    freenet::config::set_logger(
-        Some(LevelFilter::WARN),
-        Some("freenet::transport=info,freenet_core::transport=info".to_string()),
-    );
-
     println!("🔧 Testing connection timing with 2 nodes");
 
     // Setup only 2 nodes to minimize complexity