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'))