handoff-mcp-server 0.1.0

package/tests/mcp_protocol.rs

@@ -0,0 +1,204 @@
+use serde_json::{json, Value};
+
+fn send(input: &str) -> Option<Value> {
+    let result = handoff_mcp::mcp::protocol::process_line(input)?;
+    Some(serde_json::from_str(&result).expect("response should be valid JSON"))
+}
+
+#[test]
+fn initialize_returns_capabilities() {
+    let resp = send(
+        r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"0.1.0"}}}"#,
+    )
+    .expect("initialize should return a response");
+
+    assert_eq!(resp["jsonrpc"], "2.0");
+    assert_eq!(resp["id"], 1);
+    assert!(resp["error"].is_null());
+
+    let result = &resp["result"];
+    assert_eq!(result["protocolVersion"], "2025-03-26");
+    assert!(result["capabilities"]["tools"].is_object());
+    assert!(result["capabilities"]["resources"].is_object());
+    assert_eq!(result["serverInfo"]["name"], "handoff-mcp");
+    assert!(result["serverInfo"]["version"].is_string());
+    assert!(result["instructions"].is_string());
+}
+
+#[test]
+fn initialized_notification_returns_nothing() {
+    let resp = send(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);
+    assert!(
+        resp.is_none(),
+        "notifications should not produce a response"
+    );
+}
+
+#[test]
+fn tools_list_returns_all_tools() {
+    let resp = send(r#"{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}"#)
+        .expect("tools/list should return a response");
+
+    assert_eq!(resp["id"], 2);
+    assert!(resp["error"].is_null());
+
+    let tools = resp["result"]["tools"]
+        .as_array()
+        .expect("tools should be an array");
+
+    let expected_names = [
+        "handoff_init",
+        "handoff_load_context",
+        "handoff_save_context",
+        "handoff_list_tasks",
+        "handoff_update_task",
+        "handoff_get_config",
+        "handoff_update_config",
+        "handoff_dashboard",
+    ];
+
+    let tool_names: Vec<&str> = tools
+        .iter()
+        .map(|t| t["name"].as_str().expect("tool name should be a string"))
+        .collect();
+
+    for expected in &expected_names {
+        assert!(tool_names.contains(expected), "missing tool: {expected}");
+    }
+
+    for tool in tools {
+        assert!(
+            tool["description"].is_string(),
+            "tool should have description"
+        );
+        assert!(
+            tool["inputSchema"].is_object(),
+            "tool should have inputSchema"
+        );
+    }
+}
+
+#[test]
+fn resources_list_returns_resources() {
+    let resp = send(r#"{"jsonrpc":"2.0","id":3,"method":"resources/list","params":{}}"#)
+        .expect("resources/list should return a response");
+
+    assert_eq!(resp["id"], 3);
+    assert!(resp["error"].is_null());
+
+    let resources = resp["result"]["resources"]
+        .as_array()
+        .expect("resources should be an array");
+
+    assert_eq!(resources.len(), 2);
+
+    let uris: Vec<&str> = resources
+        .iter()
+        .map(|r| r["uri"].as_str().expect("resource uri"))
+        .collect();
+
+    assert!(uris.contains(&"handoff://sessions"));
+    assert!(uris.contains(&"handoff://config"));
+}
+
+#[test]
+fn invalid_json_returns_parse_error() {
+    let resp = send("not valid json at all").expect("should return error response");
+
+    assert_eq!(resp["jsonrpc"], "2.0");
+    assert!(resp["id"].is_null());
+
+    let error = &resp["error"];
+    assert_eq!(error["code"], -32700);
+    assert!(error["message"].as_str().unwrap().contains("Parse error"));
+}
+
+#[test]
+fn unknown_method_returns_method_not_found() {
+    let resp = send(r#"{"jsonrpc":"2.0","id":99,"method":"nonexistent/method","params":{}}"#)
+        .expect("should return error response");
+
+    assert_eq!(resp["id"], 99);
+
+    let error = &resp["error"];
+    assert_eq!(error["code"], -32601);
+    assert!(error["message"]
+        .as_str()
+        .unwrap()
+        .contains("Method not found"));
+}
+
+#[test]
+fn invalid_jsonrpc_version_returns_error() {
+    let resp = send(r#"{"jsonrpc":"1.0","id":5,"method":"initialize","params":{}}"#)
+        .expect("should return error response");
+
+    assert_eq!(resp["id"], 5);
+    let error = &resp["error"];
+    assert_eq!(error["code"], -32600);
+}
+
+#[test]
+fn empty_line_returns_none() {
+    assert!(send("").is_none());
+    assert!(send("   ").is_none());
+}
+
+#[test]
+fn request_id_is_preserved() {
+    let resp_str = send(r#"{"jsonrpc":"2.0","id":"abc-123","method":"tools/list","params":{}}"#)
+        .expect("should return response");
+    assert_eq!(resp_str["id"], "abc-123");
+
+    let resp_num = send(r#"{"jsonrpc":"2.0","id":42,"method":"tools/list","params":{}}"#)
+        .expect("should return response");
+    assert_eq!(resp_num["id"], 42);
+}
+
+#[test]
+fn tools_have_valid_input_schemas() {
+    let resp = send(r#"{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}"#)
+        .expect("tools/list response");
+
+    let tools = resp["result"]["tools"].as_array().unwrap();
+    for tool in tools {
+        let schema = &tool["inputSchema"];
+        assert_eq!(
+            schema["type"], "object",
+            "inputSchema for {} should have type: object",
+            tool["name"]
+        );
+    }
+}
+
+#[test]
+fn multiple_requests_in_sequence() {
+    let r1 = send(r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}"#).unwrap();
+    assert!(r1["result"].is_object());
+
+    send(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);
+
+    let r2 = send(r#"{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}"#).unwrap();
+    assert!(r2["result"]["tools"].is_array());
+
+    let r3 = send(r#"{"jsonrpc":"2.0","id":3,"method":"resources/list","params":{}}"#).unwrap();
+    assert!(r3["result"]["resources"].is_array());
+}
+
+#[test]
+fn e2e_json_roundtrip() {
+    let input = json!({
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "initialize",
+        "params": {
+            "protocolVersion": "2025-03-26",
+            "capabilities": {},
+            "clientInfo": { "name": "test-client", "version": "1.0" }
+        }
+    });
+
+    let resp = send(&input.to_string()).unwrap();
+    assert_eq!(resp["result"]["protocolVersion"], "2025-03-26");
+    assert_eq!(resp["result"]["serverInfo"]["name"], "handoff-mcp");
+}

package/tests/storage_config.rs

@@ -0,0 +1,107 @@
+use handoff_mcp::storage::config::{read_config, write_config, Config};
+use std::fs;
+use tempfile::TempDir;
+
+fn setup() -> TempDir {
+    tempfile::tempdir().expect("failed to create temp dir")
+}
+
+#[test]
+fn write_and_read_config() {
+    let dir = setup();
+    let path = dir.path().join("config.toml");
+
+    let config = Config::new("test-project", "A test project");
+    write_config(&path, &config).unwrap();
+
+    let read_back = read_config(&path).unwrap();
+    assert_eq!(read_back.project.name, "test-project");
+    assert_eq!(
+        read_back.project.description.as_deref(),
+        Some("A test project")
+    );
+}
+
+#[test]
+fn config_has_correct_defaults() {
+    let dir = setup();
+    let path = dir.path().join("config.toml");
+
+    let config = Config::new("proj", "");
+    write_config(&path, &config).unwrap();
+
+    let read_back = read_config(&path).unwrap();
+    assert_eq!(read_back.settings.history_limit, 20);
+    assert_eq!(read_back.settings.done_task_limit, 10);
+    assert!(read_back.settings.auto_git_summary);
+    assert!(read_back.settings.context_files.is_empty());
+    assert_eq!(read_back.dashboard.scan_dirs, vec!["~/pro/"]);
+    assert!(read_back.dashboard.exclude_patterns.is_empty());
+    assert!(read_back.project.description.is_none());
+}
+
+#[test]
+fn config_with_custom_values() {
+    let dir = setup();
+    let path = dir.path().join("config.toml");
+
+    let toml_content = r#"
+[project]
+name = "custom-proj"
+description = "Custom"
+
+[settings]
+history_limit = 50
+done_task_limit = 5
+auto_git_summary = false
+context_files = ["README.md", "CLAUDE.md"]
+
+[dashboard]
+scan_dirs = ["~/work/", "~/projects/"]
+exclude_patterns = ["*/target", "*/node_modules"]
+"#;
+    fs::write(&path, toml_content).unwrap();
+
+    let config = read_config(&path).unwrap();
+    assert_eq!(config.project.name, "custom-proj");
+    assert_eq!(config.settings.history_limit, 50);
+    assert_eq!(config.settings.done_task_limit, 5);
+    assert!(!config.settings.auto_git_summary);
+    assert_eq!(config.settings.context_files.len(), 2);
+    assert_eq!(config.dashboard.scan_dirs.len(), 2);
+    assert_eq!(config.dashboard.exclude_patterns.len(), 2);
+}
+
+#[test]
+fn config_missing_file_returns_error() {
+    let dir = setup();
+    let path = dir.path().join("nonexistent.toml");
+    assert!(read_config(&path).is_err());
+}
+
+#[test]
+fn config_invalid_toml_returns_error() {
+    let dir = setup();
+    let path = dir.path().join("bad.toml");
+    fs::write(&path, "this is not valid toml [[[").unwrap();
+    assert!(read_config(&path).is_err());
+}
+
+#[test]
+fn config_partial_toml_uses_defaults() {
+    let dir = setup();
+    let path = dir.path().join("config.toml");
+    fs::write(
+        &path,
+        r#"
+[project]
+name = "minimal"
+"#,
+    )
+    .unwrap();
+
+    let config = read_config(&path).unwrap();
+    assert_eq!(config.project.name, "minimal");
+    assert_eq!(config.settings.history_limit, 20);
+    assert_eq!(config.dashboard.scan_dirs, vec!["~/pro/"]);
+}

package/tests/storage_sessions.rs

@@ -0,0 +1,195 @@
+use handoff_mcp::storage::sessions::*;
+use std::fs;
+use tempfile::TempDir;
+
+fn setup() -> TempDir {
+    tempfile::tempdir().expect("failed to create temp dir")
+}
+
+fn make_session(summary: &str, ended_at: &str) -> SessionData {
+    SessionData {
+        version: 2,
+        ended_at: Some(ended_at.to_string()),
+        summary: summary.to_string(),
+        branch: Some("main".to_string()),
+        commit: Some("abc1234".to_string()),
+        dirty_files: Vec::new(),
+        decisions: Vec::new(),
+        blockers: Vec::new(),
+        checklist: Vec::new(),
+        handoff_notes: Vec::new(),
+        references: Vec::new(),
+        context_pointers: Vec::new(),
+        environment: None,
+    }
+}
+
+#[test]
+fn write_active_session_creates_file() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let data = make_session("test session", "2026-06-13T14:30:00Z");
+    let path = write_active_session(&sessions_dir, &data).unwrap();
+
+    assert!(path.exists());
+    assert!(
+        path.to_string_lossy().ends_with(".active.json"),
+        "filename: {}",
+        path.display()
+    );
+
+    let content = fs::read_to_string(&path).unwrap();
+    let parsed: serde_json::Value = serde_json::from_str(&content).unwrap();
+    assert_eq!(parsed["summary"], "test session");
+    assert_eq!(parsed["version"], 2);
+}
+
+#[test]
+fn read_active_sessions_empty() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    assert!(sessions.is_empty());
+}
+
+#[test]
+fn read_active_sessions_returns_active_only() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("active one", "2026-06-13T10:00:00Z");
+    write_active_session(&sessions_dir, &s1).unwrap();
+
+    let s2 = make_session("active two", "2026-06-13T11:00:00Z");
+    write_active_session(&sessions_dir, &s2).unwrap();
+
+    fs::write(
+        sessions_dir.join("20260612-090000-old.closed.json"),
+        r#"{"version":2,"summary":"old closed","branch":"main","commit":"111"}"#,
+    )
+    .unwrap();
+
+    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 2);
+}
+
+#[test]
+fn close_active_sessions_renames_to_closed() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let active_path = write_active_session(&sessions_dir, &s1).unwrap();
+
+    let closed = close_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(closed.len(), 1);
+    assert!(!active_path.exists());
+    assert!(closed[0].exists());
+    assert!(closed[0].to_string_lossy().contains(".closed.json"));
+}
+
+#[test]
+fn close_active_then_create_new() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("first session", "2026-06-13T10:00:00Z");
+    write_active_session(&sessions_dir, &s1).unwrap();
+
+    close_active_sessions(&sessions_dir).unwrap();
+
+    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
+    write_active_session(&sessions_dir, &s2).unwrap();
+
+    let active = read_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(active.len(), 1);
+    assert_eq!(active[0].summary, "second session");
+}
+
+#[test]
+fn enforce_history_limit_removes_oldest() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    for i in 1..=5 {
+        let name = format!("20260610-{i:06}-s{i}.closed.json");
+        fs::write(
+            sessions_dir.join(&name),
+            format!(r#"{{"version":2,"summary":"session {i}"}}"#),
+        )
+        .unwrap();
+    }
+
+    let removed = enforce_history_limit(&sessions_dir, 3).unwrap();
+    assert_eq!(removed, 2);
+
+    let remaining: Vec<_> = fs::read_dir(&sessions_dir)
+        .unwrap()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_name().to_string_lossy().ends_with(".closed.json"))
+        .collect();
+    assert_eq!(remaining.len(), 3);
+}
+
+#[test]
+fn enforce_history_limit_ignores_active() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    for i in 1..=3 {
+        let name = format!("20260610-{i:06}-s{i}.closed.json");
+        fs::write(
+            sessions_dir.join(&name),
+            format!(r#"{{"version":2,"summary":"closed {i}"}}"#),
+        )
+        .unwrap();
+    }
+
+    let s = make_session("active", "2026-06-13T10:00:00Z");
+    write_active_session(&sessions_dir, &s).unwrap();
+
+    enforce_history_limit(&sessions_dir, 2).unwrap();
+
+    let active = read_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(active.len(), 1);
+}
+
+#[test]
+fn enforce_history_limit_under_limit_removes_nothing() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    fs::write(
+        sessions_dir.join("20260610-000001-s1.closed.json"),
+        r#"{"version":2,"summary":"s1"}"#,
+    )
+    .unwrap();
+
+    let removed = enforce_history_limit(&sessions_dir, 5).unwrap();
+    assert_eq!(removed, 0);
+}
+
+#[test]
+fn generate_session_filename_format() {
+    let name = generate_session_filename("Pattern run fix", "20260613-143000");
+    assert!(name.starts_with("20260613-143000-"));
+    assert!(name.contains("pattern-run-fix"));
+}
+
+#[test]
+fn read_active_sessions_nonexistent_dir() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("nonexistent");
+    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    assert!(sessions.is_empty());
+}