Tests: Füge Bauteile in die Zonen hinzu

MechFabrik/bauteile/__init__.py

@@ -1,6 +1,4 @@
-import csv
 import enum
-import os
 from typing import Any
 
 
@@ -15,26 +13,70 @@ class AreaNames(enum.Enum):
     LEFT_ARM = 'Linker Arm'
 
 
+class ItemTypes(enum.Enum):
+    COCKPIT = 1
+    REAKTOR = 2
+    GYROSKOPE = 3
+    ACTIVATOR = 4
+    JOINT = 5
+    SENSORS = 6
+    SUSTAINMENT = 7
+
+
+class Item(object):
+    def __init__(self, type: ItemTypes):
+        self._type = type
+
+    @property
+    def type(self):
+        return self._type
+
+
+class BigItem(Item):
+
+    def __init__(self, type: ItemTypes, tonnage: float):
+        super().__init__(type)
+        self._tonnage = tonnage
 
-class Cockpit:
     @property
     def tonnage(self) -> float:
-        return 3.0
+        return self._tonnage
 
 
-class Reaktor:
+class Cockpit(BigItem):
+    def __init__(self):
+        super().__init__(ItemTypes.COCKPIT, 3.0)
+
+
+class Reaktor(BigItem):
 
     def __init__(self, value: int, tonnage: float):
-        self._tonnage = tonnage
+        super().__init__(ItemTypes.REAKTOR, tonnage)
         self._value = value
 
     @property
     def value(self):
         return self._value
 
-    @property
+
-    def tonnage(self):
+class Activator(Item):
-        return self._tonnage
+    def __init__(self):
+        super().__init__(ItemTypes.ACTIVATOR)
+
+
+class Joint(Item):
+    def __init__(self):
+        super().__init__(ItemTypes.JOINT)
+
+
+class Sensors(Item):
+    def __init__(self):
+        super().__init__(ItemTypes.SENSORS)
+
+
+class Sustainment(Item):
+    def __init__(self):
+        super().__init__(ItemTypes.SUSTAINMENT)
 
 
 class Area:
@@ -42,8 +84,9 @@ class Area:
 
     def __init__(self):
         self.__dict__['_content'] = {
-            'children': []
+                'children': [],
-        }
+                'items':    {}
+                }
 
     def __setattr__(self, key, value):
         self.__dict__['_content'][key] = value
@@ -80,7 +123,7 @@ class InnerStructure:
     def areas(self) -> dict:
         return self._areas
 
-    def add_area(self,index: AreaNames, area: Area):
+    def add_area(self, index: AreaNames, area: Area):
         self._areas[index] = area
 
 
@@ -107,3 +150,6 @@ class Mech(object):
     @property
     def movement_rate(self) -> int:
         return self._movement_rate
+
+    def set_item(self, key: tuple, item: Item):
+        pass

tests/test_mech_bau.py

@@ -1,7 +1,8 @@
 import unittest
+from tokenize import group
 
 from MechFabrik import MechFabrik
-from MechFabrik.bauteile import InnerStructure, Gyroskope, AreaNames, Area, Cockpit, Reaktor, Mech
+from MechFabrik.bauteile import InnerStructure, Gyroskope, AreaNames, Area, Cockpit, Item, ItemTypes, Reaktor, Mech
 
 
 class TestMechBau(unittest.TestCase):
@@ -32,7 +33,25 @@ class TestMechBau(unittest.TestCase):
         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.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_left_items(right_arm)
+        self._test_for_arm_left_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_left_items(left_arm)
+        self._test_for_arm_left_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
@@ -43,29 +62,63 @@ class TestMechBau(unittest.TestCase):
         self.assertEqual(6.0, reactor.tonnage)
         self.assertIsNone(middle_torso.parent)
         self.assertIsInstance(middle_torso.children, list)
-        right_torso = self._test_area(mech = mech, parent = middle_torso, index = AreaNames.RIGHT_TORSO)
+        return middle_torso
-        left_torso = self._test_area(mech = mech, parent = middle_torso, index = AreaNames.LEFT_TORSO)
-        self.assertCountEqual([right_torso, left_torso], middle_torso.children)
 
-        self._test_limbs(mech = mech, parent = right_torso, index = AreaNames.RIGHT_ARM)
+    def _test_areas(self, mech: Mech, parent: Area, index: AreaNames, children: int) -> Area:
-        self._test_limbs(mech = mech, parent = right_torso, index = AreaNames.RIGHT_LEG)
+        area = mech.inner_structure.areas.get(index)
-        self._test_limbs(mech = mech, parent = left_torso, index = AreaNames.LEFT_ARM)
+        self.assertIsInstance(area, Area)
-        self._test_limbs(mech = mech, parent = left_torso, index = AreaNames.LEFT_LEG)
+        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_area(self, mech: Mech, parent: Area, index: AreaNames):
+    def _test_for_head_items(self, area: Area):
-        side_torso = mech.inner_structure.areas.get(index)
+        self.__test_for_items(area, [
-        self.assertIsInstance(side_torso, Area)
+                ((1, 1), ItemTypes.SUSTAINMENT),
-        self.assertIsInstance(side_torso.parent, Area)
+                ((1, 2), ItemTypes.SENSORS),
-        self.assertEqual(parent, side_torso.parent)
+                ((1, 3), ItemTypes.COCKPIT),
-        self.assertIsInstance(side_torso.children, list)
+                ((1, 5), ItemTypes.SENSORS),
-        self.assertEqual(2, len(side_torso.children))
+                ((1, 6), ItemTypes.SUSTAINMENT),
-        return side_torso
+                ]
+                              )
+        self.assertIsNone(area.items[(1, 4)])
 
-    def _test_limbs(self, mech: Mech, parent: Area, index: AreaNames):
+    def _test_for_middle_torso_items(self, area: Area):
-        limbs_area = mech.inner_structure.areas.get(index)
+        self.__test_for_items(area, [
-        self.assertIsInstance(limbs_area, Area)
+                ((1, 1), ItemTypes.REAKTOR),
-        self.assertIsInstance(limbs_area.parent, Area)
+                ((1, 2), ItemTypes.REAKTOR),
-        self.assertEqual(parent, limbs_area.parent)
+                ((1, 3), ItemTypes.REAKTOR),
-        self.assertIsInstance(limbs_area.children, list)
+                ((1, 4), ItemTypes.GYROSKOPE),
-        self.assertCountEqual([], limbs_area.children)
+                ((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):
+        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_left_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)