1  package main
  2  
  3  import (
  4  	"lbbaspack/engine/components"
  5  	"lbbaspack/engine/ecs"
  6  	"lbbaspack/engine/events"
  7  	"lbbaspack/engine/systems"
  8  	"testing"
  9  
 10  	"github.com/hajimehoshi/ebiten/v2"
 11  )
 12  
 13  // TestNewGame tests the NewGame constructor
 14  func TestNewGame(t *testing.T) {
 15  	game := NewGame()
 16  
 17  	if game == nil {
 18  		t.Fatal("Expected game to be created")
 19  	}
 20  
 21  	if game.World == nil {
 22  		t.Error("Expected world to be initialized")
 23  	}
 24  
 25  	if !game.initialized {
 26  		t.Error("Expected game to be initialized")
 27  	}
 28  
 29  	if game.RenderSys == nil {
 30  		t.Error("Expected render system to be initialized")
 31  	}
 32  
 33  	if game.UISys == nil {
 34  		t.Error("Expected UI system to be initialized")
 35  	}
 36  
 37  	if game.MenuSys == nil {
 38  		t.Error("Expected menu system to be initialized")
 39  	}
 40  
 41  	if game.eventDispatcher == nil {
 42  		t.Error("Expected event dispatcher to be initialized")
 43  	}
 44  
 45  	if game.systemManager == nil {
 46  		t.Error("Expected system manager to be initialized")
 47  	}
 48  
 49  	// Verify initial game state
 50  	if game.gameState != components.StateMenu {
 51  		t.Errorf("Expected initial game state to be StateMenu, got %v", game.gameState)
 52  	}
 53  }
 54  
 55  // TestGame_Update tests the Update method
 56  func TestGame_Update(t *testing.T) {
 57  	game := NewGame()
 58  
 59  	// Test update in menu state
 60  	err := game.Update()
 61  	if err != nil {
 62  		t.Errorf("Expected no error from Update, got %v", err)
 63  	}
 64  
 65  	// Verify game state remains menu
 66  	if game.gameState != components.StateMenu {
 67  		t.Errorf("Expected game state to remain StateMenu, got %v", game.gameState)
 68  	}
 69  }
 70  
 71  // TestGame_Update_GameStart tests Update after game start event
 72  func TestGame_Update_GameStart(t *testing.T) {
 73  	game := NewGame()
 74  
 75  	// Publish game start event
 76  	gameStartEvent := events.NewEvent(events.EventGameStart, &events.EventData{
 77  		SLA:    float64Ptr(99.5),
 78  		Errors: intPtr(10),
 79  	})
 80  	game.eventDispatcher.Publish(gameStartEvent)
 81  
 82  	// Update game
 83  	err := game.Update()
 84  	if err != nil {
 85  		t.Errorf("Expected no error from Update, got %v", err)
 86  	}
 87  
 88  	// Verify game state changed to playing
 89  	if game.gameState != components.StatePlaying {
 90  		t.Errorf("Expected game state to be StatePlaying, got %v", game.gameState)
 91  	}
 92  }
 93  
 94  // TestGame_Update_GameOver tests Update after game over event
 95  func TestGame_Update_GameOver(t *testing.T) {
 96  	game := NewGame()
 97  
 98  	// Set game state directly to playing to avoid event chain issues
 99  	game.gameState = components.StatePlaying
100  
101  	// Publish game over event
102  	gameOverEvent := events.NewEvent(events.EventGameOver, nil)
103  	game.eventDispatcher.Publish(gameOverEvent)
104  
105  	// Update game to process the game over event
106  	err := game.Update()
107  	if err != nil {
108  		t.Errorf("Expected no error from Update, got %v", err)
109  	}
110  
111  	// Verify game state changed to game over
112  	if game.gameState != components.StateGameOver {
113  		t.Errorf("Expected game state to be StateGameOver, got %v", game.gameState)
114  	}
115  }
116  
117  // TestGame_Update_GameOver_EscapeKey tests that pressing escape in game over state returns to menu
118  func TestGame_Update_GameOver_EscapeKey(t *testing.T) {
119  	game := NewGame()
120  
121  	// Set game state directly to game over
122  	game.gameState = components.StateGameOver
123  
124  	// Verify we start in game over state
125  	if game.gameState != components.StateGameOver {
126  		t.Errorf("Expected game state to be StateGameOver, got %v", game.gameState)
127  	}
128  
129  	// Simulate escape key press by mocking ebiten.IsKeyPressed
130  	// Note: In a real test environment, we would need to mock the ebiten input
131  	// For now, we'll test the logic by directly calling the escape key handling
132  	// This is a simplified test that verifies the escape key logic is in place
133  
134  	// Update game (without escape key pressed)
135  	err := game.Update()
136  	if err != nil {
137  		t.Errorf("Expected no error from Update, got %v", err)
138  	}
139  
140  	// Verify game state remains game over when escape is not pressed
141  	if game.gameState != components.StateGameOver {
142  		t.Errorf("Expected game state to remain StateGameOver when escape not pressed, got %v", game.gameState)
143  	}
144  }
145  
146  // TestGame_Draw tests the Draw method
147  func TestGame_Draw(t *testing.T) {
148  	game := NewGame()
149  
150  	// Create a dummy screen for testing
151  	screen := ebiten.NewImage(800, 600)
152  	defer screen.Dispose()
153  
154  	// Test drawing in menu state
155  	game.Draw(screen)
156  
157  	// Verify systems are initialized after first draw
158  	if !game.initialized {
159  		t.Error("Expected game to be initialized after first draw")
160  	}
161  
162  	if game.UISys == nil {
163  		t.Error("Expected UI system to be initialized after draw")
164  	}
165  
166  	if game.MenuSys == nil {
167  		t.Error("Expected menu system to be initialized after draw")
168  	}
169  }
170  
171  // TestGame_Draw_PlayingState tests Draw in playing state
172  func TestGame_Draw_PlayingState(t *testing.T) {
173  	game := NewGame()
174  
175  	// Set game state directly to playing to avoid event chain issues
176  	game.gameState = components.StatePlaying
177  
178  	// Create a dummy screen for testing
179  	screen := ebiten.NewImage(800, 600)
180  	defer screen.Dispose()
181  
182  	// Test drawing in playing state
183  	game.Draw(screen)
184  
185  	// Verify game state is playing
186  	if game.gameState != components.StatePlaying {
187  		t.Errorf("Expected game state to be StatePlaying, got %v", game.gameState)
188  	}
189  }
190  
191  // TestGame_Draw_GameOverState tests Draw in game over state
192  func TestGame_Draw_GameOverState(t *testing.T) {
193  	game := NewGame()
194  
195  	// Set game state directly to game over to avoid event chain issues
196  	game.gameState = components.StateGameOver
197  
198  	// Create a dummy screen for testing
199  	screen := ebiten.NewImage(800, 600)
200  	defer screen.Dispose()
201  
202  	// Test drawing in game over state
203  	game.Draw(screen)
204  
205  	// Verify game state is game over
206  	if game.gameState != components.StateGameOver {
207  		t.Errorf("Expected game state to be StateGameOver, got %v", game.gameState)
208  	}
209  }
210  
211  // TestGame_Layout tests the Layout method
212  func TestGame_Layout(t *testing.T) {
213  	game := NewGame()
214  
215  	width, height := game.Layout(1000, 800)
216  
217  	// Verify layout returns expected dimensions
218  	if width != 800 {
219  		t.Errorf("Expected width 800, got %d", width)
220  	}
221  
222  	if height != 600 {
223  		t.Errorf("Expected height 600, got %d", height)
224  	}
225  
226  	// Test with different input dimensions
227  	width, height = game.Layout(1200, 900)
228  	if width != 800 {
229  		t.Errorf("Expected width 800, got %d", width)
230  	}
231  
232  	if height != 600 {
233  		t.Errorf("Expected height 600, got %d", height)
234  	}
235  }
236  
237  // TestGame_WorldInitialization tests that the world is properly initialized
238  func TestGame_WorldInitialization(t *testing.T) {
239  	game := NewGame()
240  
241  	if game.World == nil {
242  		t.Fatal("Expected world to be initialized")
243  	}
244  
245  	// Verify entities were created
246  	if len(game.World.Entities) == 0 {
247  		t.Error("Expected entities to be created in world")
248  	}
249  
250  	// Check for load balancer entity
251  	foundLoadBalancer := false
252  	for _, entity := range game.World.Entities {
253  		if entity.HasComponent("Transform") && entity.HasComponent("Sprite") && entity.HasComponent("Collider") {
254  			// Check if it's the load balancer (should have SLA component)
255  			if entity.HasComponent("SLA") {
256  				foundLoadBalancer = true
257  				break
258  			}
259  		}
260  	}
261  
262  	if !foundLoadBalancer {
263  		t.Error("Expected load balancer entity to be created")
264  	}
265  
266  	// Check for backend entities
267  	backendCount := 0
268  	for _, entity := range game.World.Entities {
269  		if entity.HasComponent("BackendAssignment") {
270  			backendCount++
271  		}
272  	}
273  
274  	if backendCount != 4 {
275  		t.Errorf("Expected 4 backend entities, got %d", backendCount)
276  	}
277  }
278  
279  // TestGame_SystemsInitialization tests that all systems are properly initialized
280  func TestGame_SystemsInitialization(t *testing.T) {
281  	game := NewGame()
282  
283  	if game.systemManager == nil {
284  		t.Error("Expected system manager to be initialized")
285  	}
286  
287  	// Verify specific systems are present by checking system manager
288  	expectedSystems := []systems.SystemType{
289  		systems.SystemTypeSpawn,
290  		systems.SystemTypeInput,
291  		systems.SystemTypeMovement,
292  		systems.SystemTypeCollision,
293  		systems.SystemTypePowerUp,
294  		systems.SystemTypeBackend,
295  		systems.SystemTypeSLA,
296  		systems.SystemTypeCombo,
297  		systems.SystemTypeGameState,
298  		systems.SystemTypeParticle,
299  		systems.SystemTypeRouting,
300  	}
301  
302  	for _, expectedSystemType := range expectedSystems {
303  		if _, exists := game.systemManager.GetSystem(expectedSystemType); !exists {
304  			t.Errorf("Expected system %s to be initialized", expectedSystemType)
305  		}
306  	}
307  }
308  
309  // TestGame_EventHandling tests event handling functionality
310  func TestGame_EventHandling(t *testing.T) {
311  	game := NewGame()
312  
313  	// Test game start event
314  	gameStartEvent := events.NewEvent(events.EventGameStart, &events.EventData{
315  		SLA:    float64Ptr(99.0),
316  		Errors: intPtr(5),
317  	})
318  	game.eventDispatcher.Publish(gameStartEvent)
319  
320  	// Update to process the event
321  	if err := game.Update(); err != nil {
322  		t.Errorf("Expected no error from game.Update(), got %v", err)
323  	}
324  
325  	if game.gameState != components.StatePlaying {
326  		t.Errorf("Expected game state to be StatePlaying after game start event, got %v", game.gameState)
327  	}
328  
329  	// Test game over event
330  	gameOverEvent := events.NewEvent(events.EventGameOver, nil)
331  	game.eventDispatcher.Publish(gameOverEvent)
332  
333  	// Update to process the event
334  	if err := game.Update(); err != nil {
335  		t.Errorf("Expected no error from game.Update(), got %v", err)
336  	}
337  
338  	if game.gameState != components.StateGameOver {
339  		t.Errorf("Expected game state to be StateGameOver after game over event, got %v", game.gameState)
340  	}
341  }
342  
343  // TestGame_StateTransitions tests state transition logic
344  func TestGame_StateTransitions(t *testing.T) {
345  	game := NewGame()
346  
347  	// Initial state should be menu
348  	if game.gameState != components.StateMenu {
349  		t.Errorf("Expected initial state to be StateMenu, got %v", game.gameState)
350  	}
351  
352  	// Test direct state transitions to avoid event chain issues
353  	game.gameState = components.StatePlaying
354  	if game.gameState != components.StatePlaying {
355  		t.Errorf("Expected state to be StatePlaying, got %v", game.gameState)
356  	}
357  
358  	game.gameState = components.StateGameOver
359  	if game.gameState != components.StateGameOver {
360  		t.Errorf("Expected state to be StateGameOver, got %v", game.gameState)
361  	}
362  }
363  
364  // TestGame_EdgeCases tests edge cases and error conditions
365  func TestGame_EdgeCases(t *testing.T) {
366  	t.Run("Nil Event Dispatcher", func(t *testing.T) {
367  		game := NewGame()
368  		if game.eventDispatcher == nil {
369  			t.Error("Expected event dispatcher to be initialized")
370  		}
371  	})
372  
373  	t.Run("System Manager Initialized", func(t *testing.T) {
374  		game := NewGame()
375  		if game.systemManager == nil {
376  			t.Error("Expected system manager to be initialized")
377  		}
378  	})
379  
380  	t.Run("Multiple State Changes", func(t *testing.T) {
381  		game := NewGame()
382  
383  		// Test rapid state changes directly
384  		for i := 0; i < 10; i++ {
385  			game.gameState = components.StatePlaying
386  			game.gameState = components.StateGameOver
387  		}
388  
389  		// Should end up in game over state (last assignment)
390  		if game.gameState != components.StateGameOver {
391  			t.Errorf("Expected final state to be StateGameOver, got %v", game.gameState)
392  		}
393  	})
394  
395  	t.Run("Update Without Initialization", func(t *testing.T) {
396  		game := &Game{
397  			World:       ecs.NewWorld(),
398  			initialized: false,
399  		}
400  
401  		// Should not panic
402  		err := game.Update()
403  		if err != nil {
404  			t.Errorf("Expected no error, got %v", err)
405  		}
406  	})
407  }
408  
409  // TestGame_Integration tests integration scenarios
410  func TestGame_Integration(t *testing.T) {
411  	game := NewGame()
412  
413  	// Verify initial setup
414  	if game.gameState != components.StateMenu {
415  		t.Errorf("Expected initial state to be StateMenu, got %v", game.gameState)
416  	}
417  
418  	// Test state transitions directly
419  	game.gameState = components.StatePlaying
420  	if game.gameState != components.StatePlaying {
421  		t.Errorf("Expected state to be StatePlaying, got %v", game.gameState)
422  	}
423  
424  	// Simulate some game time
425  	for i := 0; i < 10; i++ {
426  		err := game.Update()
427  		if err != nil {
428  			t.Errorf("Expected no error from Update, got %v", err)
429  		}
430  	}
431  
432  	// End the game
433  	game.gameState = components.StateGameOver
434  	if game.gameState != components.StateGameOver {
435  		t.Errorf("Expected state to be StateGameOver, got %v", game.gameState)
436  	}
437  
438  	// Test drawing in all states
439  	screen := ebiten.NewImage(800, 600)
440  	defer screen.Dispose()
441  
442  	// Should not panic
443  	game.Draw(screen)
444  }
445  
446  // Benchmark tests for performance
447  func BenchmarkNewGame(b *testing.B) {
448  	for i := 0; i < b.N; i++ {
449  		NewGame()
450  	}
451  }
452  
453  func BenchmarkGame_Update(b *testing.B) {
454  	game := NewGame()
455  	b.ResetTimer()
456  	for i := 0; i < b.N; i++ {
457  		if err := game.Update(); err != nil {
458  			b.Errorf("Expected no error from game.Update(), got %v", err)
459  		}
460  	}
461  }
462  
463  func BenchmarkGame_Draw(b *testing.B) {
464  	game := NewGame()
465  	screen := ebiten.NewImage(800, 600)
466  	defer screen.Dispose()
467  	b.ResetTimer()
468  	for i := 0; i < b.N; i++ {
469  		game.Draw(screen)
470  	}
471  }
472  
473  func BenchmarkGame_Layout(b *testing.B) {
474  	game := NewGame()
475  	b.ResetTimer()
476  	for i := 0; i < b.N; i++ {
477  		game.Layout(800, 600)
478  	}
479  }
480  
481  // Helper functions
482  func float64Ptr(v float64) *float64 {
483  	return &v
484  }
485  
486  func intPtr(v int) *int {
487  	return &v
488  }