class TestCardRepo(unittest.TestCase):
def setUp(self):
self.card = CardRepository()
def test_add_card_when_is_not_in_card(self):
card = MagicCard('magic')
self.card.add(card)
self.assertEqual(self.card.count, 1)
self.assertEqual(len(self.card.cards), 1)
def test_add_card_when_is_in_card(self):
card = MagicCard('magic')
self.card.add(card)
self.assertEqual(self.card.count, 1)
self.assertEqual(len(self.card.cards), 1)
with self.assertRaises(ValueError) as ex:
self.card.add(card)
self.assertEqual(str(ex.exception), "Card magic already exists!")
def test_remove_card_when_is_calid(self):
card = MagicCard("Magic")
self.card.add(card)
self.card.remove('Magic')
self.assertEqual(self.card.count, 0)
self.assertEqual(len(self.card.cards), 0)
def test_remove_when_not_valid_should_raise_exception(self):
with self.assertRaises(ValueError) as ex:
self.card.remove('')
self.assertEqual(str(ex.exception), "Card cannot be an empty string!")
def test_find(self):
card = MagicCard('magic')
self.card.add(card)
self.assertEqual(self.card.find('magic'), card)
class Controller:
def __init__(self) -> None:
self.player_repository = PlayerRepository()
self.card_repository = CardRepository()
def add_player(self, type, username):
if type == 'Beginner':
p = Beginner(username)
self.player_repository.add(p)
return f'Successfully added player of type {type} with username: {username}'
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':
magic_c = MagicCard(name)
self.card_repository.add(magic_c)
return f'Successfully added card of type {type}Card with name: {name}'
trap_c = TrapCard(name)
self.card_repository.add(trap_c)
return f'Successfully added card of type {type}Card with name: {name}'
def add_player_card(self, username, card_name):
card = [c for c in self.card_repository.cards if c.name == card_name][0]
for pl in self.player_repository.players:
if pl.username == username:
pl.card_repository.add(card)
return f'Successfully added card: {card_name} to user: {username}'
def fight(self, attack_name, enemy_name):
enemy = self.player_repository.find(attack_name)
attacker = 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):
message = f''
for pl in self.player_repository.players:
message += f'Username: {pl.username} - Health: {pl.health} - Cards {pl.card_repository.count}\n'
for card in pl.card_repository.cards:
message += f'### Card: {card.name} - Damage: {card.damage_points}\n'
return message
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 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:
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])
class TestCardRepository(TestCase):
def setUp(self):
self.card_repository = CardRepository()
self.card_repository.cards = ['a', 'b', 'c']
self.card_repository.count = 3
def test_check_attributes_are_set(self):
self.assertEqual(3, self.card_repository.count)
self.assertListEqual(['a', 'b', 'c'], self.card_repository.cards)
self.assertIn('a', self.card_repository.cards)
def test_add_existing_card__raises(self):
card = MagicCard('a')
with self.assertRaises(ValueError) as ex:
self.card_repository.add(card)
self.assertEqual(f"Card {card.name} already exists!",
str(ex.exception))
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 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)
