def test_find_method_finds_the_card(self):
self.magic_card = MagicCard("Michelin")
self.magic_card_2 = MagicCard("Dongle")
self.card_repository.add(self.magic_card)
self.card_repository.add(self.magic_card_2)
self.assertEqual(self.card_repository.find("Michelin"),
self.magic_card)
def test_add_method_add_card_when_unique(self):
card_repository = CardRepository()
magic_card_1 = MagicCard('test')
magic_card_2 = MagicCard('test2')
card_repository.add(magic_card_1)
card_repository.add(magic_card_2)
self.assertEqual(2, card_repository.count)
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_remove_card_successful(self):
self.magic_card = MagicCard("Michelin")
self.magic_card_2 = MagicCard("Dongle")
self.card_repository.add(self.magic_card)
self.card_repository.add(self.magic_card_2)
self.card_repository.remove("Michelin")
self.assertEqual(self.card_repository.cards, [self.magic_card_2])
self.assertEqual(self.card_repository.count, 1)
def setUp(self):
self.attacker = Advanced('I am attacker')
mc = MagicCard('carte non-magique')
self.attacker.card_repository.add(mc)
self.enemy = Beginner('I am enemy')
mc1 = MagicCard('catre magique')
self.enemy.card_repository.add(mc1)
self.battlefield = BattleField()
def test_add__when_card_invalid__expect_exception(self) -> None:
card1 = MagicCard('Card')
card2 = MagicCard('Card')
self.card_repository.add(card1)
with self.assertRaises(ValueError) as context:
self.card_repository.add(card2)
self.assertEqual(context.exception.args[0],
'Card Card already exists!')
def test_damage_and_health_with_cards(self):
p1 = Beginner('One')
p2 = Advanced('Two')
p1.card_repository.add(MagicCard('magic1'))
p2.card_repository.add(MagicCard('magic2'))
self.bf.fight(p1, p2)
self.assertEqual(p1.health, 165)
self.assertEqual(p2.health, 295)
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(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_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_add_player_card(self):
pl = Beginner('beg')
crd = MagicCard('mc')
self.ctrl.player_repository.add(pl)
self.ctrl.card_repository.add(crd)
res = self.ctrl.add_player_card('beg', 'mc')
self.assertEqual("Successfully added card: mc to user: beg", res)
def test_add_card_raise_value_error(self):
self.magic_card = MagicCard("Michelin")
self.card_repository.add(self.magic_card)
with self.assertRaises(ValueError) as exc:
self.card_repository.add(self.magic_card)
msg = f"Card {self.magic_card.name} already exists!"
self.assertEqual(str(exc.exception), msg)
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_add_existing_card_should_raise_error(self):
cr = CardRepository()
card = MagicCard("Magic")
cr.cards.append(card)
with self.assertRaises(ValueError) as cm:
cr.add(card)
self.assertEqual(str(cm.exception), "Card Magic already exists!")
def test_add__when_card_exists__expect_to_raise_exception(self):
card = MagicCard('Fire')
self.card_repo.add(card)
with self.assertRaises(ValueError) as ex:
self.card_repo.add(card)
expect = 'Card Fire already exists!'
self.assertEqual(expect, str(ex.exception))
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 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)
class TestTrapCard(TestCase):
def setUp(self):
self.magic_card = MagicCard('Test2')
def test_attributes_are_set(self):
self.assertEqual('Test1', self.magic_card.name)
self.assertEqual(5, self.magic_card.damage_points)
self.assertEqual(80, self.magic_card.health_points)
def test_set_card_name_with_empty_string__raises(self):
with self.assertRaises(ValueError) as ex:
self.magic_card.name(card=MagicCard(''))
self.assertEqual("Card's name cannot be an empty string.", str(ex.exception))
def test_check_class_name(self):
self.assertEqual("MagicCard", self.magic_card.__class__.__name__)
def test_add_player_card(self):
card = MagicCard('test')
player = Beginner('name')
self.ctrl.card_repository.add(card)
self.ctrl.player_repository.add(player)
expected = self.ctrl.add_player_card('name', 'test')
self.assertEqual(expected, "Successfully added card: test to user: name")
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_add_raises(self):
repo = CardRepository()
c = MagicCard('test')
repo.add(c)
with self.assertRaises(ValueError) as ex:
repo.add(c)
self.assertEqual(str(ex.exception), "Card test already exists!")
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)
def test_remove_card_raises_value_error_card_not_in_repository(self):
self.magic_card = MagicCard("Michelin")
self.card_repository.add(self.magic_card)
with self.assertRaises(ValueError) as exc:
self.card_repository.remove("")
msg = "Card cannot be an empty string!"
self.assertEqual(str(exc.exception), msg)
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_method_raise_ex_when_card_already_exist(self):
with self.assertRaises(Exception) as ex:
card_repository = CardRepository()
magic_card_1 = MagicCard('test')
card_repository.add(magic_card_1)
card_repository.add(magic_card_1)
self.assertIsNotNone(ex.exception)
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 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_remove(self):
card = MagicCard("Exodia")
self.cr.cards.append(card)
self.cr.count = 1
self.cr.remove("Exodia")
self.assertEqual([], self.cr.cards)
self.assertEqual(0, self.cr.count)
def test_remove__when_card_invalid__expect_exception(self) -> None:
card = MagicCard('Card')
self.card_repository.add(card)
with self.assertRaises(ValueError) as context:
self.card_repository.remove('')
self.assertEqual(context.exception.args[0],
'Card cannot be an empty string!')
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)
