def test_string_method_prints_the_expected_string(self):
self.hero = Hero('Miro', 100, 850, 5)
result = Hero.__str__(self.hero)
expected_result = f"Hero {self.hero.username}: {self.hero.level} lvl\n" \
f"Health: {self.hero.health}\n" \
f"Damage: {self.hero.damage}\n"
self.assertEqual(result, expected_result)
class TestHero(unittest.TestCase):
def setUp(self):
self.hero = Hero("Wizard", 70, 6000.00, 1500.00)
self.enemy = Hero("Barbarian", 80, 10000.00, 2000.00)
self.mario = Hero("Mario", 1, 100.00, 100.00)
def test_init(self):
self.assertEqual(self.hero.username, "Wizard")
self.assertEqual(self.hero.level, 70)
self.assertEqual(self.hero.health, 6000.00)
self.assertEqual(self.hero.damage, 1500.00)
def test_str(self):
self.assertEqual(
self.hero.__str__(), f"Hero Wizard: {self.hero.level} lvl\n"
f"Health: {self.hero.health}\nDamage: {self.hero.damage}\n")
def test_fight_with_yourself(self):
with self.assertRaises(Exception) as ex:
self.hero.battle(self.hero)
self.assertEqual("You cannot fight yourself", str(ex.exception))
def test_hero_with_zero_health(self):
self.hero.health = 0
with self.assertRaises(Exception) as ex:
self.hero.battle(self.enemy)
self.assertEqual(
"Your health is lower than or equal to 0. You need to rest",
str(ex.exception))
def test_enemy_with_zero_health(self):
self.enemy.health = 0
with self.assertRaises(Exception) as ex:
self.hero.battle(self.enemy)
self.assertEqual(
f"You cannot fight {self.enemy.username}. He needs to rest",
str(ex.exception))
def test_fight_draw_game(self):
self.hero.battle(self.enemy)
self.assertEqual(self.hero.health, -154000.00)
self.assertEqual(self.enemy.health, -95000.00)
self.assertRaises(Exception, "Draw")
def test_fight_for_win(self):
fight = self.hero.battle(self.mario)
self.assertEqual(self.hero.level, 71)
self.assertEqual(self.hero.damage, 1505.00)
self.assertEqual(self.hero.health, 5905.00)
self.assertEqual(fight, "You win")
def test_fight_for_loose(self):
self.hero = Hero("Wizard", 70, 6000.00, 10.00)
fight = self.hero.battle(self.enemy)
self.assertEqual(self.enemy.level, 81)
self.assertEqual(self.enemy.damage, 2005.00)
self.assertEqual(self.enemy.health, 9305.00)
self.assertEqual(fight, "You lose")
class HeroTest(unittest.TestCase):
def setUp(self) -> None:
self.hero = Hero("Bobby", 25, 98, 2)
def test_constructor(self):
self.assertEqual("Bobby", self.hero.username)
self.assertEqual(25, self.hero.level)
self.assertEqual(98, self.hero.health)
self.assertEqual(2, self.hero.damage)
def test_enemy_hero_and_hero_are_equal(self):
with self.assertRaises(Exception):
enemy_hero = Hero("Bobby", 25, 98, 2)
self.hero.battle(enemy_hero)
def test_battle_hero_health_less_than_zro(self):
enemy_hero = Hero("Borko", 25, 98, 2)
self.hero.health = 0
with self.assertRaises(Exception):
self.hero.battle(enemy_hero)
def test_battle_enemy_health_less_than_zro(self):
enemy_hero = Hero("Borko", 25, 0, 2)
with self.assertRaises(Exception):
self.hero.battle(enemy_hero)
def test_player_health_when_payer_loss(self):
enemy_hero = Hero("Borko", 25, 75, 2)
self.assertEqual("You lose", self.hero.battle(enemy_hero) )
self.assertEqual(48, self.hero.health)
self.assertEqual(30, enemy_hero.health)
self.assertEqual(26, enemy_hero.level)
self.assertEqual(7, enemy_hero.damage)
def test_player_health_if_payer_win(self):
enemy_hero = Hero("Borko", 25, 50, 2)
self.assertEqual("You win", self.hero.battle(enemy_hero))
self.assertEqual(53, self.hero.health)
self.assertEqual(0, enemy_hero.health)
self.assertEqual(26, self.hero.level)
self.assertEqual(7, self.hero.damage)
def test_if_hero_and_enemy_are_equal_to_zero(self):
enemy_hero = Hero("Borko", 49, 50, 2)
self.assertEqual("Draw", self.hero.battle(enemy_hero))
def test_repr_hero(self):
expect = f"Hero Bobby: 25 lvl\nHealth: 98\nDamage: 2\n"
self.assertEqual(expect, self.hero.__str__())
class TestHero(TestCase):
username = '******'
health = 100.00
damage = 20.00
level = 12
enemy_username = '******'
enemy_health = 240
enemy_damage = 10.00
enemy_level = 10
def setUp(self):
self.hero = Hero(self.username, self.level, self.health, self.damage)
self.enemy = Hero(self.enemy_username, self.enemy_level, self.enemy_health, self.enemy_damage)
def test_initialize_correct_values(self):
self.assertEqual(self.username, self.hero.username)
self.assertEqual(self.health, self.hero.health)
self.assertEqual(self.damage, self.hero.damage)
self.assertEqual(self.level, self.hero.level)
def test_can_not_fight_yourself(self):
with self.assertRaises(Exception):
self.hero.battle(self.hero)
def test_can_not_fight_when_hero_health_is_zero(self):
self.hero.health = 0
with self.assertRaises(ValueError):
self.hero.battle(self.enemy)
# self.assertEqual("Your health is lower than or equal to 0. You need to rest", str(ex.exception))
def test_can_not_fight_when_enemy_health_is_zero(self):
self.enemy.health = 0
with self.assertRaises(ValueError):
self.hero.battle(self.enemy)
# self.assertEqual(f"You cannot fight {self.enemy_username}. He needs to rest", str(ex.exception))
def test_hero_and_enemy_health_is_zero(self):
self.assertEqual('Draw', self.hero.battle(self.enemy))
def test_hero_wins_after_battle_and_values_increase(self):
self.hero.health += 100
self.assertEqual('You win', self.hero.battle(self.enemy))
self.assertEqual(self.level + 1, self.hero.level)
self.assertEqual(self.health + 5, self.hero.health)
self.assertEqual(self.damage + 5, self.hero.damage)
self.assertTrue(self.enemy.health <= 0)
def test_enemy_wins_after_battle_and_values_increase(self):
self.enemy.health += 240
self.assertEqual('You lose', self.hero.battle(self.enemy))
self.assertEqual(self.enemy_level + 1, self.enemy.level)
self.assertEqual(self.enemy_health + 5, self.enemy.health)
self.assertEqual(self.enemy_damage + 5, self.enemy.damage)
self.assertTrue(self.hero.health <= 0)
def test_hero_string_representation(self):
self.assertEqual(f"Hero {self.username}: {self.level} lvl\nHealth: {self.health}\nDamage: {self.damage}\n",
self.hero.__str__())
def test_enemy_string_representation(self):
self.assertEqual(
f"Hero {self.enemy_username}: {self.enemy_level} lvl\nHealth: {self.enemy_health}\nDamage: {self.enemy_damage}\n",
self.enemy.__str__())
class HeroTest(unittest.TestCase):
def setUp(self):
self.hero = Hero('Blue Mage', 10, 1000.1, 100.2)
def test_hero_init_method_attributes(self):
self.assertEqual('Blue Mage', self.hero.username)
self.assertEqual(10, self.hero.level)
self.assertEqual(1000.1, self.hero.health)
self.assertEqual(100.2, self.hero.damage)
def test_hero_str_method(self):
expected_result = f"Hero Blue Mage: 10 lvl\nHealth: 1000.1\nDamage: 100.2\n"
actual_result = self.hero.__str__()
self.assertEqual(expected_result, actual_result)
def test_hero_battle_when_enemy_hero_name_same_as_hero_name(self):
enemy_hero = self.hero
with self.assertRaises(Exception) as context:
self.hero.battle(enemy_hero)
self.assertEqual("You cannot fight yourself", str(context.exception))
def test_hero_battle_when_hero_health_is_0(self):
enemy_hero = Hero('Hero', 5, 100, 3)
self.hero.health = 0
with self.assertRaises(ValueError) as context:
self.hero.battle(enemy_hero)
self.assertEqual(
"Your health is lower than or equal to 0. You need to rest",
str(context.exception))
def test_hero_battle_when_hero_health_is_less_than_0(self):
enemy_hero = Hero('Hero', 5, 100, 3)
self.hero.health = -5
with self.assertRaises(ValueError) as context:
self.hero.battle(enemy_hero)
self.assertEqual(
"Your health is lower than or equal to 0. You need to rest",
str(context.exception))
def test_hero_battle_when_enemy_hero_health_is_0(self):
enemy_hero = Hero('Knight', 5, 0, 3)
with self.assertRaises(ValueError) as context:
self.hero.battle(enemy_hero)
self.assertEqual("You cannot fight Knight. He needs to rest",
str(context.exception))
def test_hero_battle_when_enemy_hero_health_is_less_than_0(self):
enemy_hero = Hero('Knight', 5, -100, 3)
with self.assertRaises(ValueError) as context:
self.hero.battle(enemy_hero)
self.assertEqual("You cannot fight Knight. He needs to rest",
str(context.exception))
def test_hero_battle_when_battle_is_draw(self):
enemy_hero = Hero('Knight', 10, 1000.1, 100.2)
expected_result = "Draw"
actual_result = self.hero.battle(enemy_hero)
self.assertEqual(expected_result, actual_result)
def test_hero_battle_when_hero_wins(self):
enemy_hero = Hero('Knight', 5, 100, 3)
expected_result = "You win"
actual_result = self.hero.battle(enemy_hero)
self.assertEqual(expected_result, actual_result)
self.assertEqual(11, self.hero.level)
self.assertEqual(990.1, self.hero.health)
self.assertEqual(105.2, self.hero.damage)
def test_hero_battle_when_enemy_hero_wins(self):
enemy_hero = Hero('Knight', 11, 10000, 110)
expected_result = "You lose"
actual_result = self.hero.battle(enemy_hero)
self.assertEqual(expected_result, actual_result)
self.assertEqual(12, enemy_hero.level)
self.assertEqual(9003, enemy_hero.health)
self.assertEqual(115, enemy_hero.damage)
class TestHero(TestCase):
username = '******'
health = 100
damage = 5
level = 5
def setUp(self):
self.hero = Hero(self.username, self.level, self.health, self.damage)
def test_hero_init_method_attributes(self):
self.assertEqual('MadMax', self.hero.username)
self.assertEqual(5, self.hero.level)
self.assertEqual(100, self.hero.health)
self.assertEqual(5, self.hero.damage)
def test_battle_exception_test(self):
with self.assertRaises(Exception) as context:
enemy_hero = self.hero
self.hero.battle(enemy_hero)
self.assertEqual('You cannot fight yourself', str(context.exception))
def test_battle_exception_if_hero_lower_health(self):
with self.assertRaises(Exception) as context:
self.hero.health = 0
enemy_hero = Hero('Hero', 5, 100, 3)
self.hero.battle(enemy_hero)
self.assertEqual(
'Your health is lower than or equal to 0. You need to rest',
str(context.exception))
def test_battle_exception_if_enemy_hero_has_lower_health(self):
with self.assertRaises(Exception) as context:
enemy_hero = Hero('Enemy Hero Pesho', 5, 0, 3)
self.hero.battle(enemy_hero)
self.assertEqual(
f'You cannot fight {enemy_hero.username}. He needs to rest',
str(context.exception))
def test_battle_results(self):
enemy_hero = Hero('Enemy Hero Pesho', 5, 100, 3)
self.hero.battle(enemy_hero)
self.assertEqual(self.hero.health, 85)
self.assertEqual(enemy_hero.health, 80)
def test_you_win_if__healt_0(self):
enemy_hero = Hero('Enemy Hero Pesho', 5, 10, 3)
expected_message = 'You win'
actual_message = self.hero.battle(enemy_hero)
self.assertEqual(expected_message, actual_message)
def test_you_loose_if_self_health_under_0(self):
enemy_hero = Hero('Enemy Hero Pesho', 50, 110, 30)
expected_message = 'You lose'
actual_message = self.hero.battle(enemy_hero)
self.assertEqual(expected_message, actual_message)
def test__rerp_method(self):
expected = f"Hero MadMax: 5 lvl\n" \
f"Health: 100\n" \
f"Damage: 5\n"
actual_result = self.hero.__str__()
self.assertEqual(expected, actual_result)
def test_if_health_of_both_hero_is_0(self):
enemy_hero = Hero('Enemy Hero Pesho', 50, 1, 30)
expected_result = 'Draw'
result = self.hero.battle(enemy_hero)
self.assertEqual(result, expected_result)
class HeroTest(unittest.TestCase):
username = '******'
level = 2
health = 100.0
damage = 10.0
def setUp(self) -> None:
self.hero = Hero(username=self.username,
level=self.level,
health=self.health,
damage=self.damage)
def test_hero_init(self):
self.assertEqual(self.username, self.hero.username)
self.assertEqual(self.health, self.hero.health)
self.assertEqual(self.damage, self.hero.damage)
self.assertEqual(self.level, self.hero.level)
def test_hero_string_representation(self):
expected = f"Hero {self.username}: {self.level} lvl\n" \
f"Health: {self.health}\n" \
f"Damage: {self.damage}\n"
actual = self.hero.__str__()
self.assertEqual(expected, actual)
def test_battle__when_self_fight__should_raise_exception(self):
enemy = self.hero
with self.assertRaises(Exception) as exc:
self.hero.battle(enemy)
msg = "You cannot fight yourself"
self.assertEqual(msg, str(exc.exception))
def test_battle__when_hero_health_is_0__should_raise_value_error(self):
enemy = Hero('enemy', 1, 100.0, 10.0)
self.hero.health = 0
with self.assertRaises(ValueError) as exc:
self.hero.battle(enemy)
msg = "Your health is lower than or equal to 0. You need to rest"
self.assertEqual(msg, str(exc.exception))
def test_battle__when_hero_health_is_negative__should_raise_value_error(
self):
enemy = Hero('enemy', 1, 100.0, 10.0)
self.hero.health = -1
with self.assertRaises(ValueError) as exc:
self.hero.battle(enemy)
msg = "Your health is lower than or equal to 0. You need to rest"
self.assertEqual(msg, str(exc.exception))
def test_battle__when_enemy_health_is_0__should_raise_value_error(self):
enemy = Hero('enemy', 1, 0.0, 10.0)
with self.assertRaises(ValueError) as exc:
self.hero.battle(enemy)
msg = f"You cannot fight {enemy.username}. He needs to rest"
self.assertEqual(msg, str(exc.exception))
def test_battle__when_enemy_health_is_negative__should_raise_value_error(
self):
enemy = Hero('enemy', 1, -1.0, 10.0)
with self.assertRaises(ValueError) as exc:
self.hero.battle(enemy)
msg = f"You cannot fight {enemy.username}. He needs to rest"
self.assertEqual(msg, str(exc.exception))
def test_battle__hero_health_is_reduced_by_enemy_dmg(self):
enemy = Hero(username='******', level=2, health=100.0, damage=10.0)
self.hero.battle(enemy)
self.assertEqual(80.0, self.hero.health)
def test_battle__enemy_health_is_reduced_by_hero_dmg(self):
enemy = Hero(username='******', level=2, health=100.0, damage=10.0)
self.hero.battle(enemy)
self.assertEqual(85.0, enemy.health)
def test_battle__when_health_is_negative__should_return_draw(self):
self.hero.damage = 100
enemy = Hero(username='******', level=2, health=100.0, damage=100.0)
expected = 'Draw'
actual = self.hero.battle(enemy)
self.assertEqual(expected, actual)
def test_battle__when_health_is_0__should_return_draw(self):
self.hero.damage = 50
enemy = Hero(username='******', level=2, health=100.0, damage=50.0)
expected = 'Draw'
actual = self.hero.battle(enemy)
self.assertEqual(expected, actual)
def test_battle__when_hero_health_is_less_than_enemy__should_return_lose(
self):
enemy = Hero(username='******', level=2, health=100.0, damage=50.0)
expected = 'You lose'
actual = self.hero.battle(enemy)
self.assertEqual(expected, actual)
def test_battle__when_enemy_health_is_0__should_return_win(self):
enemy = Hero(username='******', level=1, health=20.0, damage=10.0)
expected = 'You win'
actual = self.hero.battle(enemy)
self.assertEqual(expected, actual)
def test_battle__when_enemy_health_is_negative__should_return_win(self):
enemy = Hero(username='******', level=1, health=10.0, damage=10.0)
expected = 'You win'
actual = self.hero.battle(enemy)
self.assertEqual(expected, actual)
def test_battle__when_win__should_increase_hero_stats(self):
enemy = Hero(username='******', level=1, health=10.0, damage=0.0)
self.hero.battle(enemy)
self.assertEqual(3, self.hero.level)
self.assertEqual(105.0, self.hero.health)
self.assertEqual(15.0, self.hero.damage)
def test_battle__when_lose__should_increase_enemy_stats(self):
enemy = Hero(username='******', level=10, health=100.0, damage=100.0)
self.hero.battle(enemy)
self.assertEqual(11, enemy.level)
self.assertEqual(85.0, enemy.health)
self.assertEqual(105.0, enemy.damage)
class TestHero(unittest.TestCase):
def setUp(self):
self.my_instance_hero = Hero('username', 1, 100, 20)
self.another_hero = Hero('name', 10, 20, 30)
def test__init__hero(self):
self.assertEqual(self.my_instance_hero.username, 'username')
self.assertEqual(self.my_instance_hero.level, 1)
self.assertEqual(self.my_instance_hero.damage, 20)
self.assertEqual(self.my_instance_hero.health, 100)
"""
test battle function cases
"""
def test_both_objects_with_same_name__expected_exception(self):
self.my_instance_hero.username = '******'
with self.assertRaises(Exception) as ex:
self.my_instance_hero.battle(self.another_hero)
self.assertEqual("You cannot fight yourself", str(ex.exception))
def test_instance_hero_health_less_than__zero__expected_value_error(self):
with self.assertRaises(ValueError) as ex:
self.my_instance_hero.health = -5
self.my_instance_hero.battle(self.another_hero)
self.assertEqual('Your health is lower than or equal to 0. You need to rest', str(ex.exception))
self.assertEqual(self.my_instance_hero.health, -5)
def test_instance_hero_health_equal_to_zero__expected_value_error(self):
with self.assertRaises(ValueError) as ex:
self.my_instance_hero.health = 0
self.my_instance_hero.battle(self.another_hero)
self.assertEqual('Your health is lower than or equal to 0. You need to rest', str(ex.exception))
self.assertEqual(self.my_instance_hero.health, 0)
def test_another_hero_health_equal_to_zero_expected_value_error(self):
with self.assertRaises(ValueError) as ex:
self.another_hero.health = -5
self.my_instance_hero.battle(self.another_hero)
self.assertEqual(f"You cannot fight name. He needs to rest", str(ex.exception))
self.assertEqual(self.another_hero.health, -5)
def test_another_hero_object_health_less_than_zero__expected_value_error(self):
with self.assertRaises(ValueError) as ex:
self.another_hero.health = 0
self.my_instance_hero.battle(self.another_hero)
self.assertEqual(f"You cannot fight name. He needs to rest", str(ex.exception))
self.assertEqual(self.another_hero.health, 0)
def test_both_heroes_under_or_equal_to_zero_expected_draw(self):
result = self.my_instance_hero.battle(self.another_hero)
self.assertEqual(result, 'Draw')
self.assertTrue(self.my_instance_hero.health <= 0 and self.another_hero.health <= 0)
def test_instance_hero_win(self):
self.another_hero.damage = 1
result = self.my_instance_hero.battle(self.another_hero)
self.assertEqual(result, 'You win')
self.assertEqual(self.my_instance_hero.health, 95)
self.assertEqual(self.my_instance_hero.damage, 25)
self.assertEqual(self.my_instance_hero.level, 2)
def test_instance_hero_lose(self):
self.another_hero.health = 1000
result = self.my_instance_hero.battle(self.another_hero)
self.assertEqual(result, 'You lose')
self.assertEqual(self.another_hero.health, 985)
self.assertEqual(self.another_hero.damage, 35)
self.assertEqual(self.another_hero.level, 11)
def test_str_method(self):
massive = self.my_instance_hero.__str__().split('\n')
self.assertEqual(massive[0], f"Hero username: 1 lvl")
self.assertEqual(massive[1], f"Health: 100")
self.assertEqual(massive[2], f"Damage: 20")
class HeroTests(unittest.TestCase):
def setUp(self):
self.hero = Hero(username='******', level=80, health=12.5, damage=1.0)
self.enemy = Hero(username='******', level=10, health=2, damage=1.0)
def test_hero_if_all_attributes_are_set(self):
self.assertEqual('Bogdan', self.hero.username)
self.assertEqual(80, self.hero.level)
self.assertEqual(12.5, self.hero.health)
self.assertEqual(1.0, self.hero.damage)
def test__hero__battle_if_name_equals_username_raise_exception(self):
with self.assertRaises(Exception) as ex:
self.hero.battle(self.hero)
self.assertEqual("You cannot fight yourself", str(ex.exception))
def test_hero__battle_if_hero_health_is_equal_or_less_than_zero_raise_error(
self):
self.hero.health = 0
with self.assertRaises(Exception) as ex:
self.hero.battle(self.enemy)
self.assertEqual(
"Your health is lower than or equal to 0. You need to rest",
str(ex.exception))
def test_hero__battle_if_enemy_health_is_equal_or_less_than_zero_raise_error(
self):
self.enemy.health = -1
with self.assertRaises(Exception) as ex:
self.hero.battle(self.enemy)
self.assertEqual("You cannot fight Vicky. He needs to rest",
str(ex.exception))
def test_hero_battle__if_both_players_health_is_equal_or_less_than_zero_draw(
self):
self.hero.health = 0.5
self.enemy.health = 0.5
result = self.hero.battle(self.enemy)
expected_result = 'Draw'
self.assertEqual(expected_result, result)
def test_hero_battle__if_enemy_health_equal_or_less_than_zero_hero_wins(
self):
self.hero.health = 100.5
result = self.hero.battle(self.enemy)
expected_result = 'You win'
self.assertEqual(expected_result, result)
def test_hero_battle__if_hero_health_equal_or_less_than_zero_hero_loose(
self):
self.hero.health = 12.5
self.hero.damage = 0
result = self.hero.battle(self.enemy)
expected_result = 'You lose'
self.assertEqual(expected_result, result)
self.assertEqual(11, self.enemy.level)
self.assertEqual(7, self.enemy.health)
self.assertEqual(6.0, self.enemy.damage)
def test_hero_printing_the_summary_of_the_class(self):
self.hero.battle(self.enemy)
result = self.hero.__str__()
expected_result = f"Hero Bogdan: 81 lvl\n" \
f"Health: 7.5\n" \
f"Damage: 6.0\n"
self.assertEqual(expected_result, result)