xonecas.io
60255
Zn

Zoea-Nova / commit 83403be

test: expand coverage for core, store, mcp, and provider packages

New test files:
- agent_tools_test.go: tool execution and error handling
- commander_async_test.go: async messaging and broadcast
- memories_test.go: memory search and retrieval
- client_test.go: MCP client initialization

Enhanced existing tests:
- provider_test.go: tool calls, concurrent access, message conversion
- agent_test.go: context memory limits, system prompt handling
- commander_test.go: updated for config changes
- store_test.go: migrated to file-based temp databases
- mcp_test.go: updated mock orchestrator interface

Coverage improved from ~50% to ~61%.

xonecas2026-02-04 83403be9461399cf8b018c340f73be61d395139b parent d5c6153

9 files changed

This diff is too big to show in full. The first 1000 lines are below, and every file is listed with its counts.

internal/core/agent_test.go+150−14
@@ -1,6 +1,8 @@
11 package core
22
33 import (
4+ "errors"
5+ "path/filepath"
46 "testing"
57 "time"
68
@@ -11,9 +13,11 @@ import (
1113 func setupAgentTest(t *testing.T) (*store.Store, *EventBus, func()) {
1214 t.Helper()
1315
14- s, err := store.OpenMemory()
16+ tmpDir := t.TempDir()
17+ dbPath := filepath.Join(tmpDir, "test.db")
18+ s, err := store.Open(dbPath)
1519 if err != nil {
16- t.Fatalf("OpenMemory() error: %v", err)
20+ t.Fatalf("Open() error: %v", err)
1721 }
1822
1923 bus := NewEventBus(100)
@@ -96,18 +100,32 @@ func TestAgentSendMessage(t *testing.T) {
96100 // Subscribe to events
97101 events := bus.Subscribe()
98102
103+ // Wait for the initial autonomous turn to finish
104+ // It should emit a response event for the ContinuePrompt
105+ timeout := time.After(2 * time.Second)
106+initialTurnLoop:
107+ for {
108+ select {
109+ case e := <-events:
110+ if e.Type == EventAgentResponse {
111+ break initialTurnLoop
112+ }
113+ case <-timeout:
114+ t.Fatal("timeout waiting for initial autonomous turn")
115+ }
116+ }
117+
99118 // Send message
100119 if err := agent.SendMessage("Hello, agent!", store.MemorySourceDirect); err != nil {
101120 t.Fatalf("SendMessage() error: %v", err)
102121 }
103122
104- // Should receive message and response events
105- // Also receives network events (LLM start, idle)
123+ // Should receive message and response events for our message
106124 var messageEvent, responseEvent bool
107- timeout := time.After(500 * time.Millisecond)
125+ timeout = time.After(2 * time.Second)
108126
109127 eventLoop:
110- for i := 0; i < 10; i++ { // Allow for all events including network events
128+ for {
111129 select {
112130 case e := <-events:
113131 if e.Type == EventAgentMessage {
@@ -117,10 +135,9 @@ eventLoop:
117135 }
118136 }
119137 if e.Type == EventAgentResponse {
120- responseEvent = true
121138 data := e.Data.(MessageData)
122- if data.Content != "I received your message!" {
123- t.Errorf("expected response 'I received your message!', got %s", data.Content)
139+ if data.Content == "I received your message!" {
140+ responseEvent = true
124141 }
125142 }
126143 // Break early if we have both events
@@ -133,21 +150,67 @@ eventLoop:
133150 }
134151
135152 if !messageEvent {
136- t.Error("expected message event")
153+ t.Error("expected message event for 'Hello, agent!'")
137154 }
138155 if !responseEvent {
139- t.Error("expected response event")
156+ t.Error("expected response event for 'I received your message!'")
140157 }
141158
142159 // Check memories were stored
143- memories, _ := s.GetMemories(stored.ID)
144- if len(memories) != 3 { // system prompt + user + assistant
145- t.Errorf("expected 3 memories, got %d", len(memories))
160+ // Expected: system prompt, continue prompt (initial trigger), assistant response (initial),
161+ // user message, assistant response
162+ memories, err := s.GetMemories(stored.ID)
163+ if err != nil {
164+ t.Fatalf("GetMemories() error: %v", err)
165+ }
166+ if len(memories) != 5 {
167+ t.Errorf("expected 5 memories, got %d", len(memories))
146168 }
147169
148170 agent.Stop()
149171 }
150172
173+func TestAgentSetErrorState(t *testing.T) {
174+ s, bus, cleanup := setupAgentTest(t)
175+ defer cleanup()
176+
177+ stored, _ := s.CreateAgent("error-state-test", "mock", "test-model")
178+ mock := provider.NewMock("mock", "response")
179+ agent := NewAgent(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
180+
181+ events := bus.Subscribe()
182+
183+ testErr := errors.New("test error")
184+ agent.setErrorState(testErr)
185+
186+ if agent.State() != AgentStateErrored {
187+ t.Errorf("expected state=errored, got %s", agent.State())
188+ }
189+ if agent.LastError() != testErr {
190+ t.Errorf("expected last error %v, got %v", testErr, agent.LastError())
191+ }
192+
193+ // Should receive state change event first
194+ select {
195+ case e := <-events:
196+ if e.Type != EventAgentStateChanged {
197+ t.Errorf("expected EventAgentStateChanged, got %s", e.Type)
198+ }
199+ case <-time.After(100 * time.Millisecond):
200+ t.Fatal("timeout waiting for state change event")
201+ }
202+
203+ // Should receive error event
204+ select {
205+ case e := <-events:
206+ if e.Type != EventAgentError {
207+ t.Errorf("expected EventAgentError, got %s", e.Type)
208+ }
209+ case <-time.After(100 * time.Millisecond):
210+ t.Fatal("timeout waiting for error event")
211+ }
212+}
213+
151214 func TestAgentProviderName(t *testing.T) {
152215 s, bus, cleanup := setupAgentTest(t)
153216 defer cleanup()
@@ -198,3 +261,76 @@ func TestAgentStateEvents(t *testing.T) {
198261
199262 agent.Stop()
200263 }
264+
265+func TestAgentContextMemoryLimit(t *testing.T) {
266+ s, bus, cleanup := setupAgentTest(t)
267+ defer cleanup()
268+
269+ stored, _ := s.CreateAgent("context-test", "mock", "test-model")
270+ mock := provider.NewMock("mock", "response")
271+ agent := NewAgent(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
272+
273+ // Add system prompt
274+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt")
275+
276+ // Add more memories than MaxContextMessages
277+ for i := 0; i < MaxContextMessages+10; i++ {
278+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message")
279+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response")
280+ }
281+
282+ // Get context memories
283+ memories, err := agent.getContextMemories()
284+ if err != nil {
285+ t.Fatalf("getContextMemories() error: %v", err)
286+ }
287+
288+ // Should have system prompt + MaxContextMessages recent messages
289+ expectedCount := MaxContextMessages + 1 // +1 for system prompt
290+ if len(memories) != expectedCount {
291+ t.Errorf("expected %d memories, got %d", expectedCount, len(memories))
292+ }
293+
294+ // First memory should be system prompt
295+ if memories[0].Role != store.MemoryRoleSystem {
296+ t.Errorf("expected first memory to be system prompt, got %s", memories[0].Role)
297+ }
298+ if memories[0].Content != "System prompt" {
299+ t.Errorf("expected system prompt content, got %s", memories[0].Content)
300+ }
301+}
302+
303+func TestAgentContextMemoryWithRecentSystemPrompt(t *testing.T) {
304+ s, bus, cleanup := setupAgentTest(t)
305+ defer cleanup()
306+
307+ stored, _ := s.CreateAgent("context-test-2", "mock", "test-model")
308+ mock := provider.NewMock("mock", "response")
309+ agent := NewAgent(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
310+
311+ // Add system prompt
312+ s.AddMemory(stored.ID, store.MemoryRoleSystem, store.MemorySourceSystem, "System prompt")
313+
314+ // Add fewer memories than MaxContextMessages
315+ for i := 0; i < 5; i++ {
316+ s.AddMemory(stored.ID, store.MemoryRoleUser, store.MemorySourceDirect, "user message")
317+ s.AddMemory(stored.ID, store.MemoryRoleAssistant, store.MemorySourceLLM, "assistant response")
318+ }
319+
320+ // Get context memories
321+ memories, err := agent.getContextMemories()
322+ if err != nil {
323+ t.Fatalf("getContextMemories() error: %v", err)
324+ }
325+
326+ // Should have all memories (system + 10 messages)
327+ expectedCount := 11 // 1 system + 5*2 messages
328+ if len(memories) != expectedCount {
329+ t.Errorf("expected %d memories, got %d", expectedCount, len(memories))
330+ }
331+
332+ // First memory should still be system prompt
333+ if memories[0].Role != store.MemoryRoleSystem {
334+ t.Errorf("expected first memory to be system prompt, got %s", memories[0].Role)
335+ }
336+}
internal/core/agent_tools_test.go+197−0
@@ -0,0 +1,197 @@
1+package core
2+
3+import (
4+ "context"
5+ "encoding/json"
6+ "errors"
7+ "testing"
8+ "time"
9+
10+ "github.com/xonecas/zoea-nova/internal/mcp"
11+ "github.com/xonecas/zoea-nova/internal/provider"
12+ "github.com/xonecas/zoea-nova/internal/store"
13+)
14+
15+func TestAgentToolExecution(t *testing.T) {
16+ s, bus, cleanup := setupAgentTest(t)
17+ defer cleanup()
18+
19+ stored, _ := s.CreateAgent("tool-agent", "mock", "test-model")
20+
21+ // Mock provider that returns a tool call first, then a text response
22+ mock := provider.NewMock("mock", "Initial response")
23+
24+ agent := NewAgent(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
25+
26+ // Setup MCP proxy with a local tool
27+ proxy := mcp.NewProxy("")
28+ proxy.RegisterTool(mcp.Tool{
29+ Name: "test_tool",
30+ Description: "A test tool",
31+ InputSchema: json.RawMessage(`{"type": "object"}`),
32+ }, func(ctx context.Context, args json.RawMessage) (*mcp.ToolResult, error) {
33+ return &mcp.ToolResult{
34+ Content: []mcp.ContentBlock{{Type: "text", Text: "tool result content"}},
35+ }, nil
36+ })
37+ agent.SetMCP(proxy)
38+
39+ events := bus.Subscribe()
40+ agent.Start()
41+
42+ // Wait for initial turn to finish
43+ timeout := time.After(5 * time.Second)
44+ initialFinished := false
45+ for !initialFinished {
46+ select {
47+ case e := <-events:
48+ if e.Type == EventAgentResponse {
49+ data := e.Data.(MessageData)
50+ if data.Content == "Initial response" {
51+ initialFinished = true
52+ }
53+ }
54+ case <-timeout:
55+ t.Fatal("timeout waiting for initial turn")
56+ }
57+ }
58+
59+ // Now set tool calls for the next turn
60+ mock.WithResponse("Final response")
61+ mock.WithToolCalls([]provider.ToolCall{
62+ {
63+ ID: "call_1",
64+ Name: "test_tool",
65+ Arguments: json.RawMessage(`{"arg": "val"}`),
66+ },
67+ })
68+
69+ // Send message to trigger the loop
70+ go agent.SendMessage("Use the tool", store.MemorySourceDirect)
71+
72+ // Wait for tool call event
73+ toolCalled := false
74+ for !toolCalled {
75+ select {
76+ case e := <-events:
77+ if e.Type == EventAgentMessage {
78+ data := e.Data.(MessageData)
79+ if data.Role == "assistant" && data.Content == "Calling tools: test_tool" {
80+ toolCalled = true
81+ // Now update mock to return NO tool calls for the next iteration
82+ mock.WithToolCalls(nil)
83+ }
84+ }
85+ case <-timeout:
86+ t.Fatal("timeout waiting for tool call")
87+ }
88+ }
89+
90+ // Wait for final response
91+ finalResponse := false
92+ for !finalResponse {
93+ select {
94+ case e := <-events:
95+ if e.Type == EventAgentResponse {
96+ finalResponse = true
97+ }
98+ case <-timeout:
99+ t.Fatal("timeout waiting for final response")
100+ }
101+ }
102+
103+ // Verify memories with retry
104+ deadline := time.Now().Add(2 * time.Second)
105+ foundToolResult := false
106+ for time.Now().Before(deadline) {
107+ memories, _ := s.GetMemories(stored.ID)
108+ for _, m := range memories {
109+ if m.Role == store.MemoryRoleTool && m.Content == "call_1:tool result content" {
110+ foundToolResult = true
111+ break
112+ }
113+ }
114+ if foundToolResult {
115+ break
116+ }
117+ time.Sleep(100 * time.Millisecond)
118+ }
119+
120+ if !foundToolResult {
121+ t.Error("tool result not found in memories")
122+ }
123+}
124+
125+func TestAgentToolError(t *testing.T) {
126+ s, bus, cleanup := setupAgentTest(t)
127+ defer cleanup()
128+
129+ stored, _ := s.CreateAgent("tool-err-agent", "mock", "test-model")
130+
131+ mock := provider.NewMock("mock", "Initial response")
132+
133+ agent := NewAgent(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
134+
135+ proxy := mcp.NewProxy("")
136+ proxy.RegisterTool(mcp.Tool{
137+ Name: "error_tool",
138+ }, func(ctx context.Context, args json.RawMessage) (*mcp.ToolResult, error) {
139+ return nil, errors.New("tool failed")
140+ })
141+ agent.SetMCP(proxy)
142+
143+ events := bus.Subscribe()
144+ agent.Start()
145+
146+ // Wait for initial turn
147+ timeout := time.After(5 * time.Second)
148+ initialFinished := false
149+ for !initialFinished {
150+ select {
151+ case e := <-events:
152+ if e.Type == EventAgentResponse {
153+ initialFinished = true
154+ }
155+ case <-timeout:
156+ t.Fatal("timeout waiting for initial turn")
157+ }
158+ }
159+
160+ // Now set tool calls
161+ mock.WithToolCalls([]provider.ToolCall{
162+ {
163+ ID: "call_err",
164+ Name: "error_tool",
165+ Arguments: json.RawMessage(`{}`),
166+ },
167+ })
168+
169+ // Update mock after first call to stop the loop
170+ go func() {
171+ time.Sleep(100 * time.Millisecond)
172+ mock.WithToolCalls(nil)
173+ }()
174+
175+ agent.SendMessage("Trigger error", store.MemorySourceDirect)
176+
177+ // Verify memory contains error with retry
178+ deadline := time.Now().Add(2 * time.Second)
179+ foundError := false
180+ for time.Now().Before(deadline) {
181+ memories, _ := s.GetMemories(stored.ID)
182+ for _, m := range memories {
183+ if m.Role == store.MemoryRoleTool && m.Content == "call_err:Error: tool failed" {
184+ foundError = true
185+ break
186+ }
187+ }
188+ if foundError {
189+ break
190+ }
191+ time.Sleep(100 * time.Millisecond)
192+ }
193+
194+ if !foundError {
195+ t.Error("tool error not found in memories")
196+ }
197+}
internal/core/commander_async_test.go+162−0
@@ -0,0 +1,162 @@
1+package core
2+
3+import (
4+ "path/filepath"
5+ "testing"
6+ "time"
7+
8+ "github.com/xonecas/zoea-nova/internal/config"
9+ "github.com/xonecas/zoea-nova/internal/mcp"
10+ "github.com/xonecas/zoea-nova/internal/provider"
11+ "github.com/xonecas/zoea-nova/internal/store"
12+)
13+
14+func setupCommanderAsyncTest(t *testing.T) (*Commander, *store.Store, *EventBus, func()) {
15+ t.Helper()
16+
17+ tmpDir := t.TempDir()
18+ dbPath := filepath.Join(tmpDir, "test.db")
19+ s, err := store.Open(dbPath)
20+ if err != nil {
21+ t.Fatalf("Open() error: %v", err)
22+ }
23+
24+ bus := NewEventBus(100)
25+ reg := provider.NewRegistry()
26+ cfg := config.DefaultConfig()
27+ cfg.Providers["mock"] = config.ProviderConfig{Model: "test-model"}
28+ cfg.Providers["mock1"] = config.ProviderConfig{Model: "test-model"}
29+ cfg.Providers["mock2"] = config.ProviderConfig{Model: "test-model"}
30+
31+ c := NewCommander(s, reg, bus, cfg)
32+
33+ // Set a dummy MCP proxy to avoid "no tools" error events
34+ proxy := mcp.NewProxy("")
35+ c.SetMCP(proxy)
36+
37+ cleanup := func() {
38+ bus.Close()
39+ s.Close()
40+ }
41+
42+ return c, s, bus, cleanup
43+}
44+
45+func TestCommanderSendMessageAsync(t *testing.T) {
46+ c, _, bus, cleanup := setupCommanderAsyncTest(t)
47+ defer cleanup()
48+
49+ mock := provider.NewMock("mock", "response")
50+ c.registry.Register(mock)
51+
52+ agent, _ := c.CreateAgent("async-agent", "mock")
53+
54+ events := bus.Subscribe()
55+ agent.Start()
56+
57+ // Wait for initial turn
58+ timeout := time.After(10 * time.Second)
59+ found := false
60+ for !found {
61+ select {
62+ case e := <-events:
63+ if e.Type == EventAgentResponse {
64+ found = true
65+ }
66+ case <-timeout:
67+ t.Fatal("timeout waiting for initial turn")
68+ }
69+ }
70+
71+ // Send async message
72+ if err := c.SendMessageAsync(agent.ID(), "Hello async"); err != nil {
73+ t.Fatalf("SendMessageAsync() error: %v", err)
74+ }
75+
76+ // Should receive response eventually
77+ found = false
78+ for !found {
79+ select {
80+ case e := <-events:
81+ if e.Type == EventAgentResponse {
82+ found = true
83+ }
84+ case <-timeout:
85+ t.Fatal("timeout waiting for async response")
86+ }
87+ }
88+}
89+
90+func TestCommanderBroadcastAsync(t *testing.T) {
91+ c, _, bus, cleanup := setupCommanderAsyncTest(t)
92+ defer cleanup()
93+
94+ // Use separate mocks to avoid any potential contention
95+ m1 := provider.NewMock("mock1", "response1")
96+ m2 := provider.NewMock("mock2", "response2")
97+ c.registry.Register(m1)
98+ c.registry.Register(m2)
99+
100+ a1, err := c.CreateAgent("a1", "mock1")
101+ if err != nil {
102+ t.Fatalf("CreateAgent(a1) error: %v", err)
103+ }
104+ a2, err := c.CreateAgent("a2", "mock2")
105+ if err != nil {
106+ t.Fatalf("CreateAgent(a2) error: %v", err)
107+ }
108+
109+ events := bus.Subscribe()
110+ if err := a1.Start(); err != nil {
111+ t.Fatalf("a1.Start() error: %v", err)
112+ }
113+ // Wait for a1 initial turn
114+ timeout := time.After(10 * time.Second)
115+ found := false
116+ for !found {
117+ select {
118+ case e := <-events:
119+ if e.Type == EventAgentResponse && e.AgentID == a1.ID() {
120+ found = true
121+ }
122+ case <-timeout:
123+ t.Fatal("timeout waiting for a1 initial turn")
124+ }
125+ }
126+
127+ if err := a2.Start(); err != nil {
128+ t.Fatalf("a2.Start() error: %v", err)
129+ }
130+ // Wait for a2 initial turn
131+ timeout = time.After(10 * time.Second)
132+ found = false
133+ for !found {
134+ select {
135+ case e := <-events:
136+ if e.Type == EventAgentResponse && e.AgentID == a2.ID() {
137+ found = true
138+ }
139+ case <-timeout:
140+ t.Fatal("timeout waiting for a2 initial turn")
141+ }
142+ }
143+
144+ // Broadcast async
145+ if err := c.BroadcastAsync("Hello swarm"); err != nil {
146+ t.Fatalf("BroadcastAsync() error: %v", err)
147+ }
148+
149+ // Should receive 2 responses
150+ responses := make(map[string]bool)
151+ timeout = time.After(15 * time.Second)
152+ for len(responses) < 2 {
153+ select {
154+ case e := <-events:
155+ if e.Type == EventAgentResponse {
156+ responses[e.AgentID] = true
157+ }
158+ case <-timeout:
159+ t.Fatalf("timeout waiting for broadcast responses, got %d", len(responses))
160+ }
161+ }
162+}
internal/core/commander_test.go+21−10
@@ -1,10 +1,12 @@
11 package core
22
33 import (
4+ "path/filepath"
45 "testing"
56 "time"
67
78 "github.com/xonecas/zoea-nova/internal/config"
9+ "github.com/xonecas/zoea-nova/internal/mcp"
810 "github.com/xonecas/zoea-nova/internal/provider"
911 "github.com/xonecas/zoea-nova/internal/store"
1012 )
@@ -12,9 +14,11 @@ import (
1214 func setupCommanderTest(t *testing.T) (*Commander, *EventBus, func()) {
1315 t.Helper()
1416
15- s, err := store.OpenMemory()
17+ tmpDir := t.TempDir()
18+ dbPath := filepath.Join(tmpDir, "test.db")
19+ s, err := store.Open(dbPath)
1620 if err != nil {
17- t.Fatalf("OpenMemory() error: %v", err)
21+ t.Fatalf("Open() error: %v", err)
1822 }
1923
2024 bus := NewEventBus(100)
@@ -25,8 +29,7 @@ func setupCommanderTest(t *testing.T) (*Commander, *EventBus, func()) {
2529
2630 cfg := &config.Config{
2731 Swarm: config.SwarmConfig{
28- DefaultAgents: 4,
29- MaxAgents: 16,
32+ MaxAgents: 16,
3033 },
3134 Providers: map[string]config.ProviderConfig{
3235 "mock": {Endpoint: "http://mock", Model: "mock-model"},
@@ -36,6 +39,10 @@ func setupCommanderTest(t *testing.T) (*Commander, *EventBus, func()) {
3639
3740 cmd := NewCommander(s, reg, bus, cfg)
3841
42+ // Set a dummy MCP proxy to avoid "no tools" error events
43+ proxy := mcp.NewProxy("")
44+ cmd.SetMCP(proxy)
45+
3946 cleanup := func() {
4047 cmd.StopAll()
4148 bus.Close()
@@ -319,13 +326,17 @@ func TestCommanderBroadcast(t *testing.T) {
319326 }
320327
321328 // Should receive broadcast event
322- select {
323- case e := <-events:
324- if e.Type != EventBroadcast {
325- t.Errorf("expected EventBroadcast, got %s", e.Type)
329+ found := false
330+ timeout := time.After(2 * time.Second)
331+ for !found {
332+ select {
333+ case e := <-events:
334+ if e.Type == EventBroadcast {
335+ found = true
336+ }
337+ case <-timeout:
338+ t.Fatal("timeout waiting for broadcast event")
326339 }
327- case <-time.After(100 * time.Millisecond):
328- t.Fatal("timeout waiting for broadcast event")
329340 }
330341 }
331342
internal/mcp/client_test.go+89−0
@@ -0,0 +1,89 @@
1+package mcp
2+
3+import (
4+ "context"
5+ "encoding/json"
6+ "net/http"
7+ "net/http/httptest"
8+ "strings"
9+ "testing"
10+)
11+
12+func 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+
46+func 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+
68+func 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+}
internal/mcp/mcp_test.go+13−5
@@ -199,7 +199,7 @@ func (m *mockOrchestrator) MaxAgents() int {
199199 return 16
200200 }
201201
202-func (m *mockOrchestrator) SendMessage(agentID, message string) error {
202+func (m *mockOrchestrator) SendMessageAsync(agentID, message string) error {
203203 for _, a := range m.agents {
204204 if a.ID == agentID {
205205 return nil
@@ -208,10 +208,18 @@ func (m *mockOrchestrator) SendMessage(agentID, message string) error {
208208 return errors.New("agent not found")
209209 }
210210
211-func (m *mockOrchestrator) Broadcast(message string) error {
211+func (m *mockOrchestrator) BroadcastAsync(message string) error {
212212 return nil
213213 }
214214
215+func (m *mockOrchestrator) SearchMessages(agentID, query string, limit int) ([]SearchResult, error) {
216+ return []SearchResult{}, nil
217+}
218+
219+func (m *mockOrchestrator) SearchBroadcasts(query string, limit int) ([]BroadcastResult, error) {
220+ return []BroadcastResult{}, nil
221+}
222+
215223 func TestOrchestratorTools(t *testing.T) {
216224 // Create mock orchestrator
217225 orchestrator := &mockOrchestrator{
@@ -224,9 +232,9 @@ func TestOrchestratorTools(t *testing.T) {
224232 proxy := NewProxy("")
225233 RegisterOrchestratorTools(proxy, orchestrator)
226234
227- // Should have 5 orchestrator tools registered
228- if proxy.LocalToolCount() != 5 {
229- t.Errorf("expected 5 local tools, got %d", proxy.LocalToolCount())
235+ // Should have 7 orchestrator tools registered
236+ if proxy.LocalToolCount() != 7 {
237+ t.Errorf("expected 7 local tools, got %d", proxy.LocalToolCount())
230238 }
231239
232240 ctx := context.Background()
internal/provider/provider_test.go+155−0
@@ -2,6 +2,7 @@ package provider
22
33 import (
44 "context"
5+ "encoding/json"
56 "errors"
67 "testing"
78 )
@@ -144,3 +145,157 @@ func TestToOpenAIMessages(t *testing.T) {
144145 t.Errorf("expected content=Hello, got %s", result[1].Content)
145146 }
146147 }
148+
149+func TestToOpenAIMessagesWithToolCalls(t *testing.T) {
150+ messages := []Message{
151+ {Role: "user", Content: "What's the weather?"},
152+ {
153+ Role: "assistant",
154+ Content: "",
155+ ToolCalls: []ToolCall{
156+ {ID: "call_123", Name: "get_weather", Arguments: json.RawMessage(`{"location":"NYC"}`)},
157+ },
158+ },
159+ {Role: "tool", Content: `{"temp": 72}`, ToolCallID: "call_123"},
160+ }
161+
162+ result := toOpenAIMessages(messages)
163+
164+ if len(result) != 3 {
165+ t.Fatalf("expected 3 messages, got %d", len(result))
166+ }
167+
168+ // Check assistant message has tool calls
169+ assistantMsg := result[1]
170+ if len(assistantMsg.ToolCalls) != 1 {
171+ t.Fatalf("expected 1 tool call, got %d", len(assistantMsg.ToolCalls))
172+ }
173+ if assistantMsg.ToolCalls[0].ID != "call_123" {
174+ t.Errorf("expected tool call ID=call_123, got %s", assistantMsg.ToolCalls[0].ID)
175+ }
176+ if assistantMsg.ToolCalls[0].Function.Name != "get_weather" {
177+ t.Errorf("expected function name=get_weather, got %s", assistantMsg.ToolCalls[0].Function.Name)
178+ }
179+
180+ // Check tool result message has ToolCallID
181+ toolMsg := result[2]
182+ if toolMsg.ToolCallID != "call_123" {
183+ t.Errorf("expected ToolCallID=call_123, got %s", toolMsg.ToolCallID)
184+ }
185+}
186+
187+func TestMockProviderChatWithTools(t *testing.T) {
188+ toolCalls := []ToolCall{
189+ {ID: "call_abc", Name: "test_tool", Arguments: json.RawMessage(`{}`)},
190+ }
191+ mock := NewMock("test", "thinking...").WithToolCalls(toolCalls)
192+
193+ ctx := context.Background()
194+ messages := []Message{{Role: "user", Content: "Do something"}}
195+ tools := []Tool{{Name: "test_tool", Description: "A test tool"}}
196+
197+ resp, err := mock.ChatWithTools(ctx, messages, tools)
198+ if err != nil {
199+ t.Fatalf("ChatWithTools() error: %v", err)
200+ }
201+
202+ if resp.Content != "thinking..." {
203+ t.Errorf("expected content='thinking...', got %s", resp.Content)
204+ }
205+ if len(resp.ToolCalls) != 1 {
206+ t.Fatalf("expected 1 tool call, got %d", len(resp.ToolCalls))
207+ }
208+ if resp.ToolCalls[0].Name != "test_tool" {
209+ t.Errorf("expected tool name=test_tool, got %s", resp.ToolCalls[0].Name)
210+ }
211+}
212+
213+func TestMockProviderChatWithToolsError(t *testing.T) {
214+ expectedErr := errors.New("tools error")
215+ mock := NewMock("test", "").WithChatError(expectedErr)
216+
217+ ctx := context.Background()
218+ messages := []Message{{Role: "user", Content: "Do something"}}
219+ tools := []Tool{{Name: "test_tool", Description: "A test tool"}}
220+
221+ _, err := mock.ChatWithTools(ctx, messages, tools)
222+ if !errors.Is(err, expectedErr) {
223+ t.Errorf("expected %v, got %v", expectedErr, err)
224+ }
225+}
226+
227+func TestMockProviderWithResponse(t *testing.T) {
228+ mock := NewMock("test", "initial")
229+
230+ ctx := context.Background()
231+ messages := []Message{{Role: "user", Content: "Hi"}}
232+
233+ // Initial response
234+ resp, _ := mock.Chat(ctx, messages)
235+ if resp != "initial" {
236+ t.Errorf("expected 'initial', got %s", resp)
237+ }
238+
239+ // Change response
240+ mock.WithResponse("updated")
241+ resp, _ = mock.Chat(ctx, messages)
242+ if resp != "updated" {
243+ t.Errorf("expected 'updated', got %s", resp)
244+ }
245+}
246+
247+func TestMockProviderConcurrentAccess(t *testing.T) {
248+ mock := NewMock("test", "response")
249+ ctx := context.Background()
250+ messages := []Message{{Role: "user", Content: "Hi"}}
251+
252+ // Run concurrent reads and writes
253+ done := make(chan bool)
254+ for i := 0; i < 10; i++ {
255+ go func() {
256+ mock.Chat(ctx, messages)
257+ done <- true
258+ }()
259+ go func() {
260+ mock.WithResponse("new response")
261+ done <- true
262+ }()
263+ }
264+
265+ // Wait for all goroutines
266+ for i := 0; i < 20; i++ {
267+ <-done
268+ }
269+}
270+
271+func TestToOpenAIMessagesEmpty(t *testing.T) {
272+ result := toOpenAIMessages([]Message{})
273+ if len(result) != 0 {
274+ t.Errorf("expected empty slice, got %d messages", len(result))
275+ }
276+}
277+
278+func TestToOpenAIMessagesMultipleToolCalls(t *testing.T) {
279+ messages := []Message{
280+ {
281+ Role: "assistant",
282+ Content: "",
283+ ToolCalls: []ToolCall{
284+ {ID: "call_1", Name: "tool_a", Arguments: json.RawMessage(`{"a":1}`)},
285+ {ID: "call_2", Name: "tool_b", Arguments: json.RawMessage(`{"b":2}`)},
286+ },
287+ },
288+ }
289+
290+ result := toOpenAIMessages(messages)
291+
292+ if len(result[0].ToolCalls) != 2 {
293+ t.Fatalf("expected 2 tool calls, got %d", len(result[0].ToolCalls))
294+ }
295+ if result[0].ToolCalls[0].Function.Arguments != `{"a":1}` {
296+ t.Errorf("expected arguments={\"a\":1}, got %s", result[0].ToolCalls[0].Function.Arguments)
297+ }
298+ if result[0].ToolCalls[1].Function.Arguments != `{"b":2}` {
299+ t.Errorf("expected arguments={\"b\":2}, got %s", result[0].ToolCalls[1].Function.Arguments)
300+ }
301+}
internal/store/memories_test.go+133−0
@@ -0,0 +1,133 @@
1+package store
2+
3+import (
4+ "path/filepath"
5+ "testing"
6+)
7+
8+func setupMemoriesTest(t *testing.T) (*Store, func()) {
9+ t.Helper()
10+ tmpDir := t.TempDir()
11+ dbPath := filepath.Join(tmpDir, "test.db")
12+ s, err := Open(dbPath)
13+ if err != nil {
14+ t.Fatalf("Open() error: %v", err)
15+ }
16+ return s, func() { s.Close() }
17+}
18+
19+func TestGetSystemMemory(t *testing.T) {
20+ s, cleanup := setupMemoriesTest(t)
21+ defer cleanup()
22+
23+ agent, _ := s.CreateAgent("test", "mock", "model")
24+
25+ // No system memory yet
26+ _, err := s.GetSystemMemory(agent.ID)
27+ if err == nil {
28+ t.Error("expected error getting non-existent system memory")
29+ }
30+
31+ // Add system memory
32+ expected := "You are a test."
33+ s.AddMemory(agent.ID, MemoryRoleSystem, MemorySourceSystem, expected)
34+
35+ // Add other memories
36+ s.AddMemory(agent.ID, MemoryRoleUser, MemorySourceDirect, "hello")
37+
38+ system, err := s.GetSystemMemory(agent.ID)
39+ if err != nil {
40+ t.Fatalf("GetSystemMemory() error: %v", err)
41+ }
42+ if system.Content != expected {
43+ t.Errorf("expected content %q, got %q", expected, system.Content)
44+ }
45+}
Cut short: this commit's diff is over 1000 lines.
internal/store/store_test.go+21−21
Cut short: this commit's diff is over 1000 lines.