test runner added

2026-01-28 11:22:20 -05:00
parent 8b5a7b1989
commit f4c7bab6b0
154 changed files with 18934 additions and 22 deletions
--- a/tests/unit/test_card_instance.gd
+++ b/tests/unit/test_card_instance.gd
@@ -0,0 +1,422 @@
+extends GutTest
+
+## Unit tests for CardInstance.gd
+
+
+## Initialization Tests
+
+func test_initialization():
+	var card_data = TestCardData.create_forward("test-id", "Test Card", Enums.Element.FIRE, 3, 5000)
+	var card = CardInstance.new(card_data, 0)
+
+	assert_eq(card.card_data, card_data)
+	assert_eq(card.owner_index, 0)
+	assert_eq(card.controller_index, 0)
+	assert_eq(card.current_power, 5000)
+	assert_eq(card.state, Enums.CardState.ACTIVE)
+	assert_eq(card.damage_received, 0)
+	assert_eq(card.turns_on_field, 0)
+	assert_false(card.attacked_this_turn)
+
+
+func test_initialization_with_null_data():
+	var card = CardInstance.new(null, 0)
+
+	assert_null(card.card_data)
+	assert_eq(card.current_power, 0)
+
+
+func test_unique_instance_ids():
+	var card1 = CardInstance.new(TestCardData.create_forward(), 0)
+	var card2 = CardInstance.new(TestCardData.create_forward(), 0)
+	var card3 = CardInstance.new(TestCardData.create_forward(), 0)
+
+	assert_ne(card1.instance_id, card2.instance_id)
+	assert_ne(card2.instance_id, card3.instance_id)
+	assert_ne(card1.instance_id, card3.instance_id)
+
+
+func test_controller_defaults_to_owner():
+	var card = CardInstance.new(TestCardData.create_forward(), 1)
+
+	assert_eq(card.owner_index, 1)
+	assert_eq(card.controller_index, 1)
+
+
+## Card Type Checks
+
+func test_is_forward():
+	var forward = CardInstance.new(TestCardData.create_forward(), 0)
+	var backup = CardInstance.new(TestCardData.create_backup(), 0)
+	var summon = CardInstance.new(TestCardData.create_summon(), 0)
+
+	assert_true(forward.is_forward())
+	assert_false(backup.is_forward())
+	assert_false(summon.is_forward())
+
+
+func test_is_backup():
+	var forward = CardInstance.new(TestCardData.create_forward(), 0)
+	var backup = CardInstance.new(TestCardData.create_backup(), 0)
+	var summon = CardInstance.new(TestCardData.create_summon(), 0)
+
+	assert_false(forward.is_backup())
+	assert_true(backup.is_backup())
+	assert_false(summon.is_backup())
+
+
+func test_is_summon():
+	var forward = CardInstance.new(TestCardData.create_forward(), 0)
+	var backup = CardInstance.new(TestCardData.create_backup(), 0)
+	var summon = CardInstance.new(TestCardData.create_summon(), 0)
+
+	assert_false(forward.is_summon())
+	assert_false(backup.is_summon())
+	assert_true(summon.is_summon())
+
+
+func test_type_check_with_null_data():
+	var card = CardInstance.new(null, 0)
+
+	assert_false(card.is_forward())
+	assert_false(card.is_backup())
+	assert_false(card.is_summon())
+
+
+## State Management
+
+func test_initial_state_is_active():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+
+	assert_true(card.is_active())
+	assert_false(card.is_dull())
+
+
+func test_dull():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+
+	card.dull()
+
+	assert_true(card.is_dull())
+	assert_false(card.is_active())
+
+
+func test_activate():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.dull()
+
+	card.activate()
+
+	assert_true(card.is_active())
+	assert_false(card.is_dull())
+
+
+## Power Tests
+
+func test_get_power_base():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	assert_eq(card.get_power(), 5000)
+
+
+func test_get_power_with_positive_modifier():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	card.power_modifiers.append(1000)
+
+	assert_eq(card.get_power(), 6000)
+
+
+func test_get_power_with_multiple_modifiers():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	card.power_modifiers.append(1000)
+	card.power_modifiers.append(2000)
+	card.power_modifiers.append(-500)
+
+	assert_eq(card.get_power(), 7500)
+
+
+func test_get_power_with_negative_modifier():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	card.power_modifiers.append(-2000)
+
+	assert_eq(card.get_power(), 3000)
+
+
+func test_get_power_floors_at_zero():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	card.power_modifiers.append(-10000)
+
+	assert_eq(card.get_power(), 0)
+
+
+## Attack Eligibility Tests
+
+func test_can_attack_basic():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 1  # Been on field for a turn
+
+	assert_true(card.can_attack())
+
+
+func test_cannot_attack_if_dull():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 1
+	card.dull()
+
+	assert_false(card.can_attack())
+
+
+func test_cannot_attack_if_already_attacked():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 1
+	card.attacked_this_turn = true
+
+	assert_false(card.can_attack())
+
+
+func test_cannot_attack_summoning_sickness():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 0  # Just entered field
+
+	assert_false(card.can_attack())
+
+
+func test_can_attack_with_haste_on_first_turn():
+	var card = CardInstance.new(TestCardData.create_haste_forward(), 0)
+	card.turns_on_field = 0  # Just entered field
+
+	assert_true(card.has_haste())
+	assert_true(card.can_attack())
+
+
+func test_backup_cannot_attack():
+	var card = CardInstance.new(TestCardData.create_backup(), 0)
+	card.turns_on_field = 1
+
+	assert_false(card.can_attack())
+
+
+func test_summon_cannot_attack():
+	var card = CardInstance.new(TestCardData.create_summon(), 0)
+	card.turns_on_field = 1
+
+	assert_false(card.can_attack())
+
+
+## Block Eligibility Tests
+
+func test_can_block_basic():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+
+	assert_true(card.can_block())
+
+
+func test_cannot_block_if_dull():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.dull()
+
+	assert_false(card.can_block())
+
+
+func test_backup_cannot_block():
+	var card = CardInstance.new(TestCardData.create_backup(), 0)
+
+	assert_false(card.can_block())
+
+
+func test_can_block_even_on_first_turn():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 0  # Just entered field
+
+	# Blocking doesn't have summoning sickness
+	assert_true(card.can_block())
+
+
+## Ability Detection Tests
+
+func test_has_haste():
+	var haste_card = CardInstance.new(TestCardData.create_haste_forward(), 0)
+	var normal_card = CardInstance.new(TestCardData.create_forward(), 0)
+
+	assert_true(haste_card.has_haste())
+	assert_false(normal_card.has_haste())
+
+
+func test_has_brave():
+	var brave_card = CardInstance.new(TestCardData.create_brave_forward(), 0)
+	var normal_card = CardInstance.new(TestCardData.create_forward(), 0)
+
+	assert_true(brave_card.has_brave())
+	assert_false(normal_card.has_brave())
+
+
+func test_has_first_strike():
+	var first_strike_card = CardInstance.new(TestCardData.create_first_strike_forward(), 0)
+	var normal_card = CardInstance.new(TestCardData.create_forward(), 0)
+
+	assert_true(first_strike_card.has_first_strike())
+	assert_false(normal_card.has_first_strike())
+
+
+func test_ability_checks_with_null_data():
+	var card = CardInstance.new(null, 0)
+
+	assert_false(card.has_haste())
+	assert_false(card.has_brave())
+	assert_false(card.has_first_strike())
+
+
+## Element Tests
+
+func test_get_element():
+	var fire_card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE), 0)
+	var ice_card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.ICE), 0)
+
+	assert_eq(fire_card.get_element(), Enums.Element.FIRE)
+	assert_eq(ice_card.get_element(), Enums.Element.ICE)
+
+
+func test_get_elements():
+	var elements: Array[Enums.Element] = [Enums.Element.FIRE, Enums.Element.ICE]
+	var multi_card = CardInstance.new(TestCardData.create_multi_element_forward("id", "Multi", elements), 0)
+
+	var card_elements = multi_card.get_elements()
+
+	assert_eq(card_elements.size(), 2)
+	assert_true(Enums.Element.FIRE in card_elements)
+	assert_true(Enums.Element.ICE in card_elements)
+
+
+func test_is_light_or_dark():
+	var fire_card = CardInstance.new(TestCardData.create_forward(), 0)
+	var light_card = CardInstance.new(TestCardData.create_light_forward(), 0)
+	var dark_card = CardInstance.new(TestCardData.create_dark_forward(), 0)
+
+	assert_false(fire_card.is_light_or_dark())
+	assert_true(light_card.is_light_or_dark())
+	assert_true(dark_card.is_light_or_dark())
+
+
+## Damage Tests
+
+func test_apply_damage():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	var broken = card.apply_damage(3000)
+
+	assert_false(broken)
+	assert_eq(card.damage_received, 3000)
+
+
+func test_apply_damage_breaks_card():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	var broken = card.apply_damage(5000)  # Damage equals power
+
+	assert_true(broken)
+
+
+func test_apply_damage_accumulates():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+
+	card.apply_damage(3000)
+	var broken = card.apply_damage(2000)  # Total 5000 = power
+
+	assert_true(broken)
+	assert_eq(card.damage_received, 5000)
+
+
+func test_apply_damage_to_backup_fails():
+	var card = CardInstance.new(TestCardData.create_backup(), 0)
+
+	var broken = card.apply_damage(1000)
+
+	assert_false(broken)  # Backups can't receive combat damage
+
+
+func test_apply_damage_considers_modifiers():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Test", Enums.Element.FIRE, 3, 5000), 0)
+	card.power_modifiers.append(2000)  # Power is now 7000
+
+	var broken = card.apply_damage(5000)  # 5000 < 7000
+
+	assert_false(broken)
+
+
+## Lifecycle Tests
+
+func test_entered_field():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 5
+	card.attacked_this_turn = true
+	card.damage_received = 1000
+
+	card.entered_field()
+
+	assert_eq(card.turns_on_field, 0)
+	assert_false(card.attacked_this_turn)
+	assert_eq(card.damage_received, 0)
+
+
+func test_start_turn():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.turns_on_field = 0
+
+	card.start_turn()
+
+	assert_eq(card.turns_on_field, 1)
+
+
+func test_end_turn_cleanup():
+	var card = CardInstance.new(TestCardData.create_forward(), 0)
+	card.power_modifiers.append(1000)
+	card.power_modifiers.append(-500)
+	card.damage_received = 2000
+	card.attacked_this_turn = true
+
+	card.end_turn_cleanup()
+
+	assert_eq(card.power_modifiers.size(), 0)
+	assert_eq(card.damage_received, 0)
+	assert_false(card.attacked_this_turn)
+
+
+## Display Tests
+
+func test_get_display_name():
+	var card = CardInstance.new(TestCardData.create_forward("id", "Cloud"), 0)
+
+	assert_eq(card.get_display_name(), "Cloud")
+
+
+func test_get_display_name_null_data():
+	var card = CardInstance.new(null, 0)
+
+	assert_eq(card.get_display_name(), "Unknown Card")
+
+
+## Dull Ability Tests
+
+func test_can_use_dull_ability():
+	var card = CardInstance.new(TestCardData.create_backup(), 0)
+	card.turns_on_field = 1
+
+	assert_true(card.can_use_dull_ability())
+
+
+func test_cannot_use_dull_ability_summoning_sickness():
+	var card = CardInstance.new(TestCardData.create_backup(), 0)
+	card.turns_on_field = 0
+
+	assert_false(card.can_use_dull_ability())
+
+
+func test_can_use_dull_ability_with_haste():
+	var card = CardInstance.new(TestCardData.create_haste_forward(), 0)
+	card.turns_on_field = 0
+
+	assert_true(card.can_use_dull_ability())