matrixcode-core 0.4.39

MatrixCode Agent Core - Pure logic, no UI
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

//! LSP Manager Tests

use crate::lsp::{LspConfig, LspManager, LspServerConfig, LspServerInfo, LspServerStatus};

#[test]
fn test_lsp_manager_creation() {
    let manager = LspManager::new();
    
    assert!(!manager.has_servers());
    assert_eq!(manager.server_names().len(), 0);
    assert_eq!(manager.connected_count(), 0);
    assert_eq!(manager.error_count(), 0);
}

#[test]
fn test_lsp_manager_from_config() {
    let mut config = LspConfig::new();
    config.add_server(LspServerConfig::new("rust-analyzer", "rust"));
    config.add_server(LspServerConfig::new("typescript-language-server", "typescript"));
    
    let manager = LspManager::from_config(&config);
    
    assert!(manager.has_servers());
    assert_eq!(manager.server_names().len(), 2);
    assert_eq!(manager.connected_count(), 0); // 初始状态未连接
}

#[test]
fn test_lsp_manager_add_server() {
    let mut manager = LspManager::new();
    
    manager.add_server(LspServerConfig::new("rust-analyzer", "rust"));
    
    assert!(manager.has_servers());
    assert_eq!(manager.server_names().len(), 1);
    assert_eq!(manager.get_status("rust"), LspServerStatus::NotStarted);
}

#[test]
fn test_lsp_manager_remove_server() {
    let mut manager = LspManager::new();
    
    manager.add_server(LspServerConfig::new("rust-analyzer", "rust"));
    assert!(manager.has_servers());
    
    manager.remove_server("rust");
    assert!(!manager.has_servers());
}

#[test]
fn test_lsp_manager_status_update() {
    let mut manager = LspManager::new();
    manager.add_server(LspServerConfig::new("rust-analyzer", "rust"));
    
    // 测试状态更新
    manager.mark_starting("rust");
    assert_eq!(manager.get_status("rust"), LspServerStatus::Starting);
    
    manager.mark_connected("rust");
    assert_eq!(manager.get_status("rust"), LspServerStatus::Connected);
    assert_eq!(manager.connected_count(), 1);
    
    manager.mark_error("rust", "Connection failed");
    assert!(matches!(manager.get_status("rust"), LspServerStatus::Error(_)));
    assert_eq!(manager.error_count(), 1);
}

#[test]
fn test_lsp_manager_server_infos() {
    let mut manager = LspManager::new();
    manager.add_server(LspServerConfig::new("rust-analyzer", "rust"));
    manager.add_server(LspServerConfig::new("typescript-language-server", "typescript"));
    
    manager.mark_connected("rust");
    manager.mark_error("typescript", "Not installed");
    
    let infos = manager.server_infos();
    assert_eq!(infos.len(), 2);
    
    let rust_info = infos.iter().find(|i| i.language == "rust").unwrap();
    assert_eq!(rust_info.status, LspServerStatus::Connected);
    assert!(rust_info.status.is_ok());
    assert!(!rust_info.status.is_error());
    
    let ts_info = infos.iter().find(|i| i.language == "typescript").unwrap();
    assert!(matches!(ts_info.status, LspServerStatus::Error(_)));
    assert!(!ts_info.status.is_ok());
    assert!(ts_info.status.is_error());
}

#[test]
fn test_lsp_manager_reset_all() {
    let mut manager = LspManager::new();
    manager.add_server(LspServerConfig::new("rust-analyzer", "rust"));
    
    manager.mark_connected("rust");
    assert_eq!(manager.get_status("rust"), LspServerStatus::Connected);
    
    manager.reset_all();
    assert_eq!(manager.get_status("rust"), LspServerStatus::NotStarted);
}

#[test]
fn test_lsp_status_helpers() {
    // 测试 LspServerStatus 的辅助方法
    assert!(LspServerStatus::NotStarted.label() == "off");
    assert!(LspServerStatus::Starting.label() == "starting...");
    assert!(LspServerStatus::Connected.label() == "ok");
    
    assert!(!LspServerStatus::NotStarted.is_ok());
    assert!(!LspServerStatus::NotStarted.is_error());
    
    assert!(LspServerStatus::Connected.is_ok());
    assert!(!LspServerStatus::Connected.is_error());
    
    assert!(!LspServerStatus::Error("test".into()).is_ok());
    assert!(LspServerStatus::Error("test".into()).is_error());
}

#[test]
fn test_lsp_server_info_with_status() {
    let info = LspServerInfo::new("rust-analyzer", "rust");
    assert_eq!(info.status, LspServerStatus::NotStarted);
    
    let connected_info = info.with_status(LspServerStatus::Connected);
    assert_eq!(connected_info.status, LspServerStatus::Connected);
    assert_eq!(connected_info.name, info.name);
    assert_eq!(connected_info.language, info.language);
}