add session clean up and tests

Author: pthurlow

src/sessions.rs

@@ -86,6 +86,11 @@ fn check_session_lock() {
 }
 
 pub fn find_session_run_ancestor() -> Option<sysinfo::Pid> {
+    static CACHED: std::sync::OnceLock<Option<sysinfo::Pid>> = std::sync::OnceLock::new();
+    *CACHED.get_or_init(find_session_run_ancestor_inner)
+}
+
+fn find_session_run_ancestor_inner() -> Option<sysinfo::Pid> {
     use sysinfo::{ProcessRefreshKind, RefreshKind, System, UpdateKind};
 
     let sys = System::new_with_specifics(
@@ -174,6 +179,7 @@ pub fn update(workspace_id: &str, session_id: &str, name: Option<&str>, markdown
 }
 
 pub fn run(session_id: Option<&str>, workspace_id: &str, name: Option<&str>, cmd: &[String]) {
+    check_session_lock();
     let sid = match session_id {
         Some(id) => {
             // Verify the session exists
@@ -212,6 +218,23 @@ pub fn run(session_id: Option<&str>, workspace_id: &str, name: Option<&str>, cmd
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn find_session_run_ancestor_returns_none_in_test() {
+        // No `hotdata sessions run` ancestor exists in the test runner
+        assert!(find_session_run_ancestor_inner().is_none());
+    }
+
+    #[test]
+    fn find_session_run_ancestor_cached_matches_inner() {
+        // The cached version should agree with the inner function
+        assert_eq!(find_session_run_ancestor(), find_session_run_ancestor_inner());
+    }
+}
+
 pub fn set(session_id: Option<&str>, workspace_id: &str) {
     check_session_lock();
     match session_id {

tests/session_env.rs

@@ -0,0 +1,86 @@
+use std::process::Command;
+
+fn hotdata() -> Command {
+    Command::new(env!("CARGO_BIN_EXE_hotdata"))
+}
+
+// --- session lock tests ---
+
+#[test]
+fn sessions_run_blocked_when_hotdata_session_set() {
+    let output = hotdata()
+        .args(["sessions", "run", "echo", "hi"])
+        .env("HOTDATA_SESSION", "existing-session")
+        .env("HOTDATA_WORKSPACE", "ws-1")
+        .output()
+        .unwrap();
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stderr.contains("session is locked"), "stderr: {stderr}");
+}
+
+#[test]
+fn sessions_new_blocked_when_hotdata_session_set() {
+    let output = hotdata()
+        .args(["sessions", "new"])
+        .env("HOTDATA_SESSION", "existing-session")
+        .env("HOTDATA_WORKSPACE", "ws-1")
+        .output()
+        .unwrap();
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stderr.contains("session is locked"), "stderr: {stderr}");
+}
+
+#[test]
+fn sessions_set_blocked_when_hotdata_session_set() {
+    let output = hotdata()
+        .args(["sessions", "set", "some-id"])
+        .env("HOTDATA_SESSION", "existing-session")
+        .env("HOTDATA_WORKSPACE", "ws-1")
+        .output()
+        .unwrap();
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stderr.contains("session is locked"), "stderr: {stderr}");
+}
+
+// --- workspace env lock tests ---
+
+#[test]
+fn workspace_env_blocks_conflicting_flag() {
+    let output = hotdata()
+        .args(["sessions", "-w", "other-ws", "list"])
+        .env("HOTDATA_WORKSPACE", "locked-ws")
+        .env_remove("HOTDATA_SESSION")
+        .output()
+        .unwrap();
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("locked by HOTDATA_WORKSPACE"),
+        "stderr: {stderr}"
+    );
+}
+
+#[test]
+fn workspace_env_allows_matching_flag() {
+    // When the flag matches the env var, no workspace conflict error.
+    // Will fail later on auth, but should NOT fail on workspace lock.
+    let output = hotdata()
+        .args(["sessions", "-w", "ws-1", "list"])
+        .env("HOTDATA_WORKSPACE", "ws-1")
+        .env_remove("HOTDATA_SESSION")
+        .output()
+        .unwrap();
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        !stderr.contains("locked by HOTDATA_WORKSPACE"),
+        "unexpected workspace lock error: {stderr}"
+    );
+}