test(cli): add fixture-driven mcp diagnose coverage

rexleimo · rexleimo · commit 0609812ba55e · 2026-04-07T00:19:57.000+08:00
diff --git a/crates/loopforge-cli/src/dispatch/mcp/diagnose.rs b/crates/loopforge-cli/src/dispatch/mcp/diagnose.rs
@@ -8,6 +8,15 @@ use super::json::{build_mcp_diagnose_json, normalize_json_string};
 use super::tools::list_remote_tool_names;
 use crate::runtime_env;
 
+pub(super) struct McpDiagnoseData {
+    pub(super) sanitized_config: Value,
+    pub(super) servers_raw: String,
+    pub(super) servers_json: Value,
+    pub(super) tool_names: Vec<String>,
+    pub(super) resources_json: Option<Value>,
+    pub(super) prompts_json: Option<Value>,
+}
+
 pub(super) async fn run_diagnose(
     workspace: PathBuf,
     session: Option<String>,
@@ -43,45 +52,24 @@ pub(super) async fn run_diagnose(
         }
     };
 
-    let parsed_config: Value =
-        serde_json::from_str(&raw_config).context("parse mcp config JSON")?;
-    let sanitized_config = sanitize_mcp_config(&parsed_config);
-
-    let mut tools =
-        rexos::tools::Toolset::new_with_security_config(workspace.clone(), cfg.security.clone())?;
-    tools
-        .enable_mcp_from_json(&raw_config)
-        .await
-        .context("connect mcp servers")?;
-
-    let servers_raw = tools.call("mcp_servers_list", r#"{}"#).await?;
-    let servers_json: Value =
-        serde_json::from_str(&servers_raw).context("decode mcp_servers_list output")?;
-    let tool_names = list_remote_tool_names(&tools);
-
-    let resources_json = if resources {
-        let out = tools.call("mcp_resources_list", r#"{}"#).await?;
-        Some(serde_json::from_str(&out).context("decode mcp_resources_list output")?)
-    } else {
-        None
-    };
-
-    let prompts_json = if prompts {
-        let out = tools.call("mcp_prompts_list", r#"{}"#).await?;
-        Some(serde_json::from_str(&out).context("decode mcp_prompts_list output")?)
-    } else {
-        None
-    };
+    let data = collect_mcp_diagnose_data(
+        workspace.clone(),
+        &raw_config,
+        cfg.security.clone(),
+        resources,
+        prompts,
+    )
+    .await?;
 
     if json {
         let out = build_mcp_diagnose_json(
             &workspace,
             &session_id,
-            sanitized_config,
-            servers_json,
-            tool_names,
-            resources_json,
-            prompts_json,
+            data.sanitized_config,
+            data.servers_json,
+            data.tool_names,
+            data.resources_json,
+            data.prompts_json,
         )?;
         println!("{}", serde_json::to_string_pretty(&out)?);
         return Ok(());
@@ -96,7 +84,8 @@ pub(super) async fn run_diagnose(
     } else {
         println!("config_source: session");
     }
-    if let Some(servers) = sanitized_config
+    if let Some(servers) = data
+        .sanitized_config
         .get("servers")
         .and_then(|v| v.as_object())
         .map(|obj| obj.keys().cloned().collect::<Vec<_>>())
@@ -106,18 +95,63 @@ pub(super) async fn run_diagnose(
         }
     }
     println!();
-    println!("servers: {}", servers_raw.trim());
-    println!("remote_tools: {} tool(s)", tool_names.len());
-    for name in tool_names {
+    println!("servers: {}", data.servers_raw.trim());
+    println!("remote_tools: {} tool(s)", data.tool_names.len());
+    for name in data.tool_names {
         println!("- {name}");
     }
-    if let Some(v) = resources_json {
+    if let Some(v) = data.resources_json {
         println!();
         println!("resources_list: {}", serde_json::to_string_pretty(&v)?);
     }
-    if let Some(v) = prompts_json {
+    if let Some(v) = data.prompts_json {
         println!();
         println!("prompts_list: {}", serde_json::to_string_pretty(&v)?);
     }
     Ok(())
 }
+
+pub(super) async fn collect_mcp_diagnose_data(
+    workspace: PathBuf,
+    raw_config: &str,
+    security: rexos::security::SecurityConfig,
+    resources: bool,
+    prompts: bool,
+) -> anyhow::Result<McpDiagnoseData> {
+    let parsed_config: Value = serde_json::from_str(raw_config).context("parse mcp config JSON")?;
+    let sanitized_config = sanitize_mcp_config(&parsed_config);
+
+    let mut tools = rexos::tools::Toolset::new_with_security_config(workspace, security)?;
+    tools
+        .enable_mcp_from_json(raw_config)
+        .await
+        .context("connect mcp servers")?;
+
+    let servers_raw = tools.call("mcp_servers_list", r#"{}"#).await?;
+    let servers_json: Value =
+        serde_json::from_str(&servers_raw).context("decode mcp_servers_list output")?;
+    let tool_names = list_remote_tool_names(&tools);
+
+    let resources_json = if resources {
+        let out = tools.call("mcp_resources_list", r#"{}"#).await?;
+        Some(serde_json::from_str(&out).context("decode mcp_resources_list output")?)
+    } else {
+        None
+    };
+
+    let prompts_json = if prompts {
+        let out = tools.call("mcp_prompts_list", r#"{}"#).await?;
+        Some(serde_json::from_str(&out).context("decode mcp_prompts_list output")?)
+    } else {
+        None
+    };
+
+    Ok(McpDiagnoseData {
+        sanitized_config,
+        servers_raw,
+        servers_json,
+        tool_names,
+        resources_json,
+        prompts_json,
+    })
+}
diff --git a/crates/loopforge-cli/src/dispatch/mcp/tests.rs b/crates/loopforge-cli/src/dispatch/mcp/tests.rs
@@ -1,5 +1,108 @@
 use super::super::mcp_sanitize::sanitize_mcp_config;
+use super::diagnose::collect_mcp_diagnose_data;
 use super::json::{build_mcp_diagnose_json, normalize_json_string};
+use std::path::Path;
+
+const MCP_STUB_PY: &str = r#"
+import json
+import sys
+
+def send(obj):
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+for line in sys.stdin:
+    line = line.strip()
+    if not line:
+        continue
+    try:
+        msg = json.loads(line)
+    except Exception:
+        continue
+
+    method = msg.get("method")
+    if not method:
+        continue
+
+    # Notifications have no id; ignore them.
+    if "id" not in msg:
+        continue
+
+    msg_id = msg.get("id")
+    params = msg.get("params") or {}
+
+    if method == "initialize":
+        send({"jsonrpc": "2.0", "id": msg_id, "result": {}})
+    elif method == "tools/list":
+        send({
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "tools": [
+                    {
+                        "name": "echo",
+                        "description": "Echo input text",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {"text": {"type": "string"}},
+                            "required": ["text"],
+                            "additionalProperties": False
+                        }
+                    }
+                ]
+            }
+        })
+    elif method == "resources/list":
+        send({
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "resources": [{"uri": "mem://hello", "name": "hello", "mimeType": "text/plain"}],
+                "nextCursor": None,
+            }
+        })
+    elif method == "prompts/list":
+        send({
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "prompts": [{"name": "greet", "description": "greet prompt"}],
+                "nextCursor": None,
+            }
+        })
+    else:
+        send({"jsonrpc": "2.0", "id": msg_id, "error": {"code": -32601, "message": "unknown method"}})
+"#;
+
+fn python_exe() -> &'static str {
+    if cfg!(windows) {
+        "python"
+    } else {
+        "python3"
+    }
+}
+
+fn write_mcp_stub(root: &Path) -> std::path::PathBuf {
+    let path = root.join("mcp_diagnose_stub.py");
+    std::fs::write(&path, MCP_STUB_PY).expect("write mcp diagnose stub script");
+    path
+}
+
+fn mcp_config_json(script: &Path) -> String {
+    serde_json::json!({
+        "servers": {
+            "stub": {
+                "command": python_exe(),
+                "args": ["-u", script.to_string_lossy()],
+                "cwd": ".",
+                "env": {
+                    "API_KEY": "secret",
+                }
+            }
+        }
+    })
+    .to_string()
+}
 
 #[test]
 fn build_mcp_diagnose_json_includes_expected_keys_and_redaction() {
@@ -76,3 +179,66 @@ fn sanitize_mcp_config_redacts_env_values() {
         Some("python")
     );
 }
+
+#[tokio::test]
+async fn collect_mcp_diagnose_data_includes_tools_resources_prompts_and_redaction() {
+    let tmp = tempfile::tempdir().unwrap();
+    let workspace = tmp.path().join("workspace");
+    std::fs::create_dir_all(&workspace).unwrap();
+    let stub = write_mcp_stub(tmp.path());
+    let config_json = mcp_config_json(&stub);
+
+    let out = collect_mcp_diagnose_data(
+        workspace.clone(),
+        &config_json,
+        rexos::security::SecurityConfig::default(),
+        true,
+        true,
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(out.servers_json, serde_json::json!(["stub"]));
+    assert!(out.tool_names.contains(&"mcp_stub__echo".to_string()));
+    assert_eq!(
+        out.sanitized_config["servers"]["stub"]["env"]["API_KEY"].as_str(),
+        Some("[redacted]")
+    );
+    let resources = out
+        .resources_json
+        .as_ref()
+        .expect("resources should be present");
+    assert_eq!(resources[0]["server"].as_str(), Some("stub"));
+    assert_eq!(
+        resources[0]["resources"][0]["uri"].as_str(),
+        Some("mem://hello")
+    );
+    let prompts = out
+        .prompts_json
+        .as_ref()
+        .expect("prompts should be present");
+    assert_eq!(prompts[0]["server"].as_str(), Some("stub"));
+    assert_eq!(prompts[0]["prompts"][0]["name"].as_str(), Some("greet"));
+}
+
+#[tokio::test]
+async fn collect_mcp_diagnose_data_skips_optional_lists_when_disabled() {
+    let tmp = tempfile::tempdir().unwrap();
+    let workspace = tmp.path().join("workspace");
+    std::fs::create_dir_all(&workspace).unwrap();
+    let stub = write_mcp_stub(tmp.path());
+    let config_json = mcp_config_json(&stub);
+
+    let out = collect_mcp_diagnose_data(
+        workspace,
+        &config_json,
+        rexos::security::SecurityConfig::default(),
+        false,
+        false,
+    )
+    .await
+    .unwrap();
+
+    assert!(out.resources_json.is_none());
+    assert!(out.prompts_json.is_none());
+}
