Tests + bugfix on LeObject.get method

- Changed the way of instanciating results object in get (using __new__ )

lodel/leapi/leobject.py

     # @param set_callback method : The LeObject.set_datas() method of corresponding LeObject class
     # @param get_callback method : The LeObject.get_datas() method of corresponding LeObject class
     def __init__(self, fieldnames_callback, set_callback, get_callback):
-        self.__setter = set_callback
-        self.__getter = get_callback
+        self._setter = set_callback
+        self._getter = get_callback
     
     ##@brief Provide read access to datas values
     # @note Read access should be provided for all fields
     # @param fname str : Field name
     def __getattribute__(self, fname):
-        return self.__getter(fname)
+        getter = super().__getattribute__('_getter')
+        return getter(fname)
     
     ##@brief Provide write access to datas values
     # @note Write acces shouldn't be provided for internal or immutable fields
     # @param fname str : Field name
     # @param fval * : the field value
     def __setattribute__(self, fname, fval):
-        return self.__setter(fname, fval)
+        setter = super().__getattribute__('_setter')
+        return setter(fname, fval)
         
 
 class LeObject(object):
     ##@breif Read & write datasource ( see @ref lodel2_datasources )
     _rw_datasource = None
 
-    ##@brief Construct an object representing an Editorial component
-    # @note Can be considered as EmClass instance
-    def __init__(self, **kwargs):
-        if self._abstract:
-            raise NotImplementedError("%s is abstract, you cannot instanciate it." % self.__class__.__name__ )
+    def __new__(cls, **kwargs):
+        
+        self = object.__new__(cls)
         ##@brief A dict that stores fieldvalues indexed by fieldname
         self.__datas = { fname:None for fname in self._fields }
         ##@brief Store a list of initianilized fields when instanciation not complete else store True
         self.__initialized = list()
         ##@brief Datas accessor. Instance of @ref LeObjectValues
         self.d = LeObjectValues(self.fieldnames, self.set_data, self.data)
+        for fieldname, fieldval in kwargs.items():
+            self.__datas[fieldname] = fieldval
+            self.__initialized.append(fieldname)
+        self.__set_initialized()
+        return self
+
+    ##@brief Construct an object representing an Editorial component
+    # @note Can be considered as EmClass instance
+    def __init__(self, **kwargs):
+        if self._abstract:
+            raise NotImplementedError("%s is abstract, you cannot instanciate it." % self.__class__.__name__ )
 
         # Checks that uid is given
         for uid_name in self._uid:
             self.__datas[uid_name] = kwargs[uid_name]
             del(kwargs[uid_name])
             self.__initialized.append(uid_name)
-        
+
         # Processing given fields
         allowed_fieldnames = self.fieldnames(include_ro = False)
-        err_list = list()
+        err_list = dict()
         for fieldname, fieldval in kwargs.items():
             if fieldname not in allowed_fieldnames:
                 if fieldname in self._fields:
-                    err_list.append(
-                        LeApiError("Value given for internal field : '%s'" % fieldname)
-                    )
+                    err_list[fieldname] = LeApiError(
+                        "Value given but the field is internal")
                 else:
-                    err_list.append(
-                        LeApiError("Unknown fieldname : '%s'" % fieldname)
-                    )
+                    err_list[fieldname] = LeApiError(
+                        "Unknown fieldname : '%s'" % fieldname)
             else:
                 self.__datas[fieldname] = fieldval
                 self.__initialized.append(fieldname)
         if len(err_list) > 0:
-            raise LeApiErrors(err_list)
+            raise LeApiErrors(msg = "Unable to __init__ %s" % self.__class__,
+                exceptions = err_list)
         self.__set_initialized()
     
     #-----------------------------------#
         deleted += result
         return deleted
             
-    
-    ## @brief Load an instance of LeObject
-    #@param uid a list of tuple (uid_field_nane, value) ou a single value
-    #@return an instance of a subclass of LeObject
-    @classmethod
-    def load(cls, uid_tuples):
-        query_filter = list()
-        uids = cls._uid
-        if uids.isinstance(tuple):
-            if not uid_tuples.isinstance(list):
-                raise AttributeError ("In %s:load : uid must be a list of tuple" % cls.__name__)
-            elif len(uid_tuples) != len(uids):
-                raise AttributeError ("In %s:load : must have %d uid fields" % len(uids))
-            for fieldname, fieldvalue in uid_tuples:
-                if fieldname in uids:
-                    dhdl = cls.data_handler(fieldname)
-                    if dhdl.check_data_value(fieldvalue)[1] is None:
-                        query_filter.append((fieldname, '=', fieldvalue))
-                    else:
-                        raise AttributeError("n %s:load :%s not a valid value for %s" % (fieldvalue, fieldname))
-                else:
-                    raise AttributeError ("In %s:load :%s not a uid field for class %s" % (fieldname, cls.__name__))
-        else:
-            dhdl = cls.data_handler(uids)
-            if dhdl.check_data_value(uid_tuples)[1] is None:
-                query_filter.append((uids, '=', uid_tuples))
-            else:
-                raise AttributeError("n %s:load :%s not a valid value for %s" % (uid_tuples, uids))
-        query = LeGetQuery(cls, query_filter, limit = 1)
-        try:
-            result=query.execute()
-        except LeQueryError as err:
-            print("Unable to load object of type %s" % cls.__name__)
-            raise err
-        
-        return cls.name2class(res[CLASS_IDENTIFIER])(result[0])
-        
     ## @brief Get instances of LeObject
     #
     #@param target_class LeObject : class of object the query is about
     #@return a list of items (lists of (fieldname, fieldvalue))
     @classmethod
     def get(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0):
-        if isinstance(cls._uids, tuple):
-            for uid in cls._uids:
-                if uid not in field_list:
-                    raise AttributeError("In %s:get : Cannot instanciate a LeObject without it's identifier" % cls.__name__)
+        if field_list is None:
+            field_list = self.fieldnames(True)
         else:
-            if uid not in field_list:
-                raise AttributeError("In %s:get : Cannot instanciate a LeObject without it's identifier" % cls.__name__)
-
+            for uid in [ uidname
+                for uidname in cls.uid_fieldname()
+                if uidname not in field_list ]:
+                field_list.append(uid)
+            if CLASS_ID_FIELDNAME not in field_list:
+                field_list.append(CLASS_ID_FIELDNAME)
         try:
-            query = LeGetQuery(cls, query_filter, field_list = field_list, order = order, group = group, limit = limit, offset = offset)
+            query = LeGetQuery(
+                cls, query_filters = query_filters, field_list = field_list,
+                order = order, group = group, limit = limit, offset = offset)
         except ValueError as err:
             raise err
             
         
         objects = list()
         for res in result:
-            inst = cls.name2class(res[CLASS_ID_FIELDNAME])(res)
+            res_cls = cls.name2class(res[CLASS_ID_FIELDNAME])
+            inst = res_cls.__new__(res_cls,**res)
             objects.append(inst)
         
         return objects

lodel/leapi/query.py

                 for tclass, tfield in ref_dict.items():
                     query = LeGetQuery(
                         target_class = tclass,
-                        query_filter = [(tfield, op, value)],
+                        query_filters = [(tfield, op, value)],
                         field_list = [tfield])
                     subq.append((rfield, query))
         self.subqueries = subq
     #@param group list : A list of field names or tuple (FIELDNAME,[ASC | DESC])
     #@param limit int : The maximum number of returned results
     #@param offset int : offset
-    def __init__(self, target_class, query_filter, **kwargs):
-        super().__init__(target_class, query_filter)
+    def __init__(self, target_class, query_filters, **kwargs):
+        super().__init__(target_class, query_filters)
         
         ##@brief The fields to get
         self.__field_list = None
             self.__group = kwargs['group']
         if 'limit' in kwargs:
             try:
-                self.__limit = int(kwargs[limit])
+                self.__limit = int(kwargs['limit'])
                 if self.__limit <= 0:
                     raise ValueError()
             except ValueError:

tests/leapi/test_leobject.py

                     pass
                 mock_init.assert_called_once_with(
                     dyncode.Person, [('lodel_id', '=', 1)])
+        
+        with patch.object(
+            LeUpdateQuery, 'execute', return_value = None) as mock_update:
+            with patch.object(
+                LeObject, 'datas', return_value = {
+                    'lodel_id': 1, 'firstname': 'foo', 'lastname': 'bar',
+                    'fullname': 'Foo Bar', 'alias': None }) as mock_datas:
+            
+                inst = dyncode.Person(
+                    lodel_id = 1, firstname = "foo", lastname = "bar")
+                inst.update()
+                mock_update.assert_called_once_with({
+                    'lodel_id': 1, 'firstname': 'foo', 'lastname': 'bar',
+                    'fullname': 'Foo Bar', 'alias': None })
+                    
+    
+    def test_get(self):
+        """ Checking that LeObject.get method calls LeGetQuery
+            correctly """
+        get_args = {
+            'query_filters': ['lodel_id = 1'],
+            'field_list': ['firstname'],
+            'order': ['firstname'],
+            'group': ['alias'],
+            'limit': 42,
+            'offset': 24}
+
+        with patch.object(
+            LeGetQuery, '__init__', return_value = None) as mock_init:
+            
+            try:
+                dyncode.Person.get(**get_args)
+            except AttributeError:
+                pass
+
+            mock_init.assert_called_once_with(
+                dyncode.Person,
+                **get_args)
+
+        ret_val = [{
+            'lodel_id': 1,
+            'firstname': 'foo',
+            'lastname': 'bar',
+            'fullname': 'foo bar',
+            'alias': None,
+            'classname': 'Person'}]
+        with patch.object(
+            LeGetQuery, 'execute', return_value = ret_val) as mock_execute:
+            results = dyncode.Person.get(**get_args)
+            mock_execute.assert_called_once_with()
+            res = results[0]
+            self.assertEqual(res.d.lodel_id, 1)
+            self.assertEqual(res.d.firstname, 'foo')
+            self.assertEqual(res.d.lastname, 'bar')