def _build_unit_effects(self):
self.log.info("Building unit effects")
unit_effects_model = UnitEffects(db=self.db)
unit_effects = unit_effects_model.get_unit_effects()
unit_effects_map = \
unit_effects_model._get_unit_effects_map(unit_effects)
return unit_effects_map
def test_get_unit_effects_map(self):
"""
This method should return a dictionary with
the unit_id as the key, and the a list of effect_ids
as the value
"""
unit_effects = [{"unit_id": 1, "effect_id": 1},
{"unit_id": 2, "effect_id": 1},
{"unit_id": 1, "effect_id": 99},
{"unit_id": 2, "effect_id": 101}]
expected = {1: [1, 99], 2: [1, 101]}
unit_effects_model = UnitEffects(db="test")
actual = unit_effects_model._get_unit_effects_map(unit_effects)
self.assertEqual(expected, actual)
def test_create_units(self):
"""
The item collection is populated by models
"""
item_collection = ItemCollection()
effect_collection = EffectCollection()
dialogue_collection = UnitDialogueCollection()
"""
Prepare unit model collection
"""
unit_models = []
expected_units = []
unit_items = []
unit_effects = []
unit_dialogue = []
unit_items_model = UnitItems(db="quux")
unit_effects_model = UnitEffects(db="quux")
unit_dialogue_model = UnitDialogueModel(db="quux")
total_units = 25
item_types = ("rock", "paper", "scissors", "paper", "spock")
total_items_per_unit = len(item_types)
total_effects_per_unit = 5
total_dialogue_per_unit = 5
for j in range(0, total_units):
"""
Add items for each unit
"""
items = []
effects = []
dialogue = []
unit_model = self._get_unit_model()
unit_id = unit_model["id"]
unit_type_id = unit_model["unit_type_id"]
for it in item_types:
item = self._make_item(item_type=it,
unit_type_id=unit_type_id)
items.append(item)
item_collection.add(item)
unit_items.append({"item_id": item.id, "unit_id": unit_id})
unit_model["items"] = items
"""
Base items
"""
unit_model["base_items"] = \
item_collection.get_base_items_by_unit_type_id(unit_type_id)
"""
Add effects
"""
for k in range(0, total_effects_per_unit):
effect = self._make_effect()
effects.append(effect)
effect_collection.add(effect)
unit_effects.append(
{"effect_id": effect.id, "unit_id": unit_id})
unit_model["effects"] = effects
"""
Add dialogue
"""
for q in range(0, total_dialogue_per_unit):
a_dialogue = self._make_dialogue()
dialogue.append(a_dialogue)
dialogue_collection.add(a_dialogue)
unit_dialogue.append(
{"dialogue_id": a_dialogue.id, "unit_id": unit_id})
unit_model["dialogue"] = dialogue
"""
Add completed unit to expected
"""
unit_models.append(unit_model)
with LogCapture():
logger = logging.getLogger()
unit = Unit(unit=unit_model, log=logger)
expected_units.append(unit)
unit_items_map = unit_items_model._get_unit_items_map(unit_items)
unit_effects_map = unit_effects_model._get_unit_effects_map(
unit_effects)
unit_dialogue_map = unit_dialogue_model._get_unit_dialogue_map(
unit_dialogue)
builder = UnitBuilder()
with LogCapture():
logger = logging.getLogger()
actual_units = builder.build_units(unit_models=unit_models,
unit_items_map=unit_items_map,
item_collection=item_collection,
effect_collection=effect_collection,
unit_effects_map=unit_effects_map,
dialogue_collection=dialogue_collection,
unit_dialogue_map=unit_dialogue_map,
log=logger)
expected_unit_ids = [unit.id for e_unit in expected_units]
actual_unit_ids = [unit.id for a_unit in actual_units]
self.assertEqual(expected_unit_ids, actual_unit_ids)
"""
Test that the actual units contain the expected items
and effects
"""
self.assertEqual(len(actual_units), len(expected_units))
for e_unit in expected_units:
self.assertEqual(len(e_unit.items), total_items_per_unit)
self.assertEqual(len(e_unit.effects), total_effects_per_unit)
self.assertEqual(len(e_unit.dialogue), total_dialogue_per_unit)
for a_unit in actual_units:
self.assertEqual(len(a_unit.items), total_items_per_unit)
self.assertEqual(len(a_unit.effects), total_effects_per_unit)
self.assertEqual(len(a_unit.dialogue), total_dialogue_per_unit)
"""
Ensure each item either has no unit type requirement (0)
or it matches the unit in question
"""
for a_item in a_unit.items:
self.assertIn(a_item.unit_type_id, (0, a_unit.unit_type_id))
def test_build_world(self):
"""
Utilize models to build the world.
1. Get dungeons
2. Get effects
3. Get item effects
4. Get items
5. Get unit items
6. Get units
"""
""" Dungeons """
dungeon_model = DungeonModel(db=self.db)
dungeon_models = dungeon_model.get_dungeons()
self.assertIsInstance(dungeon_models, list)
self.assertTrue(dungeon_models)
""" Effects """
effects_model = EffectModel(db=self.db)
effects_models = effects_model.get_effects()
self.assertIsInstance(effects_models, list)
self.assertTrue(effects_models)
""" Unit effects map """
unit_effects_model = UnitEffects(db=self.db)
unit_effects = unit_effects_model.get_unit_effects()
unit_effects_map = unit_effects_model._get_unit_effects_map(unit_effects)
self.assertIsInstance(unit_effects_map, dict)
self.assertTrue(unit_effects_map)
""" Unit dialogue map """
unit_dialogue_model = UnitDialogueModel(db=self.db)
unit_dialogue = unit_dialogue_model.get_unit_dialogue()
unit_dialogue_map = unit_dialogue_model._get_unit_dialogue_map(unit_dialogue)
self.assertIsInstance(unit_dialogue, list)
self.assertIsInstance(unit_dialogue_map, dict)
self.assertTrue(unit_dialogue_map)
""" Item effects map """
item_effects_model = ItemEffects(db=self.db)
item_effects = item_effects_model.get_item_effects()
item_effects_map = item_effects_model._get_item_effects_map(item_effects)
self.assertIsInstance(item_effects, list)
self.assertIsInstance(item_effects_map, dict)
self.assertTrue(item_effects_map)
self.assertTrue(item_effects)
""" Items """
item_model = ItemModel(db=self.db)
item_models = item_model.get_items()
self.assertIsInstance(item_models, list)
self.assertTrue(item_models)
""" Unit items map """
unit_items_model = UnitItems(db=self.db)
unit_item_models = unit_items_model.get_unit_items()
unit_items_map = unit_items_model._get_unit_items_map(unit_item_models)
self.assertIsInstance(unit_item_models, list)
self.assertIsInstance(unit_items_map, dict)
self.assertTrue(unit_items_map)
self.assertTrue(unit_item_models)
""" Units """
unit_model = UnitModel(db=self.db)
unit_models = unit_model.get_units()
self.assertIsInstance(unit_models, list)
self.assertTrue(unit_models)
""" Assemble collections using models """
item_collection = ItemCollection()
effect_collection = EffectCollection()
dialogue_collection = UnitDialogueCollection()
for effect_model in effects_models:
effect = Effect(effect=effect_model)
effect_collection.add(effect)
self.assertTrue(effect_collection.effects)
item_builder = ItemBuilder()
items = item_builder.build_items(item_models=item_models,
item_effects_map=item_effects_map,
effect_collection=effect_collection)
self.assertIsInstance(items, list)
self.assertTrue(items)
for item in items:
item_collection.add(item)
self.assertTrue(item_collection.items)
for ud in unit_dialogue:
dialogue = UnitDialogue(dialogue=ud)
dialogue_collection.add(dialogue)
""" Build units using assembled collections """
unit_builder = UnitBuilder()
with LogCapture() as l:
logger = logging.getLogger()
units = unit_builder.build_units(unit_models=unit_models,
effect_collection=effect_collection,
item_collection=item_collection,
dialogue_collection=dialogue_collection,
unit_items_map=unit_items_map,
unit_effects_map=unit_effects_map,
unit_dialogue_map=unit_dialogue_map,
log=logger)
self.assertIsInstance(units, list)
self.assertTrue(units)
num_players = 0
for unit in units:
self.assertIsInstance(unit, Unit)
if unit.is_player:
num_players += 1
self.assertTrue(num_players > 0)
"""
Populate collections
"""
unit_collection = UnitCollection()
for unit in units:
unit_collection.add(unit)
self.assertEqual(len(unit_collection.units), len(unit_models))