class TestBattleFiled(unittest.TestCase): def setUp(self): self.controller = Controller() def test_fight_method(self): self.controller.add_player("Advanced", "Miro") self.controller.add_card("Trap", "Bombs") self.controller.add_player("Advanced", "Ivan") self.controller.add_card("Magic", "Nuclear") self.controller.add_player_card("Miro", "Bombs") self.controller.add_player_card("Ivan", "Nuclear") self.assertEqual(self.controller.fight("Miro", "Ivan"), f"Attack user health 250 - Enemy user health 210") def test_fight_method_if_someone_is_dead(self): self.controller.add_player("Beginner", "Miro") self.controller.add_card("Trap", "Bombs") self.controller.add_card("Magic", "Beatup") self.controller.add_card("Trap", "BrutalKill") self.controller.add_player("Advanced", "Ivan") self.controller.add_card("Magic", "Nuclear") self.controller.add_card("Trap", "Flower") self.controller.add_card("Trap", "Napkin") self.controller.add_player_card("Miro", "Bombs") self.controller.add_player_card("Miro", "Beatup") self.controller.add_player_card("Miro", "BrutalKill") self.controller.add_player_card("Ivan", "Nuclear") self.controller.add_player_card("Ivan", "Flower") self.controller.add_player_card("Ivan", "Napkin") with self.assertRaises(ValueError): self.controller.fight("Miro", "Ivan")
def test_fight_card_damage_valid_data_should_work_correctly(self): controller = Controller() add_card1 = controller.add_card("Magic", "Spell") add_card2 = controller.add_card("Magic", "Spell2") add_player1 = controller.add_player("Advanced", "Dave") add_player2 = controller.add_player("Beginner", "John") add_player_card1 = controller.add_player_card("Dave", "Spell") add_player_card2 = controller.add_player_card("John", "Spell2") controller.fight("Dave", "John") self.assertEqual(controller.card_repository.cards[1].damage_points, 35) self.assertEqual( add_card1, "Successfully added card of type MagicCard with name: Spell") self.assertEqual( add_card2, "Successfully added card of type MagicCard with name: Spell2") self.assertEqual( add_player1, "Successfully added player of type Advanced with username: Dave") self.assertEqual( add_player2, "Successfully added player of type Beginner with username: John") self.assertEqual(add_player_card1, "Successfully added card: Spell to user: Dave") self.assertEqual(add_player_card2, "Successfully added card: Spell2 to user: John")
def test_fight(self): attacker = Advanced("Test1") enemy = Beginner("Test2") c = Controller() c.player_repository.add(attacker) c.player_repository.add(enemy) res = c.fight("Test1", "Test2") self.assertEqual(res, "Attack user health 250 - Enemy user health 90")
def test_fight_should_return_message(self): controller = Controller() controller.add_player("Advanced", "Peter") controller.add_player("Advanced", "George") controller.add_card("Trap", "Trap Card") controller.player_repository.find("Peter").card_repository.add( controller.card_repository.cards[0]) message = controller.fight("Peter", "George") self.assertEqual(message, "Attack user health 255 - Enemy user health 130")
def test_fight(self): ctrl = Controller() attacker = Advanced('p1') enemy = Advanced('p2') ac = MagicCard('card1') attacker.card_repository.add(ac) ec = MagicCard('card2') enemy.card_repository.add(ec) ctrl.player_repository.add(attacker) ctrl.player_repository.add(enemy) expected = "Attack user health 325 - Enemy user health 325" self.assertEqual(expected, ctrl.fight('p1', 'p2'))
class TestController(unittest.TestCase): def setUp(self): self.controller = Controller() def test_add_player(self): self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 0) res = self.controller.add_player("Beginner", "test") self.assertEqual(self.controller.player_repository.count, 1) self.assertEqual(self.controller.card_repository.count, 0) self.assertEqual( res, "Successfully added player of type Beginner with username: test") def test_add_card(self): self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 0) res = self.controller.add_card("Magic", "test") self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 1) self.assertEqual( res, "Successfully added card of type MagicCard with name: test") def test_add_player_card(self): self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 0) self.controller.add_card("Magic", "test") self.controller.add_player("Beginner", "test") self.assertEqual(self.controller.player_repository.count, 1) self.assertEqual(self.controller.card_repository.count, 1) res = self.controller.add_player_card("test", "test") self.assertEqual(res, "Successfully added card: test to user: test") def test_fight(self): self.controller.add_player("Beginner", "beginner") self.controller.add_player("Advanced", "advanced") res = self.controller.fight("advanced", "beginner") self.assertEqual(res, "Attack user health 250 - Enemy user health 90") def test_report(self): self.controller.add_player("Beginner", "beginner") self.controller.add_player("Advanced", "advanced") self.controller.add_card("Magic", "test") self.controller.add_player_card("beginner", "test") res = self.controller.report() # check = "Username: beginner - Health: 50 - Cards 1\n### Card: test - Damage: 5\nUsername: advanced - Health: 250 - Card 0\n" self.assertEqual( res, "Username: beginner - Health: 50 - Cards 1\n### Card: test - Damage: 5\nUsername: advanced - Health: 250 - Cards 0\n" )
class TestController(unittest.TestCase): def setUp(self): self.controller = Controller() def test_add_player(self): self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 0) res = self.controller.add_player('Beginner', 'test') self.assertEqual(self.controller.player_repository.count, 1) self.assertEqual(self.controller.card_repository.count, 0) self.assertEqual( res, 'Successfully added player of type Beginner with username: test') def test_add_card(self): self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 0) res = self.controller.add_card('Magic', 'test') self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 1) self.assertEqual( res, 'Successfully added card of type MagicCard with name: test') def test_add_player_card(self): self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.count, 0) self.controller.add_card('Magic', 'test') self.controller.add_player('Beginner', 'test') self.assertEqual(self.controller.player_repository.count, 1) self.assertEqual(self.controller.card_repository.count, 1) res = self.controller.add_player_card('test', 'test') self.assertEqual(res, "Successfully added card: test to user: test") def test_fight(self): self.controller.add_player('Beginner', 'beginner') self.controller.add_player('Advanced', 'advanced') res = self.controller.fight('advanced', 'beginner') self.assertEqual(res, "Attack user health 250 - Enemy user health 90") def test_report(self): self.controller.add_player('Beginner', 'beginner') self.controller.add_player('Advanced', 'advanced') self.controller.add_card('Magic', 'test') self.controller.add_player_card('beginner', 'test') res = self.controller.report() self.assertEqual( res, 'Username: beginner - Health: 50 - Cards 1\n### Card: test - Damage: 5\nUsername: advanced - Health: 250 - Cards 0\n' )
class TestController(unittest.TestCase): def setUp(self) -> None: self.ctrl = Controller() def test_init(self): self.assertEqual(0, self.ctrl.card_repository.count) self.assertEqual(0, self.ctrl.player_repository.count) self.assertEqual(0, len(self.ctrl.card_repository.cards)) self.assertEqual(0, len(self.ctrl.player_repository.players)) def test_add_player(self): res = self.ctrl.add_player('Beginner', 'name') self.assertEqual(1, self.ctrl.player_repository.count) self.assertEqual(1, len(self.ctrl.player_repository.players)) self.assertEqual("Successfully added player of type Beginner with username: name", res) def test_add_card(self): res = self.ctrl.add_card('Trap', 'name') self.assertEqual(1, self.ctrl.card_repository.count) self.assertEqual(1, len(self.ctrl.card_repository.cards)) self.assertEqual("Successfully added card of type TrapCard with name: name", res) def test_add_player_card(self): pl = Beginner('beg') crd = MagicCard('mc') self.ctrl.player_repository.add(pl) self.ctrl.card_repository.add(crd) res = self.ctrl.add_player_card('beg', 'mc') self.assertEqual("Successfully added card: mc to user: beg", res) def test_fight(self): pl1 = Beginner('beg1') pl2 = Beginner('beg2') self.ctrl.player_repository.add(pl1) self.ctrl.player_repository.add(pl2) battlefield = BattleField() battlefield.fight(pl1, pl2) res = self.ctrl.fight('beg1', 'beg2') self.assertEqual('Attack user health 130 - Enemy user health 130', res) def test_report(self): pl = Beginner('test') c = MagicCard('name') self.ctrl.card_repository.add(c) self.ctrl.player_repository.add(pl) self.ctrl.add_player_card('test', 'name') expected = 'Username: test - Health: 50 - Cards 1\n### Card: name - Damage: 5\n' self.assertEqual(expected, self.ctrl.report())
def test_fight_valid_data_should_work_correctly(self): controller = Controller() controller.add_card("Magic", "Spell") controller.add_card("Magic", "Spell2") controller.add_player("Advanced", "Dave") controller.add_player("Advanced", "John") controller.add_player_card("Dave", "Spell") controller.add_player_card("John", "Spell2") result = controller.fight("Dave", "John") self.assertEqual(result, "Attack user health 325 - Enemy user health 325")
class TestController(unittest.TestCase): def setUp(self): self.controller = Controller() self.beginner = Beginner('Noob') self.advanced = Advanced('Pro') self.magic_card = MagicCard('Magic') self.trap_card = TrapCard('Trap') def test_initialization_should_return_correct_attributes(self): self.assertEqual(self.controller.player_repository.__class__.__name__, "PlayerRepository") self.assertEqual(self.controller.card_repository.__class__.__name__, "CardRepository") def test_add_player_should_add_player_to_the_player_repository(self): self.assertEqual( self.controller.add_player('Advanced', 'Pro'), "Successfully added player of type Advanced with username: Pro") self.assertEqual(self.controller.player_repository.count, 1) def test_add_card_should_add_card_to_the_card_repository(self): self.assertEqual( self.controller.add_card('TrapCard', 'Trap'), "Successfully added card of type TrapCardCard with name: Trap") self.assertEqual(self.controller.card_repository.count, 1) def test_add_player_card_should_add_card_in_players_repository(self): self.controller.add_player('Beginner', 'Noob') self.controller.add_card('MagicCard', 'Magic') self.assertEqual(self.controller.add_player_card('Noob', 'Magic'), 'Successfully added card: Magic to user: Noob') def test_fight_should_make_both_players_fight(self): self.controller.add_player('Advanced', 'Pro1') self.controller.add_player('Advanced', 'Pro2') self.assertEqual(self.controller.fight('Pro1', 'Pro2'), 'Attack user health 250 - Enemy user health 250') def test_report_should_return_correctly_the_result(self): self.controller.add_player('Beginner', 'Noob') self.controller.add_card('MagicCard', 'Magic') self.assertEqual(self.controller.report(), 'Username: Noob - Health: 50 - Cards 0\n')
class TestController(unittest.TestCase): def setUp(self): self.ctrl = Controller() def test_init(self): self.assertTrue(isinstance(self.ctrl.player_repository, PlayerRepository)) self.assertTrue(isinstance(self.ctrl.card_repository, CardRepository)) def test_add_player(self): expected = self.ctrl.add_player('Beginner', 'testname') self.assertEqual(1, len(self.ctrl.player_repository.players)) self.assertEqual(expected, "Successfully added player of type Beginner with username: testname") def test_add_card(self): expected = self.ctrl.add_card('Trap', 'testname') self.assertEqual(1, len(self.ctrl.card_repository.cards)) self.assertEqual(expected, "Successfully added card of type TrapCard with name: testname") def test_add_player_card(self): card = MagicCard('test') player = Beginner('name') self.ctrl.card_repository.add(card) self.ctrl.player_repository.add(player) expected = self.ctrl.add_player_card('name', 'test') self.assertEqual(expected, "Successfully added card: test to user: name") def test_fight(self): attacker = Advanced('p1') enemy = Advanced('p2') ac = MagicCard('card1') attacker.card_repository.add(ac) ec = MagicCard('card2') enemy.card_repository.add(ec) self.ctrl.player_repository.add(attacker) self.ctrl.player_repository.add(enemy) expected = "Attack user health 325 - Enemy user health 325" self.assertEqual(expected, self.ctrl.fight('p1', 'p2')) def test_report(self): self.ctrl.add_player('Beginner', 'name') self.ctrl.add_card('Magic', 'cardname') self.ctrl.add_player_card('name', 'cardname') expected = f'Username: name - Health: 50 - Cards 1\n### Card: cardname - Damage: 5\n' res = self.ctrl.report() self.assertEqual(expected, res)
class TEstController(unittest.TestCase): def setUp(self): self.controller = Controller() self.player = Advanced("Pesho") self.card = MagicCard("Magic") def test__init(self): self.assertIsInstance(self.controller.player_repository, PlayerRepository) self.assertIsInstance(self.controller.card_repository, CardRepository) def test__add_player__return_msg(self): self.assertEqual( self.controller.add_player("Beginner", "Ivan"), "Successfully added player of type Beginner with username: Ivan") def test__add_card_return_msg(self): self.assertEqual( self.controller.add_card("Magic", "Magic"), "Successfully added card of type MagicCard with name: Magic") def test__add_player_card_return_msg(self): # self.player.card_repository.add(self.card) self.controller.player_repository.add(self.player) self.controller.card_repository.add(self.card) self.assertEqual(self.controller.add_player_card("Pesho", "Magic"), "Successfully added card: Magic to user: Pesho") def test__fight__return_msg(self): player2 = Advanced("Ivan") self.controller.player_repository.add(player2) self.controller.player_repository.add(self.player) self.assertEqual( self.controller.fight("Pesho", "Ivan"), f"Attack user health {self.player.health} - Enemy user health {player2.health}" ) def test__report__return_msg(self): self.player.card_repository.add(self.card) self.controller.player_repository.add(self.player) self.assertEqual( self.controller.report(), f"Username: Pesho - Health: 250 - Cards 1\n### Card: Magic - Damage: 5\n" )
def test_fight_two_valid_data_should_work_correctly(self): controller = Controller() controller.add_card("Magic", "Spell") controller.add_card("Trap", "Spell2") controller.add_player("Advanced", "Dave") controller.add_player("Advanced", "John") controller.add_player_card("Dave", "Spell") controller.add_player_card("John", "Spell2") result = controller.fight("Dave", "John") with self.assertRaises(Exception): controller.add_card("Labala", "Magic") controller.add_player("Labala2", "Spell") controller.add_player_card("Labala2", "Spell") self.assertEqual(result, "Attack user health 210 - Enemy user health 250")
class TestControllers(unittest.TestCase): def setUp(self): self.c = Controller() def test_proper_initialization(self): self.assertEqual("PlayerRepository", self.c.player_repository.__class__.__name__) self.assertEqual("CardRepository", self.c.card_repository.__class__.__name__) def test_add_player_method(self): self.assertEqual( "Successfully added player of type Beginner with username: nameBeginner", self.c.add_player("Beginner", 'nameBeginner')) def test_add_card_method(self): self.assertEqual( "Successfully added card of type MagicCard with name: magicName", self.c.add_card("Magic", 'magicName')) def test_add_player_card(self): self.c.add_player("Beginner", 'nameBeginner') self.c.add_card("Magic", 'magicName') self.assertEqual( "Successfully added card: magicName to user: nameBeginner", self.c.add_player_card('nameBeginner', 'magicName')) def test_fight_method(self): self.c.add_player("Beginner", 'nameBeginner') self.c.add_player("Advanced", 'nameAdvanced') self.assertEqual("Attack user health 90 - Enemy user health 250", self.c.fight('nameBeginner', 'nameAdvanced')) def test_report_method(self): self.c.add_player("Beginner", 'nameBeginner') self.assertEqual("Username: nameBeginner - Health: 50 - Cards 0\n", self.c.report())
class TestController(TestCase): def setUp(self): self.controller = Controller() self.player1 = Beginner("Bushido") self.player2 = Beginner("Johny") self.player1.card_repository.cards = [ MagicCard("Some magic card"), TrapCard("Some trap card"), MagicCard("Some magic card"), TrapCard("Some trap card"), MagicCard("Some magic card"), TrapCard("Some trap card") ] self.player2.card_repository.cards = [ MagicCard("Some magic card"), TrapCard("Some trap card"), MagicCard("Some magic card"), TrapCard("Some trap card") ] def test_init(self): self.assertEqual([], self.controller.player_repository.players) self.assertEqual([], self.controller.card_repository.cards) def test_add_beginner_player(self): self.assertEqual([], self.controller.player_repository.players) result = self.controller.add_player("Beginner", "Bushido") self.assertEqual("Bushido", self.controller.player_repository.players[0].username) self.assertEqual( "Beginner", type(self.controller.player_repository.players[0]).__name__) self.assertEqual( f"Successfully added player of type Beginner with username: Bushido", result) def test_add_advanced_player(self): self.assertEqual([], self.controller.player_repository.players) result = self.controller.add_player("Advanced", "Bushido") self.assertEqual("Bushido", self.controller.player_repository.players[0].username) self.assertEqual( "Advanced", type(self.controller.player_repository.players[0]).__name__) self.assertEqual( f"Successfully added player of type Advanced with username: Bushido", result) def test_add_card_magic(self): self.assertEqual([], self.controller.card_repository.cards) result = self.controller.add_card("Magic", "Exodia") self.assertEqual("Exodia", self.controller.card_repository.cards[0].name) self.assertEqual( "MagicCard", type(self.controller.card_repository.cards[0]).__name__) self.assertEqual( f"Successfully added card of type MagicCard with name: Exodia", result) def test_add_card_trap(self): self.assertEqual([], self.controller.card_repository.cards) result = self.controller.add_card("Trap", "Exodia") self.assertEqual("Exodia", self.controller.card_repository.cards[0].name) self.assertEqual( "TrapCard", type(self.controller.card_repository.cards[0]).__name__) self.assertEqual( f"Successfully added card of type TrapCard with name: Exodia", result) def test_add_player_card(self): self.controller.player_repository.players = [ Advanced("Bushido"), Beginner("Johny") ] player = [ p for p in self.controller.player_repository.players if p.username == "Johny" ][0] self.controller.card_repository.cards = [MagicCard("Exodia")] result = self.controller.add_player_card("Johny", "Exodia") self.assertEqual("Exodia", player.card_repository.cards[0].name) self.assertEqual(f"Successfully added card: Exodia to user: Johny", result) def test_fight(self): player1 = Beginner("Bushido") player2 = Beginner("Johny") player1.card_repository.cards = [ MagicCard("Some magic card"), TrapCard("Some trap card"), MagicCard("Some magic card"), TrapCard("Some trap card"), MagicCard("Some magic card"), TrapCard("Some trap card") ] player2.card_repository.cards = [ MagicCard("Some magic card"), TrapCard("Some trap card"), MagicCard("Some magic card"), TrapCard("Some trap card") ] self.controller.player_repository.players.append(player1) self.controller.player_repository.players.append(player2) result = self.controller.fight("Bushido", "Johny") self.assertEqual(f"Attack user health 215 - Enemy user health 0", result)
class TestController(unittest.TestCase): def setUp(self): self.controller = Controller() def test_controller_init_methof(self): self.assertEqual(self.controller.player_repository.__class__.__name__, 'PlayerRepository') self.assertEqual(self.controller.card_repository.__class__.__name__, 'CardRepository') def test_controller_add_method_when_beginner_passed(self): self.controller.add_player('Beginner', 'Mitko') self.assertEqual(self.controller.player_repository.players[0].username, 'Mitko') self.assertEqual(self.controller.player_repository.count, 1) def test_controller_add_method_when_beginner_passed_should_return(self): result = self.controller.add_player('Beginner', 'Mitko') expected_result = 'Successfully added player of type Beginner with username: Mitko' self.assertEqual(result, expected_result) def test_controller_add_method_when_advanced_passed_should_return(self): result = self.controller.add_player('Advanced', 'Mitko') expected_result = 'Successfully added player of type Advanced with username: Mitko' self.assertEqual(result, expected_result) def test_controller_add_card_method_when_magic_card_added(self): self.controller.add_card('Magic', 'Magic Card') self.assertEqual(self.controller.card_repository.cards[0].name, 'Magic Card') self.assertEqual(self.controller.card_repository.count, 1) def test_controller_add_card_method_when_magic_card_added_should_return( self): result = self.controller.add_card('Magic', 'Magic Card') expected_result = 'Successfully added card of type MagicCard with name: Magic Card' self.assertEqual(result, expected_result) def test_controller_add_card_method_when_trap_card_added_should_return( self): result = self.controller.add_card('Trap', 'Trap Card') expected_result = 'Successfully added card of type TrapCard with name: Trap Card' self.assertEqual(result, expected_result) def test_controller_add_player_card_method(self): mc = MagicCard('Magic') pl = Advanced('Mitko') self.controller.player_repository.add(pl) self.controller.card_repository.add(mc) result = self.controller.add_player_card('Mitko', 'Magic') expected_result = 'Successfully added card: Magic to user: Mitko' self.assertEqual(result, expected_result) def test_controller_fight_method(self): pl = Advanced('Mitko') en = Beginner('Mitko Enemy') self.controller.player_repository.add(pl) self.controller.player_repository.add(en) result = self.controller.fight('Mitko', 'Mitko Enemy') expected_result = f'Attack user health 90 - Enemy user health 250' self.assertEqual(result, expected_result) def test_controller_report_method(self): result = self.controller.report() expected_result = '' self.assertEqual(result, expected_result)
class TestBattleField(unittest.TestCase): def initialize_players_with_cards(self) -> None: self.controller.add_player('Beginner', 'John') self.controller.add_player('Advanced', 'Mike') self.controller.add_card('Magic', 'MagicCard1') self.controller.add_card('Magic', 'MagicCard2') self.controller.add_card('Trap', 'TrapCard1') self.controller.add_card('Trap', 'TrapCard2') self.controller.add_player_card('John', 'MagicCard1') self.controller.add_player_card('John', 'TrapCard1') self.controller.add_player_card('Mike', 'MagicCard2') self.controller.add_player_card('Mike', 'TrapCard2') def setUp(self) -> None: self.controller = Controller() def test_init_attrs_set(self) -> None: self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.player_repository.players, []) self.assertEqual(self.controller.card_repository.count, 0) self.assertEqual(self.controller.card_repository.cards, []) def test_add_beginner_player(self) -> None: msg = self.controller.add_player('Beginner', 'John') self.assertEqual( msg, 'Successfully added player of type Beginner with username: John') self.assertEqual(self.controller.player_repository.count, 1) self.assertEqual(self.controller.player_repository.players[0].username, 'John') self.assertTrue( isinstance(self.controller.player_repository.players[0], Beginner)) def test_add_advanced_player(self) -> None: msg = self.controller.add_player('Advanced', 'John') self.assertEqual( msg, 'Successfully added player of type Advanced with username: John') self.assertEqual(self.controller.player_repository.players[0].username, 'John') self.assertTrue( isinstance(self.controller.player_repository.players[0], Advanced)) def test_add_card_magic(self) -> None: msg = self.controller.add_card('Magic', 'Card') self.assertEqual( msg, 'Successfully added card of type MagicCard with name: Card') self.assertEqual(self.controller.card_repository.count, 1) self.assertEqual(self.controller.card_repository.cards[0].name, 'Card') self.assertTrue( isinstance(self.controller.card_repository.cards[0], MagicCard)) def test_add_card_trap(self) -> None: msg = self.controller.add_card('Trap', 'Card') self.assertEqual( msg, 'Successfully added card of type TrapCard with name: Card') self.assertEqual(self.controller.card_repository.count, 1) self.assertEqual(self.controller.card_repository.cards[0].name, 'Card') self.assertTrue( isinstance(self.controller.card_repository.cards[0], TrapCard)) def test_add_player_card(self) -> None: self.controller.add_card('Magic', 'Card') self.controller.add_player('Beginner', 'John') msg = self.controller.add_player_card('John', 'Card') self.assertEqual(msg, 'Successfully added card: Card to user: John') self.assertEqual( self.controller.player_repository.find( 'John').card_repository.count, 1) self.assertEqual( self.controller.player_repository.find( 'John').card_repository.cards[0].name, 'Card') self.assertTrue( isinstance( self.controller.player_repository.find( 'John').card_repository.cards[0], MagicCard)) def test_fight_method(self) -> None: self.initialize_players_with_cards() msg = self.controller.fight('John', 'Mike') self.assertEqual(msg, 'Attack user health 50 - Enemy user health 150') def test_report_method(self) -> None: self.initialize_players_with_cards() self.assertEqual( self.controller.report(), 'Username: John - Health: 50 - Cards 2\n### Card: MagicCard1 - Damage: 5\n### Card: TrapCard1 - Damage: 120\nUsername: Mike - Health: 250 - Cards 2\n### Card: MagicCard2 - Damage: 5\n### Card: TrapCard2 - Damage: 120\n' )
class ControllerTests(unittest.TestCase): def setUp(self): self.controller = Controller() def test_init__expect_attributes_to_be_set(self): self.assertEqual([], self.controller.player_repository.players) self.assertEqual(0, self.controller.player_repository.count) self.assertEqual([], self.controller.card_repository.cards) self.assertEqual(0, self.controller.card_repository.count) def test_add_player__expect_to_create_and_add_player_of_given_type_and_name_and_return_msg( self): expected_msg = "Successfully added player of type Advanced with username: frodo" actual_msg = self.controller.add_player("Advanced", "frodo") self.assertEqual(1, self.controller.player_repository.count) self.assertEqual(expected_msg, actual_msg) def test_add_card__expect_to_create_and_add_card_of_given_type_and_name_and_return_msg( self): expected_msg = "Successfully added card of type MagicCard with name: magic" actual_msg = self.controller.add_card("Magic", "magic") self.assertEqual(1, self.controller.card_repository.count) self.assertEqual(expected_msg, actual_msg) def test_add_player_card__expect_to_add_card_object_to_player_object(self): self.controller.add_player("Advanced", "frodo") self.controller.add_card("Magic", "magic") expected_msg = "Successfully added card: magic to user: frodo" actual_msg = self.controller.add_player_card("frodo", "magic") self.assertEqual( 1, self.controller.player_repository.players[0].card_repository.count) self.assertEqual(expected_msg, actual_msg) def test_fight(self): self.controller.add_player("Advanced", "Aragorn") self.controller.add_card("Trap", "sword") self.controller.add_player_card("Aragorn", "sword") self.controller.add_player("Beginner", "Orc") self.controller.add_card("Trap", "axe") self.controller.add_player_card("Orc", "axe") expected_msg = "Attack user health 255 - Enemy user health 0" actual_msg = self.controller.fight("Aragorn", "Orc") self.assertEqual(expected_msg, actual_msg) def test_report__expect_info_for_players_and_their_cards_as_string(self): self.controller.add_player("Advanced", "frodo") self.controller.add_card("Magic", "magic") self.controller.add_player_card("frodo", "magic") self.controller.add_player("Beginner", "sam") self.controller.add_card("Trap", "trap") self.controller.add_player_card("sam", "trap") expected_msg = "Username: frodo - Health: 250 - Cards 1\n### Card: magic - Damage: 5\n" \ "Username: sam - Health: 50 - Cards 1\n### Card: trap - Damage: 120" actual_msg = self.controller.report() self.assertEqual(expected_msg, actual_msg)
class TestController(unittest.TestCase): def setUp(self) -> None: self.c = Controller() def test_all_setup_corect(self): self.assertEqual(self.c.player_repository.__class__.__name__, 'PlayerRepository') self.assertEqual(self.c.card_repository.__class__.__name__, 'CardRepository') def test_add_player(self): actual = self.c.add_player('Beginner', 'Borko') self.assertEqual( actual, "Successfully added player of type Beginner with username: Borko") self.assertEqual(self.c.player_repository.players[0].username, 'Borko') advanced_player = self.c.add_player("Advanced", 'Ad') self.assertEqual( advanced_player, "Successfully added player of type Advanced with username: Ad") self.assertEqual(self.c.player_repository.players[1].username, 'Ad') self.assertEqual(len(self.c.player_repository.players), 2) def test_add_card(self): magic_card = self.c.add_card('Magic', 'M') self.assertEqual(magic_card, "Successfully added card of type Magic with name: M") self.assertEqual(len(self.c.card_repository.cards), 1) self.assertEqual(self.c.card_repository.cards[0].name, 'M') trap_card = self.c.add_card('TrapCard', 'T') self.assertEqual( trap_card, "Successfully added card of type TrapCard with name: T") self.assertEqual(len(self.c.card_repository.cards), 2) self.assertEqual(self.c.card_repository.cards[1].name, 'T') self.assertEqual(self.c.card_repository.count, 1) def test_add_player_card(self): self.c.add_player('Beginner', 'B') self.c.add_card('TrapCard', 'T') actual = self.c.add_player_card('B', 'T') self.assertEqual(actual, "Successfully added card: T to user: B") self.assertEqual( len(self.c.player_repository.players[0].card_repository.cards), 1) def test_find(self): self.c.add_player('Advanced', 'A1') self.c.add_player('Advanced', 'A2') actual = self.c.fight('A1', 'A2') self.assertEqual(actual, 'Attack user health 250 - Enemy user health 250') def test_report(self): self.c.add_player('Advanced', 'A1') card = MagicCard('M') self.c.player_repository.players[0].card_repository.add(card) actual = self.c.report() self.assertEqual( actual, "Username: A1 - Health: 250 - Cards 1\n### Card: M - Damage: 5\n")
class TestController(unittest.TestCase): def setUp(self): self.controller = Controller() def test_attributes(self): self.assertEqual('PlayerRepository', self.controller.player_repository.__class__.__name__) self.assertEqual('CardRepository', self.controller.card_repository.__class__.__name__) def test_add_player__when_player_is_beginner__expect_to_add_it(self): type_p = 'Beginner' username = '******' expect = 'Successfully added player of type Beginner with username: Pesho' self.assertEqual(expect, self.controller.add_player(type_p, username)) self.assertEqual(1, len(self.controller.player_repository.players)) def test_add_player__when_player_is_advanced__expect_to_add_it(self): type_p = 'Advanced' username = '******' expect = 'Successfully added player of type Advanced with username: Gosho' self.assertEqual(expect, self.controller.add_player(type_p, username)) self.assertEqual(1, len(self.controller.player_repository.players)) def test_add_card__when_card_is_trap__expect_to_add_it(self): type_c = 'Trap' name = 'Dark Hole' expect = 'Successfully added card of type TrapCard with name: Dark Hole' self.assertEqual(expect, self.controller.add_card(type_c, name)) self.assertEqual(1, len(self.controller.card_repository.cards)) def test_add_card__when_card_is_magic__expect_to_add_it(self): type_c = 'Magic' name = 'Monster reborn' expect = 'Successfully added card of type MagicCard with name: Monster reborn' self.assertEqual(expect, self.controller.add_card(type_c, name)) self.assertEqual(1, len(self.controller.card_repository.cards)) def test_add_player_card__expect_to_add_it(self): username = '******' self.controller.add_player('Advanced', username) card_name = 'Monster reborn' self.controller.add_card('Magic', card_name) player = self.controller.player_repository.find(username) card = self.controller.card_repository.find(card_name) expect = 'Successfully added card: Monster reborn to user: Pesho' self.assertEqual(expect, self.controller.add_player_card(username, card_name)) self.assertEqual(1, len(player.card_repository.cards)) def test_fight__expect_to_return_attacker_and_enemy_healths(self): attack_name = 'Pesho' self.controller.add_player('Advanced', attack_name) enemy_name = 'Gosho' self.controller.add_player('Advanced', enemy_name) actual = self.controller.fight(attack_name, enemy_name) expect = 'Attack user health 250 - Enemy user health 250' self.assertEqual(expect, actual) def test_report__expect_to_return_it(self): type_p = 'Beginner' username = '******' self.controller.add_player(type_p, username) type_c = 'Trap' name = 'Dark Hole' self.controller.add_card(type_c, name) self.controller.add_player_card(username, name) type_c = 'Magic' name = 'Monster reborn' self.controller.add_card(type_c, name) self.controller.add_player_card(username, name) expect = 'Username: Pesho - Health: 50 - ' \ 'Cards 2\n' \ '### Card: Dark Hole - Damage: 120\n' \ '### Card: Monster reborn - Damage: 5\n' actual = self.controller.report() self.assertEqual(expect, actual)
class TestController(unittest.TestCase): def setUp(self): self.new_controller = Controller() self.beginner_player = Beginner("KOZA_BEGINNER") self.advanced_player = Advanced("KOZA_ADVANCED") self.magic_card = MagicCard("KOZA_MAGIC") self.trap_card = TrapCard("KOZA_TRAP") def test_init(self): self.assertEqual( self.new_controller.player_repository.__class__.__name__, "PlayerRepository") self.assertEqual( self.new_controller.card_repository.__class__.__name__, "CardRepository") self.assertEqual(self.new_controller.player_repository.count, 0) self.assertEqual(self.new_controller.card_repository.count, 0) self.assertEqual(self.new_controller.player_repository.players, []) self.assertEqual(self.new_controller.card_repository.cards, []) def test_add_player_beginner(self): actual_result = self.new_controller.add_player(type="Beginner", username="******") expected_result = "Successfully added player of type Beginner with username: PESHO" self.assertEqual(actual_result, expected_result) self.assertEqual( self.new_controller.player_repository.find("PESHO").username, "PESHO") self.assertEqual( type(self.new_controller.player_repository.find("PESHO")).__name__, "Beginner") def test_add_player_advanced(self): actual_result = self.new_controller.add_player(type="Advanced", username="******") expected_result = "Successfully added player of type Advanced with username: GOSHO" self.assertEqual(actual_result, expected_result) self.assertEqual( self.new_controller.player_repository.find("GOSHO").username, "GOSHO") self.assertEqual( type(self.new_controller.player_repository.find("GOSHO")).__name__, "Advanced") def test_add_card_magic(self): actual_result = self.new_controller.add_card(type="Magic", name="KOZA_MAGIC") expected_result = "Successfully added card of type MagicCard with name: KOZA_MAGIC" self.assertEqual(actual_result, expected_result) self.assertEqual( self.new_controller.card_repository.find("KOZA_MAGIC").name, "KOZA_MAGIC") self.assertEqual( type(self.new_controller.card_repository.find( "KOZA_MAGIC")).__name__, "MagicCard") def test_add_card_trap(self): actual_result = self.new_controller.add_card(type="Trap", name="KOZA_TRAP") expected_result = "Successfully added card of type TrapCard with name: KOZA_TRAP" self.assertEqual(actual_result, expected_result) self.assertEqual( self.new_controller.card_repository.find("KOZA_TRAP").name, "KOZA_TRAP") self.assertEqual( type(self.new_controller.card_repository.find( "KOZA_TRAP")).__name__, "TrapCard") def test_add_player_card(self): self.new_controller.add_card(type="Trap", name="KOZA_TRAP") self.new_controller.add_player(type="Advanced", username="******") actual_result = self.new_controller.add_player_card( username="******", card_name="KOZA_TRAP") expected_result = "Successfully added card: KOZA_TRAP to user: GOSHO" actual_card = self.new_controller.player_repository.find( "GOSHO").card_repository.find("KOZA_TRAP") self.assertEqual(actual_card.name, "KOZA_TRAP") self.assertEqual(actual_result, expected_result) def test_fight(self): self.new_controller.add_player("Beginner", "PESHO") self.new_controller.add_player("Advanced", "GOSHO") self.new_controller.add_card("Trap", "KOZA_TRAP") self.new_controller.add_player_card("PESHO", "KOZA_TRAP") actual_result = self.new_controller.fight("PESHO", "GOSHO") expected_result = "Attack user health 95 - Enemy user health 100" self.assertEqual(actual_result, expected_result) def test_report(self): self.new_controller.add_card(type="Magic", name="KOZA_MAGIC") self.new_controller.add_player(type="Beginner", username="******") self.new_controller.add_player_card(username="******", card_name="KOZA_MAGIC") self.new_controller.add_card(type="Trap", name="KOZA_TRAP") self.new_controller.add_player(type="Advanced", username="******") self.new_controller.add_player_card(username="******", card_name="KOZA_TRAP") actual_result = self.new_controller.report() expected_result = f"Username: PESHO - Health: 50 - Cards 1\n### Card: KOZA_MAGIC - Damage: 5\nUsername: GOSHO - Health: 250 - Cards 1\n### Card: KOZA_TRAP - Damage: 120\n" self.assertEqual(actual_result, expected_result)
class TestController(unittest.TestCase): def setUp(self): self.controller = Controller() def test__init__(self): self.assertEqual(self.controller.player_repository.players, []) self.assertEqual(self.controller.player_repository.count, 0) self.assertEqual(self.controller.card_repository.cards, []) self.assertEqual(self.controller.card_repository.count, 0) def test_add_player_beginner(self): result = self.controller.add_player("Beginner", "Miro") self.assertEqual( result, f"Successfully added player of type Beginner with username: Miro") self.assertEqual(self.controller.player_repository.count, 1) def test_add_player_advanced(self): result = self.controller.add_player("Advanced", "Miro") self.assertEqual( result, f"Successfully added player of type Advanced with username: Miro") self.assertEqual(self.controller.player_repository.count, 1) def test_add_card_magic(self): result = self.controller.add_card("Magic", "Kill") self.assertEqual( result, f"Successfully added card of type MagicCard with name: Kill") self.assertEqual(self.controller.card_repository.count, 1) def test_trap_card(self): result = self.controller.add_card("Trap", "Bombs") self.assertEqual( result, f"Successfully added card of type TrapCard with name: Bombs") self.assertEqual(self.controller.card_repository.count, 1) def test_add_player_card_success(self): # player = Advanced("Miro") # card = TrapCard("Bombs") self.controller.add_player("Advanced", "Miro") self.controller.add_card("Trap", "Bombs") self.assertEqual(self.controller.add_player_card("Miro", "Bombs"), f"Successfully added card: Bombs to user: Miro") def test_add_player_not_success(self): self.controller.add_player("Advanced", "Miro") self.controller.add_card("Trap", "Bombs") self.assertEqual(self.controller.add_player_card("Spiro", "Trap"), None) def test_fight_success(self): self.controller.add_player("Advanced", "Miro") self.controller.add_card("Trap", "Bombs") self.controller.add_player("Advanced", "Ivan") self.controller.add_card("Magic", "Nuclear") self.controller.add_player_card("Miro", "Bombs") self.controller.add_player_card("Ivan", "Nuclear") msg = f"Attack user health 250 - Enemy user health 210" self.assertEqual(self.controller.fight("Miro", "Ivan"), msg) # with self.assertRaises(ValueError) as exc: # self.assertEqual(str(exc.exception), msg) def test_fight_not_success(self): self.controller.add_player("Advanced", "Miro") self.controller.add_card("Trap", "Bombs") self.controller.add_player("Advanced", "Ivan") self.controller.add_card("Magic", "Nuclear") self.controller.add_player_card("Miro", "Bombs") self.assertEqual(self.controller.fight("Miro", "Pesho"), None) def test_report(self): self.controller.add_player("Advanced", "Miro") self.controller.add_player("Advanced", "Ivan") self.controller.add_card("Trap", "Bombs") self.controller.add_card("Magic", "Nuclear") self.controller.add_card("Magic", "Boom") self.controller.add_player_card("Miro", "Bombs") self.controller.add_player_card("Miro", "Boom") self.controller.add_player_card("Ivan", "Nuclear") result = f"Username: Miro - Health: 250 - Cards 2" + '\n' result += f"### Card: Bombs - Damage: 120" + '\n' result += f"### Card: Boom - Damage: 5" + '\n' result += f"Username: Ivan - Health: 250 - Cards 1" + '\n' result += f"### Card: Nuclear - Damage: 5" + '\n' self.assertEqual(self.controller.report(), result)