def test_report(self): ctrl = Controller() p = Beginner('pname') c = TrapCard('cname') p.card_repository.add(c) ctrl.player_repository.add(p) expected = f'Username: pname - Health: 50 - Cards 1\n' \ f'### Card: cname - Damage: 120\n' res = ctrl.report() self.assertEqual(res, expected)
def test_report(self): attacker = Advanced("Test1") enemy = Beginner("Test2") c = Controller() c.player_repository.add(attacker) c.player_repository.add(enemy) res = c.report() self.assertEqual( res, "Username: Test1 - Health: 250 - Cards 0\nUsername: Test2 - Health: 50 - Cards 0\n" )
def test_report_returns_correct_str(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]) self.assertEqual( controller.report(), "Username: Peter - Health: 250 - Cards 1\n### Card: Trap Card - Damage: 120\nUsername: George - 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() # 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_report_valid_data_should_work_correctly(self): controller = Controller() controller.add_card("Magic", "Magic") controller.add_card("Magic", "Magic2") controller.add_player("Advanced", "Dave") controller.add_player("Advanced", "John") controller.add_player_card("Dave", "Magic") controller.add_player_card("John", "Magic2") self.assertEqual( controller.report(), "Username: Dave - Health: 250 - Cards 1\n### Card: Magic - Damage: 5\nUsername: John - Health: 250 - Cards 1\n### Card: Magic2 - Damage: 5\n" )
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" )
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(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)
print(de.remove(Plant())) print(len(de.decorations)) print(de.find_by_type("Plant")) print(de.find_by_type("Ornament")) print(co.add_decoration("Plant")) print(co.add_decoration("Ornament")) print(co.add_decoration("Ornamentdas")) print(len(co.decorations_repository.decorations)) print(len(s.decorations)) print(co.insert_decoration("SaltAQ", "Plantаааааа")) print(co.decorations_repository.decorations) print(len(s.decorations)) print(len(s.fish)) print(co.feed_fish("SaltAQ")) print(co.calculate_value("SaltAQ")) print(co.report()) print(s.add_fish(fish2)) print(s.add_fish(fish2)) print(s.add_fish(fish3)) print(s.add_fish(fish3)) print(s.add_fish(fish3)) s.remove_fish(fish3) print(len(s.fish)) s.add_decoration(decor1) s.add_decoration(decor1) s.add_decoration(decor2) s.add_decoration(decor2) print(co.feed_fish("SaltAQ")) print(co.calculate_value("SaltAQ"))
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)
from project.controller import Controller from project.decoration.decoration_repository import DecorationRepository controller = Controller() print(controller.add_aquarium('FreshwaterAquarium', 'a')) print(controller.add_aquarium('SaltwaterAquarium', 'b')) print(controller.add_fish('b', 'FreshwaterFish', 'brr', 'brr2', 10)) print(controller.add_fish('b', 'SaltwaterFish', 'brr', 'brr2', 10)) print(controller.add_decoration('Plant')) print(controller.add_decoration('Ornament')) print(controller.add_decoration('adasda')) print(controller.feed_fish('a')) print(controller.report()) print(controller.calculate_value('b')) print(controller.insert_decoration('a', 'Plant')) print(controller.insert_decoration('a', 'Plant')) print(controller.insert_decoration('a', 'Ornament'))
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")
from project.controller import Controller from project.decoration.plant import Plant a = Controller() print(a.add_aquarium("SaltwaterAquarium", "Underworld")) print(a.add_aquarium("FreshwaterAquarium", "Swamp")) print(a.add_fish("Underworld", "FreshwaterFish", "Nemo", "Clownfish", 13.40)) print(a.add_fish("Underworld", "SaltwaterFish", "Nemo", "Clownfish", 13.40)) print(a.add_aquarium("FreshwaterAquarium", "Riverworld")) print(a.add_fish("Riverworld", "FreshwaterFish", "Emerald", "Catfish", 7.32)) print(a.add_fish("Underworld", "SweetwaterFish", "Diamond", "Catfish", 3.50)) print(a.add_decoration("Plant")) print(a.insert_decoration("Riverworld", "Plant")) print(a.insert_decoration("Underworld", "Plant")) print(a.add_decoration("Plant")) print(a.add_decoration("Plant")) print(a.insert_decoration("Underworld", "Plant")) print(a.insert_decoration("Underworld", "Plant")) print(a.feed_fish("Riverworld")) print(a.feed_fish("Underworld")) print(a.calculate_value("Riverworld")) print(a.add_fish("Riverworld", "FreshwaterFish", "", "Species", 20)) print(a.add_fish("Riverworld", "FreshwaterFish", "Name", "", 20)) print(a.add_fish("Riverworld", "FreshwaterFish", "Name", "Species", -10)) print(a.report())
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)
print(controller_one.insert_decoration("FreshPrinceAquarium", "KraKra")) controller_one.insert_decoration("FreshPrinceAquarium", "Plant") print(controller_one.insert_decoration("FreshPrinceAquarium", "Plant")) print( controller_one.add_fish("FreshPrinceAquarium", "Freshwater", "Jelly", "Name", 4.44)) print( controller_one.add_fish("FreshPrinceAquarium", "SaltwaterFish", "Jellyfish", "FreshName", 4.44)) print( controller_one.add_fish("FreshPrinceAquarium", "FreshwaterFish", "Shark", "Samantha", 23.0)) print( controller_one.add_fish("FreshPrinceAquarium", "FreshwaterFish", "Tuna", "Shits", 6.0)) print( controller_one.add_fish("FreshPrinceAquarium", "FreshwaterFish", "Sloppy", "Manic", 6.0)) print(controller_one.feed_fish("FreshPrinceAquarium")) print(controller_one.calculate_value("FreshPrinceAquarium")) print(controller_one.report()) print(controller_one.calculate_value("SomeTypeofAquarium")) controller_one.add_decoration("Ornament") controller_one.add_decoration("Plant") print( controller_one.add_fish("SaltBaeAquarium", "SaltwaterFish", "Jellyfish", "FreshName", 4.44)) controller_one.insert_decoration("SaltBaeAquarium", "Plant") controller_one.insert_decoration("SaltBaeAquarium", "Ornament") print(controller_one.calculate_value("SaltBaeAquarium"))
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)