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 setUp(self):
self.controller = Controller()
def setUp(self) -> None:
self.controller = Controller()
def test_init(self):
c = Controller()
self.assertEqual(0, c.player_repository.count)
self.assertEqual(0, len(c.player_repository.players))
self.assertEqual(0, c.card_repository.count)
self.assertEqual(0, len(c.card_repository.cards))
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)
def setUp(self) -> None:
self.player_repo = PlayerRepository()
self.card_repo = CardRepository()
self.controller = Controller()
def test_add_player_should_return_message(self):
controller = Controller()
message = controller.add_player("Advanced", "Peter")
self.assertEqual(
message,
"Successfully added player of type Advanced with username: Peter")
from project.controller import Controller
controller = Controller()
print(controller.create_driver("Peter"))
print(controller.create_car("SportsCar", "Porsche 718 Boxster", 470))
print(controller.add_car_to_driver("Peter", "SportsCar"))
print(controller.create_car("SportsCar", "Porsche 911", 580))
print(controller.add_car_to_driver("Peter", "SportsCar"))
print(controller.create_car("MuscleCar", "BMW ALPINA B7", 290))
print(controller.create_car("MuscleCar", "Mercedes-Benz AMG GLA 45", 420))
print(controller.create_driver("John"))
print(controller.create_driver("Jack"))
print(controller.create_driver("Kelly"))
print(controller.add_car_to_driver("Kelly", "MuscleCar"))
print(controller.add_car_to_driver("Jack", "MuscleCar"))
print(controller.add_car_to_driver("John", "SportsCar"))
print(controller.create_race("Christmas Top Racers"))
print(controller.add_driver_to_race("Christmas Top Racers", "John"))
print(controller.add_driver_to_race("Christmas Top Racers", "Jack"))
print(controller.add_driver_to_race("Christmas Top Racers", "Kelly"))
print(controller.add_driver_to_race("Christmas Top Racers", "Peter"))
print(controller.start_race("Christmas Top Racers"))
[print(d.name, d.number_of_wins) for d in controller.drivers]
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)
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 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")
def test_init_sets_the_correct_attributes(self):
controller = Controller()
self.assertEqual(controller.player_repository.__class__.__name__,
"PlayerRepository")
self.assertEqual(controller.card_repository.__class__.__name__,
"CardRepository")
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")
class TestController(TestCase):
def setUp(self):
self.controller = Controller()
self.player1 = Beginner("Bushido")
self.player2 = Beginner("Johny")
self.player1.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.player2.card_repository.cards = [
MagicCard("Some magic card"),
TrapCard("Some trap card"),
MagicCard("Some magic card"),
TrapCard("Some trap card")
]
def test_init(self):
self.assertEqual([], self.controller.player_repository.players)
self.assertEqual([], self.controller.card_repository.cards)
def test_add_beginner_player(self):
self.assertEqual([], self.controller.player_repository.players)
result = self.controller.add_player("Beginner", "Bushido")
self.assertEqual("Bushido",
self.controller.player_repository.players[0].username)
self.assertEqual(
"Beginner",
type(self.controller.player_repository.players[0]).__name__)
self.assertEqual(
f"Successfully added player of type Beginner with username: Bushido",
result)
def test_add_advanced_player(self):
self.assertEqual([], self.controller.player_repository.players)
result = self.controller.add_player("Advanced", "Bushido")
self.assertEqual("Bushido",
self.controller.player_repository.players[0].username)
self.assertEqual(
"Advanced",
type(self.controller.player_repository.players[0]).__name__)
self.assertEqual(
f"Successfully added player of type Advanced with username: Bushido",
result)
def test_add_card_magic(self):
self.assertEqual([], self.controller.card_repository.cards)
result = self.controller.add_card("Magic", "Exodia")
self.assertEqual("Exodia",
self.controller.card_repository.cards[0].name)
self.assertEqual(
"MagicCard",
type(self.controller.card_repository.cards[0]).__name__)
self.assertEqual(
f"Successfully added card of type MagicCard with name: Exodia",
result)
def test_add_card_trap(self):
self.assertEqual([], self.controller.card_repository.cards)
result = self.controller.add_card("Trap", "Exodia")
self.assertEqual("Exodia",
self.controller.card_repository.cards[0].name)
self.assertEqual(
"TrapCard",
type(self.controller.card_repository.cards[0]).__name__)
self.assertEqual(
f"Successfully added card of type TrapCard with name: Exodia",
result)
def test_add_player_card(self):
self.controller.player_repository.players = [
Advanced("Bushido"), Beginner("Johny")
]
player = [
p for p in self.controller.player_repository.players
if p.username == "Johny"
][0]
self.controller.card_repository.cards = [MagicCard("Exodia")]
result = self.controller.add_player_card("Johny", "Exodia")
self.assertEqual("Exodia", player.card_repository.cards[0].name)
self.assertEqual(f"Successfully added card: Exodia to user: Johny",
result)
def test_fight(self):
player1 = Beginner("Bushido")
player2 = Beginner("Johny")
player1.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")
]
player2.card_repository.cards = [
MagicCard("Some magic card"),
TrapCard("Some trap card"),
MagicCard("Some magic card"),
TrapCard("Some trap card")
]
self.controller.player_repository.players.append(player1)
self.controller.player_repository.players.append(player2)
result = self.controller.fight("Bushido", "Johny")
self.assertEqual(f"Attack user health 215 - Enemy user health 0",
result)
def __init__(self, __name__):
super().__init__(__name__)
self.controller = Controller()
def setUp(self):
self.ctrl = Controller()
from project.controller import Controller
from project.decoration.plant import Plant
a = Controller()
print(a.add_aquarium("SaltwaterAquarium", "Underworld"))
print(a.add_aquarium("FreshwaterAquarium", "Swamp"))
print(a.add_fish("Underworld", "FreshwaterFish", "Nemo", "Clownfish", 13.40))
print(a.add_fish("Underworld", "SaltwaterFish", "Nemo", "Clownfish", 13.40))
print(a.add_aquarium("FreshwaterAquarium", "Riverworld"))
print(a.add_fish("Riverworld", "FreshwaterFish", "Emerald", "Catfish", 7.32))
print(a.add_fish("Underworld", "SweetwaterFish", "Diamond", "Catfish", 3.50))
print(a.add_decoration("Plant"))
print(a.insert_decoration("Riverworld", "Plant"))
print(a.insert_decoration("Underworld", "Plant"))
print(a.add_decoration("Plant"))
print(a.add_decoration("Plant"))
print(a.insert_decoration("Underworld", "Plant"))
print(a.insert_decoration("Underworld", "Plant"))
print(a.feed_fish("Riverworld"))
print(a.feed_fish("Underworld"))
print(a.calculate_value("Riverworld"))
# print(a.add_fish("Riverworld", "FreshwaterFish", "", "Species", 20))
# print(a.add_fish("Riverworld", "FreshwaterFish", "Name", "", 20))
# print(a.add_fish("Riverworld", "FreshwaterFish", "Name", "Species", - 10))
print(a.report())
def setUp(self) -> None:
self.ctrl = Controller()
def test_add_advanced_should_add_advanced_to_player_repo(self):
controller = Controller()
controller.add_player("Advanced", "Peter")
player = controller.player_repository.players[0]
self.assertEqual(player.username, "Peter")
self.assertEqual(player.__class__.__name__, "Advanced")
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")
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 TestController(unittest.TestCase):
def setUp(self):
self.controller = Controller()
def test__init__(self):
self.assertEqual(self.controller.player_repository.players, [])
self.assertEqual(self.controller.player_repository.count, 0)
self.assertEqual(self.controller.card_repository.cards, [])
self.assertEqual(self.controller.card_repository.count, 0)
def test_add_player_beginner(self):
result = self.controller.add_player("Beginner", "Miro")
self.assertEqual(
result,
f"Successfully added player of type Beginner with username: Miro")
self.assertEqual(self.controller.player_repository.count, 1)
def test_add_player_advanced(self):
result = self.controller.add_player("Advanced", "Miro")
self.assertEqual(
result,
f"Successfully added player of type Advanced with username: Miro")
self.assertEqual(self.controller.player_repository.count, 1)
def test_add_card_magic(self):
result = self.controller.add_card("Magic", "Kill")
self.assertEqual(
result,
f"Successfully added card of type MagicCard with name: Kill")
self.assertEqual(self.controller.card_repository.count, 1)
def test_trap_card(self):
result = self.controller.add_card("Trap", "Bombs")
self.assertEqual(
result,
f"Successfully added card of type TrapCard with name: Bombs")
self.assertEqual(self.controller.card_repository.count, 1)
def test_add_player_card_success(self):
# player = Advanced("Miro")
# card = TrapCard("Bombs")
self.controller.add_player("Advanced", "Miro")
self.controller.add_card("Trap", "Bombs")
self.assertEqual(self.controller.add_player_card("Miro", "Bombs"),
f"Successfully added card: Bombs to user: Miro")
def test_add_player_not_success(self):
self.controller.add_player("Advanced", "Miro")
self.controller.add_card("Trap", "Bombs")
self.assertEqual(self.controller.add_player_card("Spiro", "Trap"),
None)
def test_fight_success(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")
msg = f"Attack user health 250 - Enemy user health 210"
self.assertEqual(self.controller.fight("Miro", "Ivan"), msg)
# with self.assertRaises(ValueError) as exc:
# self.assertEqual(str(exc.exception), msg)
def test_fight_not_success(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.assertEqual(self.controller.fight("Miro", "Pesho"), None)
def test_report(self):
self.controller.add_player("Advanced", "Miro")
self.controller.add_player("Advanced", "Ivan")
self.controller.add_card("Trap", "Bombs")
self.controller.add_card("Magic", "Nuclear")
self.controller.add_card("Magic", "Boom")
self.controller.add_player_card("Miro", "Bombs")
self.controller.add_player_card("Miro", "Boom")
self.controller.add_player_card("Ivan", "Nuclear")
result = f"Username: Miro - Health: 250 - Cards 2" + '\n'
result += f"### Card: Bombs - Damage: 120" + '\n'
result += f"### Card: Boom - Damage: 5" + '\n'
result += f"Username: Ivan - Health: 250 - Cards 1" + '\n'
result += f"### Card: Nuclear - Damage: 5" + '\n'
self.assertEqual(self.controller.report(), result)