Fix tests to build examples and run on a random port

This makes two changes to the tests to make them a little more reliable:

* The tests fail to compile when run with `cargo test
  --no-default-features`. This changes the tests to shell out to `cargo
  run ...` to run the examples with the reguired features.
* It changes the test to use a random port rather than a fixed one,
  which might be used by the current system.

Author: erickt

examples/server.rs

@@ -56,10 +56,11 @@ async fn run_server() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let key = PrivateKeyDer::from_pem_file("examples/sample.rsa")
         .map_err(|e| error(format!("could not read private key file: {e}")))?;
 
-    println!("Starting to serve on https://{addr}");
-
     // Create a TCP listener via tokio.
     let incoming = TcpListener::bind(&addr).await?;
+    let addr = incoming.local_addr()?;
+
+    println!("Starting to serve on https://{addr}");
 
     // Build TLS configuration.
     let mut server_config = ServerConfig::builder()

tests/tests.rs

@@ -1,35 +1,66 @@
 use std::env;
-use std::net::TcpStream;
-use std::path::PathBuf;
-use std::process::Command;
-use std::thread;
-use std::time;
-
-fn examples_dir() -> PathBuf {
-    let target_dir: PathBuf = env::var("CARGO_TARGET_DIR")
-        .unwrap_or_else(|_| "target".to_string())
-        .into();
-    target_dir
-        .join("debug")
-        .join("examples")
+use std::io::{BufRead, BufReader};
+use std::net::SocketAddr;
+use std::process::{Child, Command, Stdio};
+
+fn cargo_command() -> Command {
+    let cargo_bin = env::var_os("CARGO").unwrap_or_else(|| "cargo".into());
+
+    let mut cmd = Command::new(cargo_bin);
+    cmd.arg("--quiet");
+
+    cmd
 }
 
 fn server_command() -> Command {
-    Command::new(examples_dir().join("server"))
+    let mut server = cargo_command();
+    server
+        .arg("run")
+        .arg("--features=aws-lc-rs")
+        .arg("--example")
+        .arg("server")
+        .arg("0");
+
+    server
 }
 
-fn client_command() -> Command {
-    Command::new(examples_dir().join("client"))
+fn start_server() -> (Child, SocketAddr) {
+    let mut srv = server_command()
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .expect("cannot run server example");
+
+    let stdout = srv
+        .stdout
+        .take()
+        .expect("failed to get stdout");
+
+    let mut reader = BufReader::new(stdout);
+    let mut line = String::new();
+    reader
+        .read_line(&mut line)
+        .expect("failed to read line");
+
+    let addr = line
+        .trim()
+        .strip_prefix("Starting to serve on https://")
+        .expect("unexpected output")
+        .parse()
+        .expect("failed to parse socket address");
+
+    (srv, addr)
 }
 
-fn wait_for_server(addr: &str) {
-    for i in 0..10 {
-        if TcpStream::connect(addr).is_ok() {
-            return;
-        }
-        thread::sleep(time::Duration::from_millis(i * 100));
-    }
-    panic!("failed to connect to {addr:?} after 10 tries");
+fn client_command() -> Command {
+    let mut client = cargo_command();
+    client
+        .arg("run")
+        .arg("--features=native-tokio,http1")
+        .arg("--example")
+        .arg("client");
+
+    client
 }
 
 #[test]
@@ -39,23 +70,21 @@ fn client() {
         .output()
         .expect("cannot run client example");
 
-    assert!(rc.status.success());
+    if !rc.status.success() {
+        assert_eq!(String::from_utf8_lossy(&rc.stdout), "");
+        assert_eq!(String::from_utf8_lossy(&rc.stderr), "");
+        panic!("test failed");
+    }
 }
 
 #[test]
 fn server() {
-    let mut srv = server_command()
-        .arg("1337")
-        .spawn()
-        .expect("cannot run server example");
-
-    let addr = "localhost:1337";
-    wait_for_server(addr);
+    let (mut srv, addr) = start_server();
 
     let output = Command::new("curl")
         .arg("--insecure")
         .arg("--http1.0")
-        .arg(format!("https://{addr}"))
+        .arg(format!("https://localhost:{}", addr.port()))
         .output()
         .expect("cannot run curl");
 
@@ -78,16 +107,10 @@ fn server() {
 
 #[test]
 fn custom_ca_store() {
-    let mut srv = server_command()
-        .arg("1338")
-        .spawn()
-        .expect("cannot run server example");
-
-    let addr = "localhost:1338";
-    wait_for_server(addr);
+    let (mut srv, addr) = start_server();
 
     let rc = client_command()
-        .arg(format!("https://{addr}"))
+        .arg(format!("https://localhost:{}", addr.port()))
         .arg("examples/sample.pem")
         .output()
         .expect("cannot run client example");
@@ -98,5 +121,7 @@ fn custom_ca_store() {
 
     if !rc.status.success() {
         assert_eq!(String::from_utf8_lossy(&rc.stdout), "");
+        assert_eq!(String::from_utf8_lossy(&rc.stderr), "");
+        panic!("test failed");
     }
 }