xonecas.io
6119
My

mysis / files

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