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_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("")
def test_remove_count_valid_data_should_work_correctly(self):
repository = PlayerRepository()
player = Beginner("Dave")
repository.add(player)
repository.remove("Dave")
self.assertEqual(repository.count, 0)
def test_remove(self):
repo = PlayerRepository()
p = Advanced('test')
repo.add(p)
self.assertEqual(1, len(repo.players))
self.assertEqual(1, repo.count)
repo.remove('test')
self.assertEqual(0, len(repo.players))
self.assertEqual(0, repo.count)
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 TestPlayerRepository(unittest.TestCase):
def setUp(self):
self.player_repository = PlayerRepository()
def test__init__(self):
self.assertEqual(self.player_repository.players, [])
self.assertEqual(self.player_repository.count, 0)
def test_add_player_successful(self):
self.beginner = Beginner("Michelin")
self.player_repository.add(self.beginner)
self.assertEqual(self.player_repository.players, [self.beginner])
self.assertEqual(self.player_repository.count, 1)
def test_add_player_raise_value_error(self):
self.beginner = Beginner("Michelin")
self.player_repository.add(self.beginner)
with self.assertRaises(ValueError) as exc:
self.player_repository.add(self.beginner)
msg = f"Player {self.beginner.username} already exists!"
self.assertEqual(str(exc.exception), msg)
def test_remove_player_successful(self):
self.beginner = Beginner("Michelin")
self.advanced = Advanced("Dongle")
self.player_repository.add(self.beginner)
self.player_repository.add(self.advanced)
self.player_repository.remove("Michelin")
self.assertEqual(self.player_repository.players, [self.advanced])
self.assertEqual(self.player_repository.count, 1)
def test_remove_player_raises_value_error_card_not_in_repository(self):
self.beginner = Beginner("Michelin")
self.player_repository.add(self.beginner)
with self.assertRaises(ValueError) as exc:
self.player_repository.remove("")
msg = "Player cannot be an empty string!"
self.assertEqual(str(exc.exception), msg)
def test_find_method_finds_the_player(self):
self.beginner = Beginner("Michelin")
self.advanced = Advanced("Dongle")
self.player_repository.add(self.beginner)
self.player_repository.add(self.advanced)
self.assertEqual(self.player_repository.find("Michelin"),
self.beginner)
def test_find_method_not_find_player_return_none(self):
self.beginner = Beginner("Michelin")
self.player_repository.add(self.beginner)
self.assertEqual(self.player_repository.find("Dongle"), None)
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):
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.player_repo = PlayerRepository()
self.beginner = Beginner('Noob')
self.advanced = Advanced('Pro')
def test_initialization_should_return_correct_attributes(self):
self.assertEqual(self.player_repo.players, [])
def test_add_should_add_a_player_to_the_players_list(self):
self.player_repo.add(self.beginner)
self.player_repo.add(self.advanced)
self.assertEqual(self.player_repo.players, [self.beginner, self.advanced])
def test_add_should_raise_error_when_player_adding_existing_player(self):
self.player_repo.add(self.beginner)
with self.assertRaises(ValueError) as cm:
self.player_repo.add(self.beginner)
self.assertEqual(str(cm.exception), "Player Noob already exists!")
def test_remove_should_remove_player_from_the_players_list(self):
self.player_repo.add(self.beginner)
self.player_repo.add(self.advanced)
self.player_repo.remove(self.advanced.username)
self.assertEqual(self.player_repo.players, [self.beginner])
def test_remove_should_raise_error_when_there_is_no_name_for_card(self):
self.player_repo.add(self.beginner)
with self.assertRaises(ValueError) as cm:
self.player_repo.remove('')
self.assertEqual(str(cm.exception), "Player cannot be an empty string!")
def test_find_should_return_the_found_card(self):
self.player_repo.add(self.beginner)
self.player_repo.add(self.advanced)
self.assertEqual(self.player_repo.find(self.advanced.username), self.advanced)
def test_count_should_return_the_length_of_the_players_correctly(self):
self.player_repo.add(self.beginner)
self.player_repo.add(self.advanced)
self.assertEqual(self.player_repo.count, 2)
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 TestPlayerRepository(unittest.TestCase):
def setUp(self) -> None:
self.player_repository = PlayerRepository()
def test_init__attrs_set(self) -> None:
self.assertListEqual(self.player_repository.players, [])
self.assertEqual(self.player_repository.count, 0)
def test_add__when_player_valid(self) -> None:
player = Advanced('John')
self.player_repository.add(player)
self.assertEqual(self.player_repository.count, 1)
self.assertListEqual(self.player_repository.players, [player])
def test_add__when_player_invalid(self) -> None:
player1 = Advanced('John')
player2 = Advanced('John')
self.player_repository.add(player1)
with self.assertRaises(ValueError) as context:
self.player_repository.add(player2)
self.assertEqual(context.exception.args[0], 'Player John already exists!')
def test_remove__when_player_valid(self) -> None:
player = Advanced('John')
self.player_repository.add(player)
self.player_repository.remove('John')
self.assertEqual(self.player_repository.count, 0)
self.assertListEqual(self.player_repository.players, [])
def test_remove__when_player_invalid__expect_exception(self) -> None:
player = Advanced('John')
self.player_repository.add(player)
with self.assertRaises(ValueError) as context:
self.player_repository.remove('')
self.assertEqual(context.exception.args[0], 'Player cannot be an empty string!')
def test_find_method(self) -> None:
player = Advanced('John')
self.player_repository.add(player)
self.assertEqual(self.player_repository.find('John'), player)
class TestPlayerRepo(unittest.TestCase):
def setUp(self):
self.repo = PlayerRepository()
def test_set_up(self):
self.assertEqual(self.repo.count, 0)
self.assertListEqual(self.repo.players, [])
def test_addplayer_when_player_name_exists(self):
p = Beginner("Borko")
self.repo.add(p)
with self.assertRaises(ValueError) as ex:
self.repo.add(p)
self.assertEqual(str(ex.exception), "Player Borko already exists!")
def test_add_player_when_name_is_new(self):
p = Beginner('Borko')
self.repo.add(p)
self.assertTrue(len(self.repo.players), 1)
self.assertEqual(self.repo.count, 1)
self.assertEqual(self.repo.players[0].username, 'Borko')
def test_remove_when_name_is_net_defined_should_raise_error(self):
p = Beginner('Borko')
self.repo.add(p)
with self.assertRaises(ValueError) as ex:
self.repo.remove("")
self.assertEqual(str(ex.exception),
"Player cannot be an empty string!")
def test_remove_when_name_is_ncorect_remove_user(self):
p = Beginner('Borko')
self.repo.add(p)
self.repo.remove('Borko')
self.assertEqual(len(self.repo.players), 0)
self.assertEqual(self.repo.count, 0)
def test_find(self):
p = Beginner('Borko')
self.repo.add(p)
actual = self.repo.find('Borko')
self.assertEqual(p, actual)
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 TestPlayerRepository(unittest.TestCase):
def setUp(self):
self.pr = PlayerRepository()
self.player = Advanced("Pesho")
def test__init(self):
self.assertEqual(self.pr.players, [])
# self.pr.players.append(self.player)
def test__count(self):
self.assertEqual(self.pr.count, 0)
def test__add_existing_player__raise_value_error(self):
self.pr.add(self.player)
with self.assertRaises(ValueError) as context:
self.pr.add(self.player)
expected_msg = str(context.exception)
actual_msg = f"Player {self.player.username} already exists!"
self.assertEqual(expected_msg, actual_msg)
def test__add_player__append_player(self):
self.pr.add(self.player)
self.assertEqual(self.pr.players[0], self.player)
def test__remove_player_with_empty_string__raise_value_error(self):
self.pr.add(self.player)
with self.assertRaises(ValueError) as context:
self.pr.remove("")
expected_msg = str(context.exception)
actual_msg = "Player cannot be an empty string!"
self.assertEqual(expected_msg, actual_msg)
def test__remove_player__sub_him_from_the_list(self):
self.pr.add(self.player)
self.pr.remove("Pesho")
self.assertEqual(self.pr.count, 0)
def test__find_player(self):
self.pr.add(self.player)
player_to_find = self.pr.find("Pesho")
self.assertEqual(self.player, player_to_find)
class TestPlayerRepository(TestCase):
def setUp(self):
self.pr = PlayerRepository()
def test_init(self):
self.assertEqual(0, self.pr.count)
self.assertEqual([], self.pr.players)
def test_add(self):
player = Beginner("Johny")
self.pr.add(player)
self.assertIn(player, self.pr.players)
self.assertEqual(1, self.pr.count)
def test_add_raises(self):
player = Beginner("Johny")
self.pr.add(player)
with self.assertRaises(ValueError) as ex:
self.pr.add(player)
self.assertEqual("Player Johny already exists!", str(ex.exception))
def test_remove(self):
player = Beginner("Johny")
self.pr.players.append(player)
self.pr.count = 1
self.pr.remove("Johny")
self.assertEqual([], self.pr.players)
self.assertEqual(0, self.pr.count)
def test_remove_raises(self):
with self.assertRaises(ValueError) as ex:
self.pr.remove("")
self.assertEqual("Player cannot be an empty string!",
str(ex.exception))
def test_find(self):
player = Beginner("Johny")
self.pr.add(player)
result = self.pr.find("Johny")
self.assertEqual(player, result)
class PlayerRepositoryTests(unittest.TestCase):
def setUp(self):
self.repository = PlayerRepository()
def test_init__expect_attributes_to_be_set(self):
self.assertEqual(0, self.repository.count)
self.assertEqual([], self.repository.players)
def test_add__when_player_not_in_players_expect_to_add_player(self):
player = Beginner("sam")
self.repository.add(player)
self.assertEqual([player], self.repository.players)
self.assertEqual(1, self.repository.count)
def test_add__when_player_exists_expect_value_error(self):
player = Beginner("sam")
self.repository.add(player)
with self.assertRaises(ValueError) as err:
self.repository.add(player)
self.assertEqual("Player sam already exists!", str(err.exception))
def test_remove__when_player_is_empty_string_expect_value_error(self):
with self.assertRaises(ValueError) as err:
self.repository.remove("")
self.assertEqual("Player cannot be an empty string!", str(err.exception))
def test_remove_player__expect_to_remove_player(self):
player = Beginner("sam")
self.repository.add(player)
self.repository.remove("sam")
self.assertEqual([], self.repository.players)
self.assertEqual(0, self.repository.count)
def test_find__expect_to_return_object_player_with_given_name(self):
player = Beginner("sam")
self.repository.add(player)
actual = self.repository.find("sam")
self.assertEqual(player, actual)
class TestPlayerRepository(unittest.TestCase):
def setUp(self):
self.pr = PlayerRepository()
def test_init(self):
self.assertEqual(0, self.pr.count)
self.assertEqual(0, len(self.pr.players))
def test_add_raises(self):
p = Advanced('test')
self.pr.add(p)
with self.assertRaises(ValueError) as ex:
self.pr.add(p)
self.assertEqual("Player test already exists!", str(ex.exception))
def test_add_proper(self):
p = Advanced('test')
self.pr.add(p)
self.assertEqual(1, self.pr.count)
self.assertEqual(1, len(self.pr.players))
def test_remove_raises(self):
with self.assertRaises(ValueError) as ex:
self.pr.remove('')
self.assertEqual("Player cannot be an empty string!",
str(ex.exception))
def test_remove_proper(self):
p = Advanced('test')
self.pr.add(p)
self.assertEqual(1, self.pr.count)
self.assertEqual(1, len(self.pr.players))
self.pr.remove('test')
self.assertEqual(0, self.pr.count)
self.assertEqual(0, len(self.pr.players))
def test_find(self):
p = Advanced('test')
self.pr.add(p)
self.assertEqual(p, self.pr.find('test'))
class TestPlayerRepository(unittest.TestCase):
def setUp(self) -> None:
self.pr = PlayerRepository()
def test_set_attr(self):
self.assertEqual(self.pr.count, 0)
self.assertEqual(len(self.pr.players), 0)
def test_add_raises(self):
p = Advanced("test")
self.pr.add(p)
with self.assertRaises(ValueError) as ex:
self.pr.add(p)
self.assertEqual(str(ex.exception),
f"Player {p.username} already exists!")
def test_add(self):
p = Advanced("test")
self.pr.add(p)
self.assertEqual(self.pr.count, 1)
def test_remove_raises(self):
with self.assertRaises(ValueError) as ex:
self.pr.remove("")
self.assertEqual(str(ex.exception),
"Player cannot be an empty string!")
def test_remove(self):
p = Advanced("test")
self.pr.add(p)
self.assertEqual(self.pr.count, 1)
self.pr.remove("test")
self.assertEqual(self.pr.count, 0)
def test_find(self):
p = Advanced("test")
self.pr.add(p)
result = self.pr.find("test")
self.assertEqual(result.username, "test")
class TestPlayerREpo(unittest.TestCase):
def setUp(self):
self.player_repo = PlayerRepository()
def test_set_up(self):
self.assertEqual(self.player_repo.count, 0)
self.assertEqual(self.player_repo.players, [])
def test_add_player(self):
player = Beginner('Test')
self.player_repo.add(player)
self.assertEqual(self.player_repo.count, 1)
self.assertEqual(self.player_repo.players[0], player)
def test_add_player_when_player_exists_should_raise_exception(self):
player = Beginner('Test')
self.player_repo.add(player)
with self.assertRaises(ValueError) as ex:
self.player_repo.add(player)
self.assertEqual(str(ex.exception), "Player Test already exists!")
def test_find(self):
player = Beginner('Test')
self.player_repo.add(player)
self.assertEqual(self.player_repo.find('Test'), player)
def test_remove_player_when_exists(self):
player = Beginner('Test')
self.player_repo.add(player)
self.player_repo.remove('Test')
self.assertEqual(self.player_repo.count, 0)
self.assertEqual(self.player_repo.players, [])
def test_remove_player_when_name_is_empty(self):
with self.assertRaises(ValueError) as ex:
self.player_repo.remove('')
self.assertEqual(str(ex.exception), "Player cannot be an empty string!")
class TestPlayerRepository(unittest.TestCase):
def setUp(self) -> None:
# self.card1 = Advanced("Test")
# self.card2 = MagicCard("Test2")
# self.card3 = MagicCard("Test")
self.player1 = Advanced("Test")
self.player2 = Advanced("Test2")
self.player3 = Advanced("Test")
self.repository = PlayerRepository()
def test_add_player(self):
self.repository.add(self.player1)
self.assertEqual(self.player1.username, "Test")
self.assertEqual(self.repository.count, 1)
with self.assertRaises(ValueError) as ex:
self.repository.add(self.player1)
self.assertEqual(str(ex.exception), "Player Test already exists!")
self.assertEqual(self.repository.count, 1)
def test_remove_player(self):
self.repository.add(self.player1)
self.repository.add(self.player2)
self.repository.remove("Test")
self.assertEqual(self.repository.count, 1)
with self.assertRaises(ValueError) as ex:
self.repository.remove("")
self.assertEqual(str(ex.exception),
"Player cannot be an empty string!")
self.assertEqual(self.repository.count, 1)
self.repository.remove("NoPlayer")
self.assertEqual(self.repository.count, 1)
def test_find_player(self):
self.repository.add(self.player1)
result = self.repository.find("Test")
self.assertEqual(result.username, "Test")
def test_remove_method_remove_card(self):
player_repo = PlayerRepository()
beginner = Beginner('test')
player_repo.add(beginner)
player_repo.remove('test')
def test_remove_existing_player_should_decrease_count(self):
repo = PlayerRepository()
player = Advanced("Peter")
repo.add(player)
repo.remove(player.username)
self.assertEqual(repo.count, 0)
def test_remove_existing_player_should_remove_him(self):
repo = PlayerRepository()
player = Advanced("Peter")
repo.add(player)
repo.remove(player.username)
self.assertEqual(repo.players, [])
def test_remove_empty_string_should_raise_error(self):
repo = PlayerRepository()
with self.assertRaises(ValueError) as cm:
repo.remove("")
self.assertEqual(str(cm.exception),
"Player cannot be an empty string!")
def test_remove_raises(self):
repo = PlayerRepository()
with self.assertRaises(ValueError) as ex:
repo.remove('')
self.assertEqual(str(ex.exception),
"Player cannot be an empty string!")
