xonecas.io
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}