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)