fix test by calling stream.finish() (#3665)

Author: flub

iroh/src/endpoint.rs

@@ -1863,6 +1863,7 @@ mod tests {
 
             info!(me = %ep.id().fmt_short(), "client connecting");
             let conn = ep.connect(dst, TEST_ALPN).await?;
+            info!(me = %ep.id().fmt_short(), "client connected");
 
             // We should be connected via IP, because it is faster than the relay server.
             // TODO: Maybe not panic if this is not true?
@@ -1875,6 +1876,7 @@ mod tests {
                 while let Some(infos) = paths.next().await {
                     info!(?infos, "new PathInfos");
                     if infos.iter().any(|info| info.is_relay()) {
+                        info!("client has a relay path");
                         break;
                     }
                 }
@@ -1911,6 +1913,7 @@ mod tests {
 
             info!(me = %ep.id().fmt_short(), "server starting");
             let conn = ep.accept().await.anyerr()?.await.anyerr()?;
+            info!(me = %ep.id().fmt_short(), "server accepted connection");
 
             // Wait for a relay connection to be added.  Client does all the asserting here,
             // we just want to wait so we get to see all the mechanics of the connection
@@ -1920,6 +1923,7 @@ mod tests {
                 while let Some(infos) = paths.next().await {
                     info!(?infos, "new PathInfos");
                     if infos.iter().any(|path| path.is_relay()) {
+                        info!("server has a relay path");
                         break;
                     }
                 }
@@ -1929,6 +1933,8 @@ mod tests {
 
             let mut stream = conn.open_uni().await.anyerr()?;
             stream.write_all(b"have relay").await.anyerr()?;
+            stream.finish().anyerr()?;
+            info!("waiting conn.closed()");
 
             Ok(conn.closed().await)
         }

iroh/src/endpoint/connection.rs

@@ -1521,7 +1521,7 @@ mod tests {
     use n0_future::StreamExt;
     use n0_watcher::Watcher;
     use rand::SeedableRng;
-    use tracing::{Instrument, error_span, info_span, trace_span};
+    use tracing::{Instrument, error_span, info, info_span, trace_span};
     use tracing_test::traced_test;
 
     use super::Endpoint;
@@ -1740,8 +1740,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_paths_watcher() -> Result {
-        tracing_subscriber::fmt::init();
         const ALPN: &[u8] = b"test";
         let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(0u64);
         let (relay_map, _relay_map, _guard) = run_relay_server().await?;
@@ -1760,13 +1760,13 @@ mod tests {
 
         server.online().await;
         let server_addr = server.addr();
-        tracing::info!("server addr: {server_addr:?}");
+        info!("server addr: {server_addr:?}");
 
         let (conn_client, conn_server) = tokio::join!(
             async { client.connect(server_addr, ALPN).await.unwrap() },
             async { server.accept().await.unwrap().await.unwrap() }
         );
-        tracing::info!("connected");
+        info!("connected");
         let mut paths_client = conn_client.paths().stream();
         let mut paths_server = conn_server.paths().stream();
 
@@ -1778,12 +1778,12 @@ mod tests {
         ) {
             loop {
                 let paths = stream.next().await.expect("paths stream ended");
-                tracing::info!(?paths, "paths");
+                info!(?paths, "paths");
                 if paths.len() >= 2
                     && paths.iter().any(PathInfo::is_relay)
                     && paths.iter().any(PathInfo::is_ip)
                 {
-                    tracing::info!("break");
+                    info!("break");
                     return;
                 }
             }
@@ -1806,7 +1806,7 @@ mod tests {
         );
 
         // Close the client connection.
-        tracing::info!("close client conn");
+        info!("close client conn");
         conn_client.close(0u32.into(), b"");
 
         // Verify that the path watch streams close.

iroh/src/magicsock.rs

@@ -2307,11 +2307,11 @@ mod tests {
     #[traced_test]
     async fn test_two_devices_setup_teardown() -> Result {
         for i in 0..10 {
-            println!("-- round {i}");
-            println!("setting up magic stack");
+            info!("-- round {i}");
+            info!("setting up magic stack");
             let (_guard, m1, m2) = endpoint_pair().await;
 
-            println!("closing endpoints");
+            info!("closing endpoints");
             let msock1 = m1.magic_sock();
             let msock2 = m2.magic_sock();
             m1.close().await;