60255
Zn
Zoea-Nova / files
Zoea-Nova / internal / mcp / mcp_test.go
6.4 KB
1package mcp 2 3import ( 4 "context" 5 "encoding/json" 6 "errors" 7 "net/http" 8 "net/http/httptest" 9 "testing" 10) 11 12func TestNewRequest(t *testing.T) { 13 req, err := NewRequest(1, "tools/list", nil) 14 if err != nil { 15 t.Fatalf("NewRequest() error: %v", err) 16 } 17 18 if req.JSONRPC != "2.0" { 19 t.Errorf("expected jsonrpc=2.0, got %s", req.JSONRPC) 20 } 21 if req.Method != "tools/list" { 22 t.Errorf("expected method=tools/list, got %s", req.Method) 23 } 24} 25 26func TestNewResponse(t *testing.T) { 27 result := map[string]string{"foo": "bar"} 28 resp, err := NewResponse(1, result) 29 if err != nil { 30 t.Fatalf("NewResponse() error: %v", err) 31 } 32 33 if resp.JSONRPC != "2.0" { 34 t.Errorf("expected jsonrpc=2.0, got %s", resp.JSONRPC) 35 } 36 if resp.Error != nil { 37 t.Error("expected no error") 38 } 39} 40 41func TestNewErrorResponse(t *testing.T) { 42 resp := NewErrorResponse(1, ErrorCodeMethodNotFound, "method not found") 43 44 if resp.Error == nil { 45 t.Fatal("expected error") 46 } 47 if resp.Error.Code != ErrorCodeMethodNotFound { 48 t.Errorf("expected code=%d, got %d", ErrorCodeMethodNotFound, resp.Error.Code) 49 } 50} 51 52func TestProxyLocalTools(t *testing.T) { 53 proxy := NewProxy(nil) // No upstream 54 55 // Register a local tool 56 tool := Tool{ 57 Name: "test_tool", 58 Description: "A test tool", 59 InputSchema: json.RawMessage(`{"type": "object"}`), 60 } 61 handler := func(ctx context.Context, args json.RawMessage) (*ToolResult, error) { 62 return &ToolResult{ 63 Content: []ContentBlock{{Type: "text", Text: "test result"}}, 64 }, nil 65 } 66 67 proxy.RegisterTool(tool, handler) 68 69 if proxy.LocalToolCount() != 1 { 70 t.Errorf("expected 1 local tool, got %d", proxy.LocalToolCount()) 71 } 72 73 // List tools 74 ctx := context.Background() 75 tools, err := proxy.ListTools(ctx) 76 if err != nil { 77 t.Fatalf("ListTools() error: %v", err) 78 } 79 if len(tools) != 1 { 80 t.Errorf("expected 1 tool, got %d", len(tools)) 81 } 82 83 // Call tool 84 result, err := proxy.CallTool(ctx, CallerContext{}, "test_tool", nil) 85 if err != nil { 86 t.Fatalf("CallTool() error: %v", err) 87 } 88 if result.IsError { 89 t.Error("expected no error in result") 90 } 91 if len(result.Content) != 1 || result.Content[0].Text != "test result" { 92 t.Errorf("unexpected result content: %+v", result.Content) 93 } 94} 95 96func TestProxyToolNotFound(t *testing.T) { 97 proxy := NewProxy(nil) // No upstream 98 99 ctx := context.Background() 100 result, err := proxy.CallTool(ctx, CallerContext{}, "nonexistent", nil) 101 if err != nil { 102 t.Fatalf("CallTool() error: %v", err) 103 } 104 if !result.IsError { 105 t.Error("expected error in result") 106 } 107} 108 109func TestProxyHasUpstream(t *testing.T) { 110 proxyNoUpstream := NewProxy(nil) 111 if proxyNoUpstream.HasUpstream() { 112 t.Error("expected no upstream") 113 } 114 115 proxyWithUpstream := NewProxy(NewClient("http://example.com/mcp")) 116 if !proxyWithUpstream.HasUpstream() { 117 t.Error("expected upstream") 118 } 119} 120 121func TestClientWithMockServer(t *testing.T) { 122 // Create a mock MCP server 123 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 124 var req Request 125 json.NewDecoder(r.Body).Decode(&req) 126 127 var resp Response 128 resp.JSONRPC = "2.0" 129 resp.ID = req.ID 130 131 switch req.Method { 132 case "tools/list": 133 result := ListToolsResult{ 134 Tools: []Tool{ 135 {Name: "mock_tool", Description: "A mock tool"}, 136 }, 137 } 138 data, _ := json.Marshal(result) 139 resp.Result = data 140 case "tools/call": 141 result := ToolResult{ 142 Content: []ContentBlock{{Type: "text", Text: "mock response"}}, 143 } 144 data, _ := json.Marshal(result) 145 resp.Result = data 146 default: 147 resp.Error = &Error{Code: ErrorCodeMethodNotFound, Message: "method not found"} 148 } 149 150 json.NewEncoder(w).Encode(resp) 151 })) 152 defer server.Close() 153 154 client := NewClient(server.URL) 155 ctx := context.Background() 156 157 // Test ListTools 158 tools, err := client.ListTools(ctx) 159 if err != nil { 160 t.Fatalf("ListTools() error: %v", err) 161 } 162 if len(tools) != 1 || tools[0].Name != "mock_tool" { 163 t.Errorf("unexpected tools: %+v", tools) 164 } 165 166 // Test CallTool 167 result, err := client.CallTool(ctx, "mock_tool", nil) 168 if err != nil { 169 t.Fatalf("CallTool() error: %v", err) 170 } 171 if len(result.Content) != 1 || result.Content[0].Text != "mock response" { 172 t.Errorf("unexpected result: %+v", result) 173 } 174} 175 176// mockOrchestrator is a test implementation of the Orchestrator interface. 177type mockOrchestrator struct{} 178 179func (m *mockOrchestrator) MysisCount() int { 180 return 2 181} 182 183func (m *mockOrchestrator) MaxMyses() int { 184 return 16 185} 186 187func (m *mockOrchestrator) GetStateCounts() map[string]int { 188 return map[string]int{ 189 "running": 2, 190 "idle": 0, 191 "stopped": 0, 192 "errored": 0, 193 } 194} 195 196func (m *mockOrchestrator) SendMessageAsync(mysisID, message string) error { 197 if mysisID == "mysis-1" || mysisID == "mysis-2" { 198 return nil 199 } 200 return errors.New("mysis not found") 201} 202 203func (m *mockOrchestrator) BroadcastAsync(message string) error { 204 return nil 205} 206 207func (m *mockOrchestrator) BroadcastFrom(senderID, message string) error { 208 return nil 209} 210 211func (m *mockOrchestrator) SearchMessages(mysisID, query string, limit int) ([]SearchResult, error) { 212 return []SearchResult{}, nil 213} 214 215func (m *mockOrchestrator) SearchReasoning(mysisID, query string, limit int) ([]ReasoningResult, error) { 216 return []ReasoningResult{}, nil 217} 218 219func TestOrchestratorTools(t *testing.T) { 220 // Create mock orchestrator 221 orchestrator := &mockOrchestrator{} 222 223 // Create proxy and register tools 224 proxy := NewProxy(nil) 225 RegisterOrchestratorTools(proxy, orchestrator) 226 227 ctx := context.Background() 228 229 // Test zoea_search_messages 230 args := json.RawMessage(`{"mysis_id": "mysis-1", "query": "test"}`) 231 result, err := proxy.CallTool(ctx, CallerContext{}, "zoea_search_messages", args) 232 if err != nil { 233 t.Fatalf("CallTool(zoea_search_messages) error: %v", err) 234 } 235 if result.IsError { 236 t.Errorf("unexpected error: %s", result.Content[0].Text) 237 } 238 239} 240 241func TestZoeaSearchMessagesPayload(t *testing.T) { 242 // Create mock orchestrator 243 orchestrator := &mockOrchestrator{} 244 245 // Create proxy and register tools 246 proxy := NewProxy(nil) 247 RegisterOrchestratorTools(proxy, orchestrator) 248 249 ctx := context.Background() 250 251 // Call zoea_search_messages 252 args := json.RawMessage(`{"mysis_id": "mysis-1", "query": "test"}`) 253 result, err := proxy.CallTool(ctx, CallerContext{}, "zoea_search_messages", args) 254 if err != nil { 255 t.Fatalf("CallTool(zoea_search_messages) error: %v", err) 256 } 257 if result.IsError { 258 t.Fatalf("unexpected error: %s", result.Content[0].Text) 259 } 260 261 // Verify we get a response (empty results are expected with empty mock) 262 if len(result.Content) == 0 { 263 t.Fatal("expected content in result") 264 } 265}