class TestPlayerBeginner(unittest.TestCase): def setUp(self): self.player = Beginner("BeginnerPlayer") def test_setUp_class_attributes_and_properties(self): self.assertEqual(self.player.username, 'BeginnerPlayer') self.assertEqual(self.player.health, 50) 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 = Beginner('') 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(10) self.assertEqual(40, 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))
class testAdvancedPlayer(unittest.TestCase): def setUp(self): self.player = Beginner('Toto') def test_validate_player_attributes(self): self.assertEqual(self.player.username, 'Toto') self.assertEqual(self.player.health, 50) 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 = 0 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)
def test_fight_one_player_dies_valid_data_should_work_correctly(self): battlefield = BattleField() attacker = Advanced("Dave") enemy = Beginner("John") common_card = MagicCard("Magic") attacker.card_repository.cards.append(common_card) enemy.card_repository.cards.append(common_card) enemy.take_damage(50) with self.assertRaises(ValueError): battlefield.fight(attacker, enemy)
class TestBeginner(unittest.TestCase): def setUp(self): self.p = Beginner('test') def test_init(self): self.assertEqual('test', self.p.username) self.assertEqual(50, 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(45, self.p.health)
class TestBeginner(unittest.TestCase): def setUp(self): self.beginner = Beginner('Pesho') def test_name_and_health__expect_to_be_ok(self): self.assertEqual('Pesho', self.beginner.username) self.assertEqual(50, self.beginner.HEALTH) self.assertEqual('CardRepository', self.beginner.card_repository.__class__.__name__) def test_name__when_name_empty__expect_to_raise_exception(self): with self.assertRaises(ValueError) as ex: self.beginner.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.beginner.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.beginner.health = 5 self.assertFalse(False, self.beginner.is_dead) def test_is_dead__when_health_equal_to_0__expect_to_be_true(self): self.beginner.health = 0 self.assertTrue(self.beginner.is_dead) def test_take_damage__expect_to_be_ok(self): self.beginner.take_damage(5) actual = self.beginner.health expect = 45 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.beginner.take_damage(-5) actual = str(ex.exception) expect = 'Damage points cannot be less than zero.' self.assertEqual(expect, actual)
class TestBeginner(unittest.TestCase): def setUp(self) -> None: self.beginner = Beginner('test_name') def test_init_attributes(self): for attr in ['username', 'health', 'card_repository', 'is_dead']: self.assertTrue(hasattr(self.beginner, attr)) def test_health_should_be_50(self): self.assertEqual(50, self.beginner.health) def test_take_damage_with_valid_value_should_decrease_health(self): self.beginner.take_damage(49) self.assertEqual(1, self.beginner.health) def test_take_damage_with_invalid_value_should_raise(self): with self.assertRaises(ValueError) as ex: self.beginner.take_damage(-50) expected = "Damage points cannot be less than zero." self.assertEqual(expected, str(ex.exception))
class TestBeginner(unittest.TestCase): def setUp(self): self.custom_player = Beginner("KOZA_BEGINNER") def test_init(self): new_player = Beginner("KOZA_BEGINNER") self.assertEqual(new_player.username, self.custom_player.username) self.assertEqual(self.custom_player.health, 50) 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 = Beginner("") 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(51) 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(50) self.assertTrue(self.custom_player.is_dead)
class TestBeginner(unittest.TestCase): def setUp(self) -> None: self.player = Beginner('test') def test_init(self): self.assertEqual('test', self.player.username) self.assertEqual(50, 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 TestBeginner(unittest.TestCase): def setUp(self) -> None: self.beginner = Beginner('Brian') def test_init_attrs_set(self) -> None: self.assertEqual(self.beginner.username, 'Brian') self.assertEqual(self.beginner.health, 50) self.assertTrue(hasattr(self.beginner, 'card_repository')) def test_init__when_username_invalid__expect_exception(self) -> None: with self.assertRaises(ValueError) as context: Beginner('') self.assertEqual(context.exception.args[0], 'Player\'s username cannot be an empty string.') def test_take_damage__when_damage_valid(self) -> None: beginner = Beginner('Bryan') beginner.take_damage(25) self.assertEqual(beginner.health, 25) def test_take_damage__when_damage_invalid__expect_exception(self) -> None: with self.assertRaises(ValueError) as context: self.beginner.take_damage(-100) self.assertEqual(context.exception.args[0], 'Damage points cannot be less than zero.') def test_set_health_invalid__expect_exception(self) -> None: with self.assertRaises(ValueError) as context: self.beginner.health = -100 self.assertEqual(context.exception.args[0], 'Player\'s health bonus cannot be less than zero.') def test_is_dead_property(self) -> None: self.beginner.take_damage(50) self.assertEqual(self.beginner.is_dead, True)
class BeginnerTests(unittest.TestCase): def setUp(self): self.player = Beginner("henry") def test_init__expect_attributes_to_be_set(self): self.assertEqual("henry", self.player.username) self.assertEqual(50, 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_is_0_expect_player_to_be_dead_and_health_0( self): self.player.take_damage(50) 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(20) self.assertEqual(30, self.player.health) self.assertEqual(False, self.player.is_dead)
class TestBeginner(unittest.TestCase): def test_successful_create_beginner_player(self): self.beginner_player = Beginner("Miron") self.assertEqual(self.beginner_player.health, 50) self.assertEqual(self.beginner_player.username, "Miron") self.assertEqual(self.beginner_player.card_repository, self.beginner_player.card_repository) def test_advanced_player__init__with_empty_username_raises_error(self): with self.assertRaises(ValueError) as exc: self.beginner_player = Beginner("Miro") self.beginner_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.beginner_player = Beginner("Miron") self.beginner_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.beginner_player = Beginner("Miron") self.assertEqual(self.beginner_player.is_dead, False) def test_is_dead_True(self): self.beginner_player = Beginner("Miron") self.beginner_player.health = 0 self.assertEqual(self.beginner_player.is_dead, True) def test_take_damage_method_raises_value_error(self): self.beginner_player = Beginner("Miro") with self.assertRaises(ValueError) as exc: self.beginner_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.beginner_player = Beginner("Miro") self.beginner_player.take_damage(30) self.assertEqual(self.beginner_player.health, 20) def test_if_after_taking_damage_players_health_is_below_zero(self): self.beginner_player = Beginner("Miro") with self.assertRaises(ValueError) as exc: self.beginner_player.take_damage(55) msg = "Player's health bonus cannot be less than zero." self.assertEqual(str(exc.exception), msg)
def test_take_damage(self): beginner = Beginner("test") beginner.take_damage(30) self.assertEqual(beginner.health, 20)
def test_take_damage_raises(self): beginner = Beginner("test") with self.assertRaises(ValueError) as ex: beginner.take_damage(-5) self.assertEqual(str(ex.exception), "Damage points cannot be less than zero.")
def test_take_damage(self): beg = Beginner('test') beg.take_damage(25) self.assertEqual(25, beg.health)
def test_take_damage_invalid_data_should_raise_error(self): player = Beginner("Dave") with self.assertRaises(ValueError): player.take_damage(-10)
def test_take_damage_valid_data_should_work_correctly(self): player = Beginner("Dave") player.take_damage(10) self.assertEqual(player.health, 40)
def test_take_damage_player_will_be_dead(self): a = Beginner("Test") self.assertEqual(a.health, INITIAL_HEALTH) with self.assertRaises(ValueError): a.take_damage(260)
def test_take_positive_damage_should_decrease_health(self): player = Beginner("Peter") player.take_damage(20) self.assertEqual(player.health, 30)
def test_take_damage_raise_ex_when_less_than_0(self): with self.assertRaises(Exception) as ex: beginner = Beginner('test') beginner.take_damage(-3) self.assertIsNotNone(ex.exception)
def test_take_damage(self): beginner = Beginner('John') beginner.take_damage(10) self.assertEqual(40, beginner.health)
def test_is_dead(self): a = Beginner("test") self.assertFalse(a.is_dead) a.take_damage(50) self.assertTrue(a.is_dead)
def test_take_damage_is_ok_value(self): a = Beginner("test") a.take_damage(40) self.assertEqual(a.health, 10)
def test_take_damage_less_then_zero_return_raises(self): a = Beginner("test") with self.assertRaises(ValueError) as ex: a.take_damage(-1) self.assertEqual(str(ex.exception), "Damage points cannot be less than zero.")
def test_take_damage(self): beginner = Beginner('test') beginner.take_damage(40) self.assertEqual(beginner.health, 10)
def test_take_negative_damage_should_raise_error(self): player = Beginner("Peter") with self.assertRaises(ValueError): player.take_damage(-20)
def test_take_damage_raises_with_negative_value(self): a = Beginner("Test") self.assertEqual(a.health, INITIAL_HEALTH) with self.assertRaises(ValueError): a.take_damage(-50)
def test_is_dead_positive_valid_data_should_work_correctly(self): player = Beginner("Dave") player.take_damage(50) self.assertEqual(player.is_dead, True)
def test_take_damage(self): a = Beginner("Test") self.assertEqual(a.health, INITIAL_HEALTH) a.take_damage(50) self.assertEqual(a.health, 0)
def test_take_damage_lower_the_health_when_positive_number(self): beginner = Beginner('test') beginner.take_damage(10) self.assertEqual(beginner.health, 40)
def test_take_damage__when_damage_valid(self) -> None: beginner = Beginner('Bryan') beginner.take_damage(25) self.assertEqual(beginner.health, 25)