def test_fight_attacker_is_dead(self):
attacker = Advanced("Test1")
enemy = Advanced("Test2")
attacker.health = 0
with self.assertRaises(ValueError):
BattleField.fight(attacker, enemy)
def test_add__when_player_invalid(self) -> None:
player1 = Advanced('John')
player2 = Advanced('John')
self.player_repository.add(player1)
with self.assertRaises(ValueError) as context:
self.player_repository.add(player2)
self.assertEqual(context.exception.args[0], 'Player John already exists!')
def test_att_is_dead(self):
advanced = Advanced('test')
advanced.health = 0
advanced2 = Advanced('test2')
battlefield = BattleField()
with self.assertRaises(ValueError) as cm:
battlefield.fight(advanced, advanced2)
self.assertEqual('Player is dead!', str(cm.exception))
def setUp(self) -> None:
# self.card1 = Advanced("Test")
# self.card2 = MagicCard("Test2")
# self.card3 = MagicCard("Test")
self.player1 = Advanced("Test")
self.player2 = Advanced("Test2")
self.player3 = Advanced("Test")
self.repository = PlayerRepository()
def test_attacker_is_dead(self):
p1 = Advanced("test")
p1.health = 0
p2 = Advanced("test2")
bf = BattleField()
with self.assertRaises(ValueError) as ex:
bf.fight(p1, p2)
self.assertEqual(str(ex.exception), "Player is dead!")
def test_enemy_is_dead(self):
advanced = Advanced("test")
advanced_2 = Advanced("test2")
advanced_2.health = 0
bf = BattleField()
with self.assertRaises(ValueError) as ex:
bf.fight(advanced, advanced_2)
self.assertEqual(str(ex.exception), "Player is dead!")
def test_fight(self):
attacker = Advanced('p1')
enemy = Advanced('p2')
ac = MagicCard('card1')
attacker.card_repository.add(ac)
ec = MagicCard('card2')
enemy.card_repository.add(ec)
self.ctrl.player_repository.add(attacker)
self.ctrl.player_repository.add(enemy)
expected = "Attack user health 325 - Enemy user health 325"
self.assertEqual(expected, self.ctrl.fight('p1', 'p2'))
def test_fight_increase_health(self):
attacker = Advanced("Bushido")
enemy = Advanced("Onyx")
card = TrapCard("Exodia")
attacker.card_repository.cards.append(card)
enemy.card_repository.cards.append(card)
BattleField.fight(attacker, enemy)
self.assertEqual(135, attacker.health)
self.assertEqual(135, enemy.health)
self.assertFalse(attacker.is_dead)
self.assertFalse(enemy.is_dead)
def test_helth_one_hero_die2(self):
a = Advanced('A')
e = Advanced('AA')
# d- 120, h-5
c_a = TrapCard('TrapCard')
c_a.damage_points = 255
c_e = TrapCard('TrapCard')
a.card_repository.cards.append(c_a)
e.card_repository.cards.append(c_e)
self.b.fight(a, e)
self.assertTrue(e.is_dead)
self.assertEqual(a.health, 255)
def test_players_health_is_increased(self):
attacker = Advanced("Test1")
enemy = Advanced("Test2")
card = TrapCard("TrapTest")
attacker.card_repository.add(card)
enemy.card_repository.add(card)
self.assertEqual(attacker.health, 250)
self.assertEqual(enemy.health, 250)
BattleField.fight(attacker, enemy)
self.assertEqual(attacker.health, 135)
self.assertEqual(enemy.health, 135)
self.assertFalse(attacker.is_dead)
self.assertFalse(enemy.is_dead)
def test_add_raises(self):
p = Advanced("test")
self.pr.add(p)
with self.assertRaises(ValueError) as ex:
self.pr.add(p)
self.assertEqual(str(ex.exception),
f"Player {p.username} already exists!")
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 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_fight_invalid_data_should_raise_error(self):
battlefield = BattleField()
attacker = Advanced("Dave")
enemy = Advanced("John")
first_card = MagicCard("Magic")
second_card = MagicCard("Magic")
attacker.card_repository.cards.append(first_card)
enemy.card_repository.cards.append(second_card)
attacker.take_damage(250)
with self.assertRaises(ValueError):
battlefield.fight(attacker, enemy)
def test_if_init_is_properly_initialized(self):
advanced = Advanced('Test')
expected_name = 'Test'
expected_hp = 250
self.assertEqual(expected_hp, advanced.health)
self.assertEqual(expected_name, advanced.username)
self.assertFalse(advanced.is_dead)
def test_add_existing_player_should_raise_error(self):
repo = PlayerRepository()
player = Advanced("Peter")
repo.players.append(player)
with self.assertRaises(ValueError) as cm:
repo.add(player)
self.assertEqual(str(cm.exception), "Player Peter already exists!")
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_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_remove__when_player_invalid__expect_exception(self) -> None:
player = Advanced('John')
self.player_repository.add(player)
with self.assertRaises(ValueError) as context:
self.player_repository.remove('')
self.assertEqual(context.exception.args[0], 'Player cannot be an empty string!')
def add_player(self, type, username):
if type == 'Beginner':
self.player_repository.add(Beginner(username))
elif type == "Advanced":
self.player_repository.add(Advanced(username))
return f'Successfully added player of type {type} with username: {username}'
def test_set_attr(self):
advanced = Advanced("test")
self.assertEqual(advanced.username, "test")
self.assertEqual(advanced.health, 250)
self.assertEqual(advanced.card_repository.__class__.__name__,
"CardRepository")
self.assertFalse(advanced.is_dead)
def test_take_damage_to_death_valid_data_should_raise_error(self):
player = Advanced("Dave")
with self.assertRaises(ValueError):
player.take_damage(500)
self.assertEqual(player.is_dead, False)
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_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_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 test_dmg_and_hp_without_cards(self):
advanced = Advanced('test')
beginner = Beginner('test2')
battlefield = BattleField()
battlefield.fight(advanced, beginner)
self.assertEqual(advanced.health, 250)
self.assertEqual(beginner.health, 90)
def test_is_dead(self):
a = Advanced("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_add_raises(self):
repo = PlayerRepository()
p = Advanced('test')
repo.add(p)
with self.assertRaises(ValueError) as ex:
repo.add(p)
self.assertEqual(str(ex.exception), "Player test already exists!")
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_fight_valid_data_should_work_correctly(self):
battlefield = BattleField()
attacker = Advanced("Dave")
enemy = Advanced("John")
first_card = MagicCard("Magic")
second_card = MagicCard("Magic")
attacker.card_repository.cards.append(first_card)
enemy.card_repository.cards.append(second_card)
battlefield.fight(attacker, enemy)
self.assertEqual(attacker.health, 325)
self.assertEqual(enemy.health, 325)
