1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! The pool starts a server only on demand (AGENTS.md invariant 25). Each
4. 4//! test wraps the server command so every spawn appends a line to a marker
5. 5//! file, which makes "was a process started?" a count, not a guess.
6. 6
7. 7use std::collections::HashMap;
8. 8use std::path::{Path, PathBuf};
9. 9use std::sync::Arc;
10. 10use std::time::Duration;
11. 11
12. 12use serde_json::json;
13. 13
14. 14use vak_mcp::{McpManager, McpTool, ServerConfig};
15. 15use vak_tools::{Tool, ToolContext};
16. 16
17. 17fn server_script() -> PathBuf {
18. 18 PathBuf::from(env!("CARGO_MANIFEST_DIR"))
19. 19 .join("../../scripts/fake_mcp_server.py")
20. 20 .canonicalize()
21. 21 .unwrap()
22. 22}
23. 23
24. 24/// A server whose every start is recorded in `marker`; `then` is what the
25. 25/// shell runs after recording.
26. 26fn counted(marker: &Path, then: &str) -> ServerConfig {
27. 27 ServerConfig {
28. 28 command: "sh".into(),
29. 29 args: vec![
30. 30 "-c".into(),
31. 31 format!("echo started >> '{}'; {then}", marker.display()),
32. 32 ],
33. 33 env: Vec::new(),
34. 34 network: false,
35. 35 }
36. 36}
37. 37
38. 38fn spawns(marker: &Path) -> usize {
39. 39 std::fs::read_to_string(marker)
40. 40 .map(|text| text.lines().count())
41. 41 .unwrap_or(0)
42. 42}
43. 43
44. 44fn pool(name: &str, config: ServerConfig, cwd: &Path) -> McpManager {
45. 45 McpManager::new(
46. 46 HashMap::from([(name.to_string(), config)]),
47. 47 cwd.to_path_buf(),
48. 48 )
49. 49}
50. 50
51. 51fn ctx(cwd: &Path) -> ToolContext {
52. 52 ToolContext::new(cwd.to_path_buf())
53. 53}
54. 54
55. 55#[tokio::test]
56. 56async fn nothing_starts_until_a_call_needs_the_server() {
57. 57 let dir = tempfile::tempdir().unwrap();
58. 58 let marker = dir.path().join("spawns");
59. 59 let script = format!("exec python3 '{}'", server_script().display());
60. 60 let manager = Arc::new(pool("fake", counted(&marker, &script), dir.path()));
61. 61 let tool = McpTool::new(manager.clone());
62. 62
63. 63 assert!(manager.observations().is_empty());
64. 64 let names = tool
65. 65 .execute(&json!({"action": "list"}), &ctx(dir.path()))
66. 66 .await;
67. 67 assert!(!names.is_error, "{}", names.content);
68. 68 assert!(names.content.contains("- fake"), "{}", names.content);
69. 69 assert_eq!(spawns(&marker), 0, "listing server names starts nothing");
70. 70
71. 71 let listed = tool
72. 72 .execute(
73. 73 &json!({"action": "list", "server": "fake"}),
74. 74 &ctx(dir.path()),
75. 75 )
76. 76 .await;
77. 77 assert!(
78. 78 listed.content.contains("echo — Echo back"),
79. 79 "{}",
80. 80 listed.content
81. 81 );
82. 82 assert_eq!(
83. 83 spawns(&marker),
84. 84 1,
85. 85 "demand starts exactly the server asked for"
86. 86 );
87. 87
88. 88 let called = tool
89. 89 .execute(
90. 90 &json!({"action": "call", "server": "fake", "tool": "echo", "arguments": {"text": "hi"}}),
91. 91 &ctx(dir.path()),
92. 92 )
93. 93 .await;
94. 94 assert!(!called.is_error, "{}", called.content);
95. 95 assert_eq!(spawns(&marker), 1, "the pooled connection is reused");
96. 96
97. 97 let observed = manager.observations();
98. 98 let tools = observed["fake"].tools.as_ref().expect("catalog observed");
99. 99 assert!(tools.iter().any(|t| t.name == "echo"));
100. 100}
101. 101
102. 102#[tokio::test]
103. 103async fn an_evicted_server_is_not_restarted_without_demand() {
104. 104 let dir = tempfile::tempdir().unwrap();
105. 105 let marker = dir.path().join("spawns");
106. 106 let script = format!("exec python3 '{}'", server_script().display());
107. 107 let manager = pool("fake", counted(&marker, &script), dir.path());
108. 108 manager.list_tools("fake").await.unwrap();
109. 109 assert_eq!(spawns(&marker), 1);
110. 110
111. 111 assert_eq!(manager.evict_idle(Duration::ZERO).await, vec!["fake"]);
112. 112 tokio::time::sleep(Duration::from_millis(100)).await;
113. 113 assert_eq!(spawns(&marker), 1, "eviction never triggers a respawn");
114. 114 assert!(
115. 115 manager.observations()["fake"].tools.is_some(),
116. 116 "the last catalog survives eviction, so the prompt still names its tools"
117. 117 );
118. 118
119. 119 manager.list_tools("fake").await.unwrap();
120. 120 assert_eq!(spawns(&marker), 2, "the next demand respawns it");
121. 121}
122. 122
123. 123#[tokio::test]
124. 124async fn a_failing_server_backs_off_instead_of_respawning_on_every_call() {
125. 125 let dir = tempfile::tempdir().unwrap();
126. 126 let marker = dir.path().join("spawns");
127. 127 let manager = pool("broken", counted(&marker, "exit 1"), dir.path());
128. 128
129. 129 let first = manager.list_tools("broken").await.unwrap_err();
130. 130 assert_eq!(spawns(&marker), 1);
131. 131 let observed = manager.observations();
132. 132 assert!(
133. 133 observed["broken"].failure.is_some(),
134. 134 "the failure is recorded"
135. 135 );
136. 136 assert!(observed["broken"].tools.is_none());
137. 137
138. 138 let second = manager.list_tools("broken").await.unwrap_err();
139. 139 assert_eq!(
140. 140 spawns(&marker),
141. 141 1,
142. 142 "inside the backoff window nothing is spawned"
143. 143 );
144. 144 assert!(
145. 145 second.contains("next attempt in"),
146. 146 "{second} (first: {first})"
147. 147 );
148. 148}
149. 149
150. 150#[tokio::test]
151. 151async fn the_observer_hears_what_demand_learned() {
152. 152 let dir = tempfile::tempdir().unwrap();
153. 153 let marker = dir.path().join("spawns");
154. 154 let script = format!("exec python3 '{}'", server_script().display());
155. 155 let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
156. 156 let manager = pool("fake", counted(&marker, &script), dir.path()).with_observer(tx);
157. 157
158. 158 manager.list_tools("fake").await.unwrap();
159. 159 assert_eq!(
160. 160 rx.try_recv().unwrap(),
161. 161 "fake",
162. 162 "a learned catalog is announced"
163. 163 );
164. 164 manager.list_tools("fake").await.unwrap();
165. 165 assert!(rx.try_recv().is_err(), "an unchanged catalog is not news");
166. 166
167. 167 manager.forget_catalog("fake");
168. 168 assert_eq!(rx.try_recv().unwrap(), "fake");
169. 169 assert!(manager.observations()["fake"].tools.is_none());
170. 170}
171. 171