def test_swap_elemental(self): error = "Failed to swap Elementals in a valid Team slot" monze = ElementalBuilder().build() lofy = ElementalBuilder().build() self.team.add_elemental(monze) # Position 0 self.team.swap(slot=0, elemental=lofy) self.assertEqual(lofy.id, self.team.get_elemental(0).id, error)
def test_raise_attribute(self): error = "Elemental who met requirements couldn't raise an attribute" elemental = ElementalBuilder().with_level(10).build() elemental.raise_attribute(elemental.attributes[0]) attributes = elemental.attributes attribute_level = attributes[0].level self.assertEqual(attribute_level, 1, error)
def test_reset_nickname(self): error = "Elemental nickname couldn't be reset" species = SpeciesBuilder().with_name("Richard").build() elemental = ElementalBuilder().with_species(species).build() elemental.nickname = "Logi" elemental.reset_nickname() self.assertEqual(elemental.nickname, "Richard", error)
def test_skip_ko_active(self): error = "CombatTeam incorrectly set a 0 HP Elemental as the active Elemental" team = CombatTeam([ ElementalBuilder().with_current_hp(0).build(), ElementalBuilder().build() ]) Combat([team], [], Mock()) self.assertGreater(team.active_elemental.current_hp, 0, error)
def test_remove_elemental(self): error = "Failed to remove an Elemental from the Team" monze = ElementalBuilder().build() lofy = ElementalBuilder().build() self.team.add_elemental(monze) # Position 0 self.team.add_elemental(lofy) # Position 1 self.team.remove_elemental(0) # Remove monze self.assertEqual(lofy.id, self.team.get_elemental(0).id, error)
def test_bench(self): error = "CombatTeam incorrectly included the active CombatElemental in bench" team = CombatTeam( [ElementalBuilder().build(), ElementalBuilder().build()]) Combat([team], [], Mock()) self.assertEqual(len(team.bench), 1, error) self.assertEqual(team.bench[0].id, team.elementals[0].id, error)
def test_multi_level_up(self): error = "Elemental failed to level up multiple times with multiple levels' worth of experience" elemental = ElementalBuilder().with_level(1).build() before_level = elemental.level exp_gained = elemental.exp_to_level * 5 # Arbitrary large amount of exp elemental.add_exp(exp_gained) after_level = elemental.level self.assertGreater(after_level, before_level + 1, error)
def get_player(self): """ :return: A Player object with 2 Elementals on their Team. """ player = PlayerBuilder().with_level(10).build() player.add_elemental(ElementalBuilder().with_level(10).build()) player.add_elemental(ElementalBuilder().with_level(10).build()) return player
def test_eligible_bench(self): error = "CombatTeam incorrectly included knocked out CombatElementals in the eligible bench" team = CombatTeam([ ElementalBuilder().with_current_hp(0).build(), ElementalBuilder().build() ]) Combat([team], [], Mock()) self.assertEqual(len(team.eligible_bench), 0, error)
def test_find_neutral(self): error = "Should have found a neutral elemental given a list" elementals = [ ElementalBuilder().with_element(Elements.LIGHT).build(), ElementalBuilder().with_element(Elements.EARTH).build(), ElementalBuilder().with_element(Elements.WIND).build() ] result = Effectiveness.find_effective(elementals, Elements.FIRE) self.assertEqual(len(result), 1, error)
def test_swap_ability(self): error = "Elemental couldn't swap an ability" species = self.get_species() elemental = ElementalBuilder().with_level(5).with_species( species).build() active_ability = elemental.active_abilities[0] eligible_ability = elemental.eligible_abilities[0] elemental.swap_ability(active_ability, eligible_ability) self.assertIn(eligible_ability, elemental.active_abilities, error)
def test_switch_ko(self): error = "CombatTeam incorrectly allowed a knocked out CombatElemental to be switched in" team = CombatTeam([ ElementalBuilder().with_current_hp(0).build(), ElementalBuilder().build() ]) Combat([team], [], Mock()) is_switched = team.attempt_switch(team.elementals[0]) self.assertFalse(is_switched, error)
def test_reorder_elementals(self): error = "Failed to reorder Elementals in a Team" monze = ElementalBuilder().build() lofy = ElementalBuilder().build() self.team.add_elemental(monze) # Position 0 self.team.add_elemental(lofy) # Position 1 self.team.reorder(0, 1) self.assertEqual(monze.id, self.team.get_elemental(1).id, error) self.assertEqual(lofy.id, self.team.get_elemental(0).id, error)
def test_elemental_action(self): error = "ElementalAction could incorrectly trigger when the elemental is KOed." elemental = ElementalBuilder().build() team = CombatTeam([elemental], PlayerBuilder().build()) elemental.receive_damage(10000) action = ElementalAction(actor=team.elementals[0], ability=Claw(), combat=Mock()) self.assertFalse(action.can_execute, error)
def test_mana_per_turn(self): error = "CombatTeam eligible Elementals on the bench didn't gain mana on turn start" team = CombatTeam( [ElementalBuilder().build(), ElementalBuilder().build()]) Combat([team], [], Mock()) bench = team.eligible_bench starting_mana = bench[0].current_mana team.turn_start() resultant_mana = bench[0].current_mana self.assertGreater(resultant_mana, starting_mana, error)
def test_learn_abilities_by_level(self): error = "Elemental couldn't learn an ability by leveling" elemental = ElementalBuilder() \ .with_level(1) \ .with_species(self.get_species()) \ .build() initial_num_abilities = len(elemental.active_abilities) exp = elemental.exp_to_level * 500 # Arbitrary large amount of exp elemental.add_exp(exp) leveled_num_abilities = len(elemental.active_abilities) self.assertGreater(leveled_num_abilities, initial_num_abilities, error)
def test_get_enemy_target(self): error = "Ability that targets an enemy didn't get the correct target" team_a = CombatTeam([ElementalBuilder().build()], PlayerBuilder().build()) team_b = CombatTeam([ElementalBuilder().build()], PlayerBuilder().build()) combat = Combat([team_a], [team_b], Mock()) ability = Mock() ability.targeting = Target.ENEMY target = combat.get_target(ability, team_a.active_elemental) self.assertEqual(target, team_b.active_elemental, error)
def test_set_excessive_abilities(self): error = "Replacing an elemental's abilities with an excessive set wasn't handled correctly" species = self.get_species() elemental = ElementalBuilder().with_level(5).with_species( species).build() abilities = [Slam(), RollingThunder(), Rend(), Fireball(), Claw()] elemental.set_abilities(abilities) ability_names = [ ability.name for ability in elemental.active_abilities ] self.assertNotIn(Claw().name, ability_names, error) self.assertEqual(4, len(elemental.active_abilities))
def test_rolling_thunder_duration(self): error = "Rolling Thunder turn duration didn't decrement" effect = RollingThunderEffect() team = CombatTeam([ElementalBuilder().build()], PlayerBuilder().build()) effect.applier = team.elementals[0] enemy_team = CombatTeam([ElementalBuilder().build()], PlayerBuilder().build()) get_mocked_combat(team, enemy_team) enemy_team.add_status_effect(effect) duration_before = effect.rounds_remaining enemy_team.end_round() self.assertLess(effect.rounds_remaining, duration_before, error)
def test_physical_defence(self): error = "Physical defence didn't reduce any damage" low_def = CombatElementalBuilder().with_elemental( ElementalBuilder().with_physical_def(1).build()).build() high_def = CombatElementalBuilder().with_elemental( ElementalBuilder().with_physical_def(30).build()).build() actor = CombatElementalBuilder().build() low_def_calculator = DamageCalculator(low_def, actor, Claw()) low_def_calculator.calculate() high_def_calculator = DamageCalculator(high_def, actor, Claw()) high_def_calculator.calculate() self.assertGreater(low_def_calculator.final_damage, high_def_calculator.final_damage, error)
def test_defend_priority(self): error = "Defend wasn't faster than other abilities" team_a = make_combat_team() team_b = make_combat_team() combat = get_mocked_combat(team_a, team_b) faster = CombatElemental(ElementalBuilder().with_speed(10).build(), team_b) team_b.change_active_elemental(faster) slower = CombatElemental(ElementalBuilder().with_speed(1).build(), team_a) team_a.change_active_elemental(slower) combat.request_action(ElementalAction(faster, Claw(), combat)) combat.request_action(ElementalAction(slower, Defend(), combat)) self.assertIsInstance(combat.previous_round_actions[0].ability, Defend, error)
def test_set_abilities(self): error = "Elemental abilities couldn't be replaced" species = self.get_species() elemental = ElementalBuilder().with_level(5).with_species( species).build() abilities = [Slam(), RollingThunder(), Rend(), Fireball()] elemental.set_abilities(abilities) correctly_added = 0 ability_names = [ ability.name for ability in elemental.active_abilities ] for ability in abilities: if ability.name in ability_names: correctly_added += 1 self.assertEqual(correctly_added, len(abilities), error)
def test_max_num_elementals(self): error = "A Team can incorrectly have more than 4 Elementals" for i in range(5): elemental = ElementalBuilder().build() self.team.add_elemental(elemental) self.assertEqual(self.team.size, 4, error) self.assertEqual(self.team.is_space_available, False, error)
def test_create_unique_attributes(self): error = "Elemental can incorrectly have a duplicate attribute" for i in range(100): elemental = ElementalBuilder().build() attributes = elemental.attributes no_duplicates = len(attributes) == len(set(attributes)) self.assertIs(no_duplicates, True, error)
def test_level_up(self): error = "Elemental couldn't level" elemental = ElementalBuilder().with_level(1).build() before_level = elemental.level self.level_up(elemental) after_level = elemental.level self.assertGreater(after_level, before_level, error)
def test_num_active_abilities(self): error = "Elemental can incorrectly have more than 4 abilities active" species = self.get_species() elemental = ElementalBuilder().with_level(5).with_species( species).build() num_abilities = len(elemental.active_abilities) self.assertEqual(num_abilities, 4, error)
def test_level_exp_cap(self): error = "Leveling up didn't increase the Elemental's required exp" elemental = ElementalBuilder().with_level(1).build() lower_requirement = elemental.exp_to_level self.level_up(elemental) higher_requirement = elemental.exp_to_level self.assertGreater(higher_requirement, lower_requirement, error)
def test_action_speed_priority(self): error = "Faster elemental didn't attack first" team_a = make_combat_team() team_b = make_combat_team() combat = get_mocked_combat(team_a, team_b) slower = CombatElemental(ElementalBuilder().with_level(1).build(), team_a) team_a.change_active_elemental(slower) faster = CombatElemental( ElementalBuilder().with_level(10).with_nickname('loksy').build(), team_b) team_b.change_active_elemental(faster) combat.request_action(ElementalAction(slower, Claw(), combat)) faster_action = ElementalAction(faster, Claw(), combat) combat.request_action(faster_action) expected = combat.previous_round_actions[0].actor.nickname self.assertEqual(expected, faster.nickname, error)
def wild_elemental_loot(self): error = "Wild elemental didn't award loot" winning_teams = [CombatTeam.from_team(TeamBuilder().build())] wild_elemental = ElementalBuilder().with_species(Manapher()).build() # Manapher has 100% drop rate losing_teams = [CombatTeam([wild_elemental])] # Wild elemental teams have no owner generator = LootGenerator(winning_teams, losing_teams) generator.generate_loot() self.assertGreater(len(generator.items_dropped), 0, error)
def test_victory_elementalist_no_loot(self): error = "Elementalist shouldn't award loot" winning_teams = [CombatTeam([], PlayerBuilder().build())] elemental = ElementalBuilder().with_species(Manapher()).build() # Manapher has 100% drop rate losing_teams = [CombatTeam([elemental], NPCBuilder().build())] generator = LootGenerator(winning_teams, losing_teams) generator.generate_loot() self.assertEqual(len(generator.items_dropped), 0, error)