Changed LeFactory generated code (again) + Bugfix on LeCrud + more tests and tests update

EditorialModel/fieldtypes/generic.py

         if value is None and not self.nullable:
             return (None, TypeError("'None' value but field is not nullable"))
         return self._check_data_value(value)
+    
+    ## @brief Build automatic fields values
+    # @param lec LeCrud : A LeCrud child class
+    # @param fname str : The field name
+    # @param datas dict : dict storing fields values
+    # @return constructed datas
+    def construct_data(self, lec, fname, datas):
+        return datas[fname]
+    
+    ## @brief Check datas consistency
+    # @param leo LeCrud : A LeCrud child class instance
+    # @param fname str : The field name
+    # @param datas dict : dict storing fields values
+    # @return an Exception instance if fails else True
+    def check_data_consistency(self, lec, fname, datas):
+        return True
 
     ## @brief Check if a value is correct
     # @param value * : The value

leapi/leclass.py

 
 import leapi
 
-
+from leapi.leobject import _LeObject
 
 ## @brief Represent an EmClass data instance
 # @note Is not a derivated class of LeObject because the concrete class will be a derivated class from LeObject
-class _LeClass(object):
+class _LeClass(_LeObject):
 
     ## @brief Stores fieldtypes by field name
     _fieldtypes = dict()
     @classmethod
     def fieldtypes(cls):
         ret = dict()
-        ret.update(super(LeClass,cls).fieldtypes())
+        ret.update(super(_LeClass,cls).fieldtypes())
         ret.update(cls._fieldtypes)
         return ret
 

leapi/lecrud.py

 import importlib
 import re
 
-import leapi.leobject
-
 class LeApiErrors(Exception):
     ## @brief Instanciate a new exceptions handling multiple exceptions
     # @param expt_l list : A list of data check Exception
         provided = set(datas.keys())
 
         #searching unknow fields
-        print("provided", provided, "correct", correct)
         unknown = provided - correct
         for u_f in unknown:
             #here we can check if the field is unknown or rejected because it is internal
     # @return A new id if success else False
     @classmethod
     def insert(cls, datas):
-        insert_datas = self.prepare_datas(datas, complete = True, allow_internal = False)
+        insert_datas = cls.prepare_datas(datas, complete = True, allow_internal = False)
         return cls._datasource.insert(cls, insert_datas)
     
     ## @brief Check and prepare datas
     def prepare_datas(cls, datas, complete = False, allow_internal = True):
         if not complete:
             warnings.warn("Actual implementation can make datas construction and consitency checks fails when datas are not complete")
-        ret_dats = self.check_datas_value(cls, datas, complete, allow_internal)
-        ret_datas = self._construct_datas(cls, ret_datas)
-        ret_datas = self._check_data_consistency(cls, ret_datas)
+        ret_datas = cls.check_datas_value(datas, complete, allow_internal)
+        ret_datas = cls._construct_datas(ret_datas)
+        cls._check_datas_consistency(ret_datas)
         return ret_datas
 
     #-###################-#
         res_datas = dict()
         for fname, ftype in cls.fieldtypes().items():
             if fname in datas:
-                res_datas[fname] = ftype.construct_data(datas)
+                res_datas[fname] = ftype.construct_data(cls, fname, datas)
         return res_datas
     ## @brief Check datas consistency
     # 
     def _check_datas_consistency(cls, datas):
         err_l = []
         for fname, ftype in cls.fieldtypes().items():
-            ret = ftype.check_data_consistency(datas)
+            ret = ftype.check_data_consistency(cls, fname, datas)
             if isinstance(ret, Exception):
                 err_l.append(ret)
 

leapi/lefactory.py

             result += """
 ## @brief EmType {name} LeType child class
 # @see leobject::letype::LeType
-class {name}({leclass}, LeType):
+class {name}(LeType, {leclass}):
     _type_id = {uid}
 
 """.format(

leapi/leobject.py

 import warnings
 
 import leapi
-import EditorialModel
+from leapi.lecrud import _LeCrud
 from leapi.lefactory import LeFactory
+import EditorialModel
 from EditorialModel.types import EmType
 
 REL_SUP = 0
 REL_SUB = 1
 
 ## @brief Main class to handle objects defined by the types of an Editorial Model
-class _LeObject(object):
+class _LeObject(_LeCrud):
     
     ## @brief maps em uid with LeType or LeClass keys are uid values are LeObject childs classes
     # @todo check if this attribute shouldn't be in _LeCrud
             cls._fieldtypes_all.update(cls._leo_fieldtypes)
         return cls._fieldtypes_all
 
-    ## @brief Creates new entries in the datasource
-    # @param datas list : A list a dict with fieldname as key
-    # @param cls
-    # @return a list of inserted lodel_id
-    # @see leapi.datasources.dummy.DummyDatasource.insert(), leapi.letype.LeType.insert()
-    @classmethod
-    def insert(cls, letype, datas):
-        if isinstance(datas, dict):
-            datas = [datas]
-
-        if cls == _LeObject:
-            raise NotImplementedError("Abstract method")
-        letype,leclass = cls._prepare_targets(letype)
-        if letype is None:
-            raise ValueError("letype argument cannot be None")
-
-        for data in datas:
-            letype.prepare_data(data, complete = True)
-        return cls._datasource.insert(letype, leclass, datas)
-    
     ## @brief Check if a LeType is a hierarchy root
     @staticmethod
     def is_root(leo):

leapi/letype.py

 # @note LeObject will be generated by leapi.lefactory.LeFactory
 
 import leapi
+from leapi.leclass import _LeClass
 from leapi.leobject import LeObjectError
 
 ## @brief Represent an EmType data instance
 # @note Is not a derivated class of LeClass because the concrete class will be a derivated class from LeClass
-class _LeType(object):
+class _LeType(_LeClass):
     
     ## @brief Stores selected fields with key = name
     _fields = list()

leapi/test/test_lecrud.py

 import leapi.test.utils
 from leapi.lecrud import _LeCrud
 
+## @brief Test LeCrud methods
+# @note those tests need the full dynamically generated code
 class LeCrudTestCase(TestCase):
     @classmethod
     def setUpClass(cls):
         filters = ['hello world !']
         with self.assertRaises(ValueError):
             Personnes._prepare_filters(filters)
+    
+
+    # 
+    #   Tests mocking the datasource
+    # 
+
+    @patch('leapi.datasources.dummy.DummyDatasource.insert')
+    def test_insert(self, dsmock):
+        from dyncode import Publication, Numero, LeObject, Personne, Article
+        ndatas = [
+            (Numero, {'titre' : 'FooBar'}),
+            (Numero, {'titre':'hello'}),
+            (Personne, {'nom':'world', 'prenom':'hello'}),
+            (Article, {'titre': 'Ar Boof', 'soustitre': 'Wow!'}),
+        ]
+        for lecclass, ndats in ndatas:
+            lecclass.insert(ndats)
+            dsmock.assert_called_once_with(lecclass, ndats)
+            dsmock.reset_mock()
+
+            lecclass.insert(ndats)
+            dsmock.assert_called_once_with(lecclass, ndats)
+            dsmock.reset_mock()
+    
+    ## @todo try failing on inserting from LeClass child or LeObject
+    @patch('leapi.datasources.dummy.DummyDatasource.insert')
+    def test_insert_fails(self, dsmock):
+        from dyncode import Publication, Numero, LeObject, Personne, Article
+        ndatas = [
+            (Numero, dict()),
+            (Numero, {'titre':'hello', 'lodel_id':42}),
+            (Numero, {'tititre': 'hehello'}),
+            (Personne, {'titre':'hello'}),
+            (Article, {'titre': 'hello'}),
+        ]
+        for lecclass, ndats in ndatas:
+            with self.assertRaises(leapi.lecrud.LeApiDataCheckError, msg="But trying to insert %s as %s"%(ndats, lecclass.__name__)):
+                lecclass.insert(ndats)
+        pass
 

leapi/test/test_lefactory.py

     def test_leobject(self):
         """ Testing the generated LeObject class """
         import dyncode
+        from dyncode import LeType, LeClass
+
         self.assertTrue(hasattr(dyncode, 'LeObject'))
 
         for uid, cls in dyncode.LeObject._me_uid.items():
-            if leapi.letype.LeType in cls.__bases__:
-                self.assertNotEqual(cls, leapi.letype.LeType)
+            if LeType in cls.__bases__:
+                self.assertNotEqual(cls, LeType)
                 self.assertEqual(cls._type_id, uid)
-            elif leapi.leclass.LeClass in cls.__bases__:
-                self.assertNotEqual(cls, leapi.leclass.LeClass)
+            elif LeClass in cls.__bases__:
+                self.assertNotEqual(cls, LeClass)
                 self.assertEqual(cls._class_id, uid)
             else:
                 self.fail("Bad instance type for _me_uid values : %s"%type(cls))
     def test_leclass(self):
         """ Testing generated LeClass childs classes """
         import dyncode
+        from dyncode import LeType, LeClass
 
         for emclass in self.model.components(EditorialModel.classes.EmClass):
             leclass_name = LeFactory.name2classname(emclass.name)
             self.assertEqual(leclass._class_id, emclass.uid)
             
             #Testing inheritance
-            self.assertEqual(set(leclass.__bases__), set([dyncode.LeObject, leapi.leclass.LeClass]))
+            self.assertEqual(set(leclass.__bases__), set([dyncode.LeObject, dyncode.LeClass]))
             
             #Testing _linked_types attr
             self.assertEqual(
     def test_letype(self):
         """ Testing generated LeType childs classes """
         import dyncode
+        from dyncode import LeType, LeClass
 
         for emtype in self.model.components(EditorialModel.types.EmType):
             letype_name = LeFactory.name2classname(emtype.name)
             #Testing inheritance
             self.assertEqual(
                 set(letype.__bases__),
-                set([leapi.letype.LeType, letype._leclass])
+                set([LeType, letype._leclass])
             )
 
             #Testing _fields

leapi/test/test_leobject.py

     def test_uid2leobj(self):
         """ Testing _Leobject.uid2leobj() """
         import dyncode
+        from dyncode import LeType, LeClass
         for i in dyncode.LeObject._me_uid.keys():
             cls = dyncode.LeObject.uid2leobj(i)
-            if leapi.letype.LeType in cls.__bases__:
+            if LeType in cls.__bases__:
                 self.assertEqual(i, cls._type_id)
-            elif leapi.leclass.LeClass in cls.__bases__:
+            elif LeClass in cls.__bases__:
                 self.assertEqual(i, cls._class_id)
             else:
                 self.fail("Bad value returned : '%s'"%cls)

leapi/test/test_letype.py

     @unittest.skip("Waiting for EmFieldType full implementation")
     def test_init(self):
         """ testing the constructor """
-        from dyncode import Publication, Numero, LeObject
+        from dyncode import Publication, Numero, LeObject, LeType
         
         with self.assertRaises(NotImplementedError):
-            leapi.letype.LeType(42)
+            LeType(42)
 
         badargs = [
             {'class_id':Numero._class_id + 1},
             with self.assertRaises(expect_e, msg="Invalid argument given %s"%badarg):
                 Numero(**badarg)
     
-    @patch('leapi.letype.LeType.populate')
+    @patch('leapi.letype._LeType.populate')
     def test_datas(self, dsmock):
         """ Testing the datas @property method """
         from dyncode import Publication, Numero, LeObject