embedded-debugger-mcp 0.1.0

A Model Context Protocol server for embedded debugging with probe-rs - supports ARM Cortex-M, RISC-V debugging via J-Link, ST-Link, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Integration tests for debugger MCP server

use embedded_debugger_mcp::{Config, DebugSessionManager};

#[tokio::test]
async fn test_session_manager_initialization() {
    let config = Config::default();
    let manager = DebugSessionManager::new(config.server.max_sessions);
    
    // Test basic functionality
    assert_eq!(manager.session_count().await, 0);
    
    let sessions = manager.list_sessions().await;
    assert!(sessions.is_empty());
    
    let stats = manager.get_statistics().await;
    assert_eq!(stats.total_sessions, 0);
    assert_eq!(stats.max_sessions, config.server.max_sessions);
}

#[tokio::test]
async fn test_config_validation() {
    let config = Config::default();
    assert!(config.validate().is_ok());
    
    // Test TOML serialization
    let toml_str = config.to_toml().unwrap();
    assert!(!toml_str.is_empty());
    assert!(toml_str.contains("[server]"));
    assert!(toml_str.contains("[debugger]"));
}

#[tokio::test]
async fn test_probe_discovery() {
    // Test probe discovery (this will work even without hardware)
    let result = embedded_debugger_mcp::debugger::ProbeDiscovery::list_probes();
    assert!(result.is_ok());
    
    // The result might be empty if no probes are connected, which is fine
    let probes = result.unwrap();
    println!("Found {} probes", probes.len());
}

#[test]
fn test_error_types() {
    use embedded_debugger_mcp::DebugError;
    
    let error = DebugError::ProbeNotFound("test".to_string());
    assert!(error.to_string().contains("Probe not found"));
    
    let error = DebugError::SessionLimitExceeded(5);
    assert!(error.to_string().contains("Session limit exceeded"));
}

#[test]
fn test_utils_encoding() {
    use embedded_debugger_mcp::utils::encoding;
    
    let data = vec![0x01, 0x02, 0x03, 0x04];
    
    // Test hex encoding
    let hex = encoding::bytes_to_hex(&data);
    assert_eq!(hex, "01020304");
    
    let decoded = encoding::hex_to_bytes(&hex).unwrap();
    assert_eq!(decoded, data);
    
    // Test base64 encoding
    let base64 = encoding::bytes_to_base64(&data);
    let decoded = encoding::base64_to_bytes(&base64).unwrap();
    assert_eq!(decoded, data);
}

#[test]
fn test_utils_address() {
    use embedded_debugger_mcp::utils::address;
    
    // Test address parsing
    assert_eq!(address::parse_address("0x1000").unwrap(), 0x1000);
    assert_eq!(address::parse_address("1000").unwrap(), 1000);
    
    // Test address formatting
    assert_eq!(address::format_address(0x1000), "0x00001000");
    
    // Test alignment
    assert!(address::is_aligned(0x1000, 4));
    assert!(!address::is_aligned(0x1001, 4));
    assert_eq!(address::align_down(0x1003, 4), 0x1000);
    assert_eq!(address::align_up(0x1001, 4), 0x1004);
}

#[test]
fn test_data_format_parsing() {
    use embedded_debugger_mcp::utils::DataFormat;
    
    assert_eq!("hex".parse::<DataFormat>().unwrap(), DataFormat::Hex);
    assert_eq!("binary".parse::<DataFormat>().unwrap(), DataFormat::Binary);
    assert_eq!("ascii".parse::<DataFormat>().unwrap(), DataFormat::Ascii);
    assert_eq!("words".parse::<DataFormat>().unwrap(), DataFormat::Words);
    
    assert!("invalid".parse::<DataFormat>().is_err());
}

#[test]
fn test_reset_type_parsing() {
    use embedded_debugger_mcp::utils::ResetType;
    
    assert_eq!("hardware".parse::<ResetType>().unwrap(), ResetType::Hardware);
    assert_eq!("software".parse::<ResetType>().unwrap(), ResetType::Software);
    assert_eq!("system".parse::<ResetType>().unwrap(), ResetType::System);
    
    assert!("invalid".parse::<ResetType>().is_err());
}

#[tokio::test]
async fn test_mcp_tool_schemas() {
    use embedded_debugger_mcp::mcp::types::create_tool_schemas;
    
    let tools = create_tool_schemas();
    assert!(!tools.is_empty());
    
    // Check that we have the expected tools
    let tool_names: Vec<_> = tools.iter().map(|t| &t.name).collect();
    
    assert!(tool_names.contains(&&"list_probes".to_string()));
    assert!(tool_names.contains(&&"connect".to_string()));
    assert!(tool_names.contains(&&"halt".to_string()));
    assert!(tool_names.contains(&&"run".to_string()));
    assert!(tool_names.contains(&&"read_memory".to_string()));
    assert!(tool_names.contains(&&"write_memory".to_string()));
    assert!(tool_names.contains(&&"set_breakpoint".to_string()));
    assert!(tool_names.contains(&&"flash_binary".to_string()));
    assert!(tool_names.contains(&&"rtt_attach".to_string()));
    
    println!("Found {} MCP tools", tools.len());
    for tool in &tools {
        println!("  - {}: {}", tool.name, tool.description);
    }
}