tests: improve reconnect test

Author: Frando

iroh/src/endpoint.rs

@@ -3241,58 +3241,62 @@ mod tests {
         let server_loop = tokio::task::spawn(async move {
             while let Some(conn) = server.accept().await {
                 let conn = conn.accept().e()?.await.e()?;
+                info!("server ACCEPT");
+                let mut stream = conn.open_uni().await.e()?;
+                stream.write_all(b"hi").await.e()?;
+                stream.finish().e()?;
                 let res = match conn.closed().await {
                     ConnectionError::ApplicationClosed(frame) => Ok(u64::from(frame.error_code)),
                     reason => Err(reason),
                 };
+                info!("server CLOSED");
                 tx.send(res).await.e()?;
             }
             Result::<_, n0_snafu::Error>::Ok(())
         });
 
         // Clients connect to the server, and immediately close the connection with a code
         // and then close the endpoint.
-        async fn connect(secret_key: SecretKey, addr: NodeAddr, code: u32) -> Result<Endpoint> {
+        async fn connect(secret_key: SecretKey, addr: NodeAddr, code: u32) -> Result<()> {
             info!("spawn client node {}", secret_key.public().fmt_short());
             let ep = Endpoint::builder()
                 .secret_key(secret_key)
                 .relay_mode(RelayMode::Disabled)
                 .bind()
                 .await?;
-            info!(
-                "connect client {} ({:?}) to {addr:?}",
-                ep.node_id().fmt_short(),
-                ep.bound_sockets(),
-            );
+            let ipv4 = ep.bound_sockets()[0];
+            let node_id = ep.node_id().fmt_short();
+            info!(%node_id, %ipv4, "client CONNECT");
             let conn = ep.connect(addr, TEST_ALPN).await?;
+            info!(%node_id, %ipv4, "client CONNECTED");
+            let mut stream = conn.accept_uni().await.e()?;
+            let buf = stream.read_to_end(2).await.e()?;
+            assert_eq!(&buf, b"hi");
             conn.close(code.into(), b"bye");
-            Ok(ep)
+            info!(%node_id, %ipv4, "client CLOSE");
+            Ok(())
         }
 
         let client_secret_key = SecretKey::generate(&mut rng);
 
         // First connection
-        let ep = n0_future::time::timeout(
+        n0_future::time::timeout(
             TIMEOUT,
             connect(client_secret_key.clone(), server_addr.clone(), 23),
         )
         .await
         .e()??;
         assert_eq!(rx.recv().await.unwrap().unwrap(), 23);
-        // close the endpoint in a separate task, to not lose time for our immediate respawn testing
-        let close1 = tokio::task::spawn(async move { ep.close().await });
 
         // Second connection
-        let ep = n0_future::time::timeout(
+        n0_future::time::timeout(
             TIMEOUT,
             connect(client_secret_key.clone(), server_addr.clone(), 24),
         )
         .await
         .e()??;
         assert_eq!(rx.recv().await.unwrap().unwrap(), 24);
 
-        close1.await.e()?;
-        ep.close().await;
         server_loop.abort();
 
         Ok(())