LINE1 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 1701use std::fs;2use std::io::{BufRead, BufReader, Read, Write};3use std::path::{Path, PathBuf};4use std::process::{Child, ChildStderr, ChildStdin, Command, Stdio};5use std::time::{SystemTime, UNIX_EPOCH};67struct TempProject(PathBuf);89struct McpSession {10 child: Child,11 stdin: Option<ChildStdin>,12 stdout: BufReader<std::process::ChildStdout>,13 stderr: Option<ChildStderr>,14}1516impl TempProject {17 fn new() -> Self {18 let nonce = SystemTime::now()19 .duration_since(UNIX_EPOCH)20 .expect("system clock should be after the Unix epoch")21 .as_nanos();22 let path =23 std::env::temp_dir().join(format!("margaret-mcp-test-{}-{nonce}", std::process::id()));24 fs::create_dir_all(&path).expect("temporary project directory should be created");25 Self(path)26 }2728 fn path(&self) -> &Path {29 &self.030 }3132 fn write_source(&self, relative_path: &str, contents: &[u8]) {33 let path = self.path().join(relative_path);34 fs::create_dir_all(path.parent().expect("source path has parent"))35 .expect("source directory should be created");36 fs::write(path, contents).expect("Rust fixture should be written");37 }38}3940impl Drop for TempProject {41 fn drop(&mut self) {42 let _ = fs::remove_dir_all(&self.0);43 }44}4546impl McpSession {47 fn start(project: &TempProject) -> Self {48 let mut child = Command::new(env!("CARGO_BIN_EXE_marg"))49 .arg("mcp")50 .current_dir(project.path())51 .stdin(Stdio::piped())52 .stdout(Stdio::piped())53 .stderr(Stdio::piped())54 .spawn()55 .expect("MCP server should start");56 let stdin = child.stdin.take().expect("MCP server should have stdin");57 let stdout = BufReader::new(child.stdout.take().expect("MCP server should have stdout"));58 let stderr = child.stderr.take();59 let mut session = Self {60 child,61 stdin: Some(stdin),62 stdout,63 stderr,64 };65 session.send(66 r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"marg-test","version":"0.1.0"}}}"#,67 );68 session.response(1);69 session.send(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);70 session71 }7273 fn audit(&mut self, id: u64) -> serde_json::Value {74 let request = serde_json::json!({75 "jsonrpc": "2.0",76 "id": id,77 "method": "tools/call",78 "params": { "name": "audit_project", "arguments": {} }79 });80 self.send(&request.to_string());81 self.response(id)82 .pointer("/result/structuredContent")83 .cloned()84 .expect("audit call should return structured content")85 }8687 fn finish(&mut self) {88 drop(self.stdin.take());89 let mut trailing_output = String::new();90 self.stdout91 .read_to_string(&mut trailing_output)92 .expect("MCP server stdout should close cleanly");93 let status = self.child.wait().expect("MCP server should exit");94 let mut stderr = String::new();95 if let Some(mut stream) = self.stderr.take() {96 stream97 .read_to_string(&mut stderr)98 .expect("MCP server stderr should be readable");99 }100 assert!(status.success(), "MCP server failed: {stderr}");101 }102103 fn send(&mut self, request: &str) {104 writeln!(105 self.stdin.as_mut().expect("MCP session should be open"),106 "{request}"107 )108 .expect("MCP request should be written");109 }110111 fn response(&mut self, id: u64) -> serde_json::Value {112 let mut line = String::new();113 loop {114 line.clear();115 let bytes = self116 .stdout117 .read_line(&mut line)118 .expect("MCP response should be readable");119 assert_ne!(bytes, 0, "MCP server closed before response {id}");120 let response: serde_json::Value =121 serde_json::from_str(&line).expect("stdout must contain only JSON-RPC frames");122 if response.get("id") == Some(&serde_json::json!(id)) {123 return response;124 }125 }126 }127}128129impl Drop for McpSession {130 fn drop(&mut self) {131 if self.child.try_wait().ok().flatten().is_none() {132 let _ = self.child.kill();133 let _ = self.child.wait();134 }135 }136}137138#[test]139fn mcp_exposes_only_file_size_and_length_metrics() {140 let project = TempProject::new();141 project.write_source("src/lib.rs", b"fn alpha() {}\n");142 project.write_source("nested/beta.rs", b"beta\nlast");143 let responses = run_mcp(&project, true);144145 let tools = responses146 .iter()147 .find(|response| response.get("id") == Some(&serde_json::json!(2)))148 .and_then(|response| response.pointer("/result/tools"))149 .and_then(serde_json::Value::as_array)150 .expect("tools/list response should contain tools");151 assert_eq!(tools.len(), 1);152 assert_eq!(tools[0]["name"], "audit_project");153154 let result = result_for_call(&responses, 3);155 assert_eq!(result["discovered_source_count"], 2);156 assert_eq!(result["verification_complete"], true);157 assert_eq!(result["total_bytes"], 23);158 assert_eq!(result["total_physical_lines"], 3);159 let files = result["files"].as_array().unwrap();160 assert_eq!(files.len(), 2);161 assert_eq!(162 files[0],163 serde_json::json!({164 "path": "nested/beta.rs", "bytes": 9, "physical_lines": 2165 })166 );167 assert_eq!(168 files[1],169 serde_json::json!({170 "path": "src/lib.rs", "bytes": 14, "physical_lines": 1171 })172 );173 assert!(result.get("functions").is_none());174 assert!(result.get("blocking_suppressions").is_none());175 assert!(result.get("complexity").is_none());176 assert!(result.get("underscore_bindings").is_none());177178 let report_path = project.path().join(result["report_path"].as_str().unwrap());179 let report = fs::read_to_string(report_path).expect("Markdown report should be written");180 assert!(report.contains("`nested/beta.rs` | 9 | 2"));181 assert!(report.contains("`src/lib.rs` | 14 | 1"));182 assert!(!report.contains("complexity"));183 assert!(result["report_markdown"]184 .as_str()185 .unwrap()186 .contains("File size summary"));187}188189#[test]190fn mcp_reruns_measurements_and_replaces_the_dated_report() {191 let project = TempProject::new();192 project.write_source("src/lib.rs", b"a\n");193 let mut session = McpSession::start(&project);194195 let first = session.audit(2);196 assert_eq!(first["total_bytes"], 2);197 let report_path = first["report_path"].as_str().unwrap().to_owned();198199 project.write_source("src/lib.rs", b"changed\nagain\n");200 let second = session.audit(3);201 assert_eq!(second["total_bytes"], 14);202 assert_eq!(second["files"][0]["physical_lines"], 2);203 assert_eq!(second["report_path"], report_path);204 session.finish();205206 let report = fs::read_to_string(project.path().join(report_path))207 .expect("latest dated report should be readable");208 assert!(report.contains("`src/lib.rs` | 14 | 2"));209}210211#[test]212fn mcp_measures_non_utf8_source_bytes_without_analysis() {213 let project = TempProject::new();214 project.write_source("src/bytes.rs", &[0xff, b'\n', 0xfe]);215216 let result = result_for_call(&run_mcp(&project, false), 3);217218 assert_eq!(result["verification_complete"], true);219 assert_eq!(result["files"][0]["bytes"], 3);220 assert_eq!(result["files"][0]["physical_lines"], 2);221 assert!(result["scan_warnings"].as_array().unwrap().is_empty());222}223224fn run_mcp(project: &TempProject, list_tools: bool) -> Vec<serde_json::Value> {225 let mut child = Command::new(env!("CARGO_BIN_EXE_marg"))226 .arg("mcp")227 .current_dir(project.path())228 .stdin(Stdio::piped())229 .stdout(Stdio::piped())230 .stderr(Stdio::piped())231 .spawn()232 .expect("MCP server should start");233234 let mut stdin = child.stdin.take().expect("MCP server should have stdin");235 send_request(236 &mut stdin,237 r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"marg-test","version":"0.1.0"}}}"#,238 );239 send_request(240 &mut stdin,241 r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#,242 );243 if list_tools {244 send_request(245 &mut stdin,246 r#"{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}"#,247 );248 }249 send_request(250 &mut stdin,251 r#"{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"audit_project","arguments":{}}}"#,252 );253 drop(stdin);254255 let output = child256 .wait_with_output()257 .expect("MCP server should finish after stdin closes");258 assert!(259 output.status.success(),260 "MCP server failed: {}",261 String::from_utf8_lossy(&output.stderr)262 );263 String::from_utf8(output.stdout)264 .expect("MCP output should be UTF-8")265 .lines()266 .map(|line| serde_json::from_str(line).expect("stdout must contain only JSON-RPC frames"))267 .collect()268}269270fn result_for_call(responses: &[serde_json::Value], id: u64) -> serde_json::Value {271 responses272 .iter()273 .find(|response| response.get("id") == Some(&serde_json::json!(id)))274 .and_then(|response| response.pointer("/result/structuredContent"))275 .cloned()276 .expect("tools/call response should contain structured file metrics")277}278279fn send_request(stdin: &mut impl Write, request: &str) {280 writeln!(stdin, "{request}").expect("MCP request should be written");281}