def test_npc_vendor_values(self):
received_dummy = session.query(NpcVendorSchema).get(self.dummy_creature_entry)
self.assertEqual(received_dummy.__tablename__, self.expected_tablename)
self.assertEqual(received_dummy.item_id, self.dummy_item_id)
self.assertEqual(received_dummy.item_count, self.dummy_item_count)
self.assertEqual(received_dummy.price, self.dummy_price)
self.assertIsNotNone(received_dummy.item)
self.assertTrue(isinstance(received_dummy.item, ItemTemplateSchema))
vendor_item_in_db = session.query(ItemTemplateSchema).get(self.dummy_item_id)
self.assertEqual(received_dummy.item, vendor_item_in_db)
def test_npc_vendor_values(self):
received_dummy = session.query(NpcVendorSchema).get(
self.dummy_creature_entry)
self.assertEqual(received_dummy.__tablename__, self.expected_tablename)
self.assertEqual(received_dummy.item_id, self.dummy_item_id)
self.assertEqual(received_dummy.item_count, self.dummy_item_count)
self.assertEqual(received_dummy.price, self.dummy_price)
self.assertIsNotNone(received_dummy.item)
self.assertTrue(isinstance(received_dummy.item, ItemTemplateSchema))
vendor_item_in_db = session.query(ItemTemplateSchema).get(
self.dummy_item_id)
self.assertEqual(received_dummy.item, vendor_item_in_db)
def test_convert_to_living_thing_friendly_npc_object(self):
"""
Converting a CreaturesSchema with a type of 'fnpc' should convert it to a FriendlyNpc object
"""
loaded_npc: FriendlyNPC = session.query(CreaturesSchema).get(self.npc_guid).convert_to_living_thing_object()
self.assertTrue(isinstance(loaded_npc, FriendlyNPC))
self.assertEqual(vars(loaded_npc), vars(self.npc))
def test_convert_to_item_object(self):
received_item: Potion = session.query(ItemTemplateSchema).get(
self.item_entry).convert_to_item_object()
self.assertIsNotNone(received_item)
self.assertTrue(isinstance(received_item, Potion))
self.assertEqual(vars(received_item), vars(self.potion))
def test_save_loaded_scripts(self):
test_char_id = 133
loaded_scripts = {'The Beat is too low', 'and the vocals too loud'}
save_loaded_scripts(test_char_id, loaded_scripts)
loaded_scripts_count = session.query(LoadedScriptsSchema).filter_by(saved_character_id=test_char_id).count()
self.assertEqual(loaded_scripts_count, len(loaded_scripts))
def test_decide_drops(self):
"""
Test the decide drops function by calling it multiple times until
all the items drop
"""
l_table = session.query(LootTableSchema).get(self.loot_table_entry)
self.expected_item1 = Item(name='Linen Cloth', item_id=self.item_1, buy_price=1, sell_price=1)
self.effect: BeneficialBuff = BeneficialBuff(name="Heart of a Lion",
buff_stats_and_amounts=[('strength', 15)],
duration=5)
self.expected_item2 = Potion(name='Strength Potion', item_id=4, buy_price=1,
sell_price=1, buff=self.effect, quest_id=0)
self.expected_item3 = Weapon(name='Worn Axe', item_id=3,
buy_price=1, sell_price=1, min_damage=2, max_damage=6,
attributes={'bonus_health': 0, 'bonus_mana': 0, 'armor': 0, 'strength': 0, 'agility': 0})
received_items_count = 0
for _ in range(100):
drops: [Item] = l_table.decide_drops()
for drop in drops:
equal_to_one_of_the_three_items = (drop == self.expected_item1
or drop == self.expected_item2
or drop == self.expected_item3)
self.assertTrue(equal_to_one_of_the_three_items)
received_items_count += 1
self.assertGreater(received_items_count, 10)
def test_save_character(self):
save_character(self.expected_character)
received_character = session.query(SavedCharacterSchema).filter_by(name=self.expected_character.name).first()
self.assertIsNotNone(received_character)
received_character = received_character.convert_to_character_object()
self.assertIsNotNone(received_character)
self.assertTrue(isinstance(received_character, Paladin))
# Separately test out the inventory and equipment, because they do not compare well in the
# overall vars() assert equal, even though the Item object has an __eq__ method
received_eq = received_character.equipment
char_eq = self.expected_character.equipment
self.assertCountEqual(received_eq, char_eq)
received_character.equipment = None
self.expected_character.equipment = None
received_inv = received_character.inventory
char_inv = self.expected_character.inventory
self.assertCountEqual(received_inv, char_inv)
received_character.inventory = None
self.expected_character.inventory = None
received_wep = received_character.equipped_weapon
expected_wep = self.expected_character.equipped_weapon
self.assertEqual(received_wep.name, expected_wep.name)
received_character.equipped_weapon = None
self.expected_character.equipped_weapon = None
# assert they're the same
self.assertEqual(vars(received_character), vars(self.expected_character))
def test_save_completed_quests(self):
test_char_id = 94
completed_quests_ids = {9, 10, 12, 13}
save_completed_quests(test_char_id, completed_quests_ids)
completed_quests_count = session.query(CompletedQuestsSchema).filter_by(saved_character_id=test_char_id).count()
self.assertEqual(completed_quests_count, len(completed_quests_ids))
def test_save_killed_monsters(self):
test_char_id = 147
killed_monsters_guids = {109, 111, 131, 149, 13141}
save_killed_monsters(test_char_id, killed_monsters_guids)
killed_monsters_count = session.query(KilledMonstersSchema).filter_by(saved_character_id=test_char_id).count()
self.assertEqual(killed_monsters_count, len(killed_monsters_guids))
def test_build_inventory_with_non_vendor_npc(self):
"""
Test the build_inventory function with an NPC who does not have any links to the
NpcVendor DB table
"""
non_vendor_dummy: CreatureTemplateSchema = session.query(CreatureTemplateSchema).get(1)
received_inventory = non_vendor_dummy.build_vendor_inventory()
self.assertEqual(received_inventory, {})
def test_schema_values(self):
loaded_npc: CreaturesSchema = session.query(CreaturesSchema).get(self.npc_guid)
self.assertEqual(loaded_npc.guid, self.npc_guid)
self.assertEqual(loaded_npc.creature_id, self.npc_entry)
self.assertEqual(loaded_npc.type, self.npc_type)
self.assertEqual(loaded_npc.zone, self.npc_zone)
self.assertEqual(loaded_npc.sub_zone, self.npc_subzone)
self.assertTrue(isinstance(loaded_npc.creature, CreatureTemplateSchema))
def test_schema_values(self):
loaded_vendor: CreaturesSchema = session.query(CreaturesSchema).get(self.vendor_guid)
self.assertEqual(loaded_vendor.guid, self.vendor_guid)
self.assertEqual(loaded_vendor.creature_id, self.vendor_entry)
self.assertEqual(loaded_vendor.type, self.vendor_type)
self.assertEqual(loaded_vendor.zone, self.vendor_zone)
self.assertEqual(loaded_vendor.sub_zone, self.vendor_subzone)
self.assertTrue(isinstance(loaded_vendor.creature, CreatureTemplateSchema))
def test_build_inventory_with_vendor_npc(self):
"""
The build_inventory function should create a dictionary of the inventory
of the vendor. It does so by linking every NpcVendor entry with a foreign
key to the creature_template row
"""
vendor_dummy: CreatureTemplateSchema = session.query(CreatureTemplateSchema).get(self.dummy_entry)
received_inventory = vendor_dummy.build_vendor_inventory()
self.assertEqual(self.dummy_inventory, received_inventory)
def test_convert_to_dot_object(self):
"""
The function should convert out DotSchema to a DoT object
"""
loaded_dot: DoT = session.query(DotSchema).get(
self.entry).convert_to_dot_object(self.caster_level)
self.assertTrue(isinstance(loaded_dot, DoT))
self.assertEqual(loaded_dot, self.expected_dot)
self.assertEqual(vars(loaded_dot), vars(self.expected_dot))
def test_schema_values(self):
""" Load the schema and assert it's as expected """
loaded_creature: CreaturesSchema = session.query(CreaturesSchema).get(self.monster_guid)
self.assertEqual(loaded_creature.guid, self.monster_guid)
self.assertEqual(loaded_creature.creature_id, self.monster_entry)
self.assertEqual(loaded_creature.zone, self.monster_zone)
self.assertEqual(loaded_creature.sub_zone, self.monster_subzone)
self.assertIsNotNone(loaded_creature.creature)
self.assertTrue(isinstance(loaded_creature.creature, CreatureTemplateSchema))
def test_schema_attributes(self):
loaded_schema: DotSchema = session.query(DotSchema).get(self.entry)
self.assertIsNotNone(loaded_schema)
self.assertTrue(loaded_schema.entry, int)
self.assertTrue(loaded_schema.name, str)
self.assertTrue(loaded_schema.damage_per_tick, int)
self.assertTrue(loaded_schema.damage_school, str)
self.assertTrue(loaded_schema.duration, int)
self.assertTrue(loaded_schema.comment, str)
def test_schema_values(self):
loaded_schema: BuffSchema = session.query(BuffSchema).get(
self.buff_entry)
self.assertTrue(isinstance(loaded_schema, BuffSchema))
self.assertTrue(isinstance(loaded_schema.entry, int))
self.assertTrue(isinstance(loaded_schema.name, str))
self.assertTrue(isinstance(loaded_schema.duration, int))
self.assertTrue(isinstance(loaded_schema.stat1, str))
self.assertTrue(isinstance(loaded_schema.amount1, int))
self.assertIsNone(loaded_schema.stat2)
self.assertIsNone(loaded_schema.amount2)
self.assertIsNone(loaded_schema.stat3)
self.assertIsNone(loaded_schema.amount3)
self.assertTrue(isinstance(loaded_schema.comment, str))
def test_save_inventory(self):
item1_mock = mock.Mock(id=1)
item2_mock = mock.Mock(id=2)
item3_mock = mock.Mock(id=3)
inventory_mock = {
"Digital": (item1_mock, 1),
"GetRid": (item2_mock, 2),
"Bra": (item3_mock, 1)
}
test_char_id = 94
save_inventory(test_char_id, inventory_mock)
saved_inventory_count = session.query(InventorySchema).filter_by(saved_character_id=test_char_id).count()
self.assertEqual(saved_inventory_count, len(inventory_mock.keys()))
def test_delete_rows_from_table_valid_tables(self):
"""
Test the function that deletes rows from a table
"""
char_id = 1
# 1.Delete from the saved_character_inventory table
old_inventory_rows_count = session.query(InventorySchema).filter_by(saved_character_id=char_id).count()
self.assertGreater(old_inventory_rows_count, 0)
delete_rows_from_table(InventorySchema.__tablename__, char_id)
new_inventory_rows_count = session.query(InventorySchema).filter_by(saved_character_id=char_id).count()
self.assertEqual(new_inventory_rows_count, 0)
self.assertLess(new_inventory_rows_count, old_inventory_rows_count)
# 2.Delete from the saved_character_killed_monsters table
old_monsters_count = session.query(KilledMonstersSchema).filter_by(saved_character_id=char_id).count()
self.assertGreater(old_monsters_count, 0)
delete_rows_from_table(KilledMonstersSchema.__tablename__, char_id)
new_monsters_count = session.query(KilledMonstersSchema).filter_by(saved_character_id=char_id).count()
self.assertEqual(new_monsters_count, 0)
self.assertLess(new_monsters_count, old_monsters_count)
# 3.Delete from the saved_character_loaded_scripts table
old_scripts_count = session.query(LoadedScriptsSchema).filter_by(saved_character_id=char_id).count()
self.assertGreater(old_scripts_count, 0)
delete_rows_from_table(LoadedScriptsSchema.__tablename__, char_id)
new_scripts_count = session.query(LoadedScriptsSchema).filter_by(saved_character_id=char_id).count()
self.assertEqual(new_scripts_count, 0)
self.assertLess(new_scripts_count, old_scripts_count)
# 4.Delete from the saved_character_completed_quests table
old_quests_count = session.query(CompletedQuestsSchema).filter_by(saved_character_id=char_id).count()
self.assertGreater(old_quests_count, 0)
delete_rows_from_table(CompletedQuestsSchema.__tablename__, char_id)
new_quests_count = session.query(CompletedQuestsSchema).filter_by(saved_character_id=char_id).count()
self.assertEqual(new_quests_count, 0)
self.assertLess(new_quests_count, old_quests_count)
def test_convert_to_living_thing_object_monster(self):
"""
Converting a CreaturesSchema with a type of 'monster' should convert it to a Monster object
"""
converted_monster = session.query(CreaturesSchema).get(self.monster_guid).convert_to_living_thing_object()
self.assertTrue(isinstance(converted_monster, Monster))
# See that it has a loot table
self.assertTrue(isinstance(converted_monster.loot_table, LootTableSchema))
self.assertTrue(converted_monster.loot['gold'] in self.monster_gold_range)
# assert that the expected monster and the one we have are equal
converted_monster.loot_table = None # remove the loot table for easier testing
# These things hold gold which is randomized per monster
converted_monster.loot = None
converted_monster._gold_to_give = None
self.monster.loot = None
self.monster._gold_to_give = None
self.assertEqual(vars(converted_monster), vars(self.monster))
def test_decide_drops(self):
"""
Test the decide drops function by calling it multiple times until
all the items drop
"""
l_table = session.query(LootTableSchema).get(self.loot_table_entry)
self.expected_item1 = Item(name='Linen Cloth',
item_id=self.item_1,
buy_price=1,
sell_price=1)
self.effect: BeneficialBuff = BeneficialBuff(name="Heart of a Lion",
buff_stats_and_amounts=[
('strength', 15)
],
duration=5)
self.expected_item2 = Potion(name='Strength Potion',
item_id=4,
buy_price=1,
sell_price=1,
buff=self.effect,
quest_id=0)
self.expected_item3 = Weapon(name='Worn Axe',
item_id=3,
buy_price=1,
sell_price=1,
min_damage=2,
max_damage=6,
attributes={
'bonus_health': 0,
'bonus_mana': 0,
'armor': 0,
'strength': 0,
'agility': 0
})
received_items_count = 0
for _ in range(100):
drops: [Item] = l_table.decide_drops()
for drop in drops:
equal_to_one_of_the_three_items = (
drop == self.expected_item1 or drop == self.expected_item2
or drop == self.expected_item3)
self.assertTrue(equal_to_one_of_the_three_items)
received_items_count += 1
self.assertGreater(received_items_count, 10)
def test_creature_template_values(self):
dummy: CreatureTemplateSchema = session.query(CreatureTemplateSchema).get(self.dummy_entry)
self.assertEqual(self.dummy_entry, dummy.entry)
self.assertEqual(self.dummy_name, dummy.name)
self.assertEqual(self.dummy_type, dummy.type)
self.assertEqual(self.dummy_level, dummy.level)
self.assertEqual(self.dummy_health, dummy.health)
self.assertEqual(self.dummy_mana, dummy.mana)
self.assertEqual(self.dummy_quest_relation_id, dummy.quest_relation_id)
self.assertEqual(self.dummy_loot_table_id, dummy.loot_table_id)
self.assertIsNone(dummy.loot_table)
self.assertEqual(self.dummy_armor, dummy.armor)
self.assertEqual(self.dummy_min_damage, dummy.min_dmg)
self.assertEqual(self.dummy_max_damage, dummy.max_dmg)
self.assertEqual(self.dummy_gossip, dummy.gossip)
self.assertEqual(self.dummy_respawnable, dummy.respawnable)
self.assertEqual(len(dummy.vendor_inventory), 1)
self.assertTrue(isinstance(dummy.vendor_inventory[0], NpcVendorSchema))
def test_convert_to_character_object(self):
received_char = session.query(SavedCharacterSchema).get(self.entry).convert_to_character_object()
self.assertIsNotNone(received_char)
self.assertTrue(isinstance(received_char, Paladin))
# Separately test out the inventory and equipment, because they do not compare well in the
# overall vars() assert equal, even though the Item object has an __eq__ method
received_eq = received_char.equipment
char_eq = self.character.equipment
self.assertCountEqual(received_eq, char_eq)
received_char.equipment = None
self.character.equipment = None
received_inv = received_char.inventory
char_inv = self.character.inventory
self.assertCountEqual(received_inv, char_inv)
received_char.inventory = None
self.character.inventory = None
self.assertEqual(vars(received_char), vars(self.character))
def setUp(self):
"""
Self dummy is Meatseller Jack
"""
self.dummy_entry = 14
self.dummy_name = "Meatseller Jack"
self.dummy_type = "vendor"
self.dummy_level = 4
self.dummy_health = 20
self.dummy_mana = 0
self.dummy_armor = 0
self.dummy_min_damage = 5
self.dummy_max_damage = 10
self.dummy_quest_relation_id = 0
self.dummy_loot_table_id = 0
self.dummy_gossip = "Do you want to buy meat? You've come to the right place!"
self.dummy_respawnable = True
item_for_sale = session.query(ItemTemplateSchema).get(1).convert_to_item_object()
item_for_sale.buy_price = 1
self.dummy_inventory = {"Wolf Meat": (item_for_sale, 10)}
def test_schema_values(self):
""" Load a schema object and assert that every value is as expected"""
loaded_schema: PaladinSpellsSchema = session.query(PaladinSpellsSchema).get(self.spell_entry)
self.assertTrue(isinstance(loaded_schema.id, int))
self.assertTrue(isinstance(loaded_schema.name, str))
self.assertTrue(isinstance(loaded_schema.rank, int))
self.assertTrue(isinstance(loaded_schema.level_required, int))
self.assertTrue(isinstance(loaded_schema.damage1, int))
self.assertTrue(isinstance(loaded_schema.damage2, int))
self.assertTrue(isinstance(loaded_schema.damage3, int))
self.assertTrue(isinstance(loaded_schema.heal1, int))
self.assertTrue(isinstance(loaded_schema.heal2, int))
self.assertTrue(isinstance(loaded_schema.heal3, int))
self.assertTrue(isinstance(loaded_schema.mana_cost, int))
self.assertIsNone(loaded_schema.beneficial_effect)
self.assertTrue(isinstance(loaded_schema.harmful_effect, int))
self.assertTrue(isinstance(loaded_schema.cooldown, int))
self.assertTrue(isinstance(loaded_schema.comment, str))
self.assertIsNone(loaded_schema.buff)
self.assertTrue(isinstance(loaded_schema.dot, DotSchema))
def test_values(self):
received_q_schema: QuestSchema = session.query(QuestSchema).get(self.quest_entry)
self.assertTrue(isinstance(received_q_schema.entry, int))
self.assertTrue(isinstance(received_q_schema.name, str))
self.assertTrue(isinstance(received_q_schema.type, str))
self.assertTrue(isinstance(received_q_schema.level_required, int))
self.assertTrue(isinstance(received_q_schema.monster_required, str))
self.assertIsNone(received_q_schema.item_required)
self.assertTrue(isinstance(received_q_schema.amount_required, int))
self.assertTrue(isinstance(received_q_schema.zone, str))
self.assertTrue(isinstance(received_q_schema.sub_zone, str))
self.assertTrue(isinstance(received_q_schema.xp_reward, int))
self.assertTrue(isinstance(received_q_schema.description, str))
self.assertIsNone(received_q_schema.reward1_id)
self.assertIsNone(received_q_schema.reward2_id)
self.assertIsNone(received_q_schema.reward3_id)
self.assertTrue(isinstance(received_q_schema.item_choice_enabled, bool))
# since there are no items as reward these should be none
self.assertIsNone(received_q_schema.reward1)
self.assertIsNone(received_q_schema.reward2)
self.assertIsNone(received_q_schema.reward3)
def test_convert_to_character_object(self):
received_char = session.query(SavedCharacterSchema).get(
self.entry).convert_to_character_object()
self.assertIsNotNone(received_char)
self.assertTrue(isinstance(received_char, Paladin))
# Separately test out the inventory and equipment, because they do not compare well in the
# overall vars() assert equal, even though the Item object has an __eq__ method
received_eq = received_char.equipment
char_eq = self.character.equipment
self.assertCountEqual(received_eq, char_eq)
received_char.equipment = None
self.character.equipment = None
received_inv = received_char.inventory
char_inv = self.character.inventory
self.assertCountEqual(received_inv, char_inv)
received_char.inventory = None
self.character.inventory = None
self.assertEqual(vars(received_char), vars(self.character))
def test_convert_to_quest_object_fetchquest(self):
"""
Create the expected FetchQuest and compare it with the one that is loaded
:return:
"""
entry, name, type = 2, 'Canine-Like Hunger', 'fetchquest'
level_required, monster_required, amount_required = 1, None, 2
zone, sub_zone, xp_reward = 'Northshire Abbey', 'Northshire Valley', 300
description = 'Obtain 2 Wolf Meats'
item_rewards = {
'Wolf Meat': Item(name='Wolf Meat', item_id=1, buy_price=1, sell_price=1, quest_id=2),
'Strength Potion': Potion(name='Strength Potion', item_id=4, buy_price=1, sell_price=1,
buff=BeneficialBuff(name="Heart of a Lion",
buff_stats_and_amounts=[('strength', 15)],
duration=5))
}
expected_quest = FetchQuest(quest_name=name, quest_id=entry, required_item='Wolf Meat',
xp_reward=xp_reward, item_reward_dict=item_rewards, reward_choice_enabled=True,
level_required=level_required, required_item_count=amount_required, is_completed=False)
received_quest = session.query(QuestSchema).get(entry).convert_to_quest_object()
self.assertEqual(vars(received_quest), vars(expected_quest))
def test_values(self):
loot_schema: LootTableSchema = session.query(LootTableSchema).get(self.loot_table_entry)
self.assertEqual(self.item_1, loot_schema.item1_id)
self.assertEqual(self.item_1_chance, loot_schema.item1_chance)
self.assertTrue(isinstance(loot_schema.item1, ItemTemplateSchema))
self.assertEqual(self.item_2, loot_schema.item2_id)
self.assertEqual(self.item_2_chance, loot_schema.item2_chance)
self.assertTrue(isinstance(loot_schema.item2, ItemTemplateSchema))
self.assertEqual(self.item_3, loot_schema.item3_id)
self.assertEqual(self.item_3_chance, loot_schema.item3_chance)
self.assertTrue(isinstance(loot_schema.item3, ItemTemplateSchema))
for i in range(4, 21):
item_id = getattr(loot_schema, f'item{i}_id')
item_chance = getattr(loot_schema, f'item{i}_chance')
item_obj = getattr(loot_schema, f'item{i}')
self.assertFalse(item_id)
self.assertFalse(item_chance)
self.assertIsNone(item_obj)
def test_convert_to_quest_object_fetchquest(self):
"""
Create the expected FetchQuest and compare it with the one that is loaded
:return:
"""
entry, name, type = 2, 'Canine-Like Hunger', 'fetchquest'
level_required, monster_required, amount_required = 1, None, 2
zone, sub_zone, xp_reward = 'Northshire Abbey', 'Northshire Valley', 300
description = 'Obtain 2 Wolf Meats'
item_rewards = {
'Wolf Meat':
Item(name='Wolf Meat',
item_id=1,
buy_price=1,
sell_price=1,
quest_id=2),
'Strength Potion':
Potion(name='Strength Potion',
item_id=4,
buy_price=1,
sell_price=1,
buff=BeneficialBuff(name="Heart of a Lion",
buff_stats_and_amounts=[('strength', 15)
],
duration=5))
}
expected_quest = FetchQuest(quest_name=name,
quest_id=entry,
required_item='Wolf Meat',
xp_reward=xp_reward,
item_reward_dict=item_rewards,
reward_choice_enabled=True,
level_required=level_required,
required_item_count=amount_required,
is_completed=False)
received_quest = session.query(QuestSchema).get(
entry).convert_to_quest_object()
self.assertEqual(vars(received_quest), vars(expected_quest))
def test_values(self):
received_q_schema: QuestSchema = session.query(QuestSchema).get(
self.quest_entry)
self.assertTrue(isinstance(received_q_schema.entry, int))
self.assertTrue(isinstance(received_q_schema.name, str))
self.assertTrue(isinstance(received_q_schema.type, str))
self.assertTrue(isinstance(received_q_schema.level_required, int))
self.assertTrue(isinstance(received_q_schema.monster_required, str))
self.assertIsNone(received_q_schema.item_required)
self.assertTrue(isinstance(received_q_schema.amount_required, int))
self.assertTrue(isinstance(received_q_schema.zone, str))
self.assertTrue(isinstance(received_q_schema.sub_zone, str))
self.assertTrue(isinstance(received_q_schema.xp_reward, int))
self.assertTrue(isinstance(received_q_schema.description, str))
self.assertIsNone(received_q_schema.reward1_id)
self.assertIsNone(received_q_schema.reward2_id)
self.assertIsNone(received_q_schema.reward3_id)
self.assertTrue(isinstance(received_q_schema.item_choice_enabled,
bool))
# since there are no items as reward these should be none
self.assertIsNone(received_q_schema.reward1)
self.assertIsNone(received_q_schema.reward2)
self.assertIsNone(received_q_schema.reward3)
def test_values(self):
loot_schema: LootTableSchema = session.query(LootTableSchema).get(
self.loot_table_entry)
self.assertEqual(self.item_1, loot_schema.item1_id)
self.assertEqual(self.item_1_chance, loot_schema.item1_chance)
self.assertTrue(isinstance(loot_schema.item1, ItemTemplateSchema))
self.assertEqual(self.item_2, loot_schema.item2_id)
self.assertEqual(self.item_2_chance, loot_schema.item2_chance)
self.assertTrue(isinstance(loot_schema.item2, ItemTemplateSchema))
self.assertEqual(self.item_3, loot_schema.item3_id)
self.assertEqual(self.item_3_chance, loot_schema.item3_chance)
self.assertTrue(isinstance(loot_schema.item3, ItemTemplateSchema))
for i in range(4, 21):
item_id = getattr(loot_schema, f'item{i}_id')
item_chance = getattr(loot_schema, f'item{i}_chance')
item_obj = getattr(loot_schema, f'item{i}')
self.assertFalse(item_id)
self.assertFalse(item_chance)
self.assertIsNone(item_obj)
def test_convert_to_paladin_spell_object(self):
"""
See if the convert_to_paladin_spell_object works properly
"""
loaded_quest: PaladinSpell = session.query(PaladinSpellsSchema).get(self.spell_entry).convert_to_paladin_spell_object()
self.assertEqual(vars(loaded_quest), vars(self.expected_spell))
CHARACTER_EQUIPMENT_SHOULDERPAD_KEY)
from models.items.item_template import ItemTemplateSchema
from classes import Paladin
from items import Potion, Item
entry = 1
name = 'Netherblood'
class_ = 'paladin'
gold = 61
level = 3
headpiece_id = 11
shoulderpad_id = 12
necklace_id = 14
chestguard_id = 13
chestguard = session.query(ItemTemplateSchema).get(
chestguard_id).convert_to_item_object()
shoulderpad = session.query(ItemTemplateSchema).get(
shoulderpad_id).convert_to_item_object()
necklace = session.query(ItemTemplateSchema).get(
necklace_id).convert_to_item_object()
headpiece = session.query(ItemTemplateSchema).get(
headpiece_id).convert_to_item_object()
# IMPORTANT: Arrange the equipment as it is arranged in the build_equipment function in the loader exactly!
char_equipment = {
CHARACTER_EQUIPMENT_BOOTS_KEY: None,
CHARACTER_EQUIPMENT_LEGGINGS_KEY: None,
CHARACTER_EQUIPMENT_BELT_KEY: None,
CHARACTER_EQUIPMENT_GLOVES_KEY: None,
CHARACTER_EQUIPMENT_BRACER_KEY: None,
CHARACTER_EQUIPMENT_CHESTGUARD_KEY: chestguard,
CHARACTER_EQUIPMENT_SHOULDERPAD_KEY: shoulderpad,
def test_build_equipment(self):
received_eq = session.query(SavedCharacterSchema).get(
self.entry).build_equipment()
self.assertCountEqual(received_eq, self.char_equipment)
def test_convert_to_quest_object_killquest(self):
received_kill_quest = session.query(QuestSchema).get(self.quest_entry).convert_to_quest_object()
self.assertEqual(vars(received_kill_quest), vars(self.expected_kill_quest))
def test_convert_to_item_object(self):
received_item: Potion = session.query(ItemTemplateSchema).get(self.item_entry).convert_to_item_object()
self.assertIsNotNone(received_item)
self.assertTrue(isinstance(received_item, Potion))
self.assertEqual(vars(received_item), vars(self.potion))
def test_convert_to_item_object(self):
received_item = session.query(ItemTemplateSchema).get(2)
received_item = received_item.convert_to_item_object()
self.assertIsNotNone(received_item)
self.assertTrue(isinstance(received_item, Item))
self.assertEqual(vars(received_item), vars(self.expected_item))
def setUp(self):
self.expected_levelup_stats_count = session.query(LevelUpStatsSchema).count()
self.expected_levelxp_req_count = session.query(LevelXpRequirementSchema).count()
def test_build_equipment(self):
received_eq = session.query(SavedCharacterSchema).get(self.entry).build_equipment()
self.assertCountEqual(received_eq, self.char_equipment)
def test_convert_to_living_thing_vendor_npc_object(self):
loaded_vendor: VendorNPC = session.query(CreaturesSchema).get(self.vendor_guid).convert_to_living_thing_object()
self.assertIsNotNone(loaded_vendor)
self.assertEqual(vars(loaded_vendor), vars(self.vendor))
from models.items.item_template import ItemTemplateSchema
from classes import Paladin
from items import Potion, Item
entry = 1
name = 'Netherblood'
class_ = 'paladin'
gold = 61
level = 3
headpiece_id = 11
shoulderpad_id = 12
necklace_id = 14
chestguard_id = 13
chestguard = session.query(ItemTemplateSchema).get(chestguard_id).convert_to_item_object()
shoulderpad = session.query(ItemTemplateSchema).get(shoulderpad_id).convert_to_item_object()
necklace = session.query(ItemTemplateSchema).get(necklace_id).convert_to_item_object()
headpiece = session.query(ItemTemplateSchema).get(headpiece_id).convert_to_item_object()
# IMPORTANT: Arrange the equipment as it is arranged in the build_equipment function in the loader exactly!
char_equipment = {CHARACTER_EQUIPMENT_BOOTS_KEY: None,
CHARACTER_EQUIPMENT_LEGGINGS_KEY: None,
CHARACTER_EQUIPMENT_BELT_KEY: None,
CHARACTER_EQUIPMENT_GLOVES_KEY: None,
CHARACTER_EQUIPMENT_BRACER_KEY: None,
CHARACTER_EQUIPMENT_CHESTGUARD_KEY: chestguard,
CHARACTER_EQUIPMENT_SHOULDERPAD_KEY: shoulderpad,
CHARACTER_EQUIPMENT_NECKLACE_KEY: necklace,
CHARACTER_EQUIPMENT_HEADPIECE_KEY: headpiece}
char_inventory: {str: (Item, int)} = {
