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}