test: add freenet-test-network harness

Author: sanity

crates/core/tests/diagnose_connectivity.rs

@@ -0,0 +1,49 @@
+//! Diagnostic test to understand connectivity failures
+
+use freenet_test_network::{BuildProfile, FreenetBinary, TestNetwork};
+use std::time::Duration;
+
+#[tokio::test]
+async fn diagnose_connectivity_failure() {
+    // Build network with more relaxed settings
+    let result = TestNetwork::builder()
+        .gateways(1)
+        .peers(2)
+        .binary(FreenetBinary::CurrentCrate(BuildProfile::Debug))
+        .require_connectivity(0.5) // Lower threshold - just need 50%
+        .connectivity_timeout(Duration::from_secs(60)) // Longer timeout
+        .preserve_temp_dirs_on_failure(true)
+        .build()
+        .await;
+
+    match result {
+        Ok(network) => {
+            println!("\n✓ Network started successfully!");
+
+            // Print network info
+            println!("\nNetwork topology:");
+            println!("  Gateway: {}", network.gateway(0).ws_url());
+            for i in 0..2 {
+                println!("  Peer {}: {}", i, network.peer(i).ws_url());
+            }
+
+            // Read and print logs
+            println!("\n=== Network Logs ===");
+            if let Ok(logs) = network.read_logs() {
+                for entry in logs.iter().take(200) {
+                    println!(
+                        "[{}] {}: {}",
+                        entry.peer_id,
+                        entry.level.as_deref().unwrap_or("INFO"),
+                        entry.message
+                    );
+                }
+                println!("\n(Showing first 200 log lines, total: {})", logs.len());
+            }
+        }
+        Err(e) => {
+            eprintln!("\n✗ Network failed to start: {:?}", e);
+            panic!("Network startup failed - see logs above");
+        }
+    }
+}

crates/core/tests/manual_network_test.rs

@@ -0,0 +1,47 @@
+//! Manual test to inspect network logs
+
+use freenet_test_network::{BuildProfile, FreenetBinary, TestNetwork};
+use std::time::Duration;
+
+#[tokio::test]
+#[ignore] // Run manually with: cargo test manual_network_test -- --ignored --nocapture
+async fn manual_network_test() {
+    let network = TestNetwork::builder()
+        .gateways(1)
+        .peers(1)
+        .binary(FreenetBinary::CurrentCrate(BuildProfile::Debug))
+        .require_connectivity(0.5)
+        .connectivity_timeout(Duration::from_secs(10)) // Short timeout so we can inspect quickly
+        .preserve_temp_dirs_on_failure(true)
+        .build()
+        .await;
+
+    match network {
+        Ok(ref net) => {
+            println!("\n=== Network Started ===");
+            println!("Gateway: {}", net.gateway(0).ws_url());
+            println!("Peer: {}", net.peer(0).ws_url());
+
+            // Print all logs
+            if let Ok(logs) = net.read_logs() {
+                println!("\n=== Logs ===");
+                for entry in logs {
+                    println!(
+                        "[{}] {}: {}",
+                        entry.peer_id,
+                        entry.level.as_deref().unwrap_or("INFO"),
+                        entry.message
+                    );
+                }
+            }
+
+            // Keep network alive for inspection
+            println!("\nNetwork is running. Press Ctrl+C to exit.");
+            tokio::time::sleep(Duration::from_secs(300)).await;
+        }
+        Err(e) => {
+            eprintln!("\n✗ Network failed: {:?}", e);
+            // Try to read logs anyway if temp dirs still exist
+        }
+    }
+}

crates/core/tests/test_network_integration.rs

@@ -0,0 +1,66 @@
+//! Integration test demonstrating freenet-test-network usage
+//!
+//! This shows how much simpler tests become with the test-network crate
+
+use freenet_stdlib::client_api::WebApi;
+use freenet_test_network::TestNetwork;
+use testresult::TestResult;
+use tokio_tungstenite::connect_async;
+
+// Helper to get or create network
+async fn get_network() -> &'static TestNetwork {
+    use tokio::sync::OnceCell;
+    static NETWORK: OnceCell<TestNetwork> = OnceCell::const_new();
+
+    NETWORK
+        .get_or_init(|| async {
+            TestNetwork::builder()
+                .gateways(1)
+                .peers(2)
+                .binary(freenet_test_network::FreenetBinary::CurrentCrate(
+                    freenet_test_network::BuildProfile::Debug,
+                ))
+                .build()
+                .await
+                .expect("Failed to start test network")
+        })
+        .await
+}
+
+#[tokio::test]
+async fn test_network_connectivity() -> TestResult {
+    let network = get_network().await;
+
+    // Just verify we can connect to all peers
+    let gw_url = format!("{}?encodingProtocol=native", network.gateway(0).ws_url());
+    let (stream, _) = connect_async(&gw_url).await?;
+    let _gw_client = WebApi::start(stream);
+
+    let peer_url = format!("{}?encodingProtocol=native", network.peer(0).ws_url());
+    let (stream, _) = connect_async(&peer_url).await?;
+    let _peer_client = WebApi::start(stream);
+
+    println!("✓ Successfully connected to gateway and peer");
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_multiple_connections() -> TestResult {
+    let network = get_network().await;
+
+    // Each test gets its own connections - no conflicts
+    let url1 = format!("{}?encodingProtocol=native", network.gateway(0).ws_url());
+    let (stream1, _) = connect_async(&url1).await?;
+    let _client1 = WebApi::start(stream1);
+
+    let url2 = format!("{}?encodingProtocol=native", network.peer(0).ws_url());
+    let (stream2, _) = connect_async(&url2).await?;
+    let _client2 = WebApi::start(stream2);
+
+    let url3 = format!("{}?encodingProtocol=native", network.peer(1).ws_url());
+    let (stream3, _) = connect_async(&url3).await?;
+    let _client3 = WebApi::start(stream3);
+
+    println!("✓ Multiple WebSocket connections work");
+    Ok(())
+}