Skip to content
1        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}