Add tests for LeFactory generated code

leobject/lefactory.py

         return """
 {name}._fields = {fields}
 {name}._superiors = {dsups}
-{name}._leClass = {leclass}
+{name}._leclass = {leclass}
 """.format(
     name = LeFactory.name2classname(emtype.name),
     fields = repr(type_fields),
 )
 
     ## @brief Generate python code containing the LeObject API
-    # @param model_args dict : Dict of Model __init__ method arguments
-    # @param datasource_args dict : Dict of datasource __init__ method arguments
+    # @param backend_cls Backend : A model backend class
+    # @param backend_args dict : A dict representing arguments for backend_cls instanciation
+    # @param datasource_cls Datasource : A datasource class
+    # @param datasource_args dict : A dict representing arguments for datasource_cls instanciation
     # @return A string representing python code
     @staticmethod
     def generate_python(backend_cls, backend_args, datasource_cls, datasource_args):
     _datasource = %s(**%s)
     _me_uid = %s
 
-"""%(backend_constructor, datasource_cls.__name__, repr(datasource_args), repr(leobj_me_uid))
+"""%(backend_constructor, datasource_cls.__module__+'.'+datasource_cls.__name__, repr(datasource_args), repr(leobj_me_uid))
         
         emclass_l = model.components(EditorialModel.classes.EmClass)
         emtype_l = model.components(EditorialModel.types.EmType)
         #LeClass child classes definition
         for emclass in emclass_l:
            result += """
-class %s(LeObject,LeType):
+class %s(LeObject,LeClass):
     _class_id = %d
 """%(LeFactory.name2classname(emclass.name), emclass.uid)
         #LeType child classes definition
 LeObject._me_uid = %s
 """%repr({ comp.uid:LeFactory.name2classname(comp.name) for comp in emclass_l + emtype_l })
             
-            
         return result
 

leobject/letype.py

     # @thorw A leo exception if invalid stuff
     # @throw InvalidArgumentError if invalid argument
     @classmethod
-    def insert(self, **datas):
-        self.check_datas_or_raise(datas, complete=True)
-        super(LeType, self).insert(typename=self.__class__.__name__, classname=self._leclass.__name__, **datas)
+    def insert(cls, **datas):
+        cls.check_datas_or_raise(datas, complete=True)
+        super(LeType, cls).insert(typename=cls.__name__, **datas)
         pass
     
     ## @brief Check that datas are valid for this type