def test_pickup(self):
player = players.Thief()
#If scroll learn it
#If weapon equip it - if no weapon equipped and proficient
#If armor equip it - if no armor equipped and proficient
#Scroll
scroll = MockHelper.get_mock_scroll()
player.learn_spell = Mock(return_value=True)
self.assertTrue(player.pickup(scroll))
player.learn_spell.assert_called_once()
#Weapon
weapon = MockHelper.get_mock_weapon()
weapon.get_modifier_value = Mock(return_value=0)
#Not proficient
player.character_class.is_weapon_proficient = Mock(return_value=False)
self.assertFalse(player.has_weapon_equipped())
self.assertTrue(player.pickup(weapon))
self.assertFalse(player.has_weapon_equipped())
self.assertNotEqual(player.get_equipped_weapon(), weapon)
#Proficient
player.character_class.is_weapon_proficient = Mock(return_value=True)
self.assertFalse(player.has_weapon_equipped())
self.assertTrue(player.pickup(weapon))
self.assertTrue(player.has_weapon_equipped())
self.assertEqual(player.get_equipped_weapon(), weapon)
#Already equipped
another_weapon = MockHelper.get_mock_weapon()
self.assertTrue(player.pickup(another_weapon))
self.assertTrue(player.has_weapon_equipped())
self.assertEqual(player.get_equipped_weapon(), weapon)
#Armor
myarmor = MockHelper.get_mock_armor()
myarmor.get_modifier_value = Mock(return_value=0)
#Not proficient
player.character_class.is_armor_proficient = Mock(return_value=False)
self.assertFalse(player.has_armor_equipped())
self.assertTrue(player.pickup(myarmor))
self.assertFalse(player.has_armor_equipped())
self.assertNotEqual(player.get_equipped_armor(), myarmor)
#Proficient
player.character_class.is_armor_proficient = Mock(return_value=True)
self.assertFalse(player.has_armor_equipped())
self.assertTrue(player.pickup(myarmor))
self.assertTrue(player.has_armor_equipped())
self.assertEqual(player.get_equipped_armor(), myarmor)
#Already equipped
another_armor = MockHelper.get_mock_armor()
self.assertTrue(player.pickup(another_armor))
self.assertTrue(player.has_armor_equipped())
self.assertEqual(player.get_equipped_armor(), myarmor)
def test_loot_body(self):
player = players.Thief()
rat = players.Rat()
zombie_rat = players.ZombieRat()
another_rat = players.Rat()
#Inventory is empty
#Is looted
#Inventory has 1 item
#Inventory has 2 items
#Empty
self.assertEqual(player.loot_body(rat), [])
#Already looted
self.assertFalse(player.loot_body(rat))
penny = MockHelper.get_mock_item()
quarter = MockHelper.get_mock_scroll()
#1 item
self.assertTrue(zombie_rat.pickup(penny))
self.assertEqual(player.loot_body(zombie_rat), [penny])
self.assertTrue(player.is_carrying(penny))
self.assertFalse(zombie_rat.is_carrying(penny))
#2 items
self.assertTrue(another_rat.pickup(penny))
self.assertTrue(another_rat.pickup(quarter))
self.assertEqual(player.loot_body(another_rat), [penny, quarter])
self.assertTrue(player.is_carrying(penny))
self.assertTrue(player.is_carrying(quarter))
self.assertFalse(another_rat.is_carrying(penny))
self.assertFalse(another_rat.is_carrying(quarter))
def test_find_ammo(self):
player = Mock()
inventory = standard_items.Inventory(player)
import questgame.game_items.weapons as weapons
ammo_poor = MockHelper.get_mock_item(spec=weapons.WoodArrow)
ammo_poor.cost = 1
ammo_best = MockHelper.get_mock_item(spec=weapons.SteelArrow)
ammo_best.cost = 100
ammo_good = MockHelper.get_mock_item(spec=weapons.IronArrow)
ammo_good.cost = 10
#Add poor arrow
self.assertEqual(inventory.find_ammo(weapons.Arrow), False)
inventory.add(ammo_poor)
#Add best arrow
self.assertEqual(inventory.find_ammo(weapons.Arrow), ammo_poor)
inventory.add(ammo_best)
self.assertEqual(inventory.find_ammo(weapons.Arrow), ammo_best)
#Add good arrow - should still select best arrow
inventory.add(ammo_good)
self.assertEqual(inventory.find_ammo(weapons.Arrow), ammo_best)
def test_can_act(self):
#Player can act as long as not stunned, unconscious or dead
#Use mage as mocks impact other tests
player = players.Thief()
self.assertTrue(player.can_act)
with MockHelper.Property(player, 'is_dead', return_value=False) as is_dead_mock, \
MockHelper.Property(player, 'is_unconscious', return_value=False) as is_unconscious_mock, \
MockHelper.Property(player, 'is_stunned', return_value=False) as is_stunned_mock:
self.assertTrue(player.can_act)
#Check each one was called
is_dead_mock.assert_called_once()
is_stunned_mock.assert_called_once()
is_unconscious_mock.assert_called_once()
#Stunned
is_stunned_mock.return_value = True
self.assertFalse(player.can_act)
is_stunned_mock.return_value = False
#Unconscious
is_unconscious_mock.return_value = True
self.assertFalse(player.can_act)
is_unconscious_mock.return_value = False
#Dead
is_dead_mock.return_value = True
self.assertFalse(player.can_act)
is_dead_mock.return_value = False
self.assertTrue(player.can_act)
def test_throw(self):
player = players.Thief()
rat = players.Rat()
dagger = MockHelper.get_mock_weapon()
not_a_dagger = MockHelper.get_mock_item()
#Must be carrying item
#Item must be a throwable weapon
#Should decrease number of items when thrown
#If none left then no longer carrying
#Not carrying
player.is_carrying = Mock(return_value=False)
self.assertFalse(player.throw(dagger, rat))
player.is_carrying.assert_called_once()
#Not a weapon
#TODO: Allow food to be thrown?
player.is_carrying = Mock(return_value=True)
self.assertFalse(player.throw(not_a_dagger, rat))
#Not throwable
#Mock class methods
mock_is_throwable = PropertyMock(return_value=True)
type(dagger).is_throwable = mock_is_throwable
self.assertTrue(player.throw(dagger, rat))
mock_is_throwable.assert_called_once()
def test_remove_item(self):
player = players.Thief()
#Not carrying item does nothing
#Removing equipped armor resets to default
#Removing equipped weapon resets to default
#Armor
myarmor = MockHelper.get_mock_armor()
myarmor.get_modifier_value = Mock(return_value=0)
#Nothing to remove
self.assertFalse(player.remove_item(myarmor))
#Remove equipped armor
player.character_class.is_armor_proficient = Mock(return_value=True)
self.assertTrue(player.pickup(myarmor))
self.assertEqual(player.get_equipped_armor(), myarmor)
self.assertTrue(player.has_armor_equipped())
self.assertTrue(player.remove_item(myarmor))
self.assertNotEqual(player.get_equipped_armor(), myarmor)
self.assertFalse(player.has_armor_equipped())
#Remove equipped weapon
weapon = MockHelper.get_mock_weapon()
weapon.get_modifier_value = Mock(return_value=0)
player.character_class.is_weapon_proficient = Mock(return_value=True)
self.assertTrue(player.pickup(weapon))
self.assertTrue(player.has_weapon_equipped())
self.assertEqual(player.get_equipped_weapon(), weapon)
self.assertTrue(player.remove_item(weapon))
self.assertNotEqual(player.get_equipped_weapon(), weapon)
self.assertFalse(player.has_weapon_equipped())
def test_is_unconscious(self):
player = players.Thief()
self.assertFalse(player.is_dead)
self.assertFalse(player.is_unconscious)
#Ensure Save from death, but not max save
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=19) as mock_death_save:
self.assertTrue(player.wound(player.max_hit_points))
self.assertEqual(player.hit_points, 0)
self.assertFalse(player.is_dead)
self.assertTrue(player.is_unconscious)
#Can't wound if no points
self.assertFalse(player.wound(0))
mock_death_save.assert_called_once()
#Massive damage, no save
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
self.assertTrue(player.wound(player.max_hit_points))
self.assertEqual(player.hit_points, 0)
self.assertTrue(player.is_dead)
self.assertFalse(player.is_unconscious)
#Dead can't wound anymore
self.assertFalse(player.wound(player.max_hit_points))
mock_death_save.assert_not_called()
#Massive damage, no save
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
player = players.Thief()
self.assertTrue(player.wound(player.max_hit_points * 2))
self.assertTrue(player.is_dead)
self.assertFalse(player.is_unconscious)
mock_death_save.assert_not_called()
#Large damage, save matters
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
player = players.Thief()
self.assertTrue(player.wound(player.max_hit_points * 2 - 1))
self.assertFalse(player.is_dead)
self.assertEqual(player.hit_points, 0)
self.assertTrue(player.is_unconscious)
mock_death_save.assert_called_once()
def test_heal(self):
player = players.Thief()
#Returns ture if any healing occurred
#Hit points can exceed max_hit_points
#Heal amount can't be <= 0
#No healing
self.assertFalse(player.heal(-1))
self.assertFalse(player.heal(0))
#<0
self.assertGreater(player.max_hit_points, 0)
self.assertEqual(player.hit_points, player.max_hit_points)
#Ok full health
self.assertFalse(player.heal(1))
self.assertEqual(player.hit_points, player.max_hit_points)
#Wound
self.assertTrue(player.wound(1))
self.assertLess(player.hit_points, player.max_hit_points)
self.assertTrue(player.heal(20))
self.assertEqual(player.hit_points, player.max_hit_points)
#Can't heal if dead
self.assertTrue(player.wound(1))
#Mock class method
with MockHelper.Property(player, 'is_dead',
return_value=True) as mock_is_dead:
self.assertFalse(player.heal(1))
mock_is_dead.assert_called_once()
mock_is_dead.return_value = False
self.assertTrue(player.heal(1))
def test_items(self):
player = Mock()
inventory = standard_items.Inventory(player)
#Nothing in inventory
self.assertEqual(inventory.items(), [])
beer = MockHelper.get_mock_beer()
self.assertTrue(inventory.add(beer))
self.assertTrue(inventory.add(MockHelper.get_mock_beer()))
self.assertEqual(inventory.items(), [beer])
scroll = MockHelper.get_mock_scroll()
self.assertTrue(inventory.add(scroll))
self.assertTrue(inventory.add(MockHelper.get_mock_scroll()))
self.assertEqual(inventory.items(), [beer, scroll])
def test_equip_weapon(self):
#Check default armor
player = players.Thief()
self.assertEqual(player.get_equipped_weapon(), player.default_weapon)
#Equip something that isn't armor
fake_weapon = Mock()
self.assertFalse(player.equip_weapon(fake_weapon))
#Not carrying
good_weapon = MockHelper.get_mock_weapon()
player.is_carrying = Mock(return_value=False)
self.assertFalse(player.equip_weapon(good_weapon))
player.is_carrying.assert_called_once()
#Equip Weapon
player.is_carrying = Mock(return_value=True)
self.assertTrue(player.equip_weapon(good_weapon))
#Equip None, should be default
try:
player.equip_weapon(None)
except AttributeError:
self.assertTrue(True, 'None is not valid')
self.assertEqual(player.get_equipped_weapon(), good_weapon)
def test_money(self):
player = Mock()
inventory = standard_items.Inventory(player)
self.assertEqual(inventory.money, 0.00)
#Add some money
coin = MockHelper.get_mock_money()
coin.cost = 10
self.assertTrue(inventory.add(coin))
self.assertEqual(inventory.money, 10.00)
#Add some more money
coin = MockHelper.get_mock_money()
coin.cost = 0.05
self.assertTrue(inventory.add(coin))
self.assertEqual(inventory.money, 10.05)
def test_can_picklock(self):
#Can act, has a lock pick and the lock picking skill
player = players.Thief()
player.is_carrying = Mock(return_value=True)
player.has_skill = Mock(return_value=True)
#Stash can_act
with MockHelper.Property(player, 'can_act',
return_value=True) as mock_can_act:
self.assertTrue(player.can_picklock())
#No lockpick
mock_is_carrying = Mock(return_value=False)
player.is_carrying = mock_is_carrying
self.assertFalse(player.can_picklock())
#Can't act
mock_is_carrying.return_value = True
self.assertTrue(player.can_picklock())
mock_can_act.return_value = False
self.assertFalse(player.can_picklock())
#No skill
mock_can_act.return_value = True
self.assertTrue(player.can_picklock())
player.has_skill = Mock(return_value=False)
self.assertFalse(player.can_picklock())
def test_weight(self):
player = Mock()
inventory = standard_items.Inventory(player)
self.assertEqual(inventory.weight, 0)
beer = MockHelper.get_mock_beer()
scroll = MockHelper.get_mock_scroll()
inventory.add(beer)
self.assertEqual(inventory.weight, 1)
inventory.add(beer)
self.assertEqual(inventory.weight, 2)
inventory.add(scroll)
self.assertEqual(inventory.weight, 3)
inventory.remove(scroll)
self.assertEqual(inventory.weight, 2)
def test_has_weapon_equipped(self):
player = players.Thief()
self.assertFalse(player.has_armor_equipped())
armor = MockHelper.get_mock_armor()
player.is_carrying = Mock(return_value=True)
self.assertTrue(player.equip_armor(armor))
self.assertTrue(player.has_armor_equipped())
def test_contains(self):
player = Mock()
inventory = standard_items.Inventory(player)
beer = MockHelper.get_mock_beer()
self.assertFalse(inventory.contains(beer))
self.assertTrue(inventory.add(beer))
self.assertTrue(inventory.contains(beer))
def test_get_key(self):
key = Mock()
chest = standard_items.OpenableItem(key_id=10)
#Mock key lookup
with MockHelper.Method(standard_items.items.ItemStats,
'get_key',
return_value=key) as mock_get_key:
self.assertEqual(chest.get_key(), key)
mock_get_key.assert_called_once()
def test_is_encumbered(self):
player = players.Thief()
#Stash class methods
with MockHelper.Property(player, 'carry_weight', return_value=0) as mock_carry_weight, \
MockHelper.Property(player, 'carry_capacity', return_value=10) as mock_carry_capacity:
#weight < capacity
self.assertFalse(player.is_encumbered)
mock_carry_weight.assert_called_once()
mock_carry_capacity.assert_called_once()
#weight = capacity
mock_carry_weight.return_value = 10
self.assertFalse(player.is_encumbered)
#weight > capacity
mock_carry_weight.return_value = 11
self.assertTrue(player.is_encumbered)
def test_get_item(self):
player = players.Thief()
penny = MockHelper.get_mock_item()
#Get an item from inventory
#Returns False if no such item
self.assertFalse(player.get_item(penny))
self.assertTrue(player.pickup(penny))
self.assertEqual(player.get_item(penny), penny)
def test_get_item(self):
player = Mock()
inventory = standard_items.Inventory(player)
beer = MockHelper.get_mock_item()
#Nothing in inventroy
self.assertFalse(inventory.get_item(beer))
#Beer is in inventory
self.assertTrue(inventory.add(beer))
self.assertEqual(inventory.get_item(beer), beer)
def test_drop(self):
player = players.Thief()
penny = MockHelper.get_mock_item()
#Must be carrying item, then calls remove - which returns the item
player.is_carrying = Mock(return_value=True)
player.remove_item = Mock(return_value=penny)
self.assertEqual(player.drop(penny), penny)
#not carrying
player.is_carrying = Mock(return_value=False)
self.assertFalse(player.drop(penny))
def test_is_dead(self):
player = players.Thief()
self.assertFalse(player.is_dead)
#Ensure save on death
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
self.assertTrue(player.wound(player.max_hit_points))
self.assertEqual(player.hit_points, 0)
self.assertFalse(player.is_dead)
mock_death_save.assert_called()
#Massive damage - save has no effect
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
self.assertTrue(player.wound(player.max_hit_points))
self.assertEqual(player.hit_points, 0)
self.assertTrue(player.is_dead)
mock_death_save.assert_not_called()
#Massive damage - save has no effect
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
player = players.Thief()
self.assertTrue(player.wound(player.max_hit_points * 2))
self.assertTrue(player.is_dead)
mock_death_save.assert_not_called()
#Large damage - save has an effect
with MockHelper.Method(players.GameRules,
'roll_death_save',
return_value=20) as mock_death_save:
player = players.Thief()
self.assertTrue(player.wound(player.max_hit_points * 2 - 1))
self.assertFalse(player.is_dead)
mock_death_save.assert_called_once()
def test_strike(self):
player = players.Thief()
rat = players.Rat()
#Can't act
with MockHelper.Property(player, 'can_act',
return_value=False) as mock_can_act:
self.assertFalse(player.strike(rat))
mock_can_act.assert_called_once()
mock_can_act.return_value = True
strike = player.strike(rat)
self.assertIsNotNone(strike.damage)
def test_add(self):
player = Mock()
inventory = standard_items.Inventory(player)
#Add None
self.assertFalse(inventory.add(None))
#Add non-item
self.assertFalse(inventory.add(Mock()))
#Add item
beer = MockHelper.get_mock_beer()
self.assertTrue(inventory.add(beer))
self.assertTrue(inventory.contains(beer))
def test_get_item_by_name(self):
player = players.Thief()
penny = MockHelper.get_mock_item()
#Get an item from inventory
#Returns False if no such item
self.assertFalse(player.get_item_by_name('penny'))
self.assertTrue(player.pickup(penny))
penny.is_match = Mock(return_value=False)
self.assertFalse(player.get_item_by_name('penny'))
penny.is_match.assert_called_once()
penny.is_match = Mock(return_value=True)
self.assertEqual(player.get_item_by_name('penny'), penny)
def test_count_items(self):
player = Mock()
beer = MockHelper.get_mock_item()
inventory = standard_items.Inventory(player)
#Test None
self.assertEqual(inventory.count_items(None), 0)
self.assertEqual(inventory.count_items(beer), 0)
#Test 1 item
self.assertTrue(inventory.add(beer))
self.assertEqual(inventory.count_items(beer), 1)
#Test 2 items
self.assertTrue(inventory.add(beer))
self.assertEqual(inventory.count_items(beer), 2)
def test_can_cast_spell(self):
#Knows spell
#Has a sufficient level
#Has enough mana
#Can act
smiteSpell = Mock()
smiteSpell.level = 1
player = players.Thief()
player.max_mana_points = 4
player.add_mana(4)
with MockHelper.Property(player, 'can_act',
return_value=True) as can_act_mock:
player.knows_spell = Mock(return_value=True)
self.assertTrue(player.can_cast_spell(smiteSpell))
#Ensure methods called as expected
can_act_mock.assert_called_once()
player.knows_spell.assert_called_once()
#Not enough mana
player.add_mana(-4)
self.assertFalse(player.can_cast_spell(smiteSpell))
player.add_mana(4)
self.assertTrue(player.can_cast_spell(smiteSpell))
#Not a high enough level
smiteSpell.level = 2
self.assertFalse(player.can_cast_spell(smiteSpell))
smiteSpell.level = 1
self.assertTrue(player.can_cast_spell(smiteSpell))
#Can't act
can_act_mock.return_value = False
self.assertFalse(player.can_act)
self.assertFalse(player.can_cast_spell(smiteSpell))
#Doesn't know spell
player.knows_spell = Mock(return_value=False)
self.assertFalse(player.knows_spell(smiteSpell))
self.assertFalse(player.can_cast_spell(smiteSpell))
def test_give(self):
player = players.Thief()
rat = players.Rat()
penny = MockHelper.get_mock_item()
#Can give
player.is_carrying = Mock(return_value=True)
player.remove_item = Mock(return_value=True)
self.assertTrue(player.give(penny, rat))
#Not carrying
player.is_carrying = Mock(return_value=False)
self.assertFalse(player.give(penny, rat))
#Can't remove
player.is_carrying = Mock(return_value=True)
player.remove_item = Mock(return_value=False)
self.assertFalse(player.give(penny, rat))
def test_get_rid_of_one(self):
player = players.Thief()
beer = MockHelper.get_mock_beer()
#Not carrying a penny
#Carrying 2 then 1 should be left
#Carrying 1 then none should be left
#Not carrying
self.assertFalse(player.get_rid_of_one(beer))
#Carrying 2
beer.count = 2
self.assertTrue(player.pickup(beer))
self.assertTrue(player.get_rid_of_one(beer))
self.assertTrue(player.is_carrying(beer))
#Drop second one
self.assertTrue(player.get_rid_of_one(beer))
self.assertFalse(player.is_carrying(beer))
self.assertFalse(player.get_rid_of_one(beer))
def test_strike_critical_miss(self):
weapon = weapons.Spear()
attacker = Mock()
defender = Mock()
is_throw = False
attacker.get_reply_key = Mock(return_value='player_critical_miss')
defender.get_reply_key = Mock(return_value='monster_critical_miss')
attacker.determine_ability_modifier = Mock(return_value=2)
defender.get_defense = Mock(return_value=5)
with MockHelper.Method(weapons.GameRules,
'roll_weapon_attack_score') as mock_weapon_roll:
mock_weapon_roll.return_value = MockDiceRoll(1, 0)
strike = weapon.strike(attacker, defender, is_throw)
weapons.GameRules.roll_weapon_attack_score.assert_called_once()
self.assertFalse(strike.is_critical_hit)
self.assertTrue(strike.is_critical_miss)
self.assertEqual(strike.damage, 0)
self.assertFalse(strike.is_hit)
self.assertTrue(strike.is_miss)
def test_lock_with_spell(self):
player = Mock()
bad_spell = Mock()
spell = MockHelper.get_mock_lock_spell()
chest = standard_items.OpenableItem()
self.assertFalse(chest.is_locked)
self.assertFalse(chest.lock(player, spell=bad_spell))
self.assertTrue(chest.lock(player, spell=spell))
self.assertTrue(chest.is_locked)
#Can't unlock with key
key = Mock()
key.id = 1
self.assertFalse(chest.unlock(player, key))
#Can picklock
player.current_action = Actions.PICK_LOCK
player.get_attribute_modifier = Mock(return_value=5)
self.assertTrue(chest.unlock(player))
player.get_attribute_modifier.assert_called_once()
player.current_action = False