handoff-mcp-server 0.7.0 → 0.7.2

package/tests/tool_import_context.rs

@@ -1,443 +0,0 @@
-use serde_json::{json, Value};
-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 setup_project() -> TempDir {
-    let dir = tempfile::tempdir().expect("failed to create temp dir");
-
-    std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(dir.path())
-        .output()
-        .unwrap();
-    std::process::Command::new("git")
-        .args(["commit", "--allow-empty", "-m", "init"])
-        .current_dir(dir.path())
-        .output()
-        .unwrap();
-
-    let req = json!({
-        "jsonrpc": "2.0", "id": 0,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": dir.path().to_string_lossy(),
-                "project_name": "test"
-            }
-        }
-    });
-    send(&req.to_string()).unwrap();
-    dir
-}
-
-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()
-}
-
-#[test]
-fn import_source_only() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": {
-                "description": "test import",
-                "format": "markdown"
-            }
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Import complete"));
-    assert!(text.contains("Tasks created: 0"));
-}
-
-#[test]
-fn import_flat_tasks() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "flat task import" },
-            "tasks": [
-                { "title": "Task A", "status": "todo" },
-                { "title": "Task B", "status": "in_progress", "priority": "high" }
-            ]
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Tasks created: 2"));
-    assert!(text.contains("2 top-level"));
-    assert!(text.contains("0 nested"));
-
-    let list_resp = call_tool(
-        "handoff_list_tasks",
-        json!({ "project_dir": dir.path().to_string_lossy() }),
-    );
-    let list_text = get_text(&list_resp);
-    assert!(list_text.contains("Task A"));
-    assert!(list_text.contains("Task B"));
-}
-
-#[test]
-fn import_nested_tasks() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "nested import" },
-            "tasks": [
-                {
-                    "title": "Parent",
-                    "status": "in_progress",
-                    "children": [
-                        { "title": "Child 1", "status": "done" },
-                        {
-                            "title": "Child 2",
-                            "status": "todo",
-                            "children": [
-                                { "title": "Grandchild", "status": "todo" }
-                            ]
-                        }
-                    ]
-                }
-            ]
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Tasks created: 4"));
-    assert!(text.contains("1 top-level"));
-    assert!(text.contains("3 nested"));
-
-    let list_resp = call_tool(
-        "handoff_list_tasks",
-        json!({ "project_dir": dir.path().to_string_lossy() }),
-    );
-    let list_text = get_text(&list_resp);
-    assert!(list_text.contains("Parent"));
-    assert!(list_text.contains("Child 1"));
-    assert!(list_text.contains("Child 2"));
-    assert!(list_text.contains("Grandchild"));
-}
-
-#[test]
-fn import_with_session() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "session import" },
-            "session": {
-                "summary": "[import] test session",
-                "decisions": [
-                    { "decision": "Use OAuth2", "reason": "mobile support", "confidence": "confirmed" }
-                ],
-                "blockers": ["waiting on API key"],
-                "handoff_notes": [
-                    { "note": "check auth flow", "category": "caution" }
-                ]
-            }
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Session saved: yes"));
-
-    let load_resp = call_tool(
-        "handoff_load_context",
-        json!({ "project_dir": dir.path().to_string_lossy() }),
-    );
-    let load_text = get_text(&load_resp);
-    assert!(load_text.contains("[import] test session"));
-    assert!(load_text.contains("Use OAuth2"));
-    assert!(load_text.contains("waiting on API key"));
-}
-
-#[test]
-fn import_with_raw_notes() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "raw notes import" },
-            "session": {
-                "summary": "[import] with raw notes"
-            },
-            "raw_notes": "Deploy on Fridays is forbidden\nSSL cert expires 7/1"
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Raw notes: saved as handoff_note"));
-
-    let load_resp = call_tool(
-        "handoff_load_context",
-        json!({ "project_dir": dir.path().to_string_lossy() }),
-    );
-    let load_text = get_text(&load_resp);
-    assert!(load_text.contains("Deploy on Fridays is forbidden"));
-}
-
-#[test]
-fn import_raw_notes_without_session_creates_auto_session() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "auto session test" },
-            "raw_notes": "Some unstructured notes"
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Session saved: yes"));
-    assert!(text.contains("Raw notes: saved as handoff_note"));
-
-    let load_resp = call_tool(
-        "handoff_load_context",
-        json!({ "project_dir": dir.path().to_string_lossy() }),
-    );
-    let load_text = get_text(&load_resp);
-    assert!(load_text.contains("[import] auto session test"));
-    assert!(load_text.contains("Some unstructured notes"));
-}
-
-#[test]
-fn import_full_scenario() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": {
-                "description": "tmp/260601-sprint-handoff.md",
-                "format": "markdown"
-            },
-            "tasks": [
-                {
-                    "title": "Auth renewal",
-                    "status": "in_progress",
-                    "priority": "high",
-                    "labels": ["auth"],
-                    "children": [
-                        { "title": "Session migration", "status": "done" },
-                        { "title": "PKCE implementation", "status": "in_progress" }
-                    ]
-                },
-                {
-                    "title": "CI speedup",
-                    "status": "todo",
-                    "priority": "medium",
-                    "done_criteria": [
-                        { "item": "Build time under 5min", "checked": false }
-                    ]
-                }
-            ],
-            "session": {
-                "summary": "[import] Sprint handoff migration",
-                "decisions": [
-                    { "decision": "OAuth2 + PKCE", "confidence": "confirmed" }
-                ],
-                "blockers": ["DB migration window TBD"],
-                "references": [
-                    { "label": "Original doc", "uri": "tmp/260601-sprint-handoff.md", "type": "doc" }
-                ],
-                "context_pointers": [
-                    { "path": "src/auth/oauth.rs", "reason": "PKCE core" }
-                ]
-            },
-            "raw_notes": "Deploy on Fridays is forbidden"
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Tasks created: 4"));
-    assert!(text.contains("2 top-level"));
-    assert!(text.contains("2 nested"));
-    assert!(text.contains("Session saved: yes"));
-    assert!(text.contains("Raw notes: saved as handoff_note"));
-}
-
-#[test]
-fn import_without_source_fails() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "tasks": [{ "title": "Something" }]
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Error"));
-    assert!(text.contains("source"));
-}
-
-#[test]
-fn import_task_without_title_fails() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "bad task" },
-            "tasks": [{ "status": "todo" }]
-        }),
-    );
-    let text = get_text(&resp);
-    assert!(text.contains("Error"));
-    assert!(text.contains("title"));
-}
-
-#[test]
-fn import_preserves_existing_tasks() {
-    let dir = setup_project();
-
-    call_tool(
-        "handoff_update_task",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "task": { "title": "Pre-existing task", "status": "in_progress" }
-        }),
-    );
-
-    call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "import after existing" },
-            "tasks": [
-                { "title": "Imported task", "status": "todo" }
-            ]
-        }),
-    );
-
-    let list_resp = call_tool(
-        "handoff_list_tasks",
-        json!({ "project_dir": dir.path().to_string_lossy() }),
-    );
-    let list_text = get_text(&list_resp);
-    assert!(list_text.contains("Pre-existing task"));
-    assert!(list_text.contains("Imported task"));
-}
-
-#[test]
-fn import_source_recorded_in_environment() {
-    let dir = setup_project();
-    call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": {
-                "description": "my-handoff.md",
-                "format": "markdown"
-            },
-            "session": {
-                "summary": "[import] env test"
-            }
-        }),
-    );
-
-    let sessions_dir = dir.path().join(".handoff/sessions");
-    let entries: Vec<_> = std::fs::read_dir(&sessions_dir)
-        .unwrap()
-        .filter_map(|e| e.ok())
-        .filter(|e| e.file_name().to_string_lossy().ends_with(".open.json"))
-        .collect();
-    assert_eq!(entries.len(), 1);
-
-    let content = std::fs::read_to_string(entries[0].path()).unwrap();
-    let session: serde_json::Value = serde_json::from_str(&content).unwrap();
-    assert_eq!(
-        session["environment"]["import_source"]["description"],
-        "my-handoff.md"
-    );
-    assert_eq!(
-        session["environment"]["import_source"]["format"],
-        "markdown"
-    );
-}
-
-fn is_error(resp: &Value) -> bool {
-    resp["result"]["isError"].as_bool().unwrap_or(false)
-}
-
-#[test]
-fn import_invalid_priority_rejected() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "bad priority import" },
-            "tasks": [
-                { "title": "Task", "priority": "urgent" }
-            ]
-        }),
-    );
-    assert!(is_error(&resp));
-    let text = get_text(&resp);
-    assert!(text.contains("Invalid priority"));
-}
-
-#[test]
-fn import_valid_priorities_accepted() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "valid priorities" },
-            "tasks": [
-                { "title": "Low", "priority": "low" },
-                { "title": "Medium", "priority": "medium" },
-                { "title": "High", "priority": "high" }
-            ]
-        }),
-    );
-    assert!(!is_error(&resp), "error: {}", get_text(&resp));
-    let text = get_text(&resp);
-    assert!(text.contains("Tasks created: 3"));
-}
-
-#[test]
-fn import_invalid_priority_in_child_rejected() {
-    let dir = setup_project();
-    let resp = call_tool(
-        "handoff_import_context",
-        json!({
-            "project_dir": dir.path().to_string_lossy(),
-            "source": { "description": "bad child priority" },
-            "tasks": [
-                {
-                    "title": "Parent",
-                    "priority": "high",
-                    "children": [
-                        { "title": "Child", "priority": "ASAP" }
-                    ]
-                }
-            ]
-        }),
-    );
-    assert!(is_error(&resp));
-    let text = get_text(&resp);
-    assert!(text.contains("Invalid priority"));
-}

package/tests/tool_init.rs

@@ -1,176 +0,0 @@
-use serde_json::{json, Value};
-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 setup() -> TempDir {
-    tempfile::tempdir().expect("failed to create temp dir")
-}
-
-#[test]
-fn init_creates_handoff_directory() {
-    let dir = setup();
-    let project_dir = dir.path().to_string_lossy();
-
-    let req = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": project_dir,
-                "project_name": "test-project",
-                "description": "A test project"
-            }
-        }
-    });
-
-    let resp = send(&req.to_string()).expect("should return response");
-    assert_eq!(resp["id"], 1);
-    assert!(resp["error"].is_null(), "error: {:?}", resp["error"]);
-
-    let content = &resp["result"]["content"][0]["text"];
-    assert!(
-        content.as_str().unwrap().contains("test-project"),
-        "response: {content}"
-    );
-
-    let handoff = dir.path().join(".handoff");
-    assert!(handoff.exists());
-    assert!(handoff.join("config.toml").exists());
-    assert!(handoff.join("sessions").is_dir());
-    assert!(handoff.join("tasks").is_dir());
-
-    let config_content = std::fs::read_to_string(handoff.join("config.toml")).unwrap();
-    assert!(config_content.contains("test-project"));
-    assert!(config_content.contains("A test project"));
-}
-
-#[test]
-fn init_double_init_returns_error() {
-    let dir = setup();
-    let project_dir = dir.path().to_string_lossy();
-
-    let req = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": project_dir,
-                "project_name": "test-project"
-            }
-        }
-    });
-
-    send(&req.to_string()).unwrap();
-
-    let req2 = json!({
-        "jsonrpc": "2.0",
-        "id": 2,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": project_dir,
-                "project_name": "test-project"
-            }
-        }
-    });
-
-    let resp = send(&req2.to_string()).unwrap();
-    let content = &resp["result"]["content"][0]["text"];
-    assert!(content.as_str().unwrap().contains("already"));
-    assert_eq!(resp["result"]["isError"], true);
-}
-
-#[test]
-fn init_without_project_name_returns_error() {
-    let dir = setup();
-    let project_dir = dir.path().to_string_lossy();
-
-    let req = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": project_dir
-            }
-        }
-    });
-
-    let resp = send(&req.to_string()).unwrap();
-    assert_eq!(resp["result"]["isError"], true);
-}
-
-#[test]
-fn init_config_has_defaults() {
-    let dir = setup();
-    let project_dir = dir.path().to_string_lossy();
-
-    let req = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {
-            "name": "handoff_init",
-            "arguments": {
-                "project_dir": project_dir,
-                "project_name": "defaults-test"
-            }
-        }
-    });
-
-    send(&req.to_string()).unwrap();
-
-    let config =
-        handoff_mcp::storage::config::read_config(&dir.path().join(".handoff/config.toml"))
-            .unwrap();
-
-    assert_eq!(config.project.name, "defaults-test");
-    assert_eq!(config.settings.history_limit, 20);
-    assert_eq!(config.settings.done_task_limit, 10);
-    assert!(config.settings.auto_git_summary);
-}
-
-#[test]
-fn tools_call_unknown_tool_returns_error() {
-    let req = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {
-            "name": "nonexistent_tool",
-            "arguments": {}
-        }
-    });
-
-    let resp = send(&req.to_string()).unwrap();
-    assert_eq!(resp["result"]["isError"], true);
-    assert!(resp["result"]["content"][0]["text"]
-        .as_str()
-        .unwrap()
-        .contains("not implemented"));
-}
-
-#[test]
-fn tools_call_missing_name_returns_error() {
-    let req = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {
-            "arguments": {}
-        }
-    });
-
-    let resp = send(&req.to_string()).unwrap();
-    assert!(resp["error"].is_object());
-}