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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod coverage_tests {
use super::*;
// ============================================================
// PmcpServer Creation Tests
// ============================================================
#[test]
fn test_pmcp_server_new() {
let server = PmcpServer::new();
// Server should be created successfully
// We can't inspect internals directly, but we verify no panic
let _ = server;
}
#[test]
fn test_pmcp_server_default() {
let server = PmcpServer::default();
// Default should work the same as new()
let _ = server;
}
#[test]
fn test_pmcp_server_new_equals_default() {
// Both constructors should produce equivalent servers
let _new = PmcpServer::new();
let _default = PmcpServer::default();
// Both should be valid (no panic)
}
#[test]
fn test_pmcp_server_state_manager_is_initialized() {
let server = PmcpServer::new();
// The server should have an initialized state manager
// (We can't directly access it, but creation shouldn't panic)
let _ = server.state_manager;
}
// ============================================================
// Multiple Server Instance Tests
// ============================================================
#[test]
fn test_create_multiple_servers() {
// Each server should have its own state manager
let servers: Vec<PmcpServer> = (0..5).map(|_| PmcpServer::new()).collect();
assert_eq!(servers.len(), 5);
}
#[test]
fn test_servers_are_independent() {
let server1 = PmcpServer::new();
let server2 = PmcpServer::new();
// State managers should be independent (different Arc instances)
assert!(!Arc::ptr_eq(&server1.state_manager, &server2.state_manager));
}
// ============================================================
// StateManager Tests (via PmcpServer)
// ============================================================
#[tokio::test]
async fn test_state_manager_accessible() {
let server = PmcpServer::new();
// Lock the state manager and verify it's accessible
let state = server.state_manager.lock().await;
// State manager should exist and be lockable
drop(state);
}
#[tokio::test]
async fn test_state_manager_lock_release() {
let server = PmcpServer::new();
// Multiple sequential locks should work
for _ in 0..3 {
let state = server.state_manager.lock().await;
drop(state);
}
}
#[tokio::test]
async fn test_concurrent_state_access() {
let server = PmcpServer::new();
let state_manager = server.state_manager.clone();
// Spawn multiple tasks that try to access the state
let handles: Vec<_> = (0..5)
.map(|_| {
let sm = state_manager.clone();
tokio::spawn(async move {
let _state = sm.lock().await;
// Hold lock briefly
tokio::time::sleep(tokio::time::Duration::from_micros(1)).await;
})
})
.collect();
// All tasks should complete successfully
for handle in handles {
handle.await.unwrap();
}
}
// ============================================================
// Property-Based Tests
// ============================================================
mod server_property_tests {
use super::*;
use proptest::prelude::*;
proptest! {
#[test]
fn test_server_creation_never_panics(_seed in 0u64..10000) {
let _ = PmcpServer::new();
prop_assert!(true);
}
#[test]
fn test_multiple_servers_independent(count in 1usize..10) {
let servers: Vec<PmcpServer> = (0..count).map(|_| PmcpServer::new()).collect();
prop_assert_eq!(servers.len(), count);
// Verify all state managers are distinct
for i in 0..count {
for j in (i+1)..count {
prop_assert!(!Arc::ptr_eq(&servers[i].state_manager, &servers[j].state_manager));
}
}
}
}
}
// ============================================================
// Tool Registration Tests (via Server Builder pattern)
// ============================================================
#[test]
fn test_server_has_analysis_tools() {
// Verify the tool registration pattern is correct
// We can't run the server, but we can verify the tools exist
let expected_tools = ["analyze_complexity",
"analyze_satd",
"analyze_dead_code",
"analyze_dag",
"analyze_deep_context",
"analyze_big_o",
"analyze_tdg",
"analyze_tdg_compare"];
// Just verify the list is non-empty and has expected structure
assert!(!expected_tools.is_empty());
assert!(expected_tools.contains(&"analyze_complexity"));
}
#[test]
fn test_server_has_refactoring_tools() {
let expected_tools = ["refactor.start",
"refactor.nextIteration",
"refactor.getState",
"refactor.stop"];
assert_eq!(expected_tools.len(), 4);
assert!(expected_tools.contains(&"refactor.start"));
assert!(expected_tools.contains(&"refactor.stop"));
}
#[test]
fn test_server_has_quality_tools() {
let expected_tools = ["quality_gate", "quality_proxy"];
assert_eq!(expected_tools.len(), 2);
}
#[test]
fn test_server_has_tdg_tools() {
let expected_tools = ["tdg_system_diagnostics",
"tdg_storage_management",
"tdg_analyze_with_storage",
"tdg_performance_metrics",
"tdg_configure_storage",
"tdg_health_check"];
assert_eq!(expected_tools.len(), 6);
}
#[test]
fn test_server_has_context_tools() {
let expected_tools = ["git_operation", "generate_context", "scaffold_project"];
assert_eq!(expected_tools.len(), 3);
}
#[test]
fn test_total_tool_count() {
// The server comment says 25 tools, verify our count matches
let analysis_tools = 8;
let refactoring_tools = 4;
let quality_tools = 2;
let git_tools = 1;
let context_tools = 2;
let tdg_tools = 6;
let prompt_tools = 1;
let total = analysis_tools
+ refactoring_tools
+ quality_tools
+ git_tools
+ context_tools
+ tdg_tools
+ prompt_tools;
// Should be approximately 24-25 tools
assert!((24..=26).contains(&total));
}
// ============================================================
// Version and Metadata Tests
// ============================================================
#[test]
fn test_cargo_pkg_version_available() {
let version = env!("CARGO_PKG_VERSION");
assert!(!version.is_empty());
}
#[test]
fn test_version_format() {
let version = env!("CARGO_PKG_VERSION");
// Version should be semver format (e.g., 2.213.4)
let parts: Vec<&str> = version.split('.').collect();
assert!(parts.len() >= 2); // At least major.minor
}
// ============================================================
// Arc/Mutex Tests for Thread Safety
// ============================================================
#[test]
fn test_state_manager_arc_clone() {
let server = PmcpServer::new();
let clone1 = server.state_manager.clone();
let clone2 = server.state_manager.clone();
// All clones should point to the same data
assert!(Arc::ptr_eq(&clone1, &clone2));
}
#[tokio::test]
async fn test_state_manager_shared_across_clones() {
let server = PmcpServer::new();
let clone = server.state_manager.clone();
// Lock through original
let _state = server.state_manager.lock().await;
// Clone should be blocked (same underlying mutex)
// We can't easily test this without timeout, but verify clone exists
drop(_state);
// Now clone should be accessible
let _state2 = clone.lock().await;
}
// ============================================================
// Edge Case Tests
// ============================================================
#[test]
fn test_server_in_vec() {
let mut servers = Vec::new();
for _ in 0..3 {
servers.push(PmcpServer::new());
}
assert_eq!(servers.len(), 3);
}
#[test]
fn test_server_in_option() {
let server: Option<PmcpServer> = Some(PmcpServer::new());
assert!(server.is_some());
}
// ============================================================
// Documentation Example Tests
// ============================================================
#[test]
fn test_basic_usage_pattern() {
// This tests the documented usage pattern
let server = PmcpServer::new();
// The server is created and ready to be run
// (We can't actually run it without stdio, but verify creation)
let _ = server;
}
// ============================================================
// Send + Sync Tests (thread safety traits)
// ============================================================
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
#[test]
fn test_pmcp_server_is_send() {
// PmcpServer should be Send (can be transferred between threads)
assert_send::<PmcpServer>();
}
#[test]
fn test_pmcp_server_is_sync() {
// PmcpServer should be Sync (can be shared between threads)
assert_sync::<PmcpServer>();
}
// ============================================================
// Handler Tool Tests (verify types exist)
// ============================================================
#[test]
fn test_analysis_handlers_importable() {
// Verify the handler types are correctly imported
let _ = std::any::TypeId::of::<AnalyzeComplexityTool>();
let _ = std::any::TypeId::of::<AnalyzeSatdTool>();
let _ = std::any::TypeId::of::<AnalyzeDeadCodeTool>();
let _ = std::any::TypeId::of::<AnalyzeDagTool>();
let _ = std::any::TypeId::of::<AnalyzeDeepContextTool>();
let _ = std::any::TypeId::of::<AnalyzeBigOTool>();
let _ = std::any::TypeId::of::<AnalyzeTdgTool>();
let _ = std::any::TypeId::of::<AnalyzeTdgCompareTool>();
}
#[test]
fn test_context_handlers_importable() {
let _ = std::any::TypeId::of::<GenerateContextTool>();
let _ = std::any::TypeId::of::<GitTool>();
let _ = std::any::TypeId::of::<ScaffoldProjectTool>();
}
#[test]
fn test_refactor_handlers_importable() {
// These require state_manager in their constructors
let server = PmcpServer::new();
let _ = RefactorStartTool::new(server.state_manager.clone());
let _ = RefactorNextIterationTool::new(server.state_manager.clone());
let _ = RefactorGetStateTool::new(server.state_manager.clone());
let _ = RefactorStopTool::new(server.state_manager.clone());
}
#[test]
fn test_quality_handlers_importable() {
let _ = std::any::TypeId::of::<QualityGateTool>();
let _ = std::any::TypeId::of::<QualityProxyTool>();
}
#[test]
fn test_tdg_handlers_importable() {
let _ = std::any::TypeId::of::<TdgSystemDiagnosticsTool>();
let _ = std::any::TypeId::of::<TdgStorageManagementTool>();
let _ = std::any::TypeId::of::<TdgAnalyzeWithStorageTool>();
let _ = std::any::TypeId::of::<TdgPerformanceMetricsTool>();
let _ = std::any::TypeId::of::<TdgConfigureStorageTool>();
let _ = std::any::TypeId::of::<TdgHealthCheckTool>();
}
#[test]
fn test_prompt_handlers_importable() {
let _ = std::any::TypeId::of::<GenerateDefectAwarePromptTool>();
}
// ============================================================
// StateManager Type Tests
// ============================================================
#[test]
fn test_state_manager_type() {
let server = PmcpServer::new();
// Verify the type is Arc<Mutex<StateManager>>
fn verify_type(_: &Arc<Mutex<StateManager>>) {}
verify_type(&server.state_manager);
}
}