Consolidate tests with debugging

rosenpass/tests/integration_test.rs

@@ -48,18 +48,25 @@ fn find_udp_socket() -> Option<u16> {
     None
 }
 
-// check that we can exchange keys
+fn setup_logging() {
-#[test]
+    let mut log_builder = env_logger::Builder::from_default_env(); // sets log level filter from environment (or defaults)
-#[serial]
+    log_builder.filter_level(log::LevelFilter::Debug);
-fn check_exchange_under_normal() {
+    log_builder.format_timestamp_nanos();
-    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("exchange");
+    log_builder.format(|buf, record| {
-    fs::create_dir_all(&tmpdir).unwrap();
+        let ts_format = buf.timestamp_nanos().to_string();
+        writeln!(
+            buf,
+            "\x1b[1m{:?}\x1b[0m {}: {}",
+            std::thread::current().id(),
+            &ts_format[18..],
+            record.args()
+        )
+    });
 
-    let secret_key_paths = [tmpdir.join("secret-key-0"), tmpdir.join("secret-key-1")];
+    let _ = log_builder.try_init();
-    let public_key_paths = [tmpdir.join("public-key-0"), tmpdir.join("public-key-1")];
+}
-    let shared_key_paths = [tmpdir.join("shared-key-0"), tmpdir.join("shared-key-1")];
 
-    // generate key pairs
+fn generate_key_pairs(secret_key_paths: &[PathBuf], public_key_paths: &[PathBuf]) {
     for (secret_key_path, pub_key_path) in secret_key_paths.iter().zip(public_key_paths.iter()) {
         let output = test_bin::get_test_bin(BIN)
             .args(["gen-keys", "--secret-key"])
@@ -73,6 +80,74 @@ fn check_exchange_under_normal() {
         assert!(secret_key_path.is_file());
         assert!(pub_key_path.is_file());
     }
+}
+
+fn run_server_client_exchange(
+    (server_cmd, server_test_builder): (&std::process::Command, AppServerTestBuilder),
+    (client_cmd, client_test_builder): (&std::process::Command, AppServerTestBuilder),
+) {
+    let (server_terminate, server_terminate_rx) = std::sync::mpsc::channel();
+    let (client_terminate, client_terminate_rx) = std::sync::mpsc::channel();
+
+    let cli = CliArgs::try_parse_from(
+        [server_cmd.get_program()]
+            .into_iter()
+            .chain(server_cmd.get_args()),
+    )
+    .unwrap();
+
+    std::thread::spawn(move || {
+        cli.command
+            .run(Some(
+                server_test_builder
+                    .termination_handler(Some(server_terminate_rx))
+                    .build()
+                    .unwrap(),
+            ))
+            .unwrap();
+    });
+
+    let cli = CliArgs::try_parse_from(
+        [client_cmd.get_program()]
+            .into_iter()
+            .chain(client_cmd.get_args()),
+    )
+    .unwrap();
+
+    std::thread::spawn(move || {
+        cli.command
+            .run(Some(
+                client_test_builder
+                    .termination_handler(Some(client_terminate_rx))
+                    .build()
+                    .unwrap(),
+            ))
+            .unwrap();
+    });
+
+    // give them some time to do the key exchange under load
+    std::thread::sleep(Duration::from_secs(10));
+
+    // time's up, kill the childs
+    server_terminate.send(()).unwrap();
+    client_terminate.send(()).unwrap();
+}
+
+// check that we can exchange keys
+#[test]
+#[serial]
+fn check_exchange_under_normal() {
+    setup_logging();
+
+    let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("exchange");
+    fs::create_dir_all(&tmpdir).unwrap();
+
+    let secret_key_paths = [tmpdir.join("secret-key-0"), tmpdir.join("secret-key-1")];
+    let public_key_paths = [tmpdir.join("public-key-0"), tmpdir.join("public-key-1")];
+    let shared_key_paths = [tmpdir.join("shared-key-0"), tmpdir.join("shared-key-1")];
+
+    // generate key pairs
+    generate_key_pairs(&secret_key_paths, &public_key_paths);
 
     // start first process, the server
     let port = loop {
@@ -82,7 +157,9 @@ fn check_exchange_under_normal() {
     };
 
     let listen_addr = format!("localhost:{port}");
-    let mut server = test_bin::get_test_bin(BIN)
+    let mut server_cmd = std::process::Command::new(BIN);
+
+    server_cmd
         .args(["exchange", "secret-key"])
         .arg(&secret_key_paths[0])
         .arg("public-key")
@@ -90,16 +167,12 @@ fn check_exchange_under_normal() {
         .args(["listen", &listen_addr, "verbose", "peer", "public-key"])
         .arg(&public_key_paths[1])
         .arg("outfile")
-        .arg(&shared_key_paths[0])
+        .arg(&shared_key_paths[0]);
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("Failed to start {BIN}");
 
-    std::thread::sleep(Duration::from_millis(500));
+    let server_test_builder = AppServerTestBuilder::default();
 
-    // start second process, the client
+    let mut client_cmd = std::process::Command::new(BIN);
-    let mut client = test_bin::get_test_bin(BIN)
+    client_cmd
         .args(["exchange", "secret-key"])
         .arg(&secret_key_paths[1])
         .arg("public-key")
@@ -108,18 +181,14 @@ fn check_exchange_under_normal() {
         .arg(&public_key_paths[0])
         .args(["endpoint", &listen_addr])
         .arg("outfile")
-        .arg(&shared_key_paths[1])
+        .arg(&shared_key_paths[1]);
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .expect("Failed to start {BIN}");
 
-    // give them some time to do the key exchange
+    let client_test_builder = AppServerTestBuilder::default();
-    std::thread::sleep(Duration::from_secs(2));
 
-    // time's up, kill the childs
+    run_server_client_exchange(
-    server.kill().unwrap();
+        (&server_cmd, server_test_builder),
-    client.kill().unwrap();
+        (&client_cmd, client_test_builder),
+    );
 
     // read the shared keys they created
     let shared_keys: Vec<_> = shared_key_paths
@@ -140,21 +209,7 @@ fn check_exchange_under_normal() {
 #[test]
 #[serial]
 fn check_exchange_under_dos() {
-    let mut log_builder = env_logger::Builder::from_default_env(); // sets log level filter from environment (or defaults)
+    setup_logging();
-    log_builder.filter_level(log::LevelFilter::Debug);
-    log_builder.format_timestamp_nanos();
-    log_builder.format(|buf, record| {
-        let ts_format = buf.timestamp_nanos().to_string();
-        writeln!(
-            buf,
-            "\x1b[1m{:?}\x1b[0m {}: {}",
-            std::thread::current().id(),
-            &ts_format[18..],
-            record.args()
-        )
-    });
-
-    let _ = log_builder.try_init();
 
     //Generate binary with responder with feature integration_test
     let tmpdir = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("exchange-dos");
@@ -165,19 +220,7 @@ fn check_exchange_under_dos() {
     let shared_key_paths = [tmpdir.join("shared-key-0"), tmpdir.join("shared-key-1")];
 
     // generate key pairs
-    for (secret_key_path, pub_key_path) in secret_key_paths.iter().zip(public_key_paths.iter()) {
+    generate_key_pairs(&secret_key_paths, &public_key_paths);
-        let output = test_bin::get_test_bin(BIN)
-            .args(["gen-keys", "--secret-key"])
-            .arg(secret_key_path)
-            .arg("--public-key")
-            .arg(pub_key_path)
-            .output()
-            .expect("Failed to start {BIN}");
-
-        assert_eq!(String::from_utf8_lossy(&output.stdout), "");
-        assert!(secret_key_path.is_file());
-        assert!(pub_key_path.is_file());
-    }
 
     // start first process, the server
     let port = loop {
@@ -200,30 +243,8 @@ fn check_exchange_under_dos() {
         .arg("outfile")
         .arg(&shared_key_paths[0]);
 
-    let (server_terminate, server_terminate_rx) = std::sync::mpsc::channel();
+    let server_test_builder = AppServerTestBuilder::default().enable_dos_permanently(true);
 
-    let cli = CliArgs::try_parse_from(
-        [server_cmd.get_program()]
-            .into_iter()
-            .chain(server_cmd.get_args()),
-    )
-    .unwrap();
-
-    std::thread::spawn(move || {
-        cli.command
-            .run(Some(
-                AppServerTestBuilder::default()
-                    .enable_dos_permanently(true)
-                    .termination_handler(Some(server_terminate_rx))
-                    .build()
-                    .unwrap(),
-            ))
-            .unwrap();
-    });
-
-    std::thread::sleep(Duration::from_millis(500));
-
-    // start second process, the client
     let mut client_cmd = std::process::Command::new(BIN);
     client_cmd
         .args(["exchange", "secret-key"])
@@ -236,32 +257,12 @@ fn check_exchange_under_dos() {
         .arg("outfile")
         .arg(&shared_key_paths[1]);
 
-    let (client_terminate, client_terminate_rx) = std::sync::mpsc::channel();
+    let client_test_builder = AppServerTestBuilder::default();
 
-    let cli = CliArgs::try_parse_from(
+    run_server_client_exchange(
-        [client_cmd.get_program()]
+        (&server_cmd, server_test_builder),
-            .into_iter()
+        (&client_cmd, client_test_builder),
-            .chain(client_cmd.get_args()),
+    );
-    )
-    .unwrap();
-
-    std::thread::spawn(move || {
-        cli.command
-            .run(Some(
-                AppServerTestBuilder::default()
-                    .termination_handler(Some(client_terminate_rx))
-                    .build()
-                    .unwrap(),
-            ))
-            .unwrap();
-    });
-
-    // give them some time to do the key exchange under load
-    std::thread::sleep(Duration::from_secs(10));
-
-    // time's up, kill the childs
-    server_terminate.send(()).unwrap();
-    client_terminate.send(()).unwrap();
 
     // read the shared keys they created
     let shared_keys: Vec<_> = shared_key_paths