class Controller: def __init__(self): self.player_repository = PlayerRepository() self.card_repository = CardRepository() def add_player(self, player_type: str, username: str): player = Advanced(username) if player_type == 'Advance' else Beginner( username) self.player_repository.add(player) return f'Successfully add player of type{player_type} with username {username}' def add_card(self, card_type: str, name: str): card = MagicCards(name) if card_type == "Magic" else TrapCard(name) self.card_repository.add(card) return f"Successfully added cart 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"### Carde: {card.name} - Damage: {card.damage_points}\n" return result
def test_add_existing_player_should_raise_error(self): repo = PlayerRepository() player = Advanced("Peter") repo.players.append(player) with self.assertRaises(ValueError) as cm: repo.add(player) self.assertEqual(str(cm.exception), "Player Peter already exists!")
def test_add_method_add_card_when_unique(self): player_repo = PlayerRepository() beginner = Beginner('test') beginner2 = Beginner('test2') player_repo.add(beginner) player_repo.add(beginner2) self.assertEqual(2, player_repo.count)
def test_add_raises(self): repo = PlayerRepository() p = Advanced('test') repo.add(p) with self.assertRaises(ValueError) as ex: repo.add(p) self.assertEqual(str(ex.exception), "Player test already exists!")
def test_add_method_raise_ex_when_card_already_exist(self): with self.assertRaises(Exception) as ex: player_repository = PlayerRepository() beginner = Beginner('test') player_repository.add(beginner) player_repository.add(beginner) self.assertIsNotNone(ex.exception)
def test_add_player(self): r = PlayerRepository() self.assertEqual(len(r.players), 0) self.assertEqual(r.count, 0) player = Advanced("Test") r.add(player) self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1)
def test_add(self): repo = PlayerRepository() p = Advanced('test') self.assertEqual(0, len(repo.players)) self.assertEqual(0, repo.count) repo.add(p) self.assertEqual(1, len(repo.players)) self.assertEqual(1, repo.count)
def test_add_count_valid_data_should_work_correctly(self): repository = PlayerRepository() player = Beginner("Dave") repository.add(player) self.assertEqual(repository.count, 1)
def test_remove_non_existing_should_raise_error(self): repository = PlayerRepository() player = Beginner("Dave") repository.add(player) repository.remove("Gosho")
def test_remove_valid_data_second_time_should_raise_error(self): repository = PlayerRepository() player = Beginner("Dave") repository.add(player) with self.assertRaises(ValueError): repository.remove("")
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
def test_remove_valid_data_should_work_correctly(self): repository = PlayerRepository() player = Advanced("Dave") repository.add(player) self.assertEqual(repository.count, 1) repository.remove("Dave") self.assertEqual(repository.count, 0) self.assertEqual(len(repository.players), 0)
def test_remove_player(self): r = PlayerRepository() self.assertEqual(len(r.players), 0) self.assertEqual(r.count, 0) player = Advanced("Test") r.add(player) self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1) r.remove(player.username) self.assertEqual(len(r.players), 0) self.assertEqual(r.count, 0)
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
def test_remove_empty_player_name_raises(self): r = PlayerRepository() self.assertEqual(len(r.players), 0) self.assertEqual(r.count, 0) player = Advanced("Test") r.add(player) self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1) with self.assertRaises(ValueError): r.remove("") self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1)
class TestPlayerRepository(unittest.TestCase): def setUp(self) -> None: self.repo = PlayerRepository() def test_init(self): self.assertEqual(0, self.repo.count) self.assertListEqual([], self.repo.players) def test_add_raises(self): player = Advanced('test') self.repo.players.append(player) with self.assertRaises(ValueError): self.repo.add(player) def test_add_proper(self): player = Advanced('test') self.repo.add(player) self.assertEqual(1, self.repo.count) self.assertEqual(1, len(self.repo.players)) def test_remove_raises(self): with self.assertRaises(ValueError): self.repo.remove('') def test_remove_proper(self): player = Advanced('test') self.repo.add(player) self.repo.remove('test') self.assertEqual(0, self.repo.count) self.assertEqual(0, len(self.repo.players)) def test_find(self): player = Advanced('test') self.repo.add(player) self.assertEqual(player, self.repo.find('test'))
def test_find(self): r = PlayerRepository() self.assertEqual(len(r.players), 0) self.assertEqual(r.count, 0) player = Advanced("Test") r.add(player) self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1) founded = r.find("Test") self.assertEqual(founded.username, player.username) self.assertEqual(founded.health, player.health) self.assertEqual(founded, player)
def test_add_existing_player_raises(self): r = PlayerRepository() self.assertEqual(len(r.players), 0) self.assertEqual(r.count, 0) player = Advanced("Test") r.add(player) self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1) with self.assertRaises(ValueError): r.add(player) self.assertEqual(len(r.players), 1) self.assertEqual(r.count, 1)
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: def __init__(self): self.player_repository = PlayerRepository() self.card_repository = CardRepository() def add_player(self, type: str, username: str): result = "" if type == "Beginner": new_player = Beginner(username) self.player_repository.add(new_player) result = f"Successfully added player of type {type} with username: {username}" if type == "Advanced": new_player = Advanced(username) self.player_repository.add(new_player) result = f"Successfully added player of type {type} with username: {username}" return result def add_card(self, type: str, name: str): result = "" if type == "Magic": new_card = MagicCard(name) self.card_repository.add(new_card) result = f"Successfully added card of type {type}Card with name: {name}" if type == "Trap": new_card = TrapCard(name) self.card_repository.add(new_card) result = f"Successfully added card of type {type}Card with name: {name}" return result def add_player_card(self, username: str, card_name: str): for player in self.player_repository.players: if player.username == username: for card in self.card_repository.cards: if card.name == 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.fight(attacker=attacker, enemy=enemy) return f"Attack user health {attacker.health} - Enemy user health {enemy.health}" def report(self): report_msg = "" for player in self.player_repository.players: report_msg += f"Username: {player.username} - Health: {player.health} - Cards {player.card_repository.count}\n" for card in player.card_repository.cards: report_msg += f"### Card: {card.name} - Damage: {card.damage_points}\n" return report_msg
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: 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 TestPlayerRepository(unittest.TestCase): def setUp(self): self.new_player_repository = PlayerRepository() self.beginner_player = Beginner("KOZA_BEGINNER") self.advanced_player = Advanced("KOZA_ADVANCED") def test_init(self): self.assertEqual(self.new_player_repository.__class__.__name__, "PlayerRepository") self.assertEqual(self.new_player_repository.players, []) self.assertEqual(self.new_player_repository.count, 0) def test_add_player(self): self.assertEqual(self.new_player_repository.count, 0) self.new_player_repository.add(self.beginner_player) self.new_player_repository.add(self.advanced_player) self.assertEqual(self.new_player_repository.count, 2) self.assertEqual(len(self.new_player_repository.players), 2) def test_add_player_duplicate_name(self): self.new_player_repository.add(self.beginner_player) self.assertEqual(self.new_player_repository.count, 1) with self.assertRaises(Exception) as context: self.new_player_repository.add(self.beginner_player) self.assertEqual( str(context.exception), f"Player {self.beginner_player.username} already exists!") self.assertEqual(len(self.new_player_repository.players), 1) def test_remove_player(self): self.new_player_repository.add(self.beginner_player) self.assertEqual(self.new_player_repository.count, 1) self.new_player_repository.remove(self.beginner_player.username) self.assertEqual(self.new_player_repository.count, 0) self.assertEqual(self.new_player_repository.players, []) def test_remove_empty_name(self): with self.assertRaises(Exception) as context: self.new_player_repository.remove("") self.assertEqual(str(context.exception), "Player cannot be an empty string!") def test_find_username(self): self.new_player_repository.add(self.beginner_player) self.assertEqual(self.new_player_repository.count, 1) expected_player = self.new_player_repository.find("KOZA_BEGINNER") self.assertEqual(expected_player.__class__.__name__, "Beginner") self.assertEqual(expected_player, self.beginner_player)
class TestPlayerRepository(unittest.TestCase): def setUp(self): self.repository = PlayerRepository() self.beginner = Beginner('John') def test_if_init_is_set_properly(self): expected_count = 0 expected_players = [] self.assertEqual(expected_count, self.repository.count) self.assertEqual(expected_players, self.repository.players) def test_if_add_function_raises_value_error_if_player_is_already_in_list(self): self.repository.players = [self.beginner] with self.assertRaises(ValueError) as context_manager: self.repository.add(self.beginner) expected_message = f"Player John already exists!" self.assertEqual(expected_message, str(context_manager.exception)) def test_if_add_function_appends_and_increases_count(self): self.repository.add(self.beginner) expected_result_for_players_list = [self.beginner] expected_result_for_count = 1 self.assertEqual(expected_result_for_count, self.repository.count) self.assertEqual(expected_result_for_players_list, self.repository.players) def test_if_remove_function_raises_value_error(self): expected_result = "Player 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_player_and_decreases_count(self): self.repository.players = [self.beginner] self.repository.count = 1 self.repository.remove('John') expected_count = 0 expected_list = [] self.assertEqual(expected_count, self.repository.count) self.assertEqual(expected_list, self.repository.players) def test_if_find_function_works(self): self.repository.players = [self.beginner] result = self.repository.find('John') expected_result = self.beginner self.assertEqual(expected_result, result)
class TestPlayerRepository(unittest.TestCase): def setUp(self) -> None: self.repo = PlayerRepository() def test_init_method(self): self.assertEqual(self.repo.count, 0) self.assertEqual(self.repo.players, []) def test_add_method_when_player_already_in_list_should_raises(self): pl = Advanced('Mitko') self.repo.add(pl) with self.assertRaises(Exception) as ex: self.repo.add(pl) self.assertIsNotNone(str(ex.exception)) def test_add_method_when_player_not_in_list(self): pl = Advanced('Mitko') self.repo.add(pl) self.assertIsNotNone(self.repo.players[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): pl = Advanced('Mitko') self.repo.add(pl) self.repo.remove('Mitko') self.assertEqual(self.repo.players, []) def test_find_method(self): pl = Advanced('Mitko') self.repo.add(pl) resuslt = self.repo.find('Mitko') expected_result = 'Mitko' self.assertEqual(resuslt.username, expected_result)
class Controller: def __init__(self): self.player_repository = PlayerRepository() self.card_repository = CardRepository() def add_player(self, type: str, username: str): player = Beginner(username) if type == "Beginner" else 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 = MagicCard(name) if type == 'Magic' else 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): 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: # result.append(str(player)) # for card in player.card_repository.cards: # result.append(f"### {str(card)}") # return '\n'.join(result) 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_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 TestPlayerRepository(unittest.TestCase): def setUp(self): self.player_repo = PlayerRepository() def test_attributes(self): self.assertEqual(0, self.player_repo.count) self.assertListEqual([], self.player_repo.players) def test_add__expect_to_add_the_card(self): player = Beginner('Pesho') self.player_repo.add(player) self.assertEqual(1, self.player_repo.count) self.assertEqual(1, len(self.player_repo.players)) def test_add__when_card_exists__expect_to_raise_exception(self): player = Beginner('Pesho') self.player_repo.add(player) with self.assertRaises(ValueError) as ex: self.player_repo.add(player) expect = 'Player Pesho already exists!' self.assertEqual(expect, str(ex.exception)) def test_remove__expect_to_remove_the_card(self): player = Beginner('Pesho') self.player_repo.add(player) self.player_repo.remove(player.username) self.assertEqual(0, self.player_repo.count) self.assertListEqual([], self.player_repo.players) def test_remove__when_card_is_empty_string__expect_to_raise_exception( self): with self.assertRaises(ValueError) as ex: self.player_repo.remove('') expect = 'Player cannot be an empty string!' self.assertEqual(expect, str(ex.exception)) def test_find__expect_to_return_card(self): player = Beginner('Pesho') self.player_repo.add(player) actual = self.player_repo.find(player.username) self.assertEqual('Pesho', actual.username)
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