xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / mcp / client_test.go

5.4 KB
1package mcp
2
3import (
4	"context"
5	"encoding/json"
6	"net/http"
7	"net/http/httptest"
8	"strings"
9	"testing"
10)
11
12func TestClientInitialize(t *testing.T) {
13	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
14		var req Request
15		json.NewDecoder(r.Body).Decode(&req)
16
17		if req.Method == "initialize" {
18			result := map[string]interface{}{
19				"protocolVersion": "2024-11-05",
20				"capabilities":    map[string]interface{}{},
21				"serverInfo":      map[string]string{"name": "test", "version": "1.0"},
22			}
23			data, _ := json.Marshal(result)
24			resp := &Response{
25				JSONRPC: "2.0",
26				ID:      req.ID,
27				Result:  data,
28			}
29			json.NewEncoder(w).Encode(resp)
30		} else if req.Method == "notifications/initialized" {
31			w.WriteHeader(http.StatusNoContent)
32		} else {
33			resp := NewErrorResponse(req.ID, 0, "not implemented")
34			json.NewEncoder(w).Encode(resp)
35		}
36	}))
37	defer server.Close()
38
39	client := NewClient(server.URL)
40	_, err := client.Initialize(context.Background(), map[string]interface{}{"name": "test-client"})
41	if err != nil {
42		t.Fatalf("Initialize() error: %v", err)
43	}
44}
45
46func TestClientNotify(t *testing.T) {
47	received := false
48	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
49		var req Request
50		json.NewDecoder(r.Body).Decode(&req)
51		if req.Method == "notifications/initialized" {
52			received = true
53		}
54		w.WriteHeader(http.StatusNoContent)
55	}))
56	defer server.Close()
57
58	client := NewClient(server.URL)
59	err := client.Notify(context.Background(), "notifications/initialized", nil)
60	if err != nil {
61		t.Fatalf("Notify() error: %v", err)
62	}
63	if !received {
64		t.Error("notification not received by server")
65	}
66}
67
68func TestClientParseSSEResponse(t *testing.T) {
69	client := NewClient("")
70
71	sseData := "data: {\"jsonrpc\":\"2.0\",\"id\":1,\"result\":{\"foo\":\"bar\"}}\n\n"
72	resp, err := client.parseSSEResponse(strings.NewReader(sseData))
73	if err != nil {
74		t.Fatalf("parseSSEResponse() error: %v", err)
75	}
76	if resp.ID != float64(1) {
77		t.Errorf("expected ID=1, got %v", resp.ID)
78	}
79
80	// Test multiline data
81	sseData = "data: {\"jsonrpc\":\"2.0\",\ndata: \"id\":2,\"result\":{}}\n\n"
82	resp, err = client.parseSSEResponse(strings.NewReader(sseData))
83	if err != nil {
84		t.Fatalf("parseSSEResponse() error: %v", err)
85	}
86	if resp.ID != float64(2) {
87		t.Errorf("expected ID=2, got %v", resp.ID)
88	}
89}
90
91func TestClientParseSSEResponseLargePayload(t *testing.T) {
92	client := NewClient("")
93
94	largeValue := strings.Repeat("a", 70*1024)
95	sseData := "data: {\"jsonrpc\":\"2.0\",\"id\":3,\"result\":{\"payload\":\"" + largeValue + "\"}}\n\n"
96	resp, err := client.parseSSEResponse(strings.NewReader(sseData))
97	if err != nil {
98		t.Fatalf("parseSSEResponse() error: %v", err)
99	}
100	if resp.ID != float64(3) {
101		t.Errorf("expected ID=3, got %v", resp.ID)
102	}
103}
104
105func TestClientCallToolErrorReturnsToolResult(t *testing.T) {
106	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
107		var req Request
108		json.NewDecoder(r.Body).Decode(&req)
109
110		if req.Method != "tools/call" {
111			resp := NewErrorResponse(req.ID, 0, "unexpected method")
112			json.NewEncoder(w).Encode(resp)
113			return
114		}
115
116		resp := NewErrorResponse(req.ID, 42, "insufficient_items: Not enough Iron Ore")
117		json.NewEncoder(w).Encode(resp)
118	}))
119	defer server.Close()
120
121	client := NewClient(server.URL)
122	result, err := client.CallTool(context.Background(), "sell", map[string]string{"item_id": "ore_iron"})
123	if err != nil {
124		t.Fatalf("CallTool() error: %v", err)
125	}
126	if result == nil || !result.IsError {
127		t.Fatalf("expected tool error result, got %+v", result)
128	}
129	if len(result.Content) == 0 || !strings.Contains(result.Content[0].Text, "insufficient_items") {
130		t.Fatalf("expected error message in tool result, got %+v", result)
131	}
132}
133
134// TestClientClose verifies Close() is idempotent and returns nil.
135func TestClientClose(t *testing.T) {
136	client := NewClient("http://localhost:3000")
137
138	// First close should succeed
139	if err := client.Close(); err != nil {
140		t.Errorf("first Close() error: %v", err)
141	}
142
143	// Second close should also succeed (idempotent)
144	if err := client.Close(); err != nil {
145		t.Errorf("second Close() error: %v", err)
146	}
147}
148
149// TestClientInitializeRetry verifies Initialize retries on failure.
150func TestClientInitializeRetry(t *testing.T) {
151	attempts := 0
152	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
153		attempts++
154		if attempts < 2 {
155			// Fail first attempt
156			w.WriteHeader(http.StatusInternalServerError)
157			return
158		}
159
160		// Succeed on second attempt
161		var req Request
162		json.NewDecoder(r.Body).Decode(&req)
163
164		if req.Method == "initialize" {
165			result := map[string]interface{}{
166				"protocolVersion": "2024-11-05",
167				"capabilities":    map[string]interface{}{},
168				"serverInfo":      map[string]string{"name": "test", "version": "1.0"},
169			}
170			data, _ := json.Marshal(result)
171			resp := &Response{
172				JSONRPC: "2.0",
173				ID:      req.ID,
174				Result:  data,
175			}
176			json.NewEncoder(w).Encode(resp)
177		} else if req.Method == "notifications/initialized" {
178			w.WriteHeader(http.StatusNoContent)
179		}
180	}))
181	defer server.Close()
182
183	client := NewClient(server.URL)
184	_, err := client.Initialize(context.Background(), map[string]interface{}{"name": "test-client"})
185	if err != nil {
186		t.Fatalf("Initialize() should succeed after retry, got error: %v", err)
187	}
188
189	if attempts < 2 {
190		t.Errorf("expected at least 2 attempts, got %d", attempts)
191	}
192}