def test_take_damage_to_death_valid_data_should_raise_error(self):
player = Advanced("Dave")
with self.assertRaises(ValueError):
player.take_damage(500)
self.assertEqual(player.is_dead, False)
class TestAdvanced(unittest.TestCase):
def setUp(self):
self.player = Advanced("Tony")
def test_initialization_is_done_correctly(self):
self.assertEqual(self.player.username, "Tony")
self.assertEqual(self.player.health, 250)
self.assertEqual(self.player.card_repository.__class__.__name__, "CardRepository")
def test_username_raises_error_when_trying_to_set_it_to_empty_str(self):
with self.assertRaises(ValueError) as cm:
self.player.username = ""
self.assertEqual(str(cm.exception), "Player's username cannot be an empty string.")
def test_health_raises_error_when_trying_to_set_it_below_zero(self):
with self.assertRaises(ValueError) as cm:
self.player.health = -1
self.assertEqual(str(cm.exception), "Player's health bonus cannot be less than zero.")
def test_is_dead_returns_false_if_health_is_positive(self):
self.assertEqual(self.player.is_dead, False)
def test_is_dead_returns_true_if_health_is_not_positive(self):
self.player.health = 0
self.assertEqual(self.player.is_dead, True)
def test_take_damage_raises_error_when_damage_points_are_less_than_zero(self):
with self.assertRaises(ValueError) as cm:
self.player.take_damage(-10)
self.assertEqual(str(cm.exception), "Damage points cannot be less than zero.")
def test_take_damage_decreases_health_when_damage_points_is_positive_number(self):
self.player.take_damage(30)
self.assertEqual(self.player.health, 220)
class TestPlayerAdvanced(unittest.TestCase):
def setUp(self):
self.player = Advanced("AdvancedPlayer")
def test_setUp_class_attributes_and_properties(self):
self.assertEqual(self.player.username, 'AdvancedPlayer')
self.assertEqual(self.player.health, 250)
self.assertEqual("CardRepository",
self.player.card_repository.__class__.__name__)
def test_health_cannot_go_under_zero(self):
with self.assertRaises(ValueError) as exc:
self.player.health = -10
self.assertEqual("Player's health bonus cannot be less than zero.",
str(exc.exception))
def test_username_cannot_be_empty(self):
with self.assertRaises(ValueError) as exc:
pl = Advanced('')
self.assertEqual("Player's username cannot be an empty string.",
str(exc.exception))
def test_is_dead_return_True_is_health_below_zero(self):
self.assertEqual(False, self.player.is_dead)
self.player.health = 0
self.assertEqual(True, self.player.is_dead)
def test_take_damage_func_works(self):
self.player.take_damage(200)
self.assertEqual(50, self.player.health)
with self.assertRaises(ValueError) as exc:
self.player.take_damage(-200)
self.assertEqual("Damage points cannot be less than zero.",
str(exc.exception))
def test_fight_invalid_data_should_raise_error(self):
battlefield = BattleField()
attacker = Advanced("Dave")
enemy = Advanced("John")
first_card = MagicCard("Magic")
second_card = MagicCard("Magic")
attacker.card_repository.cards.append(first_card)
enemy.card_repository.cards.append(second_card)
attacker.take_damage(250)
with self.assertRaises(ValueError):
battlefield.fight(attacker, enemy)
class TestAdvanced(unittest.TestCase):
def setUp(self) -> None:
self.player = Advanced("Test")
# self.player = Advanced("")
def test_account_creation_happyCase(self):
self.assertEqual(self.player.username, "Test")
self.assertEqual(self.player.health, 250)
self.assertEqual(self.player.__class__.__name__, "Advanced")
self.assertEqual(self.player.card_repository.__class__.__name__, "CardRepository")
def test_account_creation_unhappyCase(self):
with self.assertRaises(ValueError) as ex:
Advanced("")
self.assertEqual(str(ex.exception), "Player's username cannot be an empty string.")
def test_health_setter_greaterThanZero(self):
self.player.health -= 100
self.assertEqual(self.player.health, 150)
def test_health_setter_equalThanZero(self):
self.player.health -= 250
self.assertEqual(self.player.health, 0)
def test_health_setter_greaterThanZero(self):
with self.assertRaises(ValueError) as ex:
self.player.health -= 300
self.assertEqual(str(ex.exception), "Player's health bonus cannot be less than zero.")
def test_is_dead_false(self):
result = self.player.is_dead
self.assertEqual(result, False)
def test_is_dead_True(self):
self.player.health -= 250
result = self.player.is_dead
self.assertEqual(result, True)
def test_take_damage_valueLessThanZero(self):
with self.assertRaises(ValueError) as ex:
self.player.take_damage(-100)
self.assertEqual(str(ex.exception), "Damage points cannot be less than zero.")
def test_take_damage_valueGreaterThanZero(self):
self.player.take_damage(100)
self.assertEqual(self.player.health, 150)
class TestBeginner(unittest.TestCase):
def setUp(self):
self.advanced = Advanced('Pesho')
def test_name_and_health__expect_to_be_ok(self):
self.assertEqual('Pesho', self.advanced.username)
self.assertEqual(250, self.advanced.HEALTH)
self.assertEqual('CardRepository',
self.advanced.card_repository.__class__.__name__)
def test_name__when_name_empty__expect_to_raise_exception(self):
with self.assertRaises(ValueError) as ex:
self.advanced.username = ''
expect = "Player's username cannot be an empty string."
self.assertEqual(expect, str(ex.exception))
def test_health_when_health_less_than_0__expect_to_raise_exception(self):
with self.assertRaises(ValueError) as ex:
self.advanced.health = -5
expect = "Player's health bonus cannot be less than zero."
self.assertEqual(expect, str(ex.exception))
def test_is_dead__when_health_greater_than_0__expect_to_be_false(self):
self.advanced.health = 5
self.assertFalse(False, self.advanced.is_dead)
def test_is_dead__when_health_equal_to_0__expect_to_be_true(self):
self.advanced.health = 0
self.assertTrue(self.advanced.is_dead)
def test_take_damage__expect_to_be_ok(self):
self.advanced.take_damage(5)
actual = self.advanced.health
expect = 245
self.assertEqual(expect, actual)
def test_take_damage__when_damege_less_than_0__expect_to_raise_exception(
self):
with self.assertRaises(ValueError) as ex:
self.advanced.take_damage(-5)
actual = str(ex.exception)
expect = 'Damage points cannot be less than zero.'
self.assertEqual(expect, actual)
class TestAdvanced(unittest.TestCase):
def setUp(self):
self.user = Advanced('name')
def test_all_is_ok(self):
self.assertEqual(self.user.username, 'name')
self.assertEqual(self.user.health, 250)
self.assertEqual(self.user.card_repository.__class__.__name__, CardRepository.__name__)
self.assertFalse(self.user.is_dead)
def test_advanced_is_inherit_from_player(self):
self.assertTrue(issubclass(Advanced, Player))
def test_not_valid_username(self):
with self.assertRaises(ValueError) as ex:
self.user.username = ''
self.assertEqual(str(ex.exception), "Player's username cannot be an empty string.")
def test_change_name_corect(self):
self.user.username = '******'
self.assertEqual(self.user.username, 'borko')
def test_health_less_then_zero_should_raise_exception(self):
with self.assertRaises(ValueError) as ex:
self.user.health = -1
self.assertEqual(str(ex.exception), "Player's health bonus cannot be less than zero.")
def test_health_change_with_big_then_zero_value(self):
self.user.health = 100
self.assertEqual(self.user.health, 100)
def test_is_dead(self):
self.assertFalse(self.user.is_dead)
self.user.health = 0
self.assertTrue(self.user.is_dead)
self.user.health = 100
def test_take_damage_with_zero_value_should_raise_error(self):
with self.assertRaises(ValueError) as ex:
self.user.take_damage(-100)
self.assertEqual(str(ex.exception), "Damage points cannot be less than zero.")
def test_take_damage_decrease_health(self):
self.user.take_damage(50)
self.assertEqual(self.user.health, 200)
class AdvancedTests(unittest.TestCase):
def setUp(self):
self.player = Advanced("henry")
def test_init__expect_attributes_to_be_set(self):
self.assertEqual("henry", self.player.username)
self.assertEqual(250, self.player.health)
self.assertEqual(False, self.player.is_dead)
self.assertEqual([], self.player.card_repository.cards)
self.assertEqual(0, self.player.card_repository.count)
def test_username__when_set_to_empty_string_expect_value_error(self):
with self.assertRaises(ValueError) as err:
self.player.username = ""
self.assertEqual("Player's username cannot be an empty string.",
str(err.exception))
def test_health__when_set_to_less_than_0_expect_value_error(self):
with self.assertRaises(ValueError) as err:
self.player.health = -50
self.assertEqual("Player's health bonus cannot be less than zero.",
str(err.exception))
def test_take_damage__when_points_are_less_than_0_expect_value_error(self):
with self.assertRaises(ValueError) as err:
self.player.take_damage(-50)
self.assertEqual("Damage points cannot be less than zero.",
str(err.exception))
def test_take_damage__when_health_gets_less_than_0_expect_value_error(
self):
with self.assertRaises(ValueError) as err:
self.player.take_damage(300)
self.assertEqual("Player's health bonus cannot be less than zero.",
str(err.exception))
# def test_take_damage__when_health_gets_less_than_0_expect_player_to_be_dead_and_health_0(self):
# with self.assertRaises(ValueError) as err:
# self.player.take_damage(300)
# self.assertEqual(True, self.player.is_dead)
# self.assertEqual(0, self.player.health)
def test_take_damage__when_health_is_0_expect_player_to_be_dead_and_health_0(
self):
self.player.take_damage(250)
self.assertEqual(True, self.player.is_dead)
self.assertEqual(0, self.player.health)
def test_take_damage__expect_health_to_decrease_with_given_points_and_not_to_be_dead(
self):
self.player.take_damage(100)
self.assertEqual(150, self.player.health)
self.assertEqual(False, self.player.is_dead)
class TestAdvancedPlayer(unittest.TestCase):
def setUp(self):
self.player = Advanced("IvanVeliki")
def test_init(self):
self.assertEqual(self.player.username, "IvanVeliki")
self.assertEqual(self.player.health, 250)
self.assertIsInstance(self.player.card_repository, CardRepository)
def test__set_username_to_empty_string__raise_value_error(self):
with self.assertRaises(ValueError) as context:
self.player.username = ""
expected_msg = str(context.exception)
actual_msg = "Player's username cannot be an empty string."
self.assertEqual(expected_msg, actual_msg)
def test__set_player_hp_below_zero__raise_value_error(self):
with self.assertRaises(ValueError) as context:
self.player.health = -1
expected_msg = str(context.exception)
actual_msg = "Player's health bonus cannot be less than zero."
self.assertEqual(expected_msg, actual_msg)
def test__set_player_is_dead__return_true(self):
self.player.health = 0
self.assertTrue(self.player.is_dead)
def test__set_player_not_dead_return_false(self):
self.player.health = 10
self.assertFalse(self.player.is_dead)
def test__set_dmg_below_zero__raise_value_error(self):
with self.assertRaises(ValueError) as context:
self.player.take_damage(-1)
expected_msg = str(context.exception)
actual_msg = "Damage points cannot be less than zero."
self.assertEqual(expected_msg, actual_msg)
def test__set_dmg_above_zero__take_player_hp(self):
self.player.health = 10
self.player.take_damage(5)
self.assertEqual(self.player.health, 5)
class TestAdvanced(unittest.TestCase):
def setUp(self):
self.p = Advanced('test')
def test_init(self):
self.assertEqual('test', self.p.username)
self.assertEqual(250, self.p.health)
self.assertEqual(0, len(self.p.card_repository.cards))
self.assertEqual(0, self.p.card_repository.count)
def test_username_raises_error(self):
with self.assertRaises(ValueError) as ex:
self.p.username = ''
self.assertEqual("Player's username cannot be an empty string.", str(ex.exception))
def test_username_proper_setter(self):
self.p.username = '******'
self.assertEqual('new', self.p.username)
def test_health_raises_error(self):
with self.assertRaises(ValueError) as ex:
self.p.health = -3
self.assertEqual("Player's health bonus cannot be less than zero.", str(ex.exception))
def test_health_proper_setter(self):
self.p.health = 23
self.assertEqual(23, self.p.health)
def test_is_dead(self):
self.p.health = 100
self.assertFalse(self.p.is_dead)
self.p.health = 0
self.assertTrue(self.p.is_dead)
def test_take_damage_raise(self):
with self.assertRaises(ValueError) as ex:
self.p.take_damage(-23)
self.assertEqual("Damage points cannot be less than zero.", str(ex.exception))
def test_take_damage(self):
self.p.take_damage(5)
self.assertEqual(245, self.p.health)
class testAdvancedPlayer(unittest.TestCase):
def setUp(self):
self.player = Advanced('Toto')
def test_validate_player_attributes(self):
self.assertEqual(self.player.username, 'Toto')
self.assertEqual(self.player.health, 250)
self.assertEqual(self.player.card_repository.__class__.__name__,
"CardRepository")
def test_empty_username_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.username = ''
self.assertEqual(str(cm.exception),
"Player's username cannot be an empty string.")
def test_less_than_zero_player_health_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.health = -1
self.assertEqual(str(cm.exception),
"Player's health bonus cannot be less than zero.")
def test_less_than_zero_player_damage_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.take_damage(-1)
self.assertEqual(str(cm.exception),
"Damage points cannot be less than zero.")
def test_health_points_decrease_with_damage_points(self):
self.player.take_damage(10)
self.assertEqual(self.player.health, 240)
def test_is_dead_should_return_true_if_player_health_is_equal_or_less_than_zero(
self):
self.player.health = -1
self.assertTrue(self.player.is_dead)
def test_is_dead_should_return_false_if_player_health_is_more_than_zero(
self):
self.player.health = 1
self.assertFalse(self.player.is_dead)
class TestAdvanced(unittest.TestCase):
def setUp(self) -> None:
self.advanced_test = Advanced('test_name')
def test_init_attributes(self):
for attr in ['username', 'health', 'card_repository', 'is_dead']:
self.assertTrue(hasattr(self.advanced_test, attr))
def test_health_should_be_250(self):
self.assertEqual(250, self.advanced_test.health)
def test_take_damage_with_valid_value_should_decrease_health(self):
self.advanced_test.take_damage(50)
self.assertEqual(200, self.advanced_test.health)
def test_take_damage_with_invalid_value_should_raise(self):
with self.assertRaises(ValueError) as ex:
self.advanced_test.take_damage(-50)
expected = "Damage points cannot be less than zero."
self.assertEqual(expected, str(ex.exception))
class TestsAdvancedPlayer(unittest.TestCase):
def setUp(self):
self.player = Advanced("Peter")
def test_init_should_create_player_attributes(self):
self.assertEqual(self.player.username, "Peter")
self.assertEqual(self.player.health, 250)
self.assertEqual(self.player.card_repository.__class__.__name__,
"CardRepository")
def test_set_username_empty_string_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.username = ""
self.assertEqual(str(cm.exception),
"Player's username cannot be an empty string.")
def test_set_health_less_than_zero_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.health = -1
self.assertEqual(str(cm.exception),
"Player's health bonus cannot be less than zero.")
def test_take_damage_less_than_zero_should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.take_damage(-1)
self.assertEqual(str(cm.exception),
"Damage points cannot be less than zero")
def test_take_damage_should_decrease_player_health(self):
self.player.take_damage(50)
actual = self.player.health
expected = 200
self.assertEqual(actual, expected)
def test_is_dead_should_return_true(self):
self.player.health = 0
self.assertTrue(self.player.is_dead)
def test_is_dead_should_return_false(self):
self.assertFalse(self.player.is_dead)
class TestBeginner(unittest.TestCase):
def setUp(self):
self.custom_player = Advanced("KOZA_ADVANCED")
def test_init(self):
new_player = Advanced("KOZA_ADVANCED")
self.assertEqual(new_player.username, self.custom_player.username)
self.assertEqual(self.custom_player.health, 250)
self.assertEqual(self.custom_player.is_dead, False)
self.assertEqual(self.custom_player.card_repository.__class__.__name__, "CardRepository")
def test_player_name_constraint(self):
with self.assertRaises(Exception) as context:
new_player = Advanced("")
self.assertEqual(str(context.exception), "Player's username cannot be an empty string.")
def test_player_health_constraint(self):
with self.assertRaises(Exception) as context:
self.custom_player.take_damage(251)
self.assertEqual(str(context.exception), "Player's health bonus cannot be less than zero.")
def test_player_take_damage(self):
with self.assertRaises(Exception) as context:
self.custom_player.take_damage(-5)
self.assertEqual(str(context.exception), "Damage points cannot be less than zero.")
def test_player_is_dead(self):
self.custom_player.take_damage(250)
self.assertTrue(self.custom_player.is_dead)
class TestAdvanced(unittest.TestCase):
def setUp(self) -> None:
self.player = Advanced('test')
def test_init(self):
self.assertEqual('test', self.player.username)
self.assertEqual(250, self.player.health)
self.assertEqual(0, len(self.player.card_repository.cards))
self.assertEqual(0, self.player.card_repository.count)
def test_username_raises(self):
with self.assertRaises(ValueError):
self.player.username = ''
def test_username_proper(self):
self.player.username = '******'
self.assertEqual('new', self.player.username)
def test_health_raises(self):
with self.assertRaises(ValueError):
self.player.health = -1
def test_health_proper(self):
self.player.health = 3
self.assertEqual(3, self.player.health)
def test_is_dead(self):
self.player.health = 3
self.assertFalse(self.player.is_dead)
def test_take_damage_raises(self):
with self.assertRaises(ValueError):
self.player.take_damage(-1)
def test_take_damage_proper(self):
self.player.health = 5
self.player.take_damage(1)
self.assertEqual(4, self.player.health)
class TestAdvancePlayer(unittest.TestCase):
def setUp(self) -> None:
self.player = Advanced('Peter')
def test_init_should_create_player_attributes(self):
self.assertEqual(self.player.username, "Peter")
self.assertEqual(self.player.health, 250)
self.assertEqual(self.player.card_repository.__class__.__name__, "CardRepository")
def test_set_username__with_empty_username__should_raise_error(self):
with self.assertRaises(ValueError) as context:
self.player.username = ''
self.assertIsNotNone(context.exception)
def test_set_health__with_less_than_zero__should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.health = -1
self.assertEqual(str(cm.exception), "Player's health bonus cannot be less than zero.")
def test_take_damage__with_less_than_zero__should_raise_error(self):
with self.assertRaises(ValueError) as cm:
self.player.take_damage(-1)
self.assertIsNotNone(cm.exception)
def test_take_damage__with_correct_value__should_reduce_health_with_the_value(self):
expected = 50
self.player.take_damage(200)
actual = self.player.health
self.assertEqual(actual, expected)
def test_is_dead__should_return_true(self):
self.player.health = 0
actual = self.player.is_dead
self.assertTrue(actual)
def test_is_dead__should_return_false(self):
actual = self.player.is_dead
self.assertFalse(actual)
class TestAdvanced(unittest.TestCase):
def test_successful_create_advanced_player(self):
self.advanced_player = Advanced("Miron")
self.assertEqual(self.advanced_player.health, 250)
self.assertEqual(self.advanced_player.username, "Miron")
self.assertEqual(self.advanced_player.card_repository,
self.advanced_player.card_repository)
def test_advanced_player__init__with_empty_username_raises_error(self):
with self.assertRaises(ValueError) as exc:
self.advanced_player = Advanced("Miro")
self.advanced_player.username = ''
msg = "Player's username cannot be an empty string."
self.assertEqual(str(exc.exception), msg)
def test_advanced_player__init__with_health_under_zero_raises_error(self):
with self.assertRaises(ValueError) as exc:
self.advanced_player = Advanced("Miron")
self.advanced_player.health = -9
msg = "Player's health bonus cannot be less than zero."
self.assertEqual(str(exc.exception), msg)
def test_is_dead_False(self):
self.advanced_player = Advanced("Miron")
self.assertEqual(self.advanced_player.is_dead, False)
def test_is_dead_True(self):
self.advanced_player = Advanced("Miron")
self.advanced_player.health = 0
self.assertEqual(self.advanced_player.is_dead, True)
def test_take_damage_method_raises_value_error(self):
self.advanced_player = Advanced("Miro")
with self.assertRaises(ValueError) as exc:
self.advanced_player.take_damage(-2)
msg = "Damage points cannot be less than zero."
self.assertEqual(str(exc.exception), msg)
def test_take_damage_method_health_decreased(self):
self.advanced_player = Advanced("Miro")
self.advanced_player.take_damage(30)
self.assertEqual(self.advanced_player.health, 220)
def test_if_after_taking_damage_players_health_is_below_zero(self):
self.advanced_player = Advanced("Miro")
with self.assertRaises(ValueError) as exc:
self.advanced_player.take_damage(255)
msg = "Player's health bonus cannot be less than zero."
self.assertEqual(str(exc.exception), msg)
def test_take_damage_raises(self):
adv = Advanced('test')
with self.assertRaises(ValueError) as ex:
adv.take_damage(-100)
self.assertEqual(str(ex.exception),
"Damage points cannot be less than zero.")
def test_take_damage(self):
advanced = Advanced("test")
advanced.take_damage(50)
self.assertEqual(advanced.health, 200)
def test_take_damage(self):
advanced = Advanced('John')
advanced.take_damage(10)
self.assertEqual(240, advanced.health)
def test_take_damage_player_will_be_dead(self):
a = Advanced("Test")
self.assertEqual(a.health, INITIAL_HEALTH)
with self.assertRaises(ValueError):
a.take_damage(260)
def test_take_damage(self):
a = Advanced("Test")
self.assertEqual(a.health, INITIAL_HEALTH)
a.take_damage(50)
self.assertEqual(a.health, 200)
def test_is_dead_positive_valid_data_should_work_correctly(self):
player = Advanced("Dave")
player.take_damage(250)
self.assertEqual(player.is_dead, True)
def test_take_damage_valid_data_should_work_correctly(self):
player = Advanced("Dave")
player.take_damage(10)
self.assertEqual(player.health, 240)
def test_take_damage_invalid_data_should_raise_error(self):
player = Advanced("Dave")
with self.assertRaises(ValueError):
player.take_damage(-10)
def test_take_damage_raise_ex_when_less_than_0(self):
with self.assertRaises(Exception) as ex:
advanced = Advanced('test')
advanced.take_damage(-3)
self.assertIsNotNone(ex.exception)
def test_take_damage(self):
adv = Advanced('test')
adv.take_damage(100)
self.assertEqual(150, adv.health)
def test_take_damage_raises_with_negative_value(self):
a = Advanced("Test")
self.assertEqual(a.health, INITIAL_HEALTH)
with self.assertRaises(ValueError):
a.take_damage(-50)
def test_is_dead(self):
a = Advanced("test")
self.assertFalse(a.is_dead)
a.take_damage(250)
self.assertTrue(a.is_dead)
def test_take_damage_lower_the_health_when_positive_number(self):
advanced = Advanced('test')
advanced.take_damage(50)
self.assertEqual(advanced.health, 200)
