From 92d60638982380effd3dacddcb552c3fa676f0f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marco=20Araya=20Jim=C3=A9nez?= Date: Wed, 9 Jul 2025 22:42:08 -0600 Subject: [PATCH] test: add unit tests for SkillImpl functionality and base damage calculations --- .../combat_game/src/models/skill.cairo | 216 ++++++++++++++++++ 1 file changed, 216 insertions(+) diff --git a/backend/dojo_examples/combat_game/src/models/skill.cairo b/backend/dojo_examples/combat_game/src/models/skill.cairo index 68fd15f..69fcbd8 100644 --- a/backend/dojo_examples/combat_game/src/models/skill.cairo +++ b/backend/dojo_examples/combat_game/src/models/skill.cairo @@ -64,3 +64,219 @@ pub impl SkillImpl of SkillTrait { } } +#[cfg(test)] +mod tests { + use super::{ + SkillImpl, SkillType, + SLASH_SKILL_ID, BEAM_SKILL_ID, WAVE_SKILL_ID, PUNCH_SKILL_ID, KICK_SKILL_ID, + BLAST_SKILL_ID, CRUSH_SKILL_ID, PIERCE_SKILL_ID, SMASH_SKILL_ID, BURN_SKILL_ID, + FREEZE_SKILL_ID, SHOCK_SKILL_ID, DEFAULT_SKILL_ID, + SLASH_SKILL_DAMAGE, BEAM_SKILL_DAMAGE, WAVE_SKILL_DAMAGE, PUNCH_SKILL_DAMAGE, + KICK_SKILL_DAMAGE, BLAST_SKILL_DAMAGE, CRUSH_SKILL_DAMAGE, PIERCE_SKILL_DAMAGE, + SMASH_SKILL_DAMAGE, BURN_SKILL_DAMAGE, FREEZE_SKILL_DAMAGE, SHOCK_SKILL_DAMAGE, + DEFAULT_SKILL_DAMAGE, + }; + + #[test] + #[available_gas(1000000)] + fn test_skill_initialization() { + let skill = SkillImpl::new(SLASH_SKILL_ID, 100, SkillType::Slash, 5); + + assert_eq!(skill.id, SLASH_SKILL_ID, "Skill ID should match"); + assert_eq!(skill.power, 100, "Skill power should be 100"); + assert_eq!(skill.skill_type, SkillType::Slash, "Skill type should be Slash"); + assert_eq!(skill.min_level_required, 5, "Min level required should be 5"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_new_constructor() { + let skill = SkillImpl::new(BEAM_SKILL_ID, 150, SkillType::Beam, 10); + + assert_eq!(skill.id, BEAM_SKILL_ID, "Skill ID should match BEAM_SKILL_ID"); + assert_eq!(skill.power, 150, "Skill power should be 150"); + assert_eq!(skill.skill_type, SkillType::Beam, "Skill type should be Beam"); + assert_eq!(skill.min_level_required, 10, "Min level required should be 10"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_zero_power() { + let skill = SkillImpl::new(WAVE_SKILL_ID, 0, SkillType::Wave, 1); + + assert_eq!(skill.power, 0, "Skill power should be 0"); + assert_eq!(skill.min_level_required, 1, "Min level required should be 1"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_zero_level_requirement() { + let skill = SkillImpl::new(PUNCH_SKILL_ID, 50, SkillType::Punch, 0); + + assert_eq!(skill.min_level_required, 0, "Min level required should be 0"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_max_values() { + let skill = SkillImpl::new(KICK_SKILL_ID, 65535, SkillType::Kick, 255); + + assert_eq!(skill.power, 65535, "Skill power should be max u16"); + assert_eq!(skill.min_level_required, 255, "Min level required should be max u8"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_slash() { + let damage = SkillImpl::base_damage(SkillType::Slash); + assert_eq!(damage, SLASH_SKILL_DAMAGE, "Slash base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_beam() { + let damage = SkillImpl::base_damage(SkillType::Beam); + assert_eq!(damage, BEAM_SKILL_DAMAGE, "Beam base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_wave() { + let damage = SkillImpl::base_damage(SkillType::Wave); + assert_eq!(damage, WAVE_SKILL_DAMAGE, "Wave base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_punch() { + let damage = SkillImpl::base_damage(SkillType::Punch); + assert_eq!(damage, PUNCH_SKILL_DAMAGE, "Punch base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_kick() { + let damage = SkillImpl::base_damage(SkillType::Kick); + assert_eq!(damage, KICK_SKILL_DAMAGE, "Kick base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_blast() { + let damage = SkillImpl::base_damage(SkillType::Blast); + assert_eq!(damage, BLAST_SKILL_DAMAGE, "Blast base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_crush() { + let damage = SkillImpl::base_damage(SkillType::Crush); + assert_eq!(damage, CRUSH_SKILL_DAMAGE, "Crush base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_pierce() { + let damage = SkillImpl::base_damage(SkillType::Pierce); + assert_eq!(damage, PIERCE_SKILL_DAMAGE, "Pierce base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_smash() { + let damage = SkillImpl::base_damage(SkillType::Smash); + assert_eq!(damage, SMASH_SKILL_DAMAGE, "Smash base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_burn() { + let damage = SkillImpl::base_damage(SkillType::Burn); + assert_eq!(damage, BURN_SKILL_DAMAGE, "Burn base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_freeze() { + let damage = SkillImpl::base_damage(SkillType::Freeze); + assert_eq!(damage, FREEZE_SKILL_DAMAGE, "Freeze base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_shock() { + let damage = SkillImpl::base_damage(SkillType::Shock); + assert_eq!(damage, SHOCK_SKILL_DAMAGE, "Shock base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_base_damage_default() { + let damage = SkillImpl::base_damage(SkillType::Default); + assert_eq!(damage, DEFAULT_SKILL_DAMAGE, "Default base damage should match constant"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_id_uniqueness() { + let skill1 = SkillImpl::new(SLASH_SKILL_ID, 100, SkillType::Slash, 5); + let skill2 = SkillImpl::new(BEAM_SKILL_ID, 100, SkillType::Beam, 5); + + assert!(skill1.id != skill2.id, "Skills should have unique IDs"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_equality() { + let skill1 = SkillImpl::new(BLAST_SKILL_ID, 200, SkillType::Blast, 15); + let skill2 = SkillImpl::new(BLAST_SKILL_ID, 200, SkillType::Blast, 15); + + assert_eq!(skill1, skill2, "Skills with same properties should be equal"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_inequality() { + let skill1 = SkillImpl::new(CRUSH_SKILL_ID, 200, SkillType::Crush, 15); + let skill2 = SkillImpl::new(CRUSH_SKILL_ID, 300, SkillType::Crush, 15); + + assert!(skill1 != skill2, "Skills with different properties should be different"); + } + + #[test] + #[available_gas(1000000)] + fn test_all_skill_constants() { + // Test that all skill ID constants are unique + let skill_ids = array![ + SLASH_SKILL_ID, BEAM_SKILL_ID, WAVE_SKILL_ID, PUNCH_SKILL_ID, + KICK_SKILL_ID, BLAST_SKILL_ID, CRUSH_SKILL_ID, PIERCE_SKILL_ID, + SMASH_SKILL_ID, BURN_SKILL_ID, FREEZE_SKILL_ID, SHOCK_SKILL_ID, + DEFAULT_SKILL_ID + ]; + + // Test that each ID is within expected range + assert!(SLASH_SKILL_ID >= 1 && SLASH_SKILL_ID <= 13, "Slash skill ID should be in range"); + assert!(BEAM_SKILL_ID >= 1 && BEAM_SKILL_ID <= 13, "Beam skill ID should be in range"); + assert!(WAVE_SKILL_ID >= 1 && WAVE_SKILL_ID <= 13, "Wave skill ID should be in range"); + assert!(PUNCH_SKILL_ID >= 1 && PUNCH_SKILL_ID <= 13, "Punch skill ID should be in range"); + assert!(KICK_SKILL_ID >= 1 && KICK_SKILL_ID <= 13, "Kick skill ID should be in range"); + assert!(BLAST_SKILL_ID >= 1 && BLAST_SKILL_ID <= 13, "Blast skill ID should be in range"); + assert!(CRUSH_SKILL_ID >= 1 && CRUSH_SKILL_ID <= 13, "Crush skill ID should be in range"); + assert!(PIERCE_SKILL_ID >= 1 && PIERCE_SKILL_ID <= 13, "Pierce skill ID should be in range"); + assert!(SMASH_SKILL_ID >= 1 && SMASH_SKILL_ID <= 13, "Smash skill ID should be in range"); + assert!(BURN_SKILL_ID >= 1 && BURN_SKILL_ID <= 13, "Burn skill ID should be in range"); + assert!(FREEZE_SKILL_ID >= 1 && FREEZE_SKILL_ID <= 13, "Freeze skill ID should be in range"); + assert!(SHOCK_SKILL_ID >= 1 && SHOCK_SKILL_ID <= 13, "Shock skill ID should be in range"); + assert!(DEFAULT_SKILL_ID >= 1 && DEFAULT_SKILL_ID <= 13, "Default skill ID should be in range"); + } + + #[test] + #[available_gas(1000000)] + fn test_skill_damage_consistency() { + // Test that base damage matches what would be set when creating skills + let slash_skill = SkillImpl::new(SLASH_SKILL_ID, SLASH_SKILL_DAMAGE, SkillType::Slash, 1); + let calculated_damage = SkillImpl::base_damage(SkillType::Slash); + + assert_eq!(slash_skill.power, calculated_damage, "Skill power should match base damage"); + } +} \ No newline at end of file