def setUp(self) -> None:
self.battle_field = BattleField()
self.player1 = Advanced('John')
self.player2 = Beginner('Mike')
self.player1.card_repository.add(MagicCard('MagicCard1'))
self.player1.card_repository.add(TrapCard('TrapCard1'))
self.player2.card_repository.add(MagicCard('MagicCard2'))
self.player2.card_repository.add(TrapCard('TrapCard2'))
def test_fight_advanced_as_attacker_with_additional_cards_beginner(self):
new_second_trap_card = TrapCard("KOZA_TRAP_SECOND")
new_third_trap_card = TrapCard("KOZA_TRAP_THIRD")
self.beginner_player.card_repository.add(new_second_trap_card)
self.beginner_player.card_repository.add(new_third_trap_card)
with self.assertRaises(Exception) as context:
self.battle_field.fight(self.advanced_player, self.beginner_player)
self.assertEqual(str(context.exception),
"Player's health bonus cannot be less than zero.")
def test_damage_and_health_with_cards_one_die(self):
p1 = Beginner('One')
p2 = Advanced('Two')
p1.card_repository.add(TrapCard('magic1'))
p1.card_repository.add(TrapCard('magic2'))
p1.card_repository.add(TrapCard('magic3'))
p2.card_repository.add(MagicCard('magic2'))
with self.assertRaises(ValueError) as ex:
self.bf.fight(p1, p2)
self.assertEqual(str(ex.exception), "Player's health bonus cannot be less than zero.")
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_battle_field_fight_method_when_player_dies(self):
magic_card = MagicCard('Magic card')
trap_card = TrapCard('Trap Card')
trap_card2 = TrapCard('Trap Card2')
self.beginner.card_repository.add(magic_card)
self.enemy.card_repository.add(trap_card)
self.enemy.card_repository.add(trap_card2)
with self.assertRaises(Exception) as ex:
self.battle_filed.fight(self.beginner, self.enemy)
self.assertIsNotNone(str(ex.exception))
def test_helth_one_hero_die(self):
a = Beginner('A')
e = Advanced('AA')
e.health = 1000
# d- 120, h-5
c_a = TrapCard('TrapCard')
c_e = TrapCard('TrapCard')
a.card_repository.cards.append(c_a)
e.card_repository.cards.append(c_e)
with self.assertRaises(ValueError) as ex:
self.b.fight(a, e)
self.assertEqual(str(ex.exception),
"Player's health bonus cannot be less than zero.")
def test_dead_player_while_fighing(self):
advanced = Advanced("test")
beginner = Beginner("test2")
mc = MagicCard('testmagic')
tc = TrapCard("testtrap")
tc2 = TrapCard("testtrap1")
advanced.card_repository.add(tc)
advanced.card_repository.add(tc2)
bf = BattleField()
beginner.card_repository.add(mc)
with self.assertRaises(ValueError) as ex:
bf.fight(advanced, beginner)
self.assertEqual(str(ex.exception),
"Player's health bonus cannot be less than zero.")
def add_card(self, type, name):
if type == 'Magic':
self.card_repository.add(MagicCard(name))
elif type == "Trap":
self.card_repository.add(TrapCard(name))
return f"Successfully added card of type {type}Card with name: {name}"
def test_remove_card__expect_to_remove_card(self):
card = TrapCard("trap")
self.repository.add(card)
self.repository.remove("trap")
self.assertEqual([], self.repository.cards)
self.assertEqual(0, self.repository.count)
def add_card(self, type_c: str, name: str):
if type_c == "Magic":
card = MagicCard(name)
else:
card = TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {type_c}Card with name: {name}"
def test_final_fight_logic(self):
ac = TrapCard('test')
ec = MagicCard('test2')
self.att.card_repository.add(ac)
self.en.card_repository.add(ec)
self.bf.fight(self.att, self.en)
self.assertEqual(50, self.en.health)
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_add_card_with_exists_name_should_raise_error(self):
card = TrapCard('TrapCard')
self.repo.add(card)
with self.assertRaises(ValueError) as ex:
self.repo.add(card)
self.assertEqual(str(ex.exception), 'Card TrapCard already exists!')
self.assertEqual(self.repo.count, 1)
def add_card(self, type, name):
if type == 'Magic':
card = MagicCard(name)
else:
card = TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {type}Card with name: {name}"
def test_enemy_damage_attacker(self):
trap_card = TrapCard('attacker')
magic_card2 = MagicCard('enemy')
self.attacker.card_repository.add(trap_card)
self.enemy.card_repository.add(magic_card2)
self.battle_field.fight(self.attacker, self.enemy)
self.assertEqual(60, self.attacker.health)
def add_card(self, type, name):
card = MagicCard(name) if type == "Magic" else TrapCard(name)
# if type == "Magic":
# card = MagicCard(name)
# else:
# card = TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {type}Card with name: {name}"
def test_fight_two_begginer_players(self):
new_beginner_player = Beginner("KOZA_BEGINNER_NEW")
new_second_trap_card = TrapCard("KOZA_TRAP_SECOND")
new_beginner_player.card_repository.add(new_second_trap_card)
with self.assertRaises(Exception) as context:
self.battle_field.fight(self.beginner_player, new_beginner_player)
self.assertEqual(str(context.exception),
"Player's health bonus cannot be less than zero.")
class TestTrapCard(TestCase):
def setUp(self):
self.trap_card = TrapCard('Test1')
def test_attributes_are_set(self):
self.assertEqual('Test1', self.trap_card.name)
self.assertEqual(120, self.trap_card.damage_points)
self.assertEqual(5, self.trap_card.health_points)
def test_set_card_name_with_empty_string__raises(self):
with self.assertRaises(ValueError) as ex:
self.trap_card.name(card=TrapCard(''))
self.assertEqual("Card's name cannot be an empty string.",
str(ex.exception))
def test_check_class_name(self):
self.assertEqual("TrapCard", self.trap_card.__class__.__name__)
def test_fight_raise_enemy_health_with_sum_of_cards_health(self):
magic_card = MagicCard('test')
trap_card2 = TrapCard('test2')
self.enemy.card_repository.add(magic_card)
self.enemy.card_repository.add(trap_card2)
sum_card_health = sum(
[x.health_points for x in self.enemy.card_repository.cards])
self.assertEqual(135, sum_card_health + self.enemy.health)
def setUp(self):
self.attacker = Beginner("Bushido")
self.enemy = Beginner("Onyx")
self.attacker.card_repository.cards = [
MagicCard("Some magic card"),
TrapCard("Some trap card"),
MagicCard("Some magic card"),
TrapCard("Some trap card"),
MagicCard("Some magic card"),
TrapCard("Some trap card")
]
self.enemy.card_repository.cards = [
MagicCard("Some magic card"),
TrapCard("Some trap card"),
MagicCard("Some magic card"),
TrapCard("Some trap card")
]
def test_helth_increase_beforo_fight_with_helth_of_card(self):
a = Beginner('A')
e = Advanced('AA')
a.health = 1000
# d- 120, h-5
c_a = TrapCard('TrapCard')
c_e = TrapCard('TrapCard')
a.card_repository.cards.append(c_a)
e.card_repository.cards.append(c_e)
self.b.fight(a, e)
self.assertEqual(sum(i.damage_points for i in a.card_repository.cards),
150)
self.assertEqual(sum(i.damage_points for i in e.card_repository.cards),
120)
self.assertEqual(a.health, 925)
self.assertFalse(a.is_dead)
self.assertFalse(e.is_dead)
def test_enemy_dies_in_battle(self):
attacker = Advanced("Test1")
enemy = Beginner("Test2")
card = TrapCard("TrapTest")
card_2 = TrapCard("TrapTest2")
attacker.card_repository.add(card)
attacker.card_repository.add(card_2)
enemy.card_repository.add(card)
self.assertEqual(attacker.health, 250)
self.assertEqual(enemy.health, 50)
enemy.health += 175
BattleField.fight(attacker, enemy)
self.assertEqual(attacker.health, 260)
self.assertEqual(enemy.health, 0)
self.assertFalse(attacker.is_dead)
self.assertTrue(enemy.is_dead)
def test_normal_fight_when_one_of_them_die(self):
tc = TrapCard('tc')
tc.damage_points += 400
self.enemy.card_repository.add(tc)
with self.assertRaises(ValueError) as exc:
self.battlefield.fight(self.attacker, self.enemy)
self.assertEqual("Player's health bonus cannot be less than zero.",
str(exc.exception))
def add_card(self, type: str, name: str):
if type == 'Magic':
card = MagicCard(name)
self.card_repository.cards.append(card)
else:
card = TrapCard(name)
self.card_repository.cards.append(card)
return f"Successfully added card of type {type} with name: {name}"
def setUp(self):
self.battle_field = BattleField()
self.beginner_player = Beginner("KOZA_BEGINNER")
self.advanced_player = Advanced("KOZA_ADVANCED")
self.new_trap_card = TrapCard("KOZA_TRAP")
self.new_magic_card = MagicCard("KOZA_MAGIC")
self.beginner_player.card_repository.add(self.new_trap_card)
self.advanced_player.card_repository.add(self.new_magic_card)
def test_add_player_card(self):
ctrl = Controller()
p = Beginner('pname')
c = TrapCard('cname')
ctrl.player_repository.add(p)
ctrl.card_repository.add(c)
res = ctrl.add_player_card('pname', 'cname')
self.assertEqual(res, "Successfully added card: cname to user: pname")
def test_add_when_card_is_not_exists_then_add_to_repo_cards_increase_count(
self):
# name, 120, 5
card = TrapCard('TrapCard')
self.repo.add(card)
self.assertEqual(self.repo.cards[0], card)
self.assertEqual(self.repo.count, 1)
self.assertEqual(self.repo.cards[0].damage_points, 120)
self.assertEqual(self.repo.cards[0].health_points, 5)
def add_card(self, type, name):
# global card_to_add
if type == "Magic":
card_to_add = MagicCard(name)
elif type == "Trap":
card_to_add = TrapCard(name)
self.card_repository.add(card_to_add)
return f"Successfully added card of type {type}Card with name: {name}"
def test_fight_raise_card_damage_points_when_beginner(self):
magic_card = MagicCard('test')
trap_card2 = TrapCard('test2')
self.attacker.card_repository.add(magic_card)
self.attacker.card_repository.add(trap_card2)
total_cards = [
x.damage_points + 30 for x in self.attacker.card_repository.cards
]
self.assertEqual([35, 150], total_cards)
def add_card(self, type_c: str, name: str):
# Creates a card with the provided type -> "Magic" or "Trap" and name.
# The method should return the following message:
# "Successfully added card of type {type}Card with name: {name}"
if type_c == 'Magic':
self.card_repository.add(MagicCard(name))
elif type_c == 'Trap':
self.card_repository.add(TrapCard(name))
return f'Successfully added card of type {type_c}Card with name: {name}'
