xonecas.io
60255
Zn

Zoea-Nova / commit 204ed54

test(integration): add end-to-end broadcast sender tracking test

Verify complete broadcast sender flow:
- Create sender and 2 receivers
- Sender broadcasts via zoea_broadcast tool with CallerContext
- Verify sender does NOT receive its own broadcast
- Verify receivers receive broadcast with correct sender_id
- Verify SearchBroadcasts returns sender_id
- Add orchestratorAdapter helper for integration tests

xonecas2026-02-05 204ed542a44ddd2acefac0beaa2fe697f65d0b69 parent e893f7c

1 file changed

internal/integration/broadcast_sender_test.go+235−0
@@ -0,0 +1,235 @@
1+package integration
2+
3+import (
4+ "context"
5+ "encoding/json"
6+ "path/filepath"
7+ "testing"
8+ "time"
9+
10+ "github.com/xonecas/zoea-nova/internal/config"
11+ "github.com/xonecas/zoea-nova/internal/core"
12+ "github.com/xonecas/zoea-nova/internal/mcp"
13+ "github.com/xonecas/zoea-nova/internal/provider"
14+ "github.com/xonecas/zoea-nova/internal/store"
15+ "golang.org/x/time/rate"
16+)
17+
18+type orchestratorAdapter struct {
19+ commander *core.Commander
20+}
21+
22+func (a *orchestratorAdapter) ListMyses() []mcp.MysisInfo {
23+ myses := a.commander.ListMyses()
24+ result := make([]mcp.MysisInfo, len(myses))
25+ for i, mysis := range myses {
26+ result[i] = mcp.MysisInfo{
27+ ID: mysis.ID(),
28+ Name: mysis.Name(),
29+ LastError: mysis.LastError(),
30+ }
31+ }
32+ return result
33+}
34+
35+func (a *orchestratorAdapter) MysisCount() int {
36+ return a.commander.MysisCount()
37+}
38+
39+func (a *orchestratorAdapter) MaxMyses() int {
40+ return a.commander.MaxMyses()
41+}
42+
43+func (a *orchestratorAdapter) GetStateCounts() map[string]int {
44+ return a.commander.GetStateCounts()
45+}
46+
47+func (a *orchestratorAdapter) SendMessageAsync(mysisID, message string) error {
48+ return a.commander.SendMessageAsync(mysisID, message)
49+}
50+
51+func (a *orchestratorAdapter) BroadcastAsync(message string) error {
52+ return a.commander.BroadcastAsync(message)
53+}
54+
55+func (a *orchestratorAdapter) BroadcastFrom(senderID, message string) error {
56+ return a.commander.BroadcastFrom(senderID, message)
57+}
58+
59+func (a *orchestratorAdapter) SearchMessages(mysisID, query string, limit int) ([]mcp.SearchResult, error) {
60+ memories, err := a.commander.Store().SearchMemories(mysisID, query, limit)
61+ if err != nil {
62+ return nil, err
63+ }
64+
65+ results := make([]mcp.SearchResult, len(memories))
66+ for i, m := range memories {
67+ results[i] = mcp.SearchResult{
68+ Role: string(m.Role),
69+ Source: string(m.Source),
70+ Content: m.Content,
71+ CreatedAt: m.CreatedAt.Format("2006-01-02 15:04:05"),
72+ }
73+ }
74+ return results, nil
75+}
76+
77+func (a *orchestratorAdapter) SearchReasoning(mysisID, query string, limit int) ([]mcp.ReasoningResult, error) {
78+ memories, err := a.commander.Store().SearchReasoning(mysisID, query, limit)
79+ if err != nil {
80+ return nil, err
81+ }
82+
83+ results := make([]mcp.ReasoningResult, len(memories))
84+ for i, m := range memories {
85+ results[i] = mcp.ReasoningResult{
86+ Role: string(m.Role),
87+ Source: string(m.Source),
88+ Content: m.Content,
89+ Reasoning: m.Reasoning,
90+ CreatedAt: m.CreatedAt.Format("2006-01-02 15:04:05"),
91+ }
92+ }
93+ return results, nil
94+}
95+
96+func (a *orchestratorAdapter) SearchBroadcasts(query string, limit int) ([]mcp.BroadcastResult, error) {
97+ broadcasts, err := a.commander.Store().SearchBroadcasts(query, limit)
98+ if err != nil {
99+ return nil, err
100+ }
101+
102+ results := make([]mcp.BroadcastResult, len(broadcasts))
103+ for i, b := range broadcasts {
104+ results[i] = mcp.BroadcastResult{
105+ Content: b.Content,
106+ CreatedAt: b.CreatedAt.Format("2006-01-02 15:04:05"),
107+ }
108+ }
109+ return results, nil
110+}
111+
112+func (a *orchestratorAdapter) ClaimAccount() (mcp.AccountInfo, error) {
113+ acc, err := a.commander.Store().ClaimAccount()
114+ if err != nil {
115+ return mcp.AccountInfo{}, err
116+ }
117+
118+ return mcp.AccountInfo{
119+ Username: acc.Username,
120+ Password: acc.Password,
121+ }, nil
122+}
123+
124+func setupIntegrationCommander(t *testing.T) (*core.Commander, *store.Store, *mcp.Proxy, func()) {
125+ t.Helper()
126+
127+ tmpDir := t.TempDir()
128+ dbPath := filepath.Join(tmpDir, "test.db")
129+ s, err := store.Open(dbPath)
130+ if err != nil {
131+ t.Fatalf("Open() error: %v", err)
132+ }
133+
134+ bus := core.NewEventBus(100)
135+
136+ reg := provider.NewRegistry()
137+ limiter := rate.NewLimiter(rate.Limit(1000), 1000)
138+ reg.RegisterFactory(provider.NewMockFactoryWithLimiter("mock", "mock response", limiter))
139+
140+ cfg := &config.Config{
141+ Swarm: config.SwarmConfig{
142+ MaxMyses: 16,
143+ },
144+ Providers: map[string]config.ProviderConfig{
145+ "mock": {Endpoint: "http://mock", Model: "mock-model", Temperature: 0.7},
146+ },
147+ }
148+
149+ cmd := core.NewCommander(s, reg, bus, cfg)
150+ proxy := mcp.NewProxy("")
151+ mcp.RegisterOrchestratorTools(proxy, &orchestratorAdapter{commander: cmd})
152+ cmd.SetMCP(proxy)
153+
154+ cleanup := func() {
155+ bus.Close()
156+ s.Close()
157+ }
158+
159+ return cmd, s, proxy, cleanup
160+}
161+
162+func TestBroadcastSenderTracking(t *testing.T) {
163+ cmd, s, proxy, cleanup := setupIntegrationCommander(t)
164+ defer cleanup()
165+
166+ sender, _ := cmd.CreateMysis("sender", "mock")
167+ receiver1, _ := cmd.CreateMysis("receiver1", "mock")
168+ receiver2, _ := cmd.CreateMysis("receiver2", "mock")
169+
170+ cmd.StartMysis(sender.ID())
171+ cmd.StartMysis(receiver1.ID())
172+ cmd.StartMysis(receiver2.ID())
173+
174+ deadline := time.Now().Add(time.Second)
175+ for time.Now().Before(deadline) {
176+ if sender.State() == core.MysisStateRunning && receiver1.State() == core.MysisStateRunning && receiver2.State() == core.MysisStateRunning {
177+ break
178+ }
179+ time.Sleep(10 * time.Millisecond)
180+ }
181+ if sender.State() != core.MysisStateRunning || receiver1.State() != core.MysisStateRunning || receiver2.State() != core.MysisStateRunning {
182+ t.Fatal("myses failed to start within timeout")
183+ }
184+
185+ ctx := context.Background()
186+ caller := mcp.CallerContext{MysisID: sender.ID(), MysisName: sender.Name()}
187+ args := json.RawMessage(`{"message": "integration test broadcast"}`)
188+ result, err := proxy.CallTool(ctx, caller, "zoea_broadcast", args)
189+ if err != nil {
190+ t.Fatalf("CallTool() error: %v", err)
191+ }
192+ if result.IsError {
193+ t.Fatalf("tool returned error: %v", result.Content[0].Text)
194+ }
195+
196+ time.Sleep(200 * time.Millisecond)
197+
198+ senderMems, err := s.GetRecentMemories(sender.ID(), 50)
199+ if err != nil {
200+ t.Fatalf("GetRecentMemories() error: %v", err)
201+ }
202+ for _, m := range senderMems {
203+ if m.Source == store.MemorySourceBroadcast && m.Content == "integration test broadcast" {
204+ t.Error("sender received its own broadcast")
205+ }
206+ }
207+
208+ for _, receiver := range []*core.Mysis{receiver1, receiver2} {
209+ mems, err := s.GetRecentMemories(receiver.ID(), 50)
210+ if err != nil {
211+ t.Fatalf("GetRecentMemories() error: %v", err)
212+ }
213+ found := false
214+ for _, m := range mems {
215+ if m.Source == store.MemorySourceBroadcast && m.Content == "integration test broadcast" && m.SenderID == sender.ID() {
216+ found = true
217+ break
218+ }
219+ }
220+ if !found {
221+ t.Errorf("%s did not receive broadcast with sender tracking", receiver.Name())
222+ }
223+ }
224+
225+ broadcasts, err := s.SearchBroadcasts("integration test", 10)
226+ if err != nil {
227+ t.Fatalf("SearchBroadcasts() error: %v", err)
228+ }
229+ if len(broadcasts) == 0 {
230+ t.Fatal("broadcast not found in search")
231+ }
232+ if broadcasts[0].SenderID != sender.ID() {
233+ t.Errorf("broadcast sender_id: got %q, want %q", broadcasts[0].SenderID, sender.ID())
234+ }
235+}