def test_if_attacker_is_dead_should_raise_error(self):
attacker = Beginner("Simo")
enemy = Advanced('Dimo')
attacker.health = 0
with self.assertRaises(ValueError) as cm:
self.battlefield.fight(attacker, enemy)
self.assertEqual(str(cm.exception), "Player is dead!")
class TestPlayerBeginner(unittest.TestCase):
def setUp(self):
self.player = Beginner("BeginnerPlayer")
def test_setUp_class_attributes_and_properties(self):
self.assertEqual(self.player.username, 'BeginnerPlayer')
self.assertEqual(self.player.health, 50)
self.assertEqual("CardRepository",
self.player.card_repository.__class__.__name__)
def test_health_cannot_go_under_zero(self):
with self.assertRaises(ValueError) as exc:
self.player.health = -10
self.assertEqual("Player's health bonus cannot be less than zero.",
str(exc.exception))
def test_username_cannot_be_empty(self):
with self.assertRaises(ValueError) as exc:
pl = Beginner('')
self.assertEqual("Player's username cannot be an empty string.",
str(exc.exception))
def test_is_dead_return_True_is_health_below_zero(self):
self.assertEqual(False, self.player.is_dead)
self.player.health = 0
self.assertEqual(True, self.player.is_dead)
def test_take_damage_func_works(self):
self.player.take_damage(10)
self.assertEqual(40, self.player.health)
with self.assertRaises(ValueError) as exc:
self.player.take_damage(-200)
self.assertEqual("Damage points cannot be less than zero.",
str(exc.exception))
def test_fight__when_at_least_one_player_is_dead_expect_value_error(self):
attacker = Advanced("aragorn")
enemy = Beginner("orc")
enemy.is_dead = True
with self.assertRaises(ValueError) as err:
self.battlefield.fight(attacker, enemy)
self.assertEqual("Player is dead!", str(err.exception))
def test_fight_any_is_dead(self):
p1 = Beginner('One')
p2 = Beginner('Two')
p1.health = 0
with self.assertRaises(ValueError) as ex:
self.bf.fight(p1, p2)
self.assertEqual(str(ex.exception), "Player is dead!")
def test_add_method_add_card_when_unique(self):
player_repo = PlayerRepository()
beginner = Beginner('test')
beginner2 = Beginner('test2')
player_repo.add(beginner)
player_repo.add(beginner2)
self.assertEqual(2, player_repo.count)
class testAdvancedPlayer(unittest.TestCase):
def setUp(self):
self.player = Beginner('Toto')
def test_validate_player_attributes(self):
self.assertEqual(self.player.username, 'Toto')
self.assertEqual(self.player.health, 50)
self.assertEqual(self.player.card_repository.__class__.__name__, "CardRepository")
def test_empty_username_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.username = ''
self.assertEqual(str(cm.exception), "Player's username cannot be an empty string.")
def test_less_than_zero_player_health_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.health = -1
self.assertEqual(str(cm.exception), "Player's health bonus cannot be less than zero.")
def test_less_than_zero_player_damage_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.take_damage(-1)
self.assertEqual(str(cm.exception), "Damage points cannot be less than zero.")
def test_health_points_decrease_with_damage_points(self):
self.player.take_damage(10)
self.assertEqual(self.player.health, 240)
def test_is_dead_should_return_true_if_player_health_is_equal_or_less_than_zero(self):
self.player.health = 0
self.assertTrue(self.player.is_dead)
def test_is_dead_should_return_false_if_player_health_is_more_than_zero(self):
self.player.health = 1
self.assertFalse(self.player.is_dead)
def test_fight_with_enemy_is_dead(self):
a = Beginner('A')
e = Beginner('A')
e.health = 0
with self.assertRaises(ValueError) as ex:
self.b.fight(a, e)
self.assertEqual(str(ex.exception), "Player is dead!")
def test_is_dead(self):
a = Beginner("Test")
self.assertEqual(a.health, INITIAL_HEALTH)
self.assertFalse(a.is_dead)
a.health = 0
self.assertEqual(a.health, 0)
self.assertTrue(a.is_dead)
def test_fight_with_dead_player_should_raise_error(self):
bf = BattleField()
p1 = Beginner("Peter")
p2 = Beginner("George")
p1.health = 0
with self.assertRaises(ValueError) as cm:
bf.fight(p1, p2)
self.assertEqual(str(cm.exception), "Player is dead!")
def test_fight(self):
pl1 = Beginner('beg1')
pl2 = Beginner('beg2')
self.ctrl.player_repository.add(pl1)
self.ctrl.player_repository.add(pl2)
battlefield = BattleField()
battlefield.fight(pl1, pl2)
res = self.ctrl.fight('beg1', 'beg2')
self.assertEqual('Attack user health 130 - Enemy user health 130', res)
def test_if_one_from_the_players_is_dead_should_raise_error(self):
attacker = Advanced('Thor')
enemy = Beginner('War-Machine')
enemy.health = 0
with self.assertRaises(ValueError) as cm:
self.battlefield.fight(attacker, enemy)
self.assertEqual(str(cm.exception), "Player is dead!")
def test_enemy_beginner_should_increase_attributes(self):
bf = BattleField()
p1 = Beginner("Peter")
p2 = Beginner("George")
mg1 = MagicCard("Magic One")
mg2 = MagicCard("Magic Two")
p2.card_repository.add(mg1)
p2.card_repository.add(mg2)
bf.fight(p2, p1)
self.assertEqual(p2.health, 250)
def test_fight__when_enemy_is_dead__expect_to_raise_exception(self):
attacker = Beginner('Pesho')
enemy = Beginner('Gosho')
enemy.health = 0
with self.assertRaises(ValueError) as context:
self.battle_field.fight(attacker, enemy)
expect = 'Player is dead!'
actual = str(context.exception)
self.assertEqual(expect, actual)
def test_player_dies_in_fight(self):
bf = BattleField()
mg1 = MagicCard("Magic One")
mg2 = MagicCard("Magic Two")
p1 = Beginner("Peter")
p2 = Beginner("George")
p1.card_repository.add(mg1)
p1.card_repository.add(mg2)
bf.fight(p1, p2)
with self.assertRaises(ValueError) as cm:
bf.fight(p1, p2)
self.assertEqual(str(cm.exception),
"Player's health bonus cannot be less than zero.")
def test_fight_one_player_dies_valid_data_should_work_correctly(self):
battlefield = BattleField()
attacker = Advanced("Dave")
enemy = Beginner("John")
common_card = MagicCard("Magic")
attacker.card_repository.cards.append(common_card)
enemy.card_repository.cards.append(common_card)
enemy.take_damage(50)
with self.assertRaises(ValueError):
battlefield.fight(attacker, enemy)
def test_fight_with_one_of_player_is_dead__should_raise_error(self):
attacker = Advanced('Attacker')
enemy = Beginner('Enemy')
attacker.health = 0
with self.assertRaises(ValueError) as cm:
self.battlefield.fight(attacker, enemy)
self.assertIsNotNone(cm.exception)
def test_fight__when_player_is_beginner__should_increase_health(self):
beginner = Beginner('Beginner')
advance = Advanced("Advanced")
expected = 50 + 40
self.battlefield.fight(beginner, advance)
actual = beginner.health
self.assertEqual(actual, expected)
def add_player(self, type, username):
if type == 'Beginner':
p = Beginner(username)
elif type == 'Advanced':
p = Advanced(username)
self.player_repository.add(p)
return f"Successfully added player of type {type} with username: {username}"
def setUp(self):
self.controller = Controller()
self.beginner = Beginner('Noob')
self.advanced = Advanced('Pro')
self.magic_card = MagicCard('Magic')
self.trap_card = TrapCard('Trap')
def test_if_init_is_properly_initialized(self):
beginner = Beginner('Test')
expected_name = 'Test'
expected_hp = 50
self.assertEqual(expected_hp, beginner.health)
self.assertEqual(expected_name, beginner.username)
self.assertFalse(beginner.is_dead)
def test_remove_when_name_is_net_defined_should_raise_error(self):
p = Beginner('Borko')
self.repo.add(p)
with self.assertRaises(ValueError) as ex:
self.repo.remove("")
self.assertEqual(str(ex.exception),
"Player cannot be an empty string!")
def test_beginner_health_increase(self):
a = Advanced('attacker')
e = Beginner('enemy')
self.assertEqual(50, e.health)
bf = BattleField()
bf.fight(a, e)
self.assertEqual(90, e.health)
def test_add__when_card_exists__expect_to_raise_exception(self):
player = Beginner('Pesho')
self.player_repo.add(player)
with self.assertRaises(ValueError) as ex:
self.player_repo.add(player)
expect = 'Player Pesho already exists!'
self.assertEqual(expect, str(ex.exception))
def test_remove_player__expect_to_remove_player(self):
player = Beginner("sam")
self.repository.add(player)
self.repository.remove("sam")
self.assertEqual([], self.repository.players)
self.assertEqual(0, self.repository.count)
def add_player(self, type: str, username: str):
if type == "Beginner":
player = Beginner(username)
else:
player = Advanced(username)
self.player_repository.add(player)
return f"Successfully added player of type {type} with username: {username}"
def test_set_attr(self):
beginner = Beginner("test")
self.assertEqual(beginner.username, "test")
self.assertEqual(beginner.health, 50)
self.assertEqual(beginner.card_repository.__class__.__name__,
"CardRepository")
self.assertFalse(beginner.is_dead)
def test_remove(self):
player = Beginner("Johny")
self.pr.players.append(player)
self.pr.count = 1
self.pr.remove("Johny")
self.assertEqual([], self.pr.players)
self.assertEqual(0, self.pr.count)
def test_damage_points_and_health_increased_without_cards(self):
advanced = Advanced("test")
beginner = Beginner("test2")
bf = BattleField()
bf.fight(advanced, beginner)
self.assertEqual(advanced.health, 250)
self.assertEqual(beginner.health, 90)
def test_init(self):
new_player = Beginner("KOZA_BEGINNER")
self.assertEqual(new_player.username, self.custom_player.username)
self.assertEqual(self.custom_player.health, 50)
self.assertEqual(self.custom_player.is_dead, False)
self.assertEqual(self.custom_player.card_repository.__class__.__name__,
"CardRepository")
def test_set_attr(self):
a = Beginner('test')
self.assertEqual(a.username, 'test')
self.assertEqual(a.health, 50)
self.assertEqual(a.card_repository.__class__.__name__,
CardRepository.__name__)
self.assertFalse(a.is_dead)
