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