class TestCardRepository(unittest.TestCase):
def setUp(self) -> None:
self.repo = CardRepository()
def test_init(self):
self.assertEqual(0, self.repo.count)
self.assertListEqual([], self.repo.cards)
def test_add_raises(self):
card = MagicCard('test')
self.repo.cards.append(card)
with self.assertRaises(ValueError):
self.repo.add(card)
def test_add_proper(self):
card = MagicCard('test')
self.repo.add(card)
self.assertEqual(1, self.repo.count)
self.assertEqual(1, len(self.repo.cards))
def test_remove_raises(self):
with self.assertRaises(ValueError):
self.repo.remove('')
def test_remove_proper(self):
card = MagicCard('test')
self.repo.add(card)
self.repo.remove('test')
self.assertEqual(0, self.repo.count)
self.assertEqual(0, len(self.repo.cards))
def test_find(self):
card = MagicCard('test')
self.repo.add(card)
self.assertEqual(card, self.repo.find('test'))
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, player_type: str, username: str):
player = Beginner(username) if player_type == 'Beginner' else Advanced(
username)
self.player_repository.add(player)
return f"Successfully added player of type {player_type} with username: {username}"
def add_card(self, card_type: str, name: str):
card = MagicCard(name) if card_type == 'Magic' else TrapCard(name)
self.card_repository.add(card)
return f"Successfully added card of type {card_type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attacker_name: str, enemy_name: str):
attacker = self.player_repository.find(attacker_name)
enemy = self.player_repository.find(enemy_name)
BattleField.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ""
for player in self.player_repository.players:
result += f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n"
for card in player.card_repository.cards:
result += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return result
def test_add_valid_data_should_work_correctly(self):
repository = CardRepository()
card = MagicCard("Dave")
repository.add(card)
self.assertEqual(repository.find("Dave"), card)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
player = None
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 add_card(self, type: str, name: str):
card = None
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 add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
battlefield = BattleField()
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battlefield.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ''
for player in self.player_repository.players:
result += f'Username: {player.username} - Health: {player.health} - Cards {len(player.card_repository.cards)}\n'
for card in player.card_repository.cards:
result += f'### Card: {card.name} - Damage: {card.damage_points}\n'
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type, username):
if type == 'Beginner':
new = Beginner(username)
else:
new = Advanced(username)
self.player_repository.add(new)
return f'Successfully added player of type {type} with username: {username}'
def add_card(self, type, name):
if type == 'Magic':
new = MagicCard(name)
else:
new = TrapCard(name)
self.card_repository.add(new)
return f'Successfully added card of type {type}Card with name: {name}'
def add_player_card(self, username, card_name):
card = self.card_repository.find(card_name)
player = self.player_repository.find(username)
if not card or not player: return
player.card_repository.add(card)
return f'Successfully added card: {card.name} to user: {username}'
def fight(self, attack_name, enemy_name):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
if not attacker or not enemy: return
BattleField.fight(attacker, enemy)
return f'Attack user health {attacker.health} - Enemy user health {enemy.health}'
def report(self):
result = f''
for player in self.player_repository.players:
result += f'Username: {player.username} - Health: {player.health} - ' \
f'Cards {player.card_repository.count}\n'
result += "".join(f'### Card: {card.name} - Damage: {card.damage_points}\n'
for card in player.card_repository.cards)
return result
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
@staticmethod
def create_player(player_type, username):
if player_type == "Beginner":
return Beginner(username)
if player_type == "Advanced":
return Advanced(username)
@staticmethod
def create_card(card_type, name):
if card_type == "Magic":
return MagicCard(name)
if card_type == "Trap":
return TrapCard(name)
def add_player(self, type: str, username: str):
player = self.create_player(type, username)
self.player_repository.add(player)
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type: str, name: str):
card = self.create_card(type, name)
self.card_repository.add(card)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battlefield = BattleField()
battlefield.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = []
for player in self.player_repository.players:
pl_result = f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}"
for card in player.card_repository.cards:
pl_result += f"\n### Card: {card.name} - Damage: {card.damage_points}"
result.append(pl_result)
return '\n'.join(result)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type, username):
# global player_to_add
if type == "Beginner":
player_to_add = Beginner(username)
elif type == "Advanced":
player_to_add = Advanced(username)
self.player_repository.add(player_to_add)
return f"Successfully added player of type {type} with username: {username}"
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 add_player_card(self, username, card_name):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name, enemy_name):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battle_field = BattleField()
battle_field.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ''
for player in self.player_repository.players:
result += f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n"
for card in player.card_repository.cards:
result += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return result
class Controller:
player_repository: PlayerRepository
card_repository: CardRepository
def __init__(self) -> None:
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
self.battle_field = BattleField()
def add_player(self, player_type: str, username: str) -> str:
player_types = {
'Beginner': Beginner,
'Advanced': Advanced
}
player = player_types[player_type](username)
self.player_repository.add(player)
return f'Successfully added player of type {player_type} with username: {username}'
def add_card(self, card_type: str, name: str) -> str:
card_types = {
'Magic': MagicCard,
'Trap': TrapCard,
}
card = card_types[card_type](name)
self.card_repository.add(card)
return f'Successfully added card of type {card_type}Card with name: {name}'
def add_player_card(self, username: str, card_name: str) -> Optional[str]:
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
if not (player and card):
return
player.card_repository.add(card)
return f'Successfully added card: {card_name} to user: {username}'
def fight(self, attack_name: str, enemy_name: str) -> Optional[str]:
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
if not (attacker and enemy):
return
self.battle_field.fight(attacker, enemy)
return f'Attack user health {attacker.health} - Enemy user health {enemy.health}'
def report(self):
return '\n'.join([str(p) for p in self.player_repository.players])
def test_find(self):
r = CardRepository()
self.assertEqual(len(r.cards), 0)
self.assertEqual(r.count, 0)
card = MagicCard("Test")
r.add(card)
self.assertEqual(len(r.cards), 1)
self.assertEqual(r.count, 1)
founded = r.find("Test")
self.assertEqual(founded.name, card.name)
self.assertEqual(founded.damage_points, card.damage_points)
self.assertEqual(founded.health_points, card.health_points)
self.assertEqual(founded, card)
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.card_repo = CardRepository()
self.magic_card = MagicCard('Magic')
self.trap_card = TrapCard('Trap')
def test_initialization_is_returns_correct_attributes(self):
self.assertEqual(self.card_repo.cards, [])
def test_add_should_add_a_card_to_the_cards(self):
self.card_repo.add(self.magic_card)
self.card_repo.add(self.trap_card)
self.assertEqual(self.card_repo.cards, [self.magic_card, self.trap_card])
def test_add_should_raise_error_card_already_in_cards(self):
self.card_repo.add(self.magic_card)
with self.assertRaises(ValueError) as cm:
self.card_repo.add(self.magic_card)
self.assertEqual(str(cm.exception), f"Card Magic already exists!")
def test_remove_should_remove_existing_card(self):
self.card_repo.add(self.magic_card)
self.card_repo.remove('Magic')
self.assertEqual(self.card_repo.cards, [])
def test_remove_should_raise_error_when_the_card_name_is_empty_str(self):
self.card_repo.add(self.trap_card)
with self.assertRaises(ValueError) as cm:
self.card_repo.remove('')
self.assertEqual(str(cm.exception), "Card cannot be an empty string!")
def test_find_should_return_the_found_card(self):
self.card_repo.add(self.magic_card)
self.card_repo.add(self.trap_card)
self.assertEqual(self.card_repo.find(self.trap_card.name), self.trap_card)
def test_count_should_return_the_length_of_the_cards_properly(self):
self.card_repo.add(self.magic_card)
self.card_repo.add(self.trap_card)
self.assertEqual(self.card_repo.count, 2)
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.repository = CardRepository()
self.magic_card = MagicCard("Swords Of The Revealing Light")
def test_if_init_is_properly_initialized(self):
expected_count = 0
expected_cards = []
self.assertEqual(expected_cards, self.repository.cards)
self.assertEqual(expected_count, self.repository.count)
def test_if_add_function_raises_value_error_if_name_already_in_list(self):
self.repository.add(self.magic_card)
expected_result = "Card Swords Of The Revealing Light already exists!"
with self.assertRaises(ValueError) as context_manager:
self.repository.add(self.magic_card)
self.assertEqual(expected_result, str(context_manager.exception))
def test_if_add_function_adds_the_card_and_increases_the_count(self):
self.repository.add(self.magic_card)
expected_count = 1
expected_cards = [self.magic_card]
self.assertEqual(expected_count, self.repository.count)
self.assertEqual(expected_cards, self.repository.cards)
def test_if_remove_function_raises_value_error_with_empty_string(self):
expected_result = "Card cannot be an empty string!"
with self.assertRaises(ValueError) as context_manager:
self.repository.remove('')
self.assertEqual(expected_result, str(context_manager.exception))
def test_if_remove_function_removes_the_card_and_decreases_the_count(self):
second_magic_card = MagicCard('Something')
expected_count = 1
expected_cards = [self.magic_card]
self.repository.add(self.magic_card)
self.repository.add(second_magic_card)
self.repository.remove('Something')
self.assertEqual(expected_cards, self.repository.cards)
self.assertEqual(expected_count, self.repository.count)
def test_if_find_function_returns_the_object(self):
self.repository.add(self.magic_card)
expected_result = self.magic_card
actual_result = self.repository.find('Swords Of The Revealing Light')
self.assertEqual(expected_result, actual_result)
class TestCardRepository(unittest.TestCase):
def setUp(self) -> None:
self.card_repository = CardRepository()
def test_init_attrs_set(self) -> None:
self.assertEqual(self.card_repository.count, 0)
self.assertListEqual(self.card_repository.cards, [])
def test_add__when_card_valid(self) -> None:
card = MagicCard('Card')
self.card_repository.add(card)
self.assertEqual(self.card_repository.count, 1)
self.assertEqual(self.card_repository.cards, [card])
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_remove__when_card_valid(self) -> None:
card = MagicCard('Card')
self.card_repository.add(card)
self.card_repository.remove('Card')
self.assertEqual(self.card_repository.count, 0)
self.assertEqual(self.card_repository.cards, [])
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 test_find_method(self) -> None:
card = MagicCard('Card')
self.card_repository.add(card)
self.assertEqual(self.card_repository.find('Card'), card)
class TestCardRepository(unittest.TestCase):
def setUp(self) -> None:
self.repo = CardRepository()
def test_init_method(self):
self.assertEqual(self.repo.count, 0)
self.assertEqual(self.repo.cards, [])
def test_add_method_when_player_already_in_list_should_raises(self):
mc = MagicCard('Mitko')
self.repo.add(mc)
with self.assertRaises(Exception) as ex:
self.repo.add(mc)
self.assertIsNotNone(str(ex.exception))
def test_add_method_when_player_not_in_list(self):
mc = MagicCard('Mitko')
self.repo.add(mc)
self.assertIsNotNone(self.repo.cards[0], 'Mitko')
def test_remove_method_when_empty_string_provided_should_raises(self):
with self.assertRaises(Exception) as ex:
self.repo.remove('')
self.assertIsNotNone(str(ex.exception))
def test_remove_method_when_username_provided(self):
mc = MagicCard('Mitko')
self.repo.add(mc)
self.repo.remove('Mitko')
self.assertEqual(self.repo.cards, [])
def test_find_method(self):
mc = MagicCard('Mitko')
self.repo.add(mc)
resuslt = self.repo.find('Mitko')
expected_result = 'Mitko'
self.assertEqual(resuslt.name, expected_result)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
if type == 'Beginner':
player = Beginner(username)
self.player_repository.players.append(player)
else:
player = Advanced(username)
self.player_repository.players.append(player)
return f"Successfully added player of type {type} with username: {username}"
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 add_player_card(self, username: str, card_name: str):
user = self.player_repository.find(username)
card = self.card_repository.find(card_name)
user.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
a = self.player_repository.find(attack_name)
e = self.player_repository.find(enemy_name)
BattleField.fight(a, e)
return f"Attack user health {a.health} - Enemy user health {e.health}"
def report(self):
result = ""
for user in self.player_repository.players:
result += f"Username: {user.username} - Health: {user.health} - Cards {user.card_repository.count}\n"
for card in user.card_repository.cards:
result += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return result
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.magic_card = MagicCard("KOZA_MAGIC")
self.trap_card = TrapCard("KOZA_TRAP")
self.new_repository = CardRepository()
def test_init(self):
self.assertEqual(self.new_repository.__class__.__name__,
"CardRepository")
self.assertEqual(self.new_repository.cards, [])
self.assertEqual(self.new_repository.count, 0)
def test_add_card_increase_count(self):
self.assertEqual(self.new_repository.count, 0)
self.new_repository.add(self.trap_card)
self.assertEqual(self.new_repository.count, 1)
def test_add_card_duplicate_name(self):
self.new_repository.add(self.trap_card)
with self.assertRaises(Exception) as context:
self.new_repository.add(self.trap_card)
self.assertEqual(str(context.exception),
f"Card {self.trap_card.name} already exists!")
def test_remove_card_decrease_count(self):
self.new_repository.add(self.trap_card)
self.assertEqual(self.new_repository.count, 1)
self.new_repository.remove(self.trap_card.name)
self.assertEqual(self.new_repository.count, 0)
self.assertEqual(self.new_repository.cards, [])
def test_remove_card_empty_name(self):
with self.assertRaises(Exception) as context:
self.new_repository.remove("")
self.assertEqual(str(context.exception),
"Card cannot be an empty string!")
def test_find_card(self):
self.new_repository.add(self.magic_card)
self.assertEqual(self.new_repository.count, 1)
expected_card = self.new_repository.find(self.magic_card.name)
self.assertEqual(expected_card.__class__.__name__, "MagicCard")
self.assertEqual(expected_card.name, self.magic_card.name)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type_p: str, username: str):
if type_p == 'Beginner':
player = Beginner(username)
else:
player = Advanced(username)
self.player_repository.add(player)
return f"Successfully added player of type {type_p} with username: {username}"
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 add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battle_field = BattleField()
battle_field.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
result = ""
for p in self.player_repository.players:
result += f"Username: {p.username} - Health: {p.health} - Cards {p.card_repository.count}\n"
for c in p.card_repository.cards:
result += f"### Card: {c.name} - Damage: {c.damage_points}\n"
return result
class TestCardRepository(TestCase):
def setUp(self):
self.cr = CardRepository()
def test_init(self):
self.assertEqual(0, self.cr.count)
self.assertEqual([], self.cr.cards)
def test_add(self):
card = MagicCard("Exodia")
self.cr.add(card)
self.assertIn(card, self.cr.cards)
self.assertEqual(1, self.cr.count)
def test_add_raises(self):
card = MagicCard("Exodia")
self.cr.add(card)
self.assertIn(card, self.cr.cards)
with self.assertRaises(ValueError) as ex:
self.cr.add(card)
self.assertEqual("Card Exodia already exists!", str(ex.exception))
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_raises(self):
with self.assertRaises(ValueError) as ex:
self.cr.remove("")
self.assertEqual("Card cannot be an empty string!", str(ex.exception))
def test_find(self):
card = MagicCard("Exodia")
self.cr.add(card)
result = self.cr.find("Exodia")
self.assertEqual(card, result)
class TestCardrepo(unittest.TestCase):
def setUp(self):
self.repo = CardRepository()
def test_set_up(self):
self.assertEqual(self.repo.count, 0)
self.assertEqual(self.repo.cards, [])
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 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 test_remove_when_name_equal_to_empty_should_raise_error(self):
with self.assertRaises(ValueError) as ex:
self.repo.remove('')
self.assertEqual(str(ex.exception), "Card cannot be an empty string!")
def test_remove_card_with_corect_name(self):
card = TrapCard('TrapCard')
self.repo.add(card)
self.repo.remove('TrapCard')
self.assertEqual(self.repo.count, 0)
self.assertListEqual(self.repo.cards, [])
def test_find(self):
card = TrapCard('TrapCard')
self.repo.add(card)
self.assertEqual(self.repo.find('TrapCard'), card)
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.cr = CardRepository()
def test_correct_initialization_zero_count_empty_cards_list(self):
self.assertEqual([], self.cr.cards)
self.assertEqual(0, self.cr.count)
def test_add_method_with_card(self):
card = MagicCard('card')
self.cr.add(card)
self.assertEqual([card], self.cr.cards)
self.assertEqual(1, self.cr.count)
def test_add_method_adding_same_card_more_than_once_resulting_in_value_error(self):
card = MagicCard('card')
self.cr.add(card)
self.assertEqual([card], self.cr.cards)
self.assertEqual(1, self.cr.count)
with self.assertRaises(ValueError) as exc:
self.cr.add(card)
self.assertEqual(f"Card card already exists!", str(exc.exception))
def test_remove_card(self):
card = MagicCard('card')
self.cr.add(card)
self.assertEqual([card], self.cr.cards)
self.assertEqual(1, self.cr.count)
with self.assertRaises(ValueError) as exc: # Value error if card.name = ''
self.cr.remove('')
self.assertEqual("Card cannot be an empty string!", str(exc.exception))
# correctly removing the card
self.cr.remove('card')
self.assertEqual([], self.cr.cards)
self.assertEqual(0, self.cr.count)
def test_find_card(self):
card = MagicCard('card')
self.cr.add(card)
self.assertEqual([card], self.cr.cards)
self.assertEqual(1, self.cr.count)
self.assertEqual(card, self.cr.find('card'))
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.card_repo = CardRepository()
def test_attributes(self):
self.assertEqual(0, self.card_repo.count)
self.assertListEqual([], self.card_repo.cards)
def test_add__expect_to_add_the_card(self):
card = MagicCard('Fire')
self.card_repo.add(card)
self.assertEqual(1, self.card_repo.count)
self.assertEqual(1, len(self.card_repo.cards))
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_remove__expect_to_remove_the_card(self):
card = MagicCard('Fire')
self.card_repo.add(card)
self.card_repo.remove(card.name)
self.assertEqual(0, self.card_repo.count)
self.assertListEqual([], self.card_repo.cards)
def test_remove__when_card_is_empty_string__expect_to_raise_exception(
self):
with self.assertRaises(ValueError) as ex:
self.card_repo.remove('')
expect = 'Card cannot be an empty string!'
self.assertEqual(expect, str(ex.exception))
def test_find__expect_to_return_card(self):
card = MagicCard('Fire')
self.card_repo.add(card)
actual = self.card_repo.find(card.name)
self.assertEqual('Fire', actual.name)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.cards_repository = CardRepository()
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 add_card(self, type, name):
if type == 'Magic':
c = MagicCard(name)
elif type == 'Trap':
c = TrapCard(name)
self.cards_repository.add(c)
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
card = self.cards_repository.find(card_name)
user = self.player_repository.find(username)
user.card_repositoy.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battle_field = BattleField()
battle_field.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
text = ''
for p in self.player_repository.players:
text += f'Username: {p.username} - Health: {p.health} - Cards {p.card_repository.count}\n'
for c in p.card_repository:
text += f'Card: {c.name} - Damage: {c.damage_points}'
return text
class CardRepositoryTests(unittest.TestCase):
def setUp(self):
self.repository = CardRepository()
def test_init__expect_attributes_to_be_set(self):
self.assertEqual(0, self.repository.count)
self.assertEqual([], self.repository.cards)
def test_add__when_card_not_in_cards_expect_to_add_card(self):
card = TrapCard("trap")
self.repository.add(card)
self.assertEqual([card], self.repository.cards)
self.assertEqual(1, self.repository.count)
def test_add__when_card_exists_expect_value_error(self):
card = TrapCard("trap")
self.repository.add(card)
with self.assertRaises(ValueError) as err:
self.repository.add(card)
self.assertEqual("Card trap already exists!", str(err.exception))
def test_remove__when_card_is_empty_string_expect_value_error(self):
with self.assertRaises(ValueError) as err:
self.repository.remove("")
self.assertEqual("Card cannot be an empty string!", str(err.exception))
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 test_find__expect_to_return_object_card_with_given_name(self):
card = TrapCard("trap")
self.repository.add(card)
actual = self.repository.find("trap")
self.assertEqual(card, actual)
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.cr = CardRepository()
self.card = MagicCard("Pfuuu")
def test__init(self):
self.assertEqual(self.cr.cards, [])
def test__count(self):
self.assertEqual(self.cr.count, 0)
def test__add_existing_card__raise_value_error(self):
self.cr.add(self.card)
with self.assertRaises(ValueError) as context:
self.cr.add(self.card)
expected_msg = str(context.exception)
actual_msg = f"Card {self.card.name} already exists!"
self.assertEqual(expected_msg, actual_msg)
def test__add_card__append_player(self):
self.cr.add(self.card)
self.assertEqual(self.cr.cards[0], self.card)
def test__remove_card_with_empty_string__raise_value_error(self):
self.cr.add(self.card)
with self.assertRaises(ValueError) as context:
self.cr.remove("")
expected_msg = str(context.exception)
actual_msg = "Card cannot be an empty string!"
self.assertEqual(expected_msg, actual_msg)
def test__remove_card__sub_it_from_the_list(self):
self.cr.add(self.card)
self.cr.remove("Pfuuu")
self.assertEqual(self.cr.count, 0)
def test__find_card(self):
self.cr.add(self.card)
card_to_find = self.cr.find("Pfuuu")
self.assertEqual(self.card, card_to_find)
class Controller:
def __init__(self):
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type: str, username: str):
if type == "Beginner":
self.player_repository.add(Beginner(username))
else:
self.player_repository.add(Advanced(username))
return f"Successfully added player of type {type} with username: {username}"
def add_card(self, type: str, name: str):
if type == 'Magic':
self.card_repository.add(MagicCard(name))
else:
self.card_repository.add(TrapCard(name))
return f"Successfully added card of type {type}Card with name: {name}"
def add_player_card(self, username: str, card_name: str):
player = self.player_repository.find(username)
card = self.card_repository.find(card_name)
player.card_repository.add(card)
return f"Successfully added card: {card_name} to user: {username}"
def fight(self, attack_name: str, enemy_name: str):
attacker = self.player_repository.find(attack_name)
enemy = self.player_repository.find(enemy_name)
battle_field = BattleField()
battle_field.fight(attacker, enemy)
return f"Attack user health {attacker.health} - Enemy user health {enemy.health}"
def report(self):
output = ""
for player in self.player_repository.players:
output += f'Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n'
for card in player.card_repository.cards:
output += f"### Card: {card.name} - Damage: {card.damage_points}\n"
return output
class TestCardRepository(unittest.TestCase):
def setUp(self):
self.cr = CardRepository()
def test_init(self):
self.assertEqual(0, self.cr.count)
self.assertEqual(0, len(self.cr.cards))
def test_add_raises(self):
c = MagicCard('test')
self.cr.add(c)
with self.assertRaises(ValueError) as ex:
self.cr.add(c)
self.assertEqual("Card test already exists!", str(ex.exception))
def test_add_proper(self):
c = MagicCard('test')
self.cr.add(c)
self.assertEqual(1, self.cr.count)
self.assertEqual(1, len(self.cr.cards))
def test_remove_raises(self):
with self.assertRaises(ValueError) as ex:
self.cr.remove('')
self.assertEqual("Card cannot be an empty string!", str(ex.exception))
def test_remove_proper(self):
c = MagicCard('test')
self.cr.add(c)
self.assertEqual(1, self.cr.count)
self.assertEqual(1, len(self.cr.cards))
self.cr.remove('test')
self.assertEqual(0, self.cr.count)
self.assertEqual(0, len(self.cr.cards))
def test_find(self):
c = MagicCard('test')
self.cr.add(c)
self.assertEqual(c, self.cr.find('test'))
class TestPlayerRepository(unittest.TestCase):
def setUp(self):
self.pr = CardRepository()
def test_set_attr(self):
self.assertEqual(self.pr.count, 0)
self.assertEqual(len(self.pr.cards), 0)
def test_add_raises(self):
p = MagicCard("test")
self.pr.add(p)
with self.assertRaises(ValueError) as ex:
self.pr.add(p)
self.assertEqual(str(ex.exception), "Card test already exists!")
def test_add(self):
p = MagicCard("test")
self.pr.add(p)
self.assertEqual(self.pr.count, 1)
self.assertEqual(len(self.pr.cards), 1)
def test_remove_raises(self):
with self.assertRaises(ValueError) as ex:
self.pr.remove("")
self.assertEqual(str(ex.exception), "Card cannot be an empty string!")
def test_remove(self):
p = MagicCard("test")
self.pr.add(p)
self.assertEqual(self.pr.count, 1)
self.pr.remove("test")
self.assertEqual(self.pr.count, 0)
def test_find(self):
p = MagicCard("test")
self.pr.add(p)
res = self.pr.find("test")
self.assertEqual(res.name, "test")
class TestCardRepository(unittest.TestCase):
def setUp(self) -> None:
self.cr = CardRepository()
def test_set_attr(self):
self.assertEqual(self.cr.count, 0)
self.assertEqual(len(self.cr.cards), 0)
def test_add_raises(self):
c = TrapCard("test")
self.cr.add(c)
with self.assertRaises(ValueError) as ex:
self.cr.add(c)
self.assertEqual(str(ex.exception), f"Card {c.name} already exists!")
def test_add(self):
c = TrapCard("test")
self.cr.add(c)
self.assertEqual(self.cr.count, 1)
def test_remove_raises(self):
with self.assertRaises(ValueError) as ex:
self.cr.remove("")
self.assertEqual(str(ex.exception), "Card cannot be an empty string!")
def test_remove(self):
c = TrapCard("test")
self.cr.add(c)
self.assertEqual(self.cr.count, 1)
self.cr.remove("test")
self.assertEqual(self.cr.count, 0)
def test_find(self):
p = TrapCard("test")
self.cr.add(p)
result = self.cr.find("test")
self.assertEqual(result.name, "test")
def test_find_card_by_name_should_return_card(self):
cr = CardRepository()
card = MagicCard("Magic")
cr.add(card)
found = cr.find("Magic")
self.assertEqual(found, card)
def test_find_card_method(self):
card_repository = CardRepository()
magic_card_1 = MagicCard('test')
card_repository.add(magic_card_1)
card_repository.find('test')
def test_find(self):
repo = CardRepository()
c = MagicCard('test')
repo.add(c)
self.assertEqual(c, repo.find('test'))
