166 lines
7.0 KiB
Python
Executable File
166 lines
7.0 KiB
Python
Executable File
import unittest
|
|
|
|
from hangar.mech import Mech
|
|
from mech_factory import MechFabrik
|
|
from mech_factory.component_storage import InnerStructure, AreaNames, Area, OuterAmor, Zone, ZoneNames
|
|
from mech_factory.component_storage.items import Cockpit, Gyroskope, Item, ItemTypes, Reaktor
|
|
from test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
|
|
|
|
|
|
class TestMechBau(unittest.TestCase):
|
|
|
|
def test_simple(self):
|
|
fabrik = MechFabrik('Heuschrecke', 20.0, 8)
|
|
mech = fabrik.auslieferung()
|
|
self.assertIsInstance(mech, Mech)
|
|
self.assertIsInstance(mech.name, str)
|
|
self.assertEqual('Heuschrecke', mech.name)
|
|
self.assertIsInstance(mech.tonnage, float)
|
|
self.assertEqual(20.0, mech.tonnage)
|
|
self.assertIsInstance(mech.movement_rate, int)
|
|
self.assertEqual(8, mech.movement_rate)
|
|
|
|
for ara_name in AreaNames:
|
|
area = mech.inner_structure.areas.get(ara_name)
|
|
should_amor = INNER_ARMOR[ara_name]
|
|
self.assertIsInstance(area, Zone)
|
|
self.assertIsInstance(area, Area)
|
|
self.assertEqual(should_amor, area.armor)
|
|
|
|
for zone_name in ZoneNames:
|
|
zone = mech.inner_structure.zones.get(zone_name)
|
|
self.assertIsInstance(zone, Zone)
|
|
self.assertIsInstance(zone, OuterAmor)
|
|
self.assertEqual(0, zone.armor)
|
|
|
|
self.assertIsInstance(mech.inner_structure, InnerStructure)
|
|
self.assertIsInstance(mech.inner_structure.tonnage, float)
|
|
self.assertEqual(2.0, mech.inner_structure.tonnage)
|
|
|
|
self.assertIsInstance(mech.inner_structure.gyroskope, Gyroskope)
|
|
self.assertIsInstance(mech.inner_structure.gyroskope.tonnage, float)
|
|
self.assertEqual(2.0, mech.inner_structure.gyroskope.tonnage)
|
|
self.assertIsInstance(mech.inner_structure.areas, dict)
|
|
|
|
area_head = mech.inner_structure.areas.get(AreaNames.HEAD)
|
|
self.assertIsInstance(area_head, Area)
|
|
cockpit = area_head.cockpit
|
|
self.assertIsInstance(cockpit, Cockpit)
|
|
self.assertIsInstance(cockpit.tonnage, float)
|
|
self.assertEqual(3.0, cockpit.tonnage)
|
|
self._test_for_head_items(area_head)
|
|
|
|
middle_torso = self._test_middle_torso(mech)
|
|
right_torso = self._test_areas(mech=mech, parent=middle_torso, index=AreaNames.RIGHT_TORSO, children=2)
|
|
left_torso = self._test_areas(mech=mech, parent=middle_torso, index=AreaNames.LEFT_TORSO, children=2)
|
|
self.assertIsInstance(area_head.parent, Area)
|
|
self.assertEqual(middle_torso, area_head.parent)
|
|
self.assertCountEqual([right_torso, left_torso], middle_torso.children)
|
|
|
|
right_arm = self._test_areas(mech=mech, parent=right_torso, index=AreaNames.RIGHT_ARM, children=0)
|
|
right_leg = self._test_areas(mech=mech, parent=right_torso, index=AreaNames.RIGHT_LEG, children=0)
|
|
self.assertCountEqual([right_arm, right_leg], right_torso.children)
|
|
self._test_for_arm_items(right_arm)
|
|
self._test_for_leg_items(right_leg)
|
|
left_arm = self._test_areas(mech=mech, parent=left_torso, index=AreaNames.LEFT_ARM, children=0)
|
|
left_leg = self._test_areas(mech=mech, parent=left_torso, index=AreaNames.LEFT_LEG, children=0)
|
|
self.assertCountEqual([left_arm, left_leg], left_torso.children)
|
|
self._test_for_arm_items(left_arm)
|
|
self._test_for_leg_items(left_leg)
|
|
|
|
def _test_middle_torso(self, mech) -> Area:
|
|
middle_torso = mech.inner_structure.areas.get(AreaNames.MIDDLE_TORSO)
|
|
self.assertIsInstance(middle_torso, Area)
|
|
reactor = middle_torso.reactor
|
|
self.assertIsInstance(reactor, Reaktor)
|
|
self.assertIsInstance(reactor.value, int)
|
|
self.assertEqual(160, reactor.value)
|
|
self.assertIsInstance(reactor.tonnage, float)
|
|
self.assertEqual(6.0, reactor.tonnage)
|
|
self.assertIsNone(middle_torso.parent)
|
|
self.assertIsInstance(middle_torso.children, list)
|
|
return middle_torso
|
|
|
|
def _test_areas(self, mech: Mech, parent: Area, index: AreaNames, children: int) -> Area:
|
|
area = mech.inner_structure.areas.get(index)
|
|
self.assertIsInstance(area, Area)
|
|
self.assertIsInstance(area.parent, Area)
|
|
self.assertEqual(parent, area.parent)
|
|
self.assertIsInstance(area.children, list)
|
|
self.assertEqual(children, len(area.children))
|
|
return area
|
|
|
|
def _test_for_head_items(self, area: Area):
|
|
self.assertEqual(6, len(area.items))
|
|
self.__test_for_items(area, [
|
|
((1, 1), ItemTypes.SUSTAINMENT),
|
|
((1, 2), ItemTypes.SENSORS),
|
|
((1, 3), ItemTypes.COCKPIT),
|
|
((1, 5), ItemTypes.SENSORS),
|
|
((1, 6), ItemTypes.SUSTAINMENT),
|
|
]
|
|
)
|
|
self.assertIsNone(area.items[(1, 4)])
|
|
|
|
def _test_for_middle_torso_items(self, area: Area):
|
|
self.assertEqual(12, len(area.items))
|
|
self.__test_for_items(area, [
|
|
((1, 1), ItemTypes.REAKTOR),
|
|
((1, 2), ItemTypes.REAKTOR),
|
|
((1, 3), ItemTypes.REAKTOR),
|
|
((1, 4), ItemTypes.GYROSKOPE),
|
|
((1, 5), ItemTypes.GYROSKOPE),
|
|
((1, 6), ItemTypes.GYROSKOPE),
|
|
|
|
((2, 1), ItemTypes.GYROSKOPE),
|
|
((2, 2), ItemTypes.GYROSKOPE),
|
|
((2, 3), ItemTypes.GYROSKOPE),
|
|
((2, 4), ItemTypes.REAKTOR),
|
|
]
|
|
)
|
|
self.assertIsNone(area.items[(2, 5)])
|
|
self.assertIsNone(area.items[(2, 6)])
|
|
|
|
def _test_for_side_torso_items(self, area: Area):
|
|
self.assertEqual(12, len(area.items))
|
|
for (group, key) in ((group, key + 1) for group in [1, 2] for key in range(6)):
|
|
self.assertIsNone(area.items[key])
|
|
|
|
def _test_for_arm_items(self, area: Area):
|
|
self.assertEqual(12, len(area.items))
|
|
self._test_for_arm_leg_items(area)
|
|
for key in (key + 1 for key in range(6)):
|
|
self.assertIsNone(area.items[(2, key)])
|
|
pass
|
|
|
|
def _test_for_leg_items(self, area: Area):
|
|
self.assertEqual(6, len(area.items))
|
|
self._test_for_arm_leg_items(area)
|
|
pass
|
|
|
|
def _test_for_arm_leg_items(self, area: Area):
|
|
self.__test_for_items(area, [
|
|
((1, 1), ItemTypes.JOINT),
|
|
((1, 2), ItemTypes.ACTIVATOR),
|
|
((1, 3), ItemTypes.ACTIVATOR),
|
|
((1, 4), ItemTypes.ACTIVATOR),
|
|
]
|
|
)
|
|
self.assertIsNone(area.items[(1, 5)])
|
|
self.assertIsNone(area.items[(1, 6)])
|
|
pass
|
|
|
|
def __test_for_items(self, area: Area, should_list: list):
|
|
for (key, item_type) in should_list:
|
|
self.assertIsInstance(area.items[key], Item)
|
|
self.assertEqual(area.items[key].type, item_type)
|
|
|
|
|
|
class TestMechAmor(AbstractTestMechAmor):
|
|
|
|
def test_build(self):
|
|
for zone_name in ZoneNames:
|
|
zone = self.mech.inner_structure.zones.get(zone_name)
|
|
should_outer_armor = OUTER_ARMOR[zone_name]
|
|
self.assertEqual(should_outer_armor, zone.armor)
|