def test_add_player_card_should_return_message(self):
controller = Controller()
controller.add_player("Advanced", "Peter")
controller.add_card("Trap", "Trap Card")
message = controller.add_player_card("Peter", "Trap Card")
self.assertEqual(message,
"Successfully added card: Trap Card to user: Peter")
def test_fight_card_damage_valid_data_should_work_correctly(self):
controller = Controller()
add_card1 = controller.add_card("Magic", "Spell")
add_card2 = controller.add_card("Magic", "Spell2")
add_player1 = controller.add_player("Advanced", "Dave")
add_player2 = controller.add_player("Beginner", "John")
add_player_card1 = controller.add_player_card("Dave", "Spell")
add_player_card2 = controller.add_player_card("John", "Spell2")
controller.fight("Dave", "John")
self.assertEqual(controller.card_repository.cards[1].damage_points, 35)
self.assertEqual(
add_card1,
"Successfully added card of type MagicCard with name: Spell")
self.assertEqual(
add_card2,
"Successfully added card of type MagicCard with name: Spell2")
self.assertEqual(
add_player1,
"Successfully added player of type Advanced with username: Dave")
self.assertEqual(
add_player2,
"Successfully added player of type Beginner with username: John")
self.assertEqual(add_player_card1,
"Successfully added card: Spell to user: Dave")
self.assertEqual(add_player_card2,
"Successfully added card: Spell2 to user: John")
def test_add_player_card_should_add_card_to_player_repo(self):
controller = Controller()
controller.add_player("Advanced", "Peter")
controller.add_card("Trap", "Trap Card")
controller.add_player_card("Peter", "Trap Card")
card = controller.player_repository.players[0].card_repository.cards[0]
self.assertEqual(card.name, "Trap Card")
def test_add_player_card(self):
c = Controller()
c.add_player("Beginner", "testbeginner")
c.add_card("Magic", "test1")
res = c.add_player_card("testbeginner", "test1")
self.assertEqual(
res, "Successfully added card: test1 to user: testbeginner")
def test_add_card_second_time_should_raise_error(self):
controller = Controller()
controller.add_card("Magic", "Card")
controller.card_repository.find("Card")
with self.assertRaises(ValueError):
controller.add_card("Magic", "Card")
def test_add_cards_success(self):
c = Controller()
res1 = c.add_card("Magic", "test1")
res2 = c.add_card("Trap", "test2")
self.assertEqual(
res1, "Successfully added card of type MagicCard with name: test1")
self.assertEqual(
res2, "Successfully added card of type TrapCard with name: test2")
def test_fight_should_return_message(self):
controller = Controller()
controller.add_player("Advanced", "Peter")
controller.add_player("Advanced", "George")
controller.add_card("Trap", "Trap Card")
controller.player_repository.find("Peter").card_repository.add(
controller.card_repository.cards[0])
message = controller.fight("Peter", "George")
self.assertEqual(message,
"Attack user health 255 - Enemy user health 130")
def test_report_returns_correct_str(self):
controller = Controller()
controller.add_player("Advanced", "Peter")
controller.add_player("Advanced", "George")
controller.add_card("Trap", "Trap Card")
controller.player_repository.find("Peter").card_repository.add(
controller.card_repository.cards[0])
self.assertEqual(
controller.report(),
"Username: Peter - Health: 250 - Cards 1\n### Card: Trap Card - Damage: 120\nUsername: George - Health: 250 - Cards 0\n"
)
class TestController(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test_add_player(self):
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 0)
res = self.controller.add_player("Beginner", "test")
self.assertEqual(self.controller.player_repository.count, 1)
self.assertEqual(self.controller.card_repository.count, 0)
self.assertEqual(
res,
"Successfully added player of type Beginner with username: test")
def test_add_card(self):
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 0)
res = self.controller.add_card("Magic", "test")
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 1)
self.assertEqual(
res, "Successfully added card of type MagicCard with name: test")
def test_add_player_card(self):
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 0)
self.controller.add_card("Magic", "test")
self.controller.add_player("Beginner", "test")
self.assertEqual(self.controller.player_repository.count, 1)
self.assertEqual(self.controller.card_repository.count, 1)
res = self.controller.add_player_card("test", "test")
self.assertEqual(res, "Successfully added card: test to user: test")
def test_fight(self):
self.controller.add_player("Beginner", "beginner")
self.controller.add_player("Advanced", "advanced")
res = self.controller.fight("advanced", "beginner")
self.assertEqual(res, "Attack user health 250 - Enemy user health 90")
def test_report(self):
self.controller.add_player("Beginner", "beginner")
self.controller.add_player("Advanced", "advanced")
self.controller.add_card("Magic", "test")
self.controller.add_player_card("beginner", "test")
res = self.controller.report()
# check = "Username: beginner - Health: 50 - Cards 1\n### Card: test - Damage: 5\nUsername: advanced - Health: 250 - Card 0\n"
self.assertEqual(
res,
"Username: beginner - Health: 50 - Cards 1\n### Card: test - Damage: 5\nUsername: advanced - Health: 250 - Cards 0\n"
)
class TestController(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test_add_player(self):
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 0)
res = self.controller.add_player('Beginner', 'test')
self.assertEqual(self.controller.player_repository.count, 1)
self.assertEqual(self.controller.card_repository.count, 0)
self.assertEqual(
res,
'Successfully added player of type Beginner with username: test')
def test_add_card(self):
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 0)
res = self.controller.add_card('Magic', 'test')
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 1)
self.assertEqual(
res, 'Successfully added card of type MagicCard with name: test')
def test_add_player_card(self):
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.count, 0)
self.controller.add_card('Magic', 'test')
self.controller.add_player('Beginner', 'test')
self.assertEqual(self.controller.player_repository.count, 1)
self.assertEqual(self.controller.card_repository.count, 1)
res = self.controller.add_player_card('test', 'test')
self.assertEqual(res, "Successfully added card: test to user: test")
def test_fight(self):
self.controller.add_player('Beginner', 'beginner')
self.controller.add_player('Advanced', 'advanced')
res = self.controller.fight('advanced', 'beginner')
self.assertEqual(res, "Attack user health 250 - Enemy user health 90")
def test_report(self):
self.controller.add_player('Beginner', 'beginner')
self.controller.add_player('Advanced', 'advanced')
self.controller.add_card('Magic', 'test')
self.controller.add_player_card('beginner', 'test')
res = self.controller.report()
self.assertEqual(
res,
'Username: beginner - Health: 50 - Cards 1\n### Card: test - Damage: 5\nUsername: advanced - Health: 250 - Cards 0\n'
)
def test_add_card(self):
c = Controller()
res = c.add_card('Trap', 'test')
self.assertEqual(c.card_repository.count, 1)
self.assertEqual(len(c.card_repository.cards), 1)
self.assertEqual(
res, "Successfully added card of type TrapCard with name: test")
def test_report_valid_data_should_work_correctly(self):
controller = Controller()
controller.add_card("Magic", "Magic")
controller.add_card("Magic", "Magic2")
controller.add_player("Advanced", "Dave")
controller.add_player("Advanced", "John")
controller.add_player_card("Dave", "Magic")
controller.add_player_card("John", "Magic2")
self.assertEqual(
controller.report(),
"Username: Dave - Health: 250 - Cards 1\n### Card: Magic - Damage: 5\nUsername: John - Health: 250 - Cards 1\n### Card: Magic2 - Damage: 5\n"
)
def test_fight_valid_data_should_work_correctly(self):
controller = Controller()
controller.add_card("Magic", "Spell")
controller.add_card("Magic", "Spell2")
controller.add_player("Advanced", "Dave")
controller.add_player("Advanced", "John")
controller.add_player_card("Dave", "Spell")
controller.add_player_card("John", "Spell2")
result = controller.fight("Dave", "John")
self.assertEqual(result,
"Attack user health 325 - Enemy user health 325")
class TestController(unittest.TestCase):
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_initialization_should_return_correct_attributes(self):
self.assertEqual(self.controller.player_repository.__class__.__name__,
"PlayerRepository")
self.assertEqual(self.controller.card_repository.__class__.__name__,
"CardRepository")
def test_add_player_should_add_player_to_the_player_repository(self):
self.assertEqual(
self.controller.add_player('Advanced', 'Pro'),
"Successfully added player of type Advanced with username: Pro")
self.assertEqual(self.controller.player_repository.count, 1)
def test_add_card_should_add_card_to_the_card_repository(self):
self.assertEqual(
self.controller.add_card('TrapCard', 'Trap'),
"Successfully added card of type TrapCardCard with name: Trap")
self.assertEqual(self.controller.card_repository.count, 1)
def test_add_player_card_should_add_card_in_players_repository(self):
self.controller.add_player('Beginner', 'Noob')
self.controller.add_card('MagicCard', 'Magic')
self.assertEqual(self.controller.add_player_card('Noob', 'Magic'),
'Successfully added card: Magic to user: Noob')
def test_fight_should_make_both_players_fight(self):
self.controller.add_player('Advanced', 'Pro1')
self.controller.add_player('Advanced', 'Pro2')
self.assertEqual(self.controller.fight('Pro1', 'Pro2'),
'Attack user health 250 - Enemy user health 250')
def test_report_should_return_correctly_the_result(self):
self.controller.add_player('Beginner', 'Noob')
self.controller.add_card('MagicCard', 'Magic')
self.assertEqual(self.controller.report(),
'Username: Noob - Health: 50 - Cards 0\n')
class TestController(unittest.TestCase):
def setUp(self):
self.ctrl = Controller()
def test_init(self):
self.assertTrue(isinstance(self.ctrl.player_repository, PlayerRepository))
self.assertTrue(isinstance(self.ctrl.card_repository, CardRepository))
def test_add_player(self):
expected = self.ctrl.add_player('Beginner', 'testname')
self.assertEqual(1, len(self.ctrl.player_repository.players))
self.assertEqual(expected, "Successfully added player of type Beginner with username: testname")
def test_add_card(self):
expected = self.ctrl.add_card('Trap', 'testname')
self.assertEqual(1, len(self.ctrl.card_repository.cards))
self.assertEqual(expected, "Successfully added card of type TrapCard with name: testname")
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 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_report(self):
self.ctrl.add_player('Beginner', 'name')
self.ctrl.add_card('Magic', 'cardname')
self.ctrl.add_player_card('name', 'cardname')
expected = f'Username: name - Health: 50 - Cards 1\n### Card: cardname - Damage: 5\n'
res = self.ctrl.report()
self.assertEqual(expected, res)
def test_fight_two_valid_data_should_work_correctly(self):
controller = Controller()
controller.add_card("Magic", "Spell")
controller.add_card("Trap", "Spell2")
controller.add_player("Advanced", "Dave")
controller.add_player("Advanced", "John")
controller.add_player_card("Dave", "Spell")
controller.add_player_card("John", "Spell2")
result = controller.fight("Dave", "John")
with self.assertRaises(Exception):
controller.add_card("Labala", "Magic")
controller.add_player("Labala2", "Spell")
controller.add_player_card("Labala2", "Spell")
self.assertEqual(result,
"Attack user health 210 - Enemy user health 250")
def test_add_second_card_valid_data_should_work_correctly(self):
controller = Controller()
card = TrapCard("Card")
function_result = controller.add_card("Trap", "Card")
card_result = controller.card_repository.find("Card")
self.assertEqual(card.name, card_result.name)
self.assertEqual(
function_result,
"Successfully added card of type TrapCard with name: Card")
class TestController(unittest.TestCase):
def setUp(self) -> None:
self.player_repo = PlayerRepository()
self.card_repo = CardRepository()
self.controller = Controller()
def test_adding_new_player(self):
result = self.controller.add_player('Beginner', 'test')
self.assertEqual(result, "Successfully added player of type Beginner with username: test")
def test_adding_new_card(self):
result = self.controller.add_card('Trap', 'test')
self.assertEqual(result, "Successfully added card of type TrapCard with name: test")
class TestControllers(unittest.TestCase):
def setUp(self):
self.c = Controller()
def test_proper_initialization(self):
self.assertEqual("PlayerRepository",
self.c.player_repository.__class__.__name__)
self.assertEqual("CardRepository",
self.c.card_repository.__class__.__name__)
def test_add_player_method(self):
self.assertEqual(
"Successfully added player of type Beginner with username: nameBeginner",
self.c.add_player("Beginner", 'nameBeginner'))
def test_add_card_method(self):
self.assertEqual(
"Successfully added card of type MagicCard with name: magicName",
self.c.add_card("Magic", 'magicName'))
def test_add_player_card(self):
self.c.add_player("Beginner", 'nameBeginner')
self.c.add_card("Magic", 'magicName')
self.assertEqual(
"Successfully added card: magicName to user: nameBeginner",
self.c.add_player_card('nameBeginner', 'magicName'))
def test_fight_method(self):
self.c.add_player("Beginner", 'nameBeginner')
self.c.add_player("Advanced", 'nameAdvanced')
self.assertEqual("Attack user health 90 - Enemy user health 250",
self.c.fight('nameBeginner', 'nameAdvanced'))
def test_report_method(self):
self.c.add_player("Beginner", 'nameBeginner')
self.assertEqual("Username: nameBeginner - Health: 50 - Cards 0\n",
self.c.report())
class TestController(unittest.TestCase):
def setUp(self) -> None:
self.ctrl = Controller()
def test_init(self):
self.assertEqual(0, self.ctrl.card_repository.count)
self.assertEqual(0, self.ctrl.player_repository.count)
self.assertEqual(0, len(self.ctrl.card_repository.cards))
self.assertEqual(0, len(self.ctrl.player_repository.players))
def test_add_player(self):
res = self.ctrl.add_player('Beginner', 'name')
self.assertEqual(1, self.ctrl.player_repository.count)
self.assertEqual(1, len(self.ctrl.player_repository.players))
self.assertEqual("Successfully added player of type Beginner with username: name", res)
def test_add_card(self):
res = self.ctrl.add_card('Trap', 'name')
self.assertEqual(1, self.ctrl.card_repository.count)
self.assertEqual(1, len(self.ctrl.card_repository.cards))
self.assertEqual("Successfully added card of type TrapCard with name: name", res)
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_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_report(self):
pl = Beginner('test')
c = MagicCard('name')
self.ctrl.card_repository.add(c)
self.ctrl.player_repository.add(pl)
self.ctrl.add_player_card('test', 'name')
expected = 'Username: test - Health: 50 - Cards 1\n### Card: name - Damage: 5\n'
self.assertEqual(expected, self.ctrl.report())
class TEstController(unittest.TestCase):
def setUp(self):
self.controller = Controller()
self.player = Advanced("Pesho")
self.card = MagicCard("Magic")
def test__init(self):
self.assertIsInstance(self.controller.player_repository,
PlayerRepository)
self.assertIsInstance(self.controller.card_repository, CardRepository)
def test__add_player__return_msg(self):
self.assertEqual(
self.controller.add_player("Beginner", "Ivan"),
"Successfully added player of type Beginner with username: Ivan")
def test__add_card_return_msg(self):
self.assertEqual(
self.controller.add_card("Magic", "Magic"),
"Successfully added card of type MagicCard with name: Magic")
def test__add_player_card_return_msg(self):
# self.player.card_repository.add(self.card)
self.controller.player_repository.add(self.player)
self.controller.card_repository.add(self.card)
self.assertEqual(self.controller.add_player_card("Pesho", "Magic"),
"Successfully added card: Magic to user: Pesho")
def test__fight__return_msg(self):
player2 = Advanced("Ivan")
self.controller.player_repository.add(player2)
self.controller.player_repository.add(self.player)
self.assertEqual(
self.controller.fight("Pesho", "Ivan"),
f"Attack user health {self.player.health} - Enemy user health {player2.health}"
)
def test__report__return_msg(self):
self.player.card_repository.add(self.card)
self.controller.player_repository.add(self.player)
self.assertEqual(
self.controller.report(),
f"Username: Pesho - Health: 250 - Cards 1\n### Card: Magic - Damage: 5\n"
)
class TestController(unittest.TestCase):
def setUp(self) -> None:
self.c = Controller()
def test_all_setup_corect(self):
self.assertEqual(self.c.player_repository.__class__.__name__,
'PlayerRepository')
self.assertEqual(self.c.card_repository.__class__.__name__,
'CardRepository')
def test_add_player(self):
actual = self.c.add_player('Beginner', 'Borko')
self.assertEqual(
actual,
"Successfully added player of type Beginner with username: Borko")
self.assertEqual(self.c.player_repository.players[0].username, 'Borko')
advanced_player = self.c.add_player("Advanced", 'Ad')
self.assertEqual(
advanced_player,
"Successfully added player of type Advanced with username: Ad")
self.assertEqual(self.c.player_repository.players[1].username, 'Ad')
self.assertEqual(len(self.c.player_repository.players), 2)
def test_add_card(self):
magic_card = self.c.add_card('Magic', 'M')
self.assertEqual(magic_card,
"Successfully added card of type Magic with name: M")
self.assertEqual(len(self.c.card_repository.cards), 1)
self.assertEqual(self.c.card_repository.cards[0].name, 'M')
trap_card = self.c.add_card('TrapCard', 'T')
self.assertEqual(
trap_card, "Successfully added card of type TrapCard with name: T")
self.assertEqual(len(self.c.card_repository.cards), 2)
self.assertEqual(self.c.card_repository.cards[1].name, 'T')
self.assertEqual(self.c.card_repository.count, 1)
def test_add_player_card(self):
self.c.add_player('Beginner', 'B')
self.c.add_card('TrapCard', 'T')
actual = self.c.add_player_card('B', 'T')
self.assertEqual(actual, "Successfully added card: T to user: B")
self.assertEqual(
len(self.c.player_repository.players[0].card_repository.cards), 1)
def test_find(self):
self.c.add_player('Advanced', 'A1')
self.c.add_player('Advanced', 'A2')
actual = self.c.fight('A1', 'A2')
self.assertEqual(actual,
'Attack user health 250 - Enemy user health 250')
def test_report(self):
self.c.add_player('Advanced', 'A1')
card = MagicCard('M')
self.c.player_repository.players[0].card_repository.add(card)
actual = self.c.report()
self.assertEqual(
actual,
"Username: A1 - Health: 250 - Cards 1\n### Card: M - Damage: 5\n")
class TestBattleField(unittest.TestCase):
def initialize_players_with_cards(self) -> None:
self.controller.add_player('Beginner', 'John')
self.controller.add_player('Advanced', 'Mike')
self.controller.add_card('Magic', 'MagicCard1')
self.controller.add_card('Magic', 'MagicCard2')
self.controller.add_card('Trap', 'TrapCard1')
self.controller.add_card('Trap', 'TrapCard2')
self.controller.add_player_card('John', 'MagicCard1')
self.controller.add_player_card('John', 'TrapCard1')
self.controller.add_player_card('Mike', 'MagicCard2')
self.controller.add_player_card('Mike', 'TrapCard2')
def setUp(self) -> None:
self.controller = Controller()
def test_init_attrs_set(self) -> None:
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.player_repository.players, [])
self.assertEqual(self.controller.card_repository.count, 0)
self.assertEqual(self.controller.card_repository.cards, [])
def test_add_beginner_player(self) -> None:
msg = self.controller.add_player('Beginner', 'John')
self.assertEqual(
msg,
'Successfully added player of type Beginner with username: John')
self.assertEqual(self.controller.player_repository.count, 1)
self.assertEqual(self.controller.player_repository.players[0].username,
'John')
self.assertTrue(
isinstance(self.controller.player_repository.players[0], Beginner))
def test_add_advanced_player(self) -> None:
msg = self.controller.add_player('Advanced', 'John')
self.assertEqual(
msg,
'Successfully added player of type Advanced with username: John')
self.assertEqual(self.controller.player_repository.players[0].username,
'John')
self.assertTrue(
isinstance(self.controller.player_repository.players[0], Advanced))
def test_add_card_magic(self) -> None:
msg = self.controller.add_card('Magic', 'Card')
self.assertEqual(
msg, 'Successfully added card of type MagicCard with name: Card')
self.assertEqual(self.controller.card_repository.count, 1)
self.assertEqual(self.controller.card_repository.cards[0].name, 'Card')
self.assertTrue(
isinstance(self.controller.card_repository.cards[0], MagicCard))
def test_add_card_trap(self) -> None:
msg = self.controller.add_card('Trap', 'Card')
self.assertEqual(
msg, 'Successfully added card of type TrapCard with name: Card')
self.assertEqual(self.controller.card_repository.count, 1)
self.assertEqual(self.controller.card_repository.cards[0].name, 'Card')
self.assertTrue(
isinstance(self.controller.card_repository.cards[0], TrapCard))
def test_add_player_card(self) -> None:
self.controller.add_card('Magic', 'Card')
self.controller.add_player('Beginner', 'John')
msg = self.controller.add_player_card('John', 'Card')
self.assertEqual(msg, 'Successfully added card: Card to user: John')
self.assertEqual(
self.controller.player_repository.find(
'John').card_repository.count, 1)
self.assertEqual(
self.controller.player_repository.find(
'John').card_repository.cards[0].name, 'Card')
self.assertTrue(
isinstance(
self.controller.player_repository.find(
'John').card_repository.cards[0], MagicCard))
def test_fight_method(self) -> None:
self.initialize_players_with_cards()
msg = self.controller.fight('John', 'Mike')
self.assertEqual(msg, 'Attack user health 50 - Enemy user health 150')
def test_report_method(self) -> None:
self.initialize_players_with_cards()
self.assertEqual(
self.controller.report(),
'Username: John - Health: 50 - Cards 2\n### Card: MagicCard1 - Damage: 5\n### Card: TrapCard1 - Damage: 120\nUsername: Mike - Health: 250 - Cards 2\n### Card: MagicCard2 - Damage: 5\n### Card: TrapCard2 - Damage: 120\n'
)
def test_add_trap_should_add_trap_to_card_repo(self):
controller = Controller()
controller.add_card("Trap", "Trap Card")
card = controller.card_repository.cards[0]
self.assertEqual(card.name, "Trap Card")
self.assertEqual(card.__class__.__name__, "TrapCard")
class TestBattleFiled(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test_fight_method(self):
self.controller.add_player("Advanced", "Miro")
self.controller.add_card("Trap", "Bombs")
self.controller.add_player("Advanced", "Ivan")
self.controller.add_card("Magic", "Nuclear")
self.controller.add_player_card("Miro", "Bombs")
self.controller.add_player_card("Ivan", "Nuclear")
self.assertEqual(self.controller.fight("Miro", "Ivan"), f"Attack user health 250 - Enemy user health 210")
def test_fight_method_if_someone_is_dead(self):
self.controller.add_player("Beginner", "Miro")
self.controller.add_card("Trap", "Bombs")
self.controller.add_card("Magic", "Beatup")
self.controller.add_card("Trap", "BrutalKill")
self.controller.add_player("Advanced", "Ivan")
self.controller.add_card("Magic", "Nuclear")
self.controller.add_card("Trap", "Flower")
self.controller.add_card("Trap", "Napkin")
self.controller.add_player_card("Miro", "Bombs")
self.controller.add_player_card("Miro", "Beatup")
self.controller.add_player_card("Miro", "BrutalKill")
self.controller.add_player_card("Ivan", "Nuclear")
self.controller.add_player_card("Ivan", "Flower")
self.controller.add_player_card("Ivan", "Napkin")
with self.assertRaises(ValueError):
self.controller.fight("Miro", "Ivan")
class TestController(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test_attributes(self):
self.assertEqual('PlayerRepository',
self.controller.player_repository.__class__.__name__)
self.assertEqual('CardRepository',
self.controller.card_repository.__class__.__name__)
def test_add_player__when_player_is_beginner__expect_to_add_it(self):
type_p = 'Beginner'
username = '******'
expect = 'Successfully added player of type Beginner with username: Pesho'
self.assertEqual(expect, self.controller.add_player(type_p, username))
self.assertEqual(1, len(self.controller.player_repository.players))
def test_add_player__when_player_is_advanced__expect_to_add_it(self):
type_p = 'Advanced'
username = '******'
expect = 'Successfully added player of type Advanced with username: Gosho'
self.assertEqual(expect, self.controller.add_player(type_p, username))
self.assertEqual(1, len(self.controller.player_repository.players))
def test_add_card__when_card_is_trap__expect_to_add_it(self):
type_c = 'Trap'
name = 'Dark Hole'
expect = 'Successfully added card of type TrapCard with name: Dark Hole'
self.assertEqual(expect, self.controller.add_card(type_c, name))
self.assertEqual(1, len(self.controller.card_repository.cards))
def test_add_card__when_card_is_magic__expect_to_add_it(self):
type_c = 'Magic'
name = 'Monster reborn'
expect = 'Successfully added card of type MagicCard with name: Monster reborn'
self.assertEqual(expect, self.controller.add_card(type_c, name))
self.assertEqual(1, len(self.controller.card_repository.cards))
def test_add_player_card__expect_to_add_it(self):
username = '******'
self.controller.add_player('Advanced', username)
card_name = 'Monster reborn'
self.controller.add_card('Magic', card_name)
player = self.controller.player_repository.find(username)
card = self.controller.card_repository.find(card_name)
expect = 'Successfully added card: Monster reborn to user: Pesho'
self.assertEqual(expect,
self.controller.add_player_card(username, card_name))
self.assertEqual(1, len(player.card_repository.cards))
def test_fight__expect_to_return_attacker_and_enemy_healths(self):
attack_name = 'Pesho'
self.controller.add_player('Advanced', attack_name)
enemy_name = 'Gosho'
self.controller.add_player('Advanced', enemy_name)
actual = self.controller.fight(attack_name, enemy_name)
expect = 'Attack user health 250 - Enemy user health 250'
self.assertEqual(expect, actual)
def test_report__expect_to_return_it(self):
type_p = 'Beginner'
username = '******'
self.controller.add_player(type_p, username)
type_c = 'Trap'
name = 'Dark Hole'
self.controller.add_card(type_c, name)
self.controller.add_player_card(username, name)
type_c = 'Magic'
name = 'Monster reborn'
self.controller.add_card(type_c, name)
self.controller.add_player_card(username, name)
expect = 'Username: Pesho - Health: 50 - ' \
'Cards 2\n' \
'### Card: Dark Hole - Damage: 120\n' \
'### Card: Monster reborn - Damage: 5\n'
actual = self.controller.report()
self.assertEqual(expect, actual)
class ControllerTests(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test_init__expect_attributes_to_be_set(self):
self.assertEqual([], self.controller.player_repository.players)
self.assertEqual(0, self.controller.player_repository.count)
self.assertEqual([], self.controller.card_repository.cards)
self.assertEqual(0, self.controller.card_repository.count)
def test_add_player__expect_to_create_and_add_player_of_given_type_and_name_and_return_msg(
self):
expected_msg = "Successfully added player of type Advanced with username: frodo"
actual_msg = self.controller.add_player("Advanced", "frodo")
self.assertEqual(1, self.controller.player_repository.count)
self.assertEqual(expected_msg, actual_msg)
def test_add_card__expect_to_create_and_add_card_of_given_type_and_name_and_return_msg(
self):
expected_msg = "Successfully added card of type MagicCard with name: magic"
actual_msg = self.controller.add_card("Magic", "magic")
self.assertEqual(1, self.controller.card_repository.count)
self.assertEqual(expected_msg, actual_msg)
def test_add_player_card__expect_to_add_card_object_to_player_object(self):
self.controller.add_player("Advanced", "frodo")
self.controller.add_card("Magic", "magic")
expected_msg = "Successfully added card: magic to user: frodo"
actual_msg = self.controller.add_player_card("frodo", "magic")
self.assertEqual(
1,
self.controller.player_repository.players[0].card_repository.count)
self.assertEqual(expected_msg, actual_msg)
def test_fight(self):
self.controller.add_player("Advanced", "Aragorn")
self.controller.add_card("Trap", "sword")
self.controller.add_player_card("Aragorn", "sword")
self.controller.add_player("Beginner", "Orc")
self.controller.add_card("Trap", "axe")
self.controller.add_player_card("Orc", "axe")
expected_msg = "Attack user health 255 - Enemy user health 0"
actual_msg = self.controller.fight("Aragorn", "Orc")
self.assertEqual(expected_msg, actual_msg)
def test_report__expect_info_for_players_and_their_cards_as_string(self):
self.controller.add_player("Advanced", "frodo")
self.controller.add_card("Magic", "magic")
self.controller.add_player_card("frodo", "magic")
self.controller.add_player("Beginner", "sam")
self.controller.add_card("Trap", "trap")
self.controller.add_player_card("sam", "trap")
expected_msg = "Username: frodo - Health: 250 - Cards 1\n### Card: magic - Damage: 5\n" \
"Username: sam - Health: 50 - Cards 1\n### Card: trap - Damage: 120"
actual_msg = self.controller.report()
self.assertEqual(expected_msg, actual_msg)
class TestController(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test_controller_init_methof(self):
self.assertEqual(self.controller.player_repository.__class__.__name__,
'PlayerRepository')
self.assertEqual(self.controller.card_repository.__class__.__name__,
'CardRepository')
def test_controller_add_method_when_beginner_passed(self):
self.controller.add_player('Beginner', 'Mitko')
self.assertEqual(self.controller.player_repository.players[0].username,
'Mitko')
self.assertEqual(self.controller.player_repository.count, 1)
def test_controller_add_method_when_beginner_passed_should_return(self):
result = self.controller.add_player('Beginner', 'Mitko')
expected_result = 'Successfully added player of type Beginner with username: Mitko'
self.assertEqual(result, expected_result)
def test_controller_add_method_when_advanced_passed_should_return(self):
result = self.controller.add_player('Advanced', 'Mitko')
expected_result = 'Successfully added player of type Advanced with username: Mitko'
self.assertEqual(result, expected_result)
def test_controller_add_card_method_when_magic_card_added(self):
self.controller.add_card('Magic', 'Magic Card')
self.assertEqual(self.controller.card_repository.cards[0].name,
'Magic Card')
self.assertEqual(self.controller.card_repository.count, 1)
def test_controller_add_card_method_when_magic_card_added_should_return(
self):
result = self.controller.add_card('Magic', 'Magic Card')
expected_result = 'Successfully added card of type MagicCard with name: Magic Card'
self.assertEqual(result, expected_result)
def test_controller_add_card_method_when_trap_card_added_should_return(
self):
result = self.controller.add_card('Trap', 'Trap Card')
expected_result = 'Successfully added card of type TrapCard with name: Trap Card'
self.assertEqual(result, expected_result)
def test_controller_add_player_card_method(self):
mc = MagicCard('Magic')
pl = Advanced('Mitko')
self.controller.player_repository.add(pl)
self.controller.card_repository.add(mc)
result = self.controller.add_player_card('Mitko', 'Magic')
expected_result = 'Successfully added card: Magic to user: Mitko'
self.assertEqual(result, expected_result)
def test_controller_fight_method(self):
pl = Advanced('Mitko')
en = Beginner('Mitko Enemy')
self.controller.player_repository.add(pl)
self.controller.player_repository.add(en)
result = self.controller.fight('Mitko', 'Mitko Enemy')
expected_result = f'Attack user health 90 - Enemy user health 250'
self.assertEqual(result, expected_result)
def test_controller_report_method(self):
result = self.controller.report()
expected_result = ''
self.assertEqual(result, expected_result)
class TestController(unittest.TestCase):
def setUp(self):
self.new_controller = Controller()
self.beginner_player = Beginner("KOZA_BEGINNER")
self.advanced_player = Advanced("KOZA_ADVANCED")
self.magic_card = MagicCard("KOZA_MAGIC")
self.trap_card = TrapCard("KOZA_TRAP")
def test_init(self):
self.assertEqual(
self.new_controller.player_repository.__class__.__name__,
"PlayerRepository")
self.assertEqual(
self.new_controller.card_repository.__class__.__name__,
"CardRepository")
self.assertEqual(self.new_controller.player_repository.count, 0)
self.assertEqual(self.new_controller.card_repository.count, 0)
self.assertEqual(self.new_controller.player_repository.players, [])
self.assertEqual(self.new_controller.card_repository.cards, [])
def test_add_player_beginner(self):
actual_result = self.new_controller.add_player(type="Beginner",
username="******")
expected_result = "Successfully added player of type Beginner with username: PESHO"
self.assertEqual(actual_result, expected_result)
self.assertEqual(
self.new_controller.player_repository.find("PESHO").username,
"PESHO")
self.assertEqual(
type(self.new_controller.player_repository.find("PESHO")).__name__,
"Beginner")
def test_add_player_advanced(self):
actual_result = self.new_controller.add_player(type="Advanced",
username="******")
expected_result = "Successfully added player of type Advanced with username: GOSHO"
self.assertEqual(actual_result, expected_result)
self.assertEqual(
self.new_controller.player_repository.find("GOSHO").username,
"GOSHO")
self.assertEqual(
type(self.new_controller.player_repository.find("GOSHO")).__name__,
"Advanced")
def test_add_card_magic(self):
actual_result = self.new_controller.add_card(type="Magic",
name="KOZA_MAGIC")
expected_result = "Successfully added card of type MagicCard with name: KOZA_MAGIC"
self.assertEqual(actual_result, expected_result)
self.assertEqual(
self.new_controller.card_repository.find("KOZA_MAGIC").name,
"KOZA_MAGIC")
self.assertEqual(
type(self.new_controller.card_repository.find(
"KOZA_MAGIC")).__name__, "MagicCard")
def test_add_card_trap(self):
actual_result = self.new_controller.add_card(type="Trap",
name="KOZA_TRAP")
expected_result = "Successfully added card of type TrapCard with name: KOZA_TRAP"
self.assertEqual(actual_result, expected_result)
self.assertEqual(
self.new_controller.card_repository.find("KOZA_TRAP").name,
"KOZA_TRAP")
self.assertEqual(
type(self.new_controller.card_repository.find(
"KOZA_TRAP")).__name__, "TrapCard")
def test_add_player_card(self):
self.new_controller.add_card(type="Trap", name="KOZA_TRAP")
self.new_controller.add_player(type="Advanced", username="******")
actual_result = self.new_controller.add_player_card(
username="******", card_name="KOZA_TRAP")
expected_result = "Successfully added card: KOZA_TRAP to user: GOSHO"
actual_card = self.new_controller.player_repository.find(
"GOSHO").card_repository.find("KOZA_TRAP")
self.assertEqual(actual_card.name, "KOZA_TRAP")
self.assertEqual(actual_result, expected_result)
def test_fight(self):
self.new_controller.add_player("Beginner", "PESHO")
self.new_controller.add_player("Advanced", "GOSHO")
self.new_controller.add_card("Trap", "KOZA_TRAP")
self.new_controller.add_player_card("PESHO", "KOZA_TRAP")
actual_result = self.new_controller.fight("PESHO", "GOSHO")
expected_result = "Attack user health 95 - Enemy user health 100"
self.assertEqual(actual_result, expected_result)
def test_report(self):
self.new_controller.add_card(type="Magic", name="KOZA_MAGIC")
self.new_controller.add_player(type="Beginner", username="******")
self.new_controller.add_player_card(username="******",
card_name="KOZA_MAGIC")
self.new_controller.add_card(type="Trap", name="KOZA_TRAP")
self.new_controller.add_player(type="Advanced", username="******")
self.new_controller.add_player_card(username="******",
card_name="KOZA_TRAP")
actual_result = self.new_controller.report()
expected_result = f"Username: PESHO - Health: 50 - Cards 1\n### Card: KOZA_MAGIC - Damage: 5\nUsername: GOSHO - Health: 250 - Cards 1\n### Card: KOZA_TRAP - Damage: 120\n"
self.assertEqual(actual_result, expected_result)
def test_add_card_should_return_message(self):
controller = Controller()
message = controller.add_card("Trap", "Trap Card")
self.assertEqual(
message,
"Successfully added card of type TrapCard with name: Trap Card")