Add test + small bugfixes in fieldtypes + implementations of short utils methods

EditorialModel/fieldtypes/leo.py

@@ -12,7 +12,7 @@ class EmFieldType(GenericFieldType):
     ftype = 'leobject'
 
     def __init__(self, superior=True, **kwargs):
-        super(EmFieldType, self).__init__(ftype = 'leobject', **kwargs)
+        super(EmFieldType, self).__init__(ftype = 'leobject', superior = superior, **kwargs)
 
     def _check_data_value(self, value):
         err = None
@@ -25,18 +25,17 @@ class EmFieldType(GenericFieldType):
     
     ## @brief If field value is an integer, returns a partially instanciated LeObject (only with an ID)
     def construct_data(self, lec, fname, datas):
-        import leapi.lecrud as lecrud
         if isinstance(datas[fname], int):
-            leobject = lecrud._LeCrud.name2class('LeObject')
-            return leobject.get(datas[fname])
+            leobject = lec.name2class('LeObject')
+            return leobject(datas[fname])
         else:
             return datas[fname]
     
     def check_data_consistency(self, lec, fname, datas):
         if self.superior:
-            return self.check_sup_consistency()
+            return self.check_sup_consistency(lec, fname, datas)
         else:
-            return self.check_sub_consistency()
+            return self.check_sub_consistency(lec, fname, datas)
 
     def check_sup_consistency(self, lec, fname, datas):
         pass

EditorialModel/fieldtypes/naturerelation.py

@@ -14,26 +14,35 @@ class EmFieldType(EmFieldType):
         super(EmFieldType, self).__init__(**kwargs)
 
     def check_data_value(self, value):
-        return value is None or ( value in classtypes.EmNature.getall())
-
+        if value is None or ( value in classtypes.EmNature.getall()):
+            return value, None
+        else:
+            return None, ValueError("Unknown relation nature '%s'"%value)
+    
+    ## @todo implements types checks
     def check_data_consistency(self, lec, fname, datas):
         #Checking given component
-        if not isinstance(lec, lerelation.LeRelation):
-            return ValueError("A field naturerelation has to be in a LeRelation object, but this one is in a '%s'"%lec.__name__)
+        #Replace with a test from _LeCrud
+        #if not isinstance(lec, lerelation._LeRelation):
+        #    return ValueError("A field naturerelation has to be in a LeRelation object, but this one is in a '%s'"%lec.__name__)
         nature = datas[fname]
         lesup = datas['lesup']
         lesub = datas['lesub']
         if nature is None:
-            if not isinstance(lec, lerelation.LeRel2Type):
-                return ValueError("Only LeRel2Type are allowed to have NULL nature")
+            #if not isinstance(lec, lerelation.LeRel2Type):
+            #Replace with a test from _LeCrud
+            #    return ValueError("Only LeRel2Type are allowed to have NULL nature")
+            pass
         else:
-            if not isinstance(lec, lerelation.LeHierarch):
-                return ValueError("Only LeHierarch has not NULL nature")
+            #if not isinstance(lec, lerelation.LeHierarch):
+            #Replace with a test from _LeCrud
+            #    return ValueError("Only LeHierarch has not NULL nature")
             #Checking if nature <=> lesup & lesub classtypes
-            if nature not in classtypes.EmClassType.natures(lesub._classtype):
-                return ValueError("Invalid nature '%s' for %s"%(nature, lesub.__class__.__name__))
-
-            if not lesup.is_root():
+            if not lesub.is_partial():
+                if nature not in classtypes.EmClassType.natures(lesub._classtype):
+                    return ValueError("Invalid nature '%s' for %s"%(nature, lesub.__class__.__name__))
+            
+            if not lesup.is_partial() and not lesup.is_root():
                 if nature not in classtypes.EmClassType.natures(lesup._classtype):
                     return ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
         return True

leapi/lecrud.py

@@ -169,7 +169,11 @@ class _LeCrud(object):
         #Checks datas
         checked_datas = dict()
         for name, value in [ (name, value) for name, value in datas.items() if name in correct ]:
-            checked_datas[name], err = cls.fieldtypes()[name].check_data_value(value)
+            ft = cls.fieldtypes()
+            ft = ft[name]
+            r = ft.check_data_value(value)
+            checked_datas[name], err = r
+            #checked_datas[name], err = cls.fieldtypes()[name].check_data_value(value)
             if err:
                 err_l.append(err)
 

leapi/leobject.py

@@ -49,6 +49,15 @@ class _LeObject(_LeCrud):
         qfilter = '{uid_fname} = {uid}'.format(uid_fname = uid_fname, uid = getattr(self, uid_fname))
         return leobject.get([qfilter])[0]
     
+    ## @return True if the LeObject is partially instanciated
+    def is_partial(self):
+        return not hasattr(self, '_classtype')
+
+    ## @brief Check if a LeObject is the relation tree Root
+    # @todo implementation
+    def is_root(self):
+        return False
+
     ## @brief Dirty & quick comparison implementation
     def __cmp__(self, other):
         return 0 if self == other else 1

leapi/lerelation.py

@@ -31,7 +31,6 @@ class _LeRelation(lecrud._LeCrud):
         if isinstance(leo, leobject._LeObject):
             return ('lesub', '=', leo)
 
-
     @classmethod
     def fieldtypes(cls):
         rel_ft = dict()
@@ -44,8 +43,6 @@ class _LeRelation(lecrud._LeCrud):
     @classmethod
     def _prepare_relational_fields(cls, field):
         return lecrud.LeApiQueryError("Relational field '%s' given but %s doesn't is not a LeObject"%(field,cls.__name__))
-
-
             
 
 ## @brief Abstract class to handle hierarchy relations

leapi/test/test_lerelation.py

@@ -72,6 +72,7 @@ class LeHierarch(LeRelationTestCase):
     @unittest.skip("Wait for  LeRelation._prepare_filters() to unskip")
     @patch('leapi.datasources.dummy.DummyDatasource.select')
     def test_get(self, dsmock):
+        """ Tests the LeHierarch.get() method """
         from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
 
         queries = [
@@ -111,7 +112,41 @@ class LeHierarch(LeRelationTestCase):
             self.assertEqual(cargs[3], rfilters_ds, "%s != %s"%(cargs, eargs))
 
             dsmock.reset_mock()
-        
+    
+    @unittest.skip("Wait for  LeRelation._prepare_filters() to unskip")
+    @patch('leapi.datasources.dummy.DummyDatasource.insert')
+    def test_insert(self, dsmock):
+        from dyncode import LeCrud, Publication, Numero, Personnes, LeObject, Rubrique, LeHierarch, LeRelation
+        queries = [
+            {
+                'lesup': Rubrique(7),
+                'lesub': Numero(42),
+                'nature': 'parent',
+            },
+            {
+                'lesup': 7,
+                'lesub': 42,
+                'nature': 'parent',
+            },
+            {
+                'lesup': LeObject(7),
+                'lesub': LeObject(42),
+                'nature': 'parent',
+            },
+            {
+                'lesup': LeObject(7),
+                'lesub': 42,
+                'nature': 'parent',
+            }
+        ]
+        for query in queries:
+            LeHierarch.insert(query)
+            dsmock.assert_called_once_with(LeHierarch, **query)
+            dsmock.reset_mock()
+
+            LeRelation.insert(query, 'LeHierarch')
+            dsmock.assert_called_once_with(LeHierarch, **query)
+            dsmock.reset_mock()
 
 class LeRel2TypeTestCase(LeRelationTestCase):
     pass