whale-town/tests/test_game_state_manager.gd

extends Node
## 游戏状态管理器单元测试
## 测试状态转换逻辑和数据持久化

var game_state_manager: GameStateManager

func _ready():
	print("\n=== GameStateManager Unit Tests ===")
	_setup()
	test_initial_state()
	test_state_transitions()
	test_state_change_signal()
	test_data_persistence()
	test_data_serialization()
	_cleanup()
	print("=== All GameStateManager tests completed ===\n")

func _setup():
	"""设置测试环境"""
	game_state_manager = GameStateManager.new()
	add_child(game_state_manager)

func _cleanup():
	"""清理测试环境"""
	if game_state_manager:
		game_state_manager.clear_player_data()
		game_state_manager.queue_free()

func test_initial_state():
	"""测试初始状态"""
	print("\n[Unit Test] Initial State")
	
	assert(game_state_manager.current_state == GameStateManager.GameState.LOGIN, 
		"Initial state should be LOGIN")
	
	print("  ✅ PASSED: Initial state is LOGIN")

func test_state_transitions():
	"""测试各种状态转换场景"""
	print("\n[Unit Test] State Transitions")
	
	# 测试 LOGIN -> CHARACTER_CREATION
	game_state_manager.change_state(GameStateManager.GameState.CHARACTER_CREATION)
	assert(game_state_manager.current_state == GameStateManager.GameState.CHARACTER_CREATION,
		"State should change to CHARACTER_CREATION")
	
	# 测试 CHARACTER_CREATION -> IN_GAME
	game_state_manager.change_state(GameStateManager.GameState.IN_GAME)
	assert(game_state_manager.current_state == GameStateManager.GameState.IN_GAME,
		"State should change to IN_GAME")
	
	# 测试 IN_GAME -> DISCONNECTED
	game_state_manager.change_state(GameStateManager.GameState.DISCONNECTED)
	assert(game_state_manager.current_state == GameStateManager.GameState.DISCONNECTED,
		"State should change to DISCONNECTED")
	
	# 测试 DISCONNECTED -> LOGIN
	game_state_manager.change_state(GameStateManager.GameState.LOGIN)
	assert(game_state_manager.current_state == GameStateManager.GameState.LOGIN,
		"State should change back to LOGIN")
	
	# 测试相同状态不触发变化
	var old_state = game_state_manager.current_state
	game_state_manager.change_state(old_state)
	assert(game_state_manager.current_state == old_state,
		"State should remain the same when changing to current state")
	
	print("  ✅ PASSED: All state transitions work correctly")

func test_state_change_signal():
	"""测试状态变化信号"""
	print("\n[Unit Test] State Change Signal")
	
	# 使用字典来存储信号接收状态（避免 lambda 捕获问题）
	var signal_data = {
		"received": false,
		"old_state": null,
		"new_state": null
	}
	
	# 连接信号
	var callback = func(prev_state, next_state):
		signal_data["received"] = true
		signal_data["old_state"] = prev_state
		signal_data["new_state"] = next_state
	
	game_state_manager.state_changed.connect(callback)
	
	# 改变状态
	var old_state = game_state_manager.current_state
	var new_state = GameStateManager.GameState.IN_GAME
	game_state_manager.change_state(new_state)
	
	# 信号是同步的，应该立即触发
	assert(signal_data["received"], "State change signal should be emitted")
	assert(signal_data["old_state"] == old_state, "Old state should match")
	assert(signal_data["new_state"] == new_state, "New state should match")
	
	# 测试相同状态不发射信号
	signal_data["received"] = false
	game_state_manager.change_state(new_state)
	assert(not signal_data["received"], "Signal should not be emitted when state doesn't change")
	
	print("  ✅ PASSED: State change signal works correctly")

func test_data_persistence():
	"""测试数据持久化"""
	print("\n[Unit Test] Data Persistence")
	
	# 设置测试数据
	game_state_manager.player_data = {
		"username": "test_player",
		"character_id": "char_123",
		"level": 5,
		"position": {
			"x": 100.0,
			"y": 200.0
		}
	}
	
	# 保存数据
	game_state_manager.save_player_data()
	
	# 清空内存中的数据
	game_state_manager.player_data.clear()
	assert(game_state_manager.player_data.is_empty(), "Player data should be cleared")
	
	# 加载数据
	var loaded_data = game_state_manager.load_player_data()
	
	# 验证数据
	assert(not loaded_data.is_empty(), "Loaded data should not be empty")
	assert(loaded_data.has("username"), "Loaded data should have username")
	assert(loaded_data["username"] == "test_player", "Username should match")
	assert(loaded_data.has("character_id"), "Loaded data should have character_id")
	assert(loaded_data["character_id"] == "char_123", "Character ID should match")
	assert(loaded_data.has("level"), "Loaded data should have level")
	assert(loaded_data["level"] == 5, "Level should match")
	
	print("  ✅ PASSED: Data persistence works correctly")

func test_data_serialization():
	"""测试数据序列化（JSON 格式）"""
	print("\n[Unit Test] Data Serialization")
	
	# 创建包含各种数据类型的测试数据
	var test_data = {
		"string": "test_value",
		"int": 42,
		"float": 3.14,
		"bool": true,
		"array": [1, 2, 3],
		"nested": {
			"key": "value",
			"number": 123
		}
	}
	
	game_state_manager.player_data = test_data
	game_state_manager.save_player_data()
	
	# 清空并重新加载
	game_state_manager.player_data.clear()
	var loaded = game_state_manager.load_player_data()
	
	# 验证所有数据类型
	assert(loaded["string"] == "test_value", "String should be preserved")
	assert(loaded["int"] == 42, "Integer should be preserved")
	assert(abs(loaded["float"] - 3.14) < 0.001, "Float should be preserved")
	assert(loaded["bool"] == true, "Boolean should be preserved")
	assert(loaded["array"].size() == 3, "Array should be preserved")
	assert(loaded["nested"]["key"] == "value", "Nested data should be preserved")
	
	print("  ✅ PASSED: Data serialization (JSON) works correctly")