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)