Added some tests to tests_types.py

Added hierarchy tests

EditorialModel/test/test_types.py

@@ -30,9 +30,19 @@ def setUpModule():
 
     emclass1 = EmClass.create("entity1", EmClassType.entity)
     emclass2 = EmClass.create("entity2", EmClassType.entity)
+    emclass3 = EmClass.create("entry1", EmClassType.entry)
+    emclass4 = EmClass.create("person1", EmClassType.person)
+
     emtype = EmType.create(name='type1', em_class=emclass2)
     EmType.create(name='type2', em_class=emclass2)
     EmType.create(name='type3', em_class=emclass2)
+
+    EmType.create(name='type4', em_class=emclass3)
+    EmType.create(name='type5', em_class=emclass3)
+
+    EmType.create(name='type6', em_class=emclass4)
+    EmType.create(name='type7', em_class=emclass4)
+
     emfieldgroup = EmFieldGroup.create(name='fieldgroup1', em_class=emclass1)
     emfieldtype = get_field_type('integer')
     EmField.create(name='field1', fieldgroup=emfieldgroup, fieldtype=emfieldtype, rel_to_type_id=emtype.uid)
@@ -52,6 +62,10 @@ class TypeTestCase(TestCase):
         self.emtype = EmType('type1')
         self.emtype2 = EmType('type2')
         self.emtype3 = EmType('type3')
+        self.emtype4 = EmType('type4')
+        self.emtype5 = EmType('type5')
+        self.emtype6 = EmType('type6')
+        self.emtype7 = EmType('type7')
         self.emfieldgroup = EmFieldGroup('fieldgroup1')
         self.emfieldtype = get_field_type('integer')
         self.emfield = EmField('field1')
@@ -67,6 +81,7 @@ class TestSelectField(TypeTestCase):
         self.assertFalse(Em_Field_Type(self.emtype.uid, self.emfield.uid).exists())
 
 class TestLinkedTypes(TypeTestCase):
+    @unittest.skip("Not yet implemented")
     def testLinkedtypes(self):
         self.emtype.add_superior(self.emtype2, EmNature.PARENT)
         self.emtype3.add_superior(self.emtype, EmNature.PARENT)
@@ -78,10 +93,104 @@ class TestLinkedTypes(TypeTestCase):
         self.assertIn(self.emtype2, linked_types)
         self.assertIn(self.emtype3, linked_types)
 
+class TestTypeHierarchy(TypeTestCase):
+
+    @staticmethod
+    ## Replace instances by uid in subordinates or superiors return values
+    def _hierarch_uid(subs):
+        res = dict()
+        for nat in subs:
+            res[nat] = []
+            for sub in subs[nat]:
+                res[nat].append(sub.uid)
+        return res
+
+    # Check that the superior has been added
+    def check_add_sup(self, subtype, suptype, relnat):
+        subuid = self._hierarch_uid(suptype.subordinates())
+        supuid = self._hierarch_uid(subtype.superiors())
+
+        for nat in subuid:
+            if nat == relnat:
+                check = self.assertIn
+                msg = " should be in "
+            else:
+                check = self.assertNotIn
+                msg = " should not be in "
+            check(subtype.uid, subuid[nat], subtype.name+msg+suptype.name+" subordinates with nature '"+nat+"'")
+            check(suptype.uid, supuid[nat], suptype.name+msg+subtype.name+" superiors with nature '"+nat+"'")
+        pass
+            
+
+    def testAddSuperiorParent(self):
+        self.emtype.add_superior(self.emtype2, EmNature.PARENT)
+        self.check_add_sup(self.emtype, self.emtype2, EmNature.PARENT)
+
+        self.emtype4.add_superior(self.emtype4, EmNature.PARENT)
+        self.check_add_sup(self.emtype4, self.emtype4, EmNature.PARENT)
+        pass
+
+    def testAddSuperiorTranslation(self):
+        self.emtype.add_superior(self.emtype, EmNature.TRANSLATION)
+        self.check_add_sup(self.emtype, self.emtype, EmNature.TRANSLATION)
+
+        self.emtype4.add_superior(self.emtype4, EmNature.TRANSLATION)
+        self.check_add_sup(self.emtype4, self.emtype4, EmNature.TRANSLATION)
+        pass
+
+    def testAddSuperiorIdentity(self):
+        self.emtype6.add_superior(self.emtype6, EmNature.IDENTITY)
+        self.check_add_sup(self.emtype6, self.emtype6, EmNature.IDENTITY)
+        self.emtype6.add_superior(self.emtype7, EmNature.IDENTITY)
+        self.check_add_sup(self.emtype6, self.emtype6, EmNature.IDENTITY)
+        pass
+
+    def testIllegalSuperior(self):
+        illegal_combinations = [
+            (self.emtype, self.emtype4, EmNature.PARENT),
+            (self.emtype, self.emtype2, EmNature.TRANSLATION),
+            (self.emtype4, self.emtype5, EmNature.PARENT),
+            (self.emtype4, self.emtype5, EmNature.TRANSLATION),
+            (self.emtype6, self.emtype, EmNature.IDENTITY),
+            (self.emtype4, self.emtype, EmNature.PARENT),
+            (self.emtype6, self.emtype, EmNature.PARENT),
+            (self.emtype, self.emtype2, EmNature.IDENTITY),
+
+        ]
+        for t1, t2, rnat in illegal_combinations:
+            with self.assertRaises(ValueError, msg="When trying to add an illegal superior "+str(t2)+" to "+str(t1)+" with '"+rnat+"' as relation nature"):
+                t1.add_superior(t2, rnat)
+        pass
+    
+    def testDelSuperior(self):
+        self.emtype.add_superior(self.emtype2, EmNature.PARENT)
+        self.emtype.add_superior(self.emtype, EmNature.PARENT)
+        self.emtype.add_superior(self.emtype, EmNature.TRANSLATION)
+
+        self.emtype.del_superior(self.emtype2, EmNature.PARENT)
+        supuid = self._hierarch_uid(self.emtype.superiors())
+        self.assertNotIn(self.emtype2.uid, supuid[EmNature.PARENT], str(self.emtype2)+" should have been deleted as superior of "+str(self.emtype))
+
+        self.assertIn(self.emtype.uid, supuid[EmNature.PARENT], "Deleted more than wanted in the same relation nature")
+        self.assertIn(self.emtype.uid, supuid[EmNature.TRANSLATION], "Deleted more than wanted in another relation nature")
+        pass
+        
+        
+
 class TestDeleteTypes(TypeTestCase):
-    @unittest.skip("Test invalid, le type n'existe pas")
     def testDeleteTypes(self):
         type_name = self.emtype.name
-        self.emtype.delete()
+        self.assertTrue(self.emtype.delete(), "delete method returns False but should return True")
         with self.assertRaises(EmComponentNotExistError, msg="Type not deleted"):
             EmType(type_name)
+
+    def testUndeletableTypes(self):
+        type_name = self.emtype.name
+        self.emtype2.add_superior(self.emtype, 'parent')
+        self.assertFalse(self.emtype.delete(), "delete return True but should return False")
+        try:
+            tmptype = EmType(type_name)
+        except EmComponentNotExistError:
+            self.fail("The type was deleted but it has subordinates when deleted")
+        pass
+