xonecas.io
60255
Zn

Zoea-Nova / files

Zoea-Nova / internal / core / commander_test.go

21.6 KB
1package core
2
3import (
4	"fmt"
5	"path/filepath"
6	"testing"
7	"time"
8
9	"github.com/xonecas/zoea-nova/internal/config"
10	"github.com/xonecas/zoea-nova/internal/provider"
11	"github.com/xonecas/zoea-nova/internal/store"
12)
13
14func setupCommanderTest(t *testing.T) (*Commander, *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
26	reg := provider.NewRegistry()
27	reg.RegisterFactory("mock", provider.NewMockFactory("mock", "mock response"))
28	reg.RegisterFactory("ollama", provider.NewMockFactory("ollama", "ollama response"))
29
30	cfg := &config.Config{
31		Swarm: config.SwarmConfig{
32			MaxMyses: 16,
33		},
34		Providers: map[string]config.ProviderConfig{
35			"mock":   {Endpoint: "http://mock", Model: "mock-model", Temperature: 0.7},
36			"ollama": {Endpoint: "http://ollama", Model: "llama3", Temperature: 0.7},
37		},
38	}
39
40	cmd := NewCommander(s, reg, bus, cfg, "")
41
42	// Set a dummy MCP proxy to avoid "no tools" error events
43	// Note: Each mysis creates its own MCP client during Start()
44
45	cleanup := func() {
46		cmd.StopAll()
47		bus.Close()
48		s.Close()
49	}
50
51	return cmd, bus, cleanup
52}
53
54func TestCommanderStartStopMysis(t *testing.T) {
55	cmd, _, cleanup := setupCommanderTest(t)
56	defer cleanup()
57
58	mysis, _ := cmd.CreateMysis("lifecycle-test", "mock")
59	id := mysis.ID()
60
61	// Start
62	if err := cmd.StartMysis(id); err != nil {
63		t.Fatalf("StartMysis() error: %v", err)
64	}
65	if mysis.State() != MysisStateRunning {
66		t.Errorf("expected state=running, got %s", mysis.State())
67	}
68
69	// Give mysis time to process first turn (triggered by encouragement message)
70	// (otherwise Stop cancels mid-turn and state becomes errored)
71	time.Sleep(150 * time.Millisecond)
72
73	// Stop
74	if err := cmd.StopMysis(id); err != nil {
75		t.Fatalf("StopMysis() error: %v", err)
76	}
77	// After stopping, state should be stopped (not errored)
78	// Note: If stopped mid-turn, it may be errored with "context canceled"
79	// which is acceptable behavior
80	if mysis.State() != MysisStateStopped && mysis.State() != MysisStateErrored {
81		t.Errorf("expected state=stopped or errored, got %s (lastError: %v)", mysis.State(), mysis.LastError())
82	}
83
84	// Start/stop non-existent
85	if err := cmd.StartMysis("nonexistent"); err == nil {
86		t.Error("expected error starting non-existent mysis")
87	}
88	if err := cmd.StopMysis("nonexistent"); err == nil {
89		t.Error("expected error stopping non-existent mysis")
90	}
91}
92
93func TestCommanderRestartErroredMysis(t *testing.T) {
94	cmd, _, cleanup := setupCommanderTest(t)
95	defer cleanup()
96
97	mysis, _ := cmd.CreateMysis("restart-test", "mock")
98	id := mysis.ID()
99
100	// Start mysis
101	if err := cmd.StartMysis(id); err != nil {
102		t.Fatalf("StartMysis() error: %v", err)
103	}
104	if mysis.State() != MysisStateRunning {
105		t.Errorf("expected state=running, got %s", mysis.State())
106	}
107
108	// Simulate error by calling setError
109	mysis.SetErrorState(fmt.Errorf("simulated error"))
110	if mysis.State() != MysisStateErrored {
111		t.Errorf("expected state=errored after SetErrorState, got %s", mysis.State())
112	}
113
114	// Wait a moment for any pending operations
115	time.Sleep(100 * time.Millisecond)
116
117	// Restart the errored mysis
118	if err := cmd.StartMysis(id); err != nil {
119		t.Fatalf("Restart errored mysis failed: %v", err)
120	}
121
122	// Should now be running
123	if mysis.State() != MysisStateRunning {
124		t.Errorf("expected state=running after restart, got %s (lastError: %v)", mysis.State(), mysis.LastError())
125	}
126
127	// Verify lastError was cleared
128	if mysis.LastError() != nil {
129		t.Errorf("expected lastError to be cleared, got: %v", mysis.LastError())
130	}
131
132	// Clean stop
133	cmd.StopMysis(id)
134}
135
136func TestCommanderConfigureMysis(t *testing.T) {
137	cmd, bus, cleanup := setupCommanderTest(t)
138	defer cleanup()
139
140	// Subscribe before creating mysis
141	events := bus.Subscribe()
142
143	mysis, _ := cmd.CreateMysis("config-test", "mock")
144	id := mysis.ID()
145
146	// Drain created event
147	select {
148	case <-events:
149	case <-time.After(100 * time.Millisecond):
150		t.Fatal("timeout waiting for created event")
151	}
152
153	if err := cmd.ConfigureMysis(id, "ollama", "llama3"); err != nil {
154		t.Fatalf("ConfigureMysis() error: %v", err)
155	}
156
157	// Should receive config changed event
158	select {
159	case e := <-events:
160		if e.Type != EventMysisConfigChanged {
161			t.Errorf("expected EventMysisConfigChanged, got %s", e.Type)
162		}
163		if e.Config == nil {
164			t.Fatal("expected config change data")
165		}
166		if e.Config.Provider != "ollama" {
167			t.Errorf("expected provider=ollama, got %s", e.Config.Provider)
168		}
169		if e.Config.Model != "llama3" {
170			t.Errorf("expected model=llama3, got %s", e.Config.Model)
171		}
172	case <-time.After(100 * time.Millisecond):
173		t.Fatal("timeout waiting for config changed event")
174	}
175
176	stored, err := cmd.Store().GetMysis(id)
177	if err != nil {
178		t.Fatalf("GetMysis() error: %v", err)
179	}
180	if stored.Model != "llama3" {
181		t.Errorf("expected stored model=llama3, got %s", stored.Model)
182	}
183	if stored.Temperature != 0.7 {
184		t.Errorf("expected stored temperature=0.7, got %v", stored.Temperature)
185	}
186
187	// Configure with non-existent provider
188	if err := cmd.ConfigureMysis(id, "nonexistent", "model"); err == nil {
189		t.Error("expected error configuring with non-existent provider")
190	}
191
192	// Configure non-existent mysis
193	if err := cmd.ConfigureMysis("nonexistent", "mock", "mock-model"); err == nil {
194		t.Error("expected error configuring non-existent mysis")
195	}
196}
197
198func TestCommanderListMyses(t *testing.T) {
199	cmd, _, cleanup := setupCommanderTest(t)
200	defer cleanup()
201
202	cmd.CreateMysis("mysis-1", "mock")
203	cmd.CreateMysis("mysis-2", "mock")
204
205	myses := cmd.ListMyses()
206	if len(myses) != 2 {
207		t.Errorf("expected 2 myses, got %d", len(myses))
208	}
209}
210
211func TestCommanderGetMysis(t *testing.T) {
212	cmd, _, cleanup := setupCommanderTest(t)
213	defer cleanup()
214
215	mysis, _ := cmd.CreateMysis("get-test", "mock")
216
217	fetched, err := cmd.GetMysis(mysis.ID())
218	if err != nil {
219		t.Fatalf("GetMysis() error: %v", err)
220	}
221	if fetched.Name() != "get-test" {
222		t.Errorf("expected name=get-test, got %s", fetched.Name())
223	}
224
225	// Get non-existent
226	_, err = cmd.GetMysis("nonexistent")
227	if err == nil {
228		t.Error("expected error getting non-existent mysis")
229	}
230}
231
232func TestCommanderSendMessage(t *testing.T) {
233	cmd, _, cleanup := setupCommanderTest(t)
234	defer cleanup()
235
236	mysis, _ := cmd.CreateMysis("msg-test", "mock")
237	id := mysis.ID()
238
239	// Start mysis
240	cmd.StartMysis(id)
241
242	// Send message
243	if err := cmd.SendMessage(id, "Hello!"); err != nil {
244		t.Fatalf("SendMessage() error: %v", err)
245	}
246
247	// Send to non-existent
248	if err := cmd.SendMessage("nonexistent", "Hello!"); err == nil {
249		t.Error("expected error sending to non-existent mysis")
250	}
251}
252
253func TestCommanderBroadcast(t *testing.T) {
254	cmd, bus, cleanup := setupCommanderTest(t)
255	defer cleanup()
256
257	// Subscribe first
258	events := bus.Subscribe()
259
260	mysis1, _ := cmd.CreateMysis("broadcast-1", "mock")
261	mysis2, _ := cmd.CreateMysis("broadcast-2", "mock")
262
263	cmd.StartMysis(mysis1.ID())
264	cmd.StartMysis(mysis2.ID())
265
266	// Drain created/started events with timeout
267	for i := 0; i < 4; i++ {
268		select {
269		case <-events:
270		case <-time.After(100 * time.Millisecond):
271			// Some events may not have been emitted yet
272		}
273	}
274
275	if err := cmd.Broadcast("Hello everyone!"); err != nil {
276		t.Fatalf("Broadcast() error: %v", err)
277	}
278
279	// Should receive broadcast event
280	found := false
281	timeout := time.After(2 * time.Second)
282	for !found {
283		select {
284		case e := <-events:
285			if e.Type == EventBroadcast {
286				found = true
287			}
288		case <-timeout:
289			t.Fatal("timeout waiting for broadcast event")
290		}
291	}
292}
293
294func TestCommanderBroadcastToIdleMyses(t *testing.T) {
295	cmd, bus, cleanup := setupCommanderTest(t)
296	defer cleanup()
297
298	// Subscribe first
299	events := bus.Subscribe()
300
301	// Create myses but don't start them (they'll be in idle state)
302	mysis1, _ := cmd.CreateMysis("idle-1", "mock")
303	mysis2, _ := cmd.CreateMysis("idle-2", "mock")
304
305	// Verify they're idle
306	if mysis1.State() != MysisStateIdle {
307		t.Fatalf("mysis1 should be idle, got %s", mysis1.State())
308	}
309	if mysis2.State() != MysisStateIdle {
310		t.Fatalf("mysis2 should be idle, got %s", mysis2.State())
311	}
312
313	// Drain created events with timeout
314	for i := 0; i < 2; i++ {
315		select {
316		case <-events:
317		case <-time.After(100 * time.Millisecond):
318		}
319	}
320
321	// Should be able to broadcast to idle myses
322	if err := cmd.Broadcast("Wake up!"); err != nil {
323		t.Fatalf("Broadcast() should accept idle myses, got error: %v", err)
324	}
325
326	// Should receive broadcast event
327	found := false
328	timeout := time.After(2 * time.Second)
329	for !found {
330		select {
331		case e := <-events:
332			if e.Type == EventBroadcast {
333				found = true
334			}
335		case <-timeout:
336			t.Fatal("timeout waiting for broadcast event")
337		}
338	}
339
340	// Verify messages were stored (even though myses were idle)
341	memories1, err := cmd.Store().GetMemories(mysis1.ID())
342	if err != nil {
343		t.Fatalf("GetMemories() error: %v", err)
344	}
345	if len(memories1) == 0 {
346		t.Error("broadcast should be stored for idle mysis1")
347	}
348
349	memories2, err := cmd.Store().GetMemories(mysis2.ID())
350	if err != nil {
351		t.Fatalf("GetMemories() error: %v", err)
352	}
353	if len(memories2) == 0 {
354		t.Error("broadcast should be stored for idle mysis2")
355	}
356
357	// NEW: Verify myses auto-started (transitioned from idle to running)
358	// Wait up to 1 second for state transition
359	deadline := time.Now().Add(time.Second)
360	for time.Now().Before(deadline) {
361		if mysis1.State() == MysisStateRunning && mysis2.State() == MysisStateRunning {
362			break
363		}
364		time.Sleep(10 * time.Millisecond)
365	}
366
367	if mysis1.State() != MysisStateRunning {
368		t.Errorf("mysis1 should auto-start on broadcast, got state %s", mysis1.State())
369	}
370	if mysis2.State() != MysisStateRunning {
371		t.Errorf("mysis2 should auto-start on broadcast, got state %s", mysis2.State())
372	}
373}
374
375func TestCommanderBroadcastSource(t *testing.T) {
376	cmd, _, cleanup := setupCommanderTest(t)
377	defer cleanup()
378
379	mysis, _ := cmd.CreateMysis("broadcast-source-test", "mock")
380	cmd.StartMysis(mysis.ID())
381
382	// Wait for mysis to be running with timeout
383	deadline := time.Now().Add(time.Second)
384	for time.Now().Before(deadline) {
385		if mysis.State() == MysisStateRunning {
386			break
387		}
388		time.Sleep(10 * time.Millisecond)
389	}
390	if mysis.State() != MysisStateRunning {
391		t.Fatal("mysis failed to start within timeout")
392	}
393
394	// Send broadcast
395	if err := cmd.Broadcast("Swarm command!"); err != nil {
396		t.Fatalf("Broadcast() error: %v", err)
397	}
398
399	// Poll for broadcast message with timeout
400	var found bool
401	deadline = time.Now().Add(time.Second)
402	for time.Now().Before(deadline) && !found {
403		broadcasts, err := cmd.Store().GetRecentBroadcasts(10)
404		if err != nil {
405			t.Fatalf("GetRecentBroadcasts() error: %v", err)
406		}
407		for _, b := range broadcasts {
408			if b.Content == "Swarm command!" {
409				found = true
410				break
411			}
412		}
413		if !found {
414			time.Sleep(10 * time.Millisecond)
415		}
416	}
417
418	if !found {
419		t.Error("broadcast message not found with source='broadcast' within timeout")
420	}
421}
422
423func TestBroadcastExcludesSender(t *testing.T) {
424	cmd, _, cleanup := setupCommanderTest(t)
425	defer cleanup()
426
427	sender, _ := cmd.CreateMysis("sender", "mock")
428	receiver, _ := cmd.CreateMysis("receiver", "mock")
429
430	cmd.StartMysis(sender.ID())
431	cmd.StartMysis(receiver.ID())
432
433	deadline := time.Now().Add(time.Second)
434	for time.Now().Before(deadline) {
435		if sender.State() == MysisStateRunning && receiver.State() == MysisStateRunning {
436			break
437		}
438		time.Sleep(10 * time.Millisecond)
439	}
440	if sender.State() != MysisStateRunning || receiver.State() != MysisStateRunning {
441		t.Fatal("myses failed to start within timeout")
442	}
443
444	if err := cmd.BroadcastFrom(sender.ID(), "test broadcast"); err != nil {
445		t.Fatalf("BroadcastFrom() error: %v", err)
446	}
447
448	senderMemories, err := cmd.Store().GetRecentMemories(sender.ID(), 50)
449	if err != nil {
450		t.Fatalf("GetRecentMemories() error: %v", err)
451	}
452	for _, m := range senderMemories {
453		if m.Source == store.MemorySourceBroadcast && m.Content == "test broadcast" {
454			t.Error("sender received its own broadcast - should be excluded")
455		}
456	}
457
458	receiverMemories, err := cmd.Store().GetRecentMemories(receiver.ID(), 50)
459	if err != nil {
460		t.Fatalf("GetRecentMemories() error: %v", err)
461	}
462
463	found := false
464	for _, m := range receiverMemories {
465		if m.Source == store.MemorySourceBroadcast && m.Content == "test broadcast" && m.SenderID == sender.ID() {
466			found = true
467			break
468		}
469	}
470	if !found {
471		t.Error("receiver did not receive broadcast with correct sender_id")
472	}
473}
474
475func TestCommanderStopAll(t *testing.T) {
476	cmd, _, cleanup := setupCommanderTest(t)
477	defer cleanup()
478
479	mysis1, _ := cmd.CreateMysis("stopall-1", "mock")
480	mysis2, _ := cmd.CreateMysis("stopall-2", "mock")
481
482	cmd.StartMysis(mysis1.ID())
483	cmd.StartMysis(mysis2.ID())
484
485	cmd.StopAll()
486
487	// After StopAll(), myses should be either stopped or errored
488	// (errored if an async processing error occurred before stop completed)
489	if mysis1.State() != MysisStateStopped && mysis1.State() != MysisStateErrored {
490		t.Errorf("expected mysis1 state=stopped or errored, got %s", mysis1.State())
491	}
492	if mysis2.State() != MysisStateStopped && mysis2.State() != MysisStateErrored {
493		t.Errorf("expected mysis2 state=stopped or errored, got %s", mysis2.State())
494	}
495}
496
497func TestCommanderLoadMyses(t *testing.T) {
498	s, err := store.OpenMemory()
499	if err != nil {
500		t.Fatalf("OpenMemory() error: %v", err)
501	}
502	defer s.Close()
503
504	// Pre-populate store
505	s.CreateMysis("existing-1", "mock", "mock-model", 0.7)
506	s.CreateMysis("existing-2", "mock", "mock-model", 0.7)
507
508	bus := NewEventBus(100)
509	defer bus.Close()
510
511	reg := provider.NewRegistry()
512	reg.RegisterFactory("mock", provider.NewMockFactory("mock", "response"))
513
514	cfg := &config.Config{
515		Swarm: config.SwarmConfig{MaxMyses: 16},
516		Providers: map[string]config.ProviderConfig{
517			"mock": {Endpoint: "http://mock", Model: "mock-model", Temperature: 0.7},
518		},
519	}
520
521	cmd := NewCommander(s, reg, bus, cfg, "")
522
523	if err := cmd.LoadMyses(); err != nil {
524		t.Fatalf("LoadMyses() error: %v", err)
525	}
526
527	if cmd.MysisCount() != 2 {
528		t.Errorf("expected 2 myses loaded, got %d", cmd.MysisCount())
529	}
530}
531
532// TestBroadcastDoesNotBlockOnBusyMysis verifies that broadcasting doesn't block
533// when one or more myses are busy processing a previous message.
534// This test ensures the parallel broadcast implementation works correctly.
535func TestBroadcastDoesNotBlockOnBusyMysis(t *testing.T) {
536	tmpDir := t.TempDir()
537	dbPath := filepath.Join(tmpDir, "test.db")
538	s, err := store.Open(dbPath)
539	if err != nil {
540		t.Fatalf("Open() error: %v", err)
541	}
542	defer s.Close()
543
544	bus := NewEventBus(100)
545	defer bus.Close()
546
547	reg := provider.NewRegistry()
548
549	// Create a slow provider that will block for 2 seconds
550	slowProvider := provider.NewMock("slow", "slow response").
551		SetDelay(2 * time.Second)
552
553	// Create a fast provider for the other mysis
554	fastProvider := provider.NewMock("fast", "fast response")
555
556	// Register custom factories that return our specific providers
557	reg.RegisterFactory("slow", &customMockFactory{
558		name:     "slow",
559		provider: slowProvider,
560	})
561	reg.RegisterFactory("fast", &customMockFactory{
562		name:     "fast",
563		provider: fastProvider,
564	})
565
566	cfg := &config.Config{
567		Swarm: config.SwarmConfig{MaxMyses: 16},
568		Providers: map[string]config.ProviderConfig{
569			"slow": {Endpoint: "http://slow", Model: "slow-model", Temperature: 0.7},
570			"fast": {Endpoint: "http://fast", Model: "fast-model", Temperature: 0.7},
571		},
572	}
573
574	cmd := NewCommander(s, reg, bus, cfg, "")
575	// Note: Each mysis creates its own MCP client during Start()
576
577	// Create two myses: one slow, one fast
578	slowMysis, err := cmd.CreateMysis("slow-mysis", "slow")
579	if err != nil {
580		t.Fatalf("CreateMysis(slow) error: %v", err)
581	}
582
583	fastMysis, err := cmd.CreateMysis("fast-mysis", "fast")
584	if err != nil {
585		t.Fatalf("CreateMysis(fast) error: %v", err)
586	}
587
588	// Start both myses
589	if err := cmd.StartMysis(slowMysis.ID()); err != nil {
590		t.Fatalf("StartMysis(slow) error: %v", err)
591	}
592	if err := cmd.StartMysis(fastMysis.ID()); err != nil {
593		t.Fatalf("StartMysis(fast) error: %v", err)
594	}
595
596	// Wait for both to be running
597	deadline := time.Now().Add(2 * time.Second)
598	for time.Now().Before(deadline) {
599		if slowMysis.State() == MysisStateRunning && fastMysis.State() == MysisStateRunning {
600			break
601		}
602		time.Sleep(10 * time.Millisecond)
603	}
604	if slowMysis.State() != MysisStateRunning || fastMysis.State() != MysisStateRunning {
605		t.Fatal("myses failed to start within timeout")
606	}
607
608	// Send a direct message to the slow mysis to make it busy
609	// This will block for 2 seconds due to the delay
610	go func() {
611		cmd.SendMessage(slowMysis.ID(), "make slow mysis busy")
612	}()
613
614	// Give the slow mysis time to start processing (acquire turnMu lock)
615	time.Sleep(100 * time.Millisecond)
616
617	// Now broadcast a message - this should NOT block waiting for the slow mysis
618	// The broadcast should complete quickly (within 500ms) because it sends in parallel
619	start := time.Now()
620	err = cmd.Broadcast("broadcast message")
621	elapsed := time.Since(start)
622
623	if err != nil {
624		t.Fatalf("Broadcast() error: %v", err)
625	}
626
627	// The broadcast should complete much faster than the 2-second delay
628	// We allow up to 1 second for the broadcast to complete (generous margin)
629	// If it takes longer, it means the broadcast blocked waiting for the slow mysis
630	if elapsed > 1*time.Second {
631		t.Errorf("Broadcast took too long (%v), likely blocked on busy mysis", elapsed)
632	}
633
634	// Verify both myses received the broadcast
635	// Wait a bit for the slow mysis to finish processing
636	time.Sleep(2500 * time.Millisecond)
637
638	slowMemories, err := s.GetRecentMemories(slowMysis.ID(), 50)
639	if err != nil {
640		t.Fatalf("GetRecentMemories(slow) error: %v", err)
641	}
642
643	fastMemories, err := s.GetRecentMemories(fastMysis.ID(), 50)
644	if err != nil {
645		t.Fatalf("GetRecentMemories(fast) error: %v", err)
646	}
647
648	// Check that both myses have the broadcast message
649	slowHasBroadcast := false
650	for _, m := range slowMemories {
651		if m.Source == store.MemorySourceBroadcast && m.Content == "broadcast message" {
652			slowHasBroadcast = true
653			break
654		}
655	}
656
657	fastHasBroadcast := false
658	for _, m := range fastMemories {
659		if m.Source == store.MemorySourceBroadcast && m.Content == "broadcast message" {
660			fastHasBroadcast = true
661			break
662		}
663	}
664
665	if !slowHasBroadcast {
666		t.Error("slow mysis did not receive broadcast message")
667	}
668	if !fastHasBroadcast {
669		t.Error("fast mysis did not receive broadcast message")
670	}
671
672	cmd.StopAll()
673}
674
675// customMockFactory is a factory that returns a specific provider instance
676type customMockFactory struct {
677	name     string
678	provider provider.Provider
679}
680
681func (f *customMockFactory) Name() string { return f.name }
682
683func (f *customMockFactory) Create(model string, temperature float64) provider.Provider {
684	return f.provider
685}
686
687// TestAggregateTick_MaxAcrossMyses verifies that AggregateTick returns the maximum
688// lastServerTick across all myses in the swarm.
689func TestAggregateTick_MaxAcrossMyses(t *testing.T) {
690	cmd, _, cleanup := setupCommanderTest(t)
691	defer cleanup()
692
693	// Empty swarm should return 0
694	if tick := cmd.AggregateTick(); tick != 0 {
695		t.Errorf("empty swarm: expected tick=0, got %d", tick)
696	}
697
698	// Create myses
699	m1, _ := cmd.CreateMysis("mysis-1", "mock")
700	m2, _ := cmd.CreateMysis("mysis-2", "mock")
701	m3, _ := cmd.CreateMysis("mysis-3", "mock")
702
703	// Set lastServerTick directly for testing
704	m1.mu.Lock()
705	m1.lastServerTick = 98
706	m1.mu.Unlock()
707
708	m2.mu.Lock()
709	m2.lastServerTick = 120
710	m2.mu.Unlock()
711
712	m3.mu.Lock()
713	m3.lastServerTick = 0 // No tick data yet
714	m3.mu.Unlock()
715
716	// Should return max tick (120)
717	if tick := cmd.AggregateTick(); tick != 120 {
718		t.Errorf("expected aggregate tick=120, got %d", tick)
719	}
720}
721
722// TestAggregateTick_EdgeCases verifies edge cases for aggregate tick calculation.
723func TestAggregateTick_EdgeCases(t *testing.T) {
724	cmd, _, cleanup := setupCommanderTest(t)
725	defer cleanup()
726
727	t.Run("all myses with zero tick", func(t *testing.T) {
728		m1, _ := cmd.CreateMysis("zero-1", "mock")
729		m2, _ := cmd.CreateMysis("zero-2", "mock")
730
731		m1.mu.Lock()
732		m1.lastServerTick = 0
733		m1.mu.Unlock()
734
735		m2.mu.Lock()
736		m2.lastServerTick = 0
737		m2.mu.Unlock()
738
739		if tick := cmd.AggregateTick(); tick != 0 {
740			t.Errorf("expected tick=0 when all myses have zero tick, got %d", tick)
741		}
742	})
743
744	t.Run("single mysis", func(t *testing.T) {
745		// Clean up previous myses
746		for _, m := range cmd.ListMyses() {
747			cmd.DeleteMysis(m.ID(), false)
748		}
749
750		m, _ := cmd.CreateMysis("single", "mock")
751		m.mu.Lock()
752		m.lastServerTick = 42
753		m.mu.Unlock()
754
755		if tick := cmd.AggregateTick(); tick != 42 {
756			t.Errorf("expected tick=42 for single mysis, got %d", tick)
757		}
758	})
759}
760
761// TestMaxMyses verifies the MaxMyses getter returns the configured value.
762func TestMaxMyses(t *testing.T) {
763	cmd, _, cleanup := setupCommanderTest(t)
764	defer cleanup()
765
766	expected := 16 // From setupCommanderTest config
767	if got := cmd.MaxMyses(); got != expected {
768		t.Errorf("MaxMyses() = %d, want %d", got, expected)
769	}
770}
771
772// TestGetStateCounts verifies the GetStateCounts method returns accurate counts.
773func TestGetStateCounts(t *testing.T) {
774	cmd, _, cleanup := setupCommanderTest(t)
775	defer cleanup()
776
777	// Empty swarm - may have zero counts for all states
778	counts := cmd.GetStateCounts()
779	total := 0
780	for _, count := range counts {
781		total += count
782	}
783	if total != 0 {
784		t.Errorf("empty swarm should have 0 total myses, got %d", total)
785	}
786
787	// Create myses in various states
788	cmd.CreateMysis("idle-1", "mock")
789	cmd.CreateMysis("idle-2", "mock")
790	m3, _ := cmd.CreateMysis("running-1", "mock")
791
792	// Start one mysis
793	cmd.StartMysis(m3.ID())
794	time.Sleep(50 * time.Millisecond) // Give it time to start
795
796	counts = cmd.GetStateCounts()
797
798	// Should have at least idle and running states
799	if counts["idle"] < 2 {
800		t.Errorf("expected at least 2 idle myses, got %d", counts["idle"])
801	}
802	if counts["running"] < 1 {
803		t.Errorf("expected at least 1 running mysis, got %d", counts["running"])
804	}
805
806	// Total should match number of myses
807	total = 0
808	for _, count := range counts {
809		total += count
810	}
811	if total != 3 {
812		t.Errorf("total myses across states = %d, want 3", total)
813	}
814}