handoff-mcp-server 0.7.0 → 0.7.2

package/tests/storage_tasks.rs

@@ -1,339 +0,0 @@
-use handoff_mcp::storage::tasks::*;
-use std::fs;
-use tempfile::TempDir;
-
-fn setup() -> TempDir {
-    tempfile::tempdir().expect("failed to create temp dir")
-}
-
-fn create_task_dir(base: &std::path::Path, dir_name: &str, status: &str, data: &TaskData) {
-    let dir = base.join(dir_name);
-    fs::create_dir_all(&dir).unwrap();
-    write_task(&dir, status, data).unwrap();
-}
-
-fn make_task(id: &str, title: &str) -> TaskData {
-    TaskData {
-        id: id.to_string(),
-        title: title.to_string(),
-        notes: None,
-        priority: None,
-        created_at: None,
-        updated_at: None,
-        completed_at: None,
-        labels: Vec::new(),
-        links: Vec::new(),
-        done_criteria: Vec::new(),
-        schedule: None,
-        dependencies: Vec::new(),
-        order: None,
-    }
-}
-
-#[test]
-fn write_and_read_task() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    let data = make_task("t1", "Test task");
-    write_task(&task_dir, "todo", &data).unwrap();
-
-    let (read_data, status) = read_task(&task_dir).unwrap().unwrap();
-    assert_eq!(read_data.id, "t1");
-    assert_eq!(read_data.title, "Test task");
-    assert_eq!(status, "todo");
-}
-
-#[test]
-fn change_task_status() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    let data = make_task("t1", "Test");
-    write_task(&task_dir, "todo", &data).unwrap();
-
-    change_status(&task_dir, "in_progress").unwrap();
-
-    let (_, status) = read_task(&task_dir).unwrap().unwrap();
-    assert_eq!(status, "in_progress");
-
-    assert!(!task_dir.join("_task.todo.json").exists());
-    assert!(task_dir.join("_task.in_progress.json").exists());
-}
-
-#[test]
-fn change_to_same_status_is_noop() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    let data = make_task("t1", "Test");
-    write_task(&task_dir, "todo", &data).unwrap();
-
-    change_status(&task_dir, "todo").unwrap();
-    let (_, status) = read_task(&task_dir).unwrap().unwrap();
-    assert_eq!(status, "todo");
-}
-
-#[test]
-fn invalid_status_returns_error() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    let data = make_task("t1", "Test");
-    write_task(&task_dir, "todo", &data).unwrap();
-
-    assert!(change_status(&task_dir, "invalid_status").is_err());
-}
-
-#[test]
-fn next_top_level_id_empty() {
-    let dir = setup();
-    let tasks_dir = dir.path().join("tasks");
-    fs::create_dir_all(&tasks_dir).unwrap();
-
-    assert_eq!(next_top_level_id(&tasks_dir).unwrap(), "t1");
-}
-
-#[test]
-fn next_top_level_id_with_existing() {
-    let dir = setup();
-    let tasks_dir = dir.path().join("tasks");
-    fs::create_dir_all(tasks_dir.join("t1-first")).unwrap();
-    fs::create_dir_all(tasks_dir.join("t3-third")).unwrap();
-
-    assert_eq!(next_top_level_id(&tasks_dir).unwrap(), "t4");
-}
-
-#[test]
-fn next_child_id_empty_parent() {
-    let dir = setup();
-    let parent_dir = dir.path().join("tasks/t1-parent");
-    fs::create_dir_all(&parent_dir).unwrap();
-
-    assert_eq!(next_child_id(&parent_dir, "t1").unwrap(), "t1.1");
-}
-
-#[test]
-fn next_child_id_with_existing_children() {
-    let dir = setup();
-    let parent_dir = dir.path().join("tasks/t1-parent");
-    fs::create_dir_all(parent_dir.join("t1.1-first")).unwrap();
-    fs::create_dir_all(parent_dir.join("t1.2-second")).unwrap();
-
-    assert_eq!(next_child_id(&parent_dir, "t1").unwrap(), "t1.3");
-}
-
-#[test]
-fn title_to_slug_basic() {
-    assert_eq!(title_to_slug("Hello World"), "hello-world");
-    assert_eq!(title_to_slug("P0: SM_RESTART"), "p0-sm-restart");
-    assert_eq!(title_to_slug("  Multiple   Spaces  "), "multiple-spaces");
-}
-
-#[test]
-fn title_to_slug_empty() {
-    assert_eq!(title_to_slug(""), "task");
-}
-
-#[test]
-fn find_task_dir_by_id_finds_nested() {
-    let dir = setup();
-    let tasks_dir = dir.path().join("tasks");
-    let nested = tasks_dir.join("t1-parent/t1.1-child");
-    fs::create_dir_all(&nested).unwrap();
-    write_task(&nested, "todo", &make_task("t1.1", "child")).unwrap();
-
-    let found = find_task_dir_by_id(&tasks_dir, "t1.1").unwrap();
-    assert!(found.is_some());
-    assert!(found.unwrap().ends_with("t1.1-child"));
-}
-
-#[test]
-fn find_task_dir_by_id_not_found() {
-    let dir = setup();
-    let tasks_dir = dir.path().join("tasks");
-    fs::create_dir_all(&tasks_dir).unwrap();
-
-    assert!(find_task_dir_by_id(&tasks_dir, "t99").unwrap().is_none());
-}
-
-#[test]
-fn build_task_index_basic() {
-    let dir = setup();
-    let tasks_dir = dir.path().join("tasks");
-
-    create_task_dir(
-        &tasks_dir,
-        "t1-parent",
-        "in_progress",
-        &make_task("t1", "Parent"),
-    );
-    create_task_dir(
-        &tasks_dir.join("t1-parent"),
-        "t1.1-child",
-        "done",
-        &make_task("t1.1", "Child Done"),
-    );
-    create_task_dir(&tasks_dir, "t2-other", "todo", &make_task("t2", "Other"));
-
-    let (tree, summary) = build_task_index(&tasks_dir, 10).unwrap();
-    assert_eq!(summary.total, 3);
-    assert_eq!(*summary.by_status.get("in_progress").unwrap_or(&0), 1);
-    assert_eq!(*summary.by_status.get("done").unwrap_or(&0), 1);
-    assert_eq!(*summary.by_status.get("todo").unwrap_or(&0), 1);
-
-    assert_eq!(tree.len(), 2);
-    let t1 = tree.iter().find(|t| t.id == "t1").unwrap();
-    assert_eq!(t1.children.len(), 1);
-    assert_eq!(t1.children[0].id, "t1.1");
-}
-
-#[test]
-fn build_task_index_done_limit() {
-    let dir = setup();
-    let tasks_dir = dir.path().join("tasks");
-
-    for i in 1..=5 {
-        create_task_dir(
-            &tasks_dir,
-            &format!("t{i}-task-{i}"),
-            "done",
-            &make_task(&format!("t{i}"), &format!("Task {i}")),
-        );
-    }
-
-    let (tree, summary) = build_task_index(&tasks_dir, 3).unwrap();
-    assert_eq!(summary.total, 5);
-    assert_eq!(*summary.by_status.get("done").unwrap(), 5);
-    assert_eq!(tree.len(), 3);
-}
-
-#[test]
-fn validate_done_unchecked_criteria_fails() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    let data = TaskData {
-        done_criteria: vec![
-            DoneCriterion {
-                item: "test passes".to_string(),
-                checked: true,
-            },
-            DoneCriterion {
-                item: "review done".to_string(),
-                checked: false,
-            },
-        ],
-        ..make_task("t1", "Test")
-    };
-
-    assert!(validate_done_transition(&task_dir, &data).is_err());
-}
-
-#[test]
-fn validate_done_all_checked_passes() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    let data = TaskData {
-        done_criteria: vec![DoneCriterion {
-            item: "test passes".to_string(),
-            checked: true,
-        }],
-        ..make_task("t1", "Test")
-    };
-
-    assert!(validate_done_transition(&task_dir, &data).is_ok());
-}
-
-#[test]
-fn validate_done_child_not_terminal_fails() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    create_task_dir(
-        &task_dir,
-        "t1.1-child",
-        "in_progress",
-        &make_task("t1.1", "Child"),
-    );
-
-    let data = make_task("t1", "Parent");
-    assert!(validate_done_transition(&task_dir, &data).is_err());
-}
-
-#[test]
-fn validate_done_child_all_terminal_passes() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    create_task_dir(
-        &task_dir,
-        "t1.1-child-a",
-        "done",
-        &make_task("t1.1", "Child A"),
-    );
-    create_task_dir(
-        &task_dir,
-        "t1.2-child-b",
-        "skipped",
-        &make_task("t1.2", "Child B"),
-    );
-
-    let data = make_task("t1", "Parent");
-    assert!(validate_done_transition(&task_dir, &data).is_ok());
-}
-
-#[test]
-fn validate_skipped_child_not_terminal_fails() {
-    let dir = setup();
-    let task_dir = dir.path().join("t1-test");
-    fs::create_dir_all(&task_dir).unwrap();
-
-    create_task_dir(&task_dir, "t1.1-child", "todo", &make_task("t1.1", "Child"));
-
-    let data = make_task("t1", "Parent");
-    assert!(validate_skipped_transition(&task_dir, &data).is_err());
-}
-
-#[test]
-fn is_valid_priority_accepts_valid() {
-    assert!(is_valid_priority("low"));
-    assert!(is_valid_priority("medium"));
-    assert!(is_valid_priority("high"));
-}
-
-#[test]
-fn is_valid_priority_rejects_invalid() {
-    assert!(!is_valid_priority("critical"));
-    assert!(!is_valid_priority("urgent"));
-    assert!(!is_valid_priority(""));
-    assert!(!is_valid_priority("HIGH"));
-}
-
-#[test]
-fn validate_priority_none_is_ok() {
-    assert!(validate_priority(None).is_ok());
-}
-
-#[test]
-fn validate_priority_valid_is_ok() {
-    assert!(validate_priority(Some("low")).is_ok());
-    assert!(validate_priority(Some("medium")).is_ok());
-    assert!(validate_priority(Some("high")).is_ok());
-}
-
-#[test]
-fn validate_priority_invalid_is_err() {
-    let err = validate_priority(Some("critical")).unwrap_err();
-    assert!(err.to_string().contains("Invalid priority"));
-    assert!(err.to_string().contains("critical"));
-}

package/tests/tool_dashboard.rs

@@ -1,165 +0,0 @@
-use serde_json::{json, Value};
-use std::fs;
-use tempfile::TempDir;
-
-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"))
-}
-
-fn call_tool(name: &str, arguments: Value) -> Value {
-    let req = json!({
-        "jsonrpc": "2.0", "id": 1,
-        "method": "tools/call",
-        "params": { "name": name, "arguments": arguments }
-    });
-    send(&req.to_string()).unwrap()
-}
-
-fn get_text(resp: &Value) -> String {
-    resp["result"]["content"][0]["text"]
-        .as_str()
-        .unwrap_or("")
-        .to_string()
-}
-
-fn is_error(resp: &Value) -> bool {
-    resp["result"]["isError"].as_bool().unwrap_or(false)
-}
-
-fn init_project(base: &std::path::Path, name: &str) {
-    let project_dir = base.join(name);
-    fs::create_dir_all(&project_dir).unwrap();
-
-    let req = json!({
-        "jsonrpc": "2.0", "id": 0,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": project_dir.to_string_lossy(),
-                "project_name": name
-            }
-        }
-    });
-    send(&req.to_string()).unwrap();
-}
-
-fn setup_scan_dir() -> TempDir {
-    tempfile::tempdir().expect("failed to create temp dir")
-}
-
-#[test]
-fn dashboard_multiple_projects() {
-    let scan_dir = setup_scan_dir();
-
-    init_project(scan_dir.path(), "project-a");
-    init_project(scan_dir.path(), "project-b");
-
-    let resp = call_tool(
-        "handoff_dashboard",
-        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
-    );
-
-    assert!(!is_error(&resp), "error: {}", get_text(&resp));
-    let text = get_text(&resp);
-    let parsed: Value = serde_json::from_str(&text).unwrap();
-
-    let projects = parsed["projects"].as_array().unwrap();
-    assert_eq!(projects.len(), 2);
-
-    let names: Vec<&str> = projects
-        .iter()
-        .map(|p| p["name"].as_str().unwrap())
-        .collect();
-    assert!(names.contains(&"project-a"));
-    assert!(names.contains(&"project-b"));
-}
-
-#[test]
-fn dashboard_skips_non_handoff_dirs() {
-    let scan_dir = setup_scan_dir();
-
-    init_project(scan_dir.path(), "real-project");
-    fs::create_dir_all(scan_dir.path().join("not-a-project")).unwrap();
-
-    let resp = call_tool(
-        "handoff_dashboard",
-        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
-    );
-
-    let text = get_text(&resp);
-    let parsed: Value = serde_json::from_str(&text).unwrap();
-    let projects = parsed["projects"].as_array().unwrap();
-    assert_eq!(projects.len(), 1);
-}
-
-#[test]
-fn dashboard_with_tasks() {
-    let scan_dir = setup_scan_dir();
-    init_project(scan_dir.path(), "proj-tasks");
-
-    let pd = scan_dir
-        .path()
-        .join("proj-tasks")
-        .to_string_lossy()
-        .to_string();
-
-    call_tool(
-        "handoff_update_task",
-        json!({
-            "project_dir": &pd,
-            "task": { "title": "Task 1", "status": "in_progress" }
-        }),
-    );
-    call_tool(
-        "handoff_update_task",
-        json!({
-            "project_dir": &pd,
-            "task": { "title": "Task 2", "status": "blocked", "notes": "Waiting" }
-        }),
-    );
-
-    let resp = call_tool(
-        "handoff_dashboard",
-        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
-    );
-
-    let text = get_text(&resp);
-    let parsed: Value = serde_json::from_str(&text).unwrap();
-
-    assert_eq!(parsed["total_active_tasks"], 1);
-    assert_eq!(parsed["total_blocked"], 1);
-
-    let proj = &parsed["projects"][0];
-    assert_eq!(proj["active_tasks"], 1);
-    assert_eq!(proj["blocked_tasks"], 1);
-}
-
-#[test]
-fn dashboard_empty_scan_dir() {
-    let scan_dir = setup_scan_dir();
-
-    let resp = call_tool(
-        "handoff_dashboard",
-        json!({ "scan_dirs": [scan_dir.path().to_string_lossy()] }),
-    );
-
-    let text = get_text(&resp);
-    let parsed: Value = serde_json::from_str(&text).unwrap();
-    assert!(parsed["projects"].as_array().unwrap().is_empty());
-    assert_eq!(parsed["total_active_tasks"], 0);
-}
-
-#[test]
-fn dashboard_nonexistent_scan_dir() {
-    let resp = call_tool(
-        "handoff_dashboard",
-        json!({ "scan_dirs": ["/nonexistent/path/that/does/not/exist"] }),
-    );
-
-    assert!(!is_error(&resp));
-    let text = get_text(&resp);
-    let parsed: Value = serde_json::from_str(&text).unwrap();
-    assert!(parsed["projects"].as_array().unwrap().is_empty());
-}