test(browser): use owned process harness

examples/workout/tests/browser_e2e.rs

@@ -1,44 +1,24 @@
-use std::process::{Child, Command, Stdio};
+use hemx_test::TestProcess;
+use std::process::Command;
 use std::time::{Duration, Instant};
 use thirtyfour::prelude::*;
 
 const APP_ADDR: &str = "127.0.0.1:3037";
 const WEBDRIVER_ADDR: &str = "127.0.0.1:4447";
-
-struct ChildProcess {
-    child: Child,
-}
-
-impl ChildProcess {
-    fn spawn(mut command: Command) -> Self {
-        let child = command
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .expect("spawn child process");
-        Self { child }
-    }
-}
-
-impl Drop for ChildProcess {
-    fn drop(&mut self) {
-        let _ = self.child.kill();
-        let _ = self.child.wait();
-    }
-}
+const STARTUP_TIMEOUT: Duration = Duration::from_secs(8);
 
 #[tokio::test]
 async fn browser_proves_phone_first_workout_flow() -> WebDriverResult<()> {
     // req: examples/001 req: local/001 req: host/002
     let mut app = Command::new(env!("CARGO_BIN_EXE_hemx-workout-example"));
     app.env("HEMX_WORKOUT_ADDR", APP_ADDR);
-    let _app = ChildProcess::spawn(app);
-    wait_for_tcp(APP_ADDR);
+    let _app = TestProcess::start(app, "hemx-workout-example", APP_ADDR, STARTUP_TIMEOUT)
+        .expect("start ready hemx-workout-example");
 
     let mut webdriver = Command::new("geckodriver");
     webdriver.arg("--port").arg("4447");
-    let _webdriver = ChildProcess::spawn(webdriver);
-    wait_for_tcp(WEBDRIVER_ADDR);
+    let _webdriver = TestProcess::start(webdriver, "geckodriver", WEBDRIVER_ADDR, STARTUP_TIMEOUT)
+        .expect("start ready geckodriver");
 
     let mut caps = DesiredCapabilities::firefox();
     caps.set_headless()?;
@@ -87,17 +67,6 @@ async fn browser_proves_phone_first_workout_flow() -> WebDriverResult<()> {
     result.and(quit)
 }
 
-fn wait_for_tcp(addr: &str) {
-    let deadline = Instant::now() + Duration::from_secs(8);
-    while Instant::now() < deadline {
-        if std::net::TcpStream::connect(addr).is_ok() {
-            return;
-        }
-        std::thread::sleep(Duration::from_millis(25));
-    }
-    panic!("timed out waiting for {addr}");
-}
-
 async fn wait_for_runtime(driver: &WebDriver) -> WebDriverResult<()> {
     let deadline = Instant::now() + Duration::from_secs(8);
     loop {