xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / core / commander_async_test.go

3.6 KB
1package core
2
3import (
4	"path/filepath"
5	"testing"
6	"time"
7
8	"github.com/xonecas/zoea-nova/internal/config"
9	"github.com/xonecas/zoea-nova/internal/provider"
10	"github.com/xonecas/zoea-nova/internal/store"
11)
12
13func setupCommanderAsyncTest(t *testing.T) (*Commander, *store.Store, *EventBus, func()) {
14	t.Helper()
15
16	tmpDir := t.TempDir()
17	dbPath := filepath.Join(tmpDir, "test.db")
18	s, err := store.Open(dbPath)
19	if err != nil {
20		t.Fatalf("Open() error: %v", err)
21	}
22
23	bus := NewEventBus(100)
24	reg := provider.NewRegistry()
25	cfg := &config.Config{
26		Swarm: config.SwarmConfig{
27			MaxMyses: 16,
28		},
29		Providers: map[string]config.ProviderConfig{
30			"mock":  {Model: "test-model", Temperature: 0.7},
31			"mock1": {Model: "test-model", Temperature: 0.7},
32			"mock2": {Model: "test-model", Temperature: 0.7},
33		},
34	}
35
36	c := NewCommander(s, reg, bus, cfg, "")
37
38	// Note: Each mysis creates its own MCP client during Start()
39
40	cleanup := func() {
41		bus.Close()
42		s.Close()
43	}
44
45	return c, s, bus, cleanup
46}
47
48func TestCommanderSendMessageAsync(t *testing.T) {
49	c, _, bus, cleanup := setupCommanderAsyncTest(t)
50	defer cleanup()
51
52	c.registry.RegisterFactory("mock", provider.NewMockFactory("mock", "response"))
53
54	mysis, _ := c.CreateMysis("async-mysis", "mock")
55
56	events := bus.Subscribe()
57	mysis.Start()
58
59	// Wait for initial turn
60	timeout := time.After(10 * time.Second)
61	found := false
62	for !found {
63		select {
64		case e := <-events:
65			if e.Type == EventMysisResponse {
66				found = true
67			}
68		case <-timeout:
69			t.Fatal("timeout waiting for initial turn")
70		}
71	}
72
73	// Send async message
74	if err := c.SendMessageAsync(mysis.ID(), "Hello async"); err != nil {
75		t.Fatalf("SendMessageAsync() error: %v", err)
76	}
77
78	// Should receive response eventually
79	found = false
80	for !found {
81		select {
82		case e := <-events:
83			if e.Type == EventMysisResponse {
84				found = true
85			}
86		case <-timeout:
87			t.Fatal("timeout waiting for async response")
88		}
89	}
90}
91
92func TestCommanderBroadcastAsync(t *testing.T) {
93	c, _, bus, cleanup := setupCommanderAsyncTest(t)
94	defer cleanup()
95
96	// Use separate mocks to avoid any potential contention
97	c.registry.RegisterFactory("mock1", provider.NewMockFactory("mock1", "response1"))
98	c.registry.RegisterFactory("mock2", provider.NewMockFactory("mock2", "response2"))
99
100	a1, err := c.CreateMysis("m1", "mock1")
101	if err != nil {
102		t.Fatalf("CreateMysis(m1) error: %v", err)
103	}
104	a2, err := c.CreateMysis("m2", "mock2")
105	if err != nil {
106		t.Fatalf("CreateMysis(m2) 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 == EventMysisResponse && e.MysisID == 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 == EventMysisResponse && e.MysisID == 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 == EventMysisResponse {
156				responses[e.MysisID] = true
157			}
158		case <-timeout:
159			t.Fatalf("timeout waiting for broadcast responses, got %d", len(responses))
160		}
161	}
162}