test(ie-shell): add E2E test harness with BrowserHandle and test server #10

BrowserHandle drives headless browser via JSON protocol with typed
methods (navigate, get_source, get_tabs, etc.) and 10s command timeout.
TestServer serves HTML fixtures from tests/fixtures/ directory.

E2E test suites:
- navigation.rs: 14 tests (fetch, status, 404, redirect, history, HTTPS-only)
- tabs.rs: 7 tests (lifecycle, switching, multi-tab navigation)
- bookmarks.rs: 4 tests (add/list, persistence, isolation)

Also fixes smoke_test.rs to use isolated data dirs per test.

Author: thomasnemer

crates/ie-shell/tests/bookmarks.rs

@@ -0,0 +1,63 @@
+mod harness;
+
+use harness::BrowserHandle;
+
+#[tokio::test]
+async fn test_bookmark_add_and_list() {
+    let mut browser = BrowserHandle::spawn().await;
+    browser.bookmark_add("https://example.com", "Example").await;
+    let bookmarks = browser.bookmark_list().await;
+    assert_eq!(bookmarks.len(), 1);
+    assert_eq!(bookmarks[0].url, "https://example.com");
+    assert_eq!(bookmarks[0].title, "Example");
+    browser.quit().await;
+}
+
+#[tokio::test]
+async fn test_bookmark_multiple() {
+    let mut browser = BrowserHandle::spawn().await;
+    browser.bookmark_add("https://example.com", "Example").await;
+    browser.bookmark_add("https://rust-lang.org", "Rust").await;
+    browser.bookmark_add("https://github.com", "GitHub").await;
+    let bookmarks = browser.bookmark_list().await;
+    assert_eq!(bookmarks.len(), 3);
+    browser.quit().await;
+}
+
+#[tokio::test]
+async fn test_bookmark_persists_across_restart() {
+    let data_dir = tempfile::tempdir().unwrap();
+    let data_dir_str = data_dir.path().to_string_lossy().to_string();
+
+    // First session: add bookmark
+    {
+        let mut browser = BrowserHandle::spawn_with_data_dir(&data_dir_str).await;
+        browser.bookmark_add("https://example.com", "Example").await;
+        browser.quit().await;
+    }
+
+    // Second session: verify bookmark persists
+    {
+        let mut browser = BrowserHandle::spawn_with_data_dir(&data_dir_str).await;
+        let bookmarks = browser.bookmark_list().await;
+        assert_eq!(bookmarks.len(), 1);
+        assert_eq!(bookmarks[0].url, "https://example.com");
+        browser.quit().await;
+    }
+}
+
+#[tokio::test]
+async fn test_bookmark_isolation() {
+    let mut browser_a = BrowserHandle::spawn().await;
+    let mut browser_b = BrowserHandle::spawn().await;
+
+    browser_a
+        .bookmark_add("https://example.com", "Example")
+        .await;
+
+    let bookmarks_b = browser_b.bookmark_list().await;
+    assert_eq!(bookmarks_b.len(), 0);
+
+    browser_a.quit().await;
+    browser_b.quit().await;
+}

crates/ie-shell/tests/harness/mod.rs

@@ -0,0 +1,229 @@
+pub mod server;
+
+use std::time::Duration;
+
+use serde::Deserialize;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, BufWriter};
+use tokio::process::{Child, ChildStdin, ChildStdout, Command};
+use tokio::time::timeout;
+
+const CMD_TIMEOUT: Duration = Duration::from_secs(10);
+
+pub struct BrowserHandle {
+    child: Child,
+    stdin: BufWriter<ChildStdin>,
+    reader: BufReader<ChildStdout>,
+    _data_dir: tempfile::TempDir,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct NavigateResponse {
+    pub status: u64,
+    pub url: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct TabInfo {
+    pub id: u64,
+    pub url: Option<String>,
+    pub title: String,
+    pub state: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BookmarkInfo {
+    pub url: String,
+    pub title: String,
+}
+
+fn binary_path() -> String {
+    let mut path = std::env::current_exe()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .to_path_buf();
+    path.push("ie-shell");
+    path.to_string_lossy().to_string()
+}
+
+impl BrowserHandle {
+    pub async fn spawn() -> Self {
+        Self::spawn_with_args(&["--allow-http"]).await
+    }
+
+    pub async fn spawn_https_only() -> Self {
+        Self::spawn_with_args(&[]).await
+    }
+
+    pub async fn spawn_with_data_dir(data_dir: &str) -> Self {
+        let child_result = Command::new(binary_path())
+            .args(["--headless", "--allow-http", "--data-dir", data_dir])
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::inherit())
+            .spawn();
+        let mut child = child_result.expect("failed to spawn ie-shell");
+        let stdin = BufWriter::new(child.stdin.take().unwrap());
+        let reader = BufReader::new(child.stdout.take().unwrap());
+        // Use a dummy TempDir that won't be used for actual storage
+        let _data_dir = tempfile::tempdir().unwrap();
+        Self {
+            child,
+            stdin,
+            reader,
+            _data_dir,
+        }
+    }
+
+    async fn spawn_with_args(extra_args: &[&str]) -> Self {
+        let data_dir = tempfile::tempdir().unwrap();
+        let data_dir_str = data_dir.path().to_string_lossy().to_string();
+        let mut args = vec!["--headless", "--data-dir", &data_dir_str];
+        args.extend(extra_args);
+        let child_result = Command::new(binary_path())
+            .args(&args)
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::inherit())
+            .spawn();
+        let mut child = child_result.expect("failed to spawn ie-shell");
+        let stdin = BufWriter::new(child.stdin.take().unwrap());
+        let reader = BufReader::new(child.stdout.take().unwrap());
+        Self {
+            child,
+            stdin,
+            reader,
+            _data_dir: data_dir,
+        }
+    }
+
+    pub async fn send_command(&mut self, cmd: serde_json::Value) -> serde_json::Value {
+        let json = serde_json::to_string(&cmd).unwrap();
+        self.stdin
+            .write_all(json.as_bytes())
+            .await
+            .expect("write to stdin");
+        self.stdin.write_all(b"\n").await.expect("write newline");
+        self.stdin.flush().await.expect("flush stdin");
+
+        let mut line = String::new();
+        timeout(CMD_TIMEOUT, self.reader.read_line(&mut line))
+            .await
+            .unwrap_or_else(|_| panic!("command timed out after {CMD_TIMEOUT:?}: {cmd}"))
+            .expect("read from stdout");
+
+        serde_json::from_str(&line).unwrap_or_else(|e| {
+            panic!("invalid JSON response: {e}\nraw: {line}\ncommand was: {cmd}")
+        })
+    }
+
+    pub async fn navigate(&mut self, url: &str) -> NavigateResponse {
+        let resp = self
+            .send_command(serde_json::json!({"cmd": "navigate", "url": url}))
+            .await;
+        assert!(
+            resp["ok"].as_bool().unwrap(),
+            "navigate failed: {}",
+            resp["error"]
+        );
+        serde_json::from_value(resp["data"].clone()).unwrap()
+    }
+
+    pub async fn navigate_raw(&mut self, url: &str) -> serde_json::Value {
+        self.send_command(serde_json::json!({"cmd": "navigate", "url": url}))
+            .await
+    }
+
+    pub async fn get_source(&mut self) -> String {
+        let resp = self
+            .send_command(serde_json::json!({"cmd": "get_source"}))
+            .await;
+        assert!(
+            resp["ok"].as_bool().unwrap(),
+            "get_source failed: {}",
+            resp["error"]
+        );
+        resp["data"].as_str().unwrap().to_string()
+    }
+
+    pub async fn get_tabs(&mut self) -> Vec<TabInfo> {
+        let resp = self
+            .send_command(serde_json::json!({"cmd": "get_tabs"}))
+            .await;
+        assert!(
+            resp["ok"].as_bool().unwrap(),
+            "get_tabs failed: {}",
+            resp["error"]
+        );
+        serde_json::from_value(resp["data"].clone()).unwrap()
+    }
+
+    pub async fn new_tab(&mut self) -> u64 {
+        let resp = self
+            .send_command(serde_json::json!({"cmd": "new_tab"}))
+            .await;
+        assert!(
+            resp["ok"].as_bool().unwrap(),
+            "new_tab failed: {}",
+            resp["error"]
+        );
+        resp["data"]["id"].as_u64().unwrap()
+    }
+
+    pub async fn close_tab(&mut self, id: u64) -> serde_json::Value {
+        self.send_command(serde_json::json!({"cmd": "close_tab", "id": id}))
+            .await
+    }
+
+    pub async fn switch_tab(&mut self, id: u64) -> serde_json::Value {
+        self.send_command(serde_json::json!({"cmd": "switch_tab", "id": id}))
+            .await
+    }
+
+    pub async fn go_back(&mut self) -> serde_json::Value {
+        self.send_command(serde_json::json!({"cmd": "go_back"}))
+            .await
+    }
+
+    pub async fn go_forward(&mut self) -> serde_json::Value {
+        self.send_command(serde_json::json!({"cmd": "go_forward"}))
+            .await
+    }
+
+    pub async fn bookmark_add(&mut self, url: &str, title: &str) {
+        let resp = self
+            .send_command(serde_json::json!({"cmd": "bookmark_add", "url": url, "title": title}))
+            .await;
+        assert!(
+            resp["ok"].as_bool().unwrap(),
+            "bookmark_add failed: {}",
+            resp["error"]
+        );
+    }
+
+    pub async fn bookmark_list(&mut self) -> Vec<BookmarkInfo> {
+        let resp = self
+            .send_command(serde_json::json!({"cmd": "bookmark_list"}))
+            .await;
+        assert!(
+            resp["ok"].as_bool().unwrap(),
+            "bookmark_list failed: {}",
+            resp["error"]
+        );
+        serde_json::from_value(resp["data"].clone()).unwrap()
+    }
+
+    pub async fn quit(&mut self) {
+        let _ = self.send_command(serde_json::json!({"cmd": "quit"})).await;
+        let _ = timeout(Duration::from_secs(2), self.child.wait()).await;
+    }
+}
+
+impl Drop for BrowserHandle {
+    fn drop(&mut self) {
+        // Best-effort kill
+        let _ = self.child.start_kill();
+    }
+}

crates/ie-shell/tests/harness/server.rs

@@ -0,0 +1,66 @@
+use std::net::SocketAddr;
+use std::path::PathBuf;
+
+pub struct TestServer {
+    addr: SocketAddr,
+    _handle: std::thread::JoinHandle<()>,
+}
+
+impl TestServer {
+    pub fn start() -> Self {
+        Self::start_with_handler(|path| {
+            let fixtures_dir = fixtures_dir();
+            let file_path = fixtures_dir.join(path.trim_start_matches('/'));
+            if file_path.exists() {
+                let body = std::fs::read_to_string(&file_path).unwrap();
+                (200, "text/html", body)
+            } else {
+                (404, "text/html", "Not Found".to_string())
+            }
+        })
+    }
+
+    pub fn start_with_handler<F>(handler: F) -> Self
+    where
+        F: Fn(&str) -> (u16, &'static str, String) + Send + 'static,
+    {
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let addr = listener.local_addr().unwrap();
+        let handle = std::thread::spawn(move || {
+            for stream in listener.incoming() {
+                let Ok(mut stream) = stream else { break };
+                let mut buf = [0u8; 4096];
+                let n = std::io::Read::read(&mut stream, &mut buf).unwrap_or(0);
+                let request = String::from_utf8_lossy(&buf[..n]);
+                let path = request
+                    .lines()
+                    .next()
+                    .and_then(|line| line.split_whitespace().nth(1))
+                    .unwrap_or("/");
+                let (status, content_type, body) = handler(path);
+                let response = format!(
+                    "HTTP/1.1 {status} OK\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                    body.len()
+                );
+                let _ = std::io::Write::write_all(&mut stream, response.as_bytes());
+            }
+        });
+        Self {
+            addr,
+            _handle: handle,
+        }
+    }
+
+    pub fn url(&self, path: &str) -> String {
+        format!("http://127.0.0.1:{}{path}", self.addr.port())
+    }
+}
+
+fn fixtures_dir() -> PathBuf {
+    let mut dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    // Go up from crates/ie-shell to project root
+    dir.pop();
+    dir.pop();
+    dir.push("tests/fixtures");
+    dir
+}