Bugfixes on leobject & query

lodel/leapi/leobject.py

@@ -1,7 +1,6 @@
 #-*- coding: utf-8 -*-
 
 import importlib
-import warnings
 
 from lodel.plugin import Plugin
 from lodel import logger
@@ -91,7 +90,7 @@ class LeObject(object):
                     )
             else:
                 self.__datas[fieldname] = fieldval
-                self.__initialized = list()
+                self.__initialized.append(fieldname)
         if len(err_list) > 0:
             raise LeApiErrors(err_list)
         self.__set_initialized()
@@ -145,7 +144,7 @@ class LeObject(object):
         mod = importlib.import_module(cls.__module__)
         try:
             return getattr(mod, leobject_name)
-        except AttributeError:
+        except (AttributeError, TypeError) :
             raise LeApiError("No LeObject named '%s'" % leobject_name)
     
     @classmethod
@@ -512,10 +511,10 @@ raised when trying to import Datasource"
         query_filter = list()
         for uid in uids:
             query_filter.append((uid, '=', self.data(uid)))
-        query = LeDeleteQuery(cls, query_filter)
+        query = LeDeleteQuery(self.__class__, query_filter)
         try:
             result = query.execute()
-        except LeQueryError as err:
+        except LeApiQueryError as err:
             raise err
             
         return result

lodel/leapi/query.py

@@ -33,10 +33,10 @@ class LeQuery(object):
     ##@brief Execute a query and return the result
     # @param **datas
     # @return the query result
-    # @see LeQuery.__query()
+    # @see LeQuery._query()
     #
     def execute(self, **datas):
-        if len(datas) > 0:
+        if 'datas' in datas and len(datas['datas']) > 0:
             self._target_class.check_datas_value(
                                                     datas['datas'],
                                                     **self._data_check_args)
@@ -46,7 +46,7 @@ class LeQuery(object):
         LodelHook.call_hook(    self._hook_prefix+'_pre',
                                 self._target_class,
                                 datas)
-        ret = self.__query(target = self._target_class, **datas)
+        ret = self._query(**datas)
         ret = LodelHook.call_hook(  self._hook_prefix+'_post',
                                     self._target_class,
                                     ret)
@@ -55,7 +55,7 @@ class LeQuery(object):
     ##@brief Childs classes implements this method to execute the query
     # @param **datas
     # @return query result
-    def __query(self, **datas):
+    def _query(self, **datas):
         raise NotImplementedError("Asbtract method")
     
     ##@return a dict with query infos
@@ -95,7 +95,7 @@ class LeFilteredQuery(LeQuery):
     def __init__(self, target_class, query_filters = None):
         super().__init__(target_class)
         ##@brief The query filter tuple(std_filter, relational_filters)
-        self.__query_filter = None
+        self._query_filter = None
         ##@brief Stores potential subqueries (used when a query implies
         # more than one datasource.
         #
@@ -108,23 +108,23 @@ class LeFilteredQuery(LeQuery):
     # This method takes care to execute subqueries before calling super execute
     def execute(self, datas = None):
         #copy originals filters
-        orig_filters = copy.copy(self.__query_filter)
-        std_filters, rel_filters = self.__query_filter
+        orig_filters = copy.copy(self._query_filter)
+        std_filters, rel_filters = self._query_filter
 
         for rfield, subq in self.subqueries:
             subq_res = subq.execute()
             std_filters.append(
                 (rfield, ' in ', subq_res))
-        self.__query_filter = (std_filters, rel_filters)
+        self._query_filter = (std_filters, rel_filters)
         try:
-            filters, rel_filters = self.__query_filter
+            filters, rel_filters = self._query_filter
             res = super().execute(filters = filters, rel_filters = rel_filters)
         except Exception as e:
             #restoring filters even if an exception is raised
-            self.__query_filter = orig_filter
+            self._query_filter = orig_filters
             raise e #reraise
         #restoring filters
-        self.__query_filter = orig_filters
+        self._query_filter = orig_filters
         return res
 
     ##@brief Add filter(s) to the query
@@ -185,8 +185,8 @@ class LeFilteredQuery(LeQuery):
                     ((rfield, ref_dict), op, value))
         #deduplication of std filters
         filters_orig = list(set(filters_orig))
-        # Sets __query_filter attribute of self query
-        self.__query_filter = (filters_orig, result_rel_filters)
+        # Sets _query_filter attribute of self query
+        self._query_filter = (filters_orig, result_rel_filters)
 
         #Sub queries creation
         subq = list()
@@ -204,7 +204,7 @@ class LeFilteredQuery(LeQuery):
     ##@return informations
     def dump_infos(self):
         ret = super().dump_infos()
-        ret['query_filter'] = self.__query_filter
+        ret['query_filter'] = self._query_filter
         ret['subqueries'] = self.subqueries
         return ret
 
@@ -212,7 +212,7 @@ class LeFilteredQuery(LeQuery):
         res = "<{classname} target={target_class} query_filter={query_filter}"
         res = ret.format(
             classname=self.__class__.__name__,
-            query_filter = self.__query_filter,
+            query_filter = self._query_filter,
             target_class = self._target_class)
         if len(self.subqueries) > 0:
             for n,subq in enumerate(self.subqueries):
@@ -459,7 +459,7 @@ class LeInsertQuery(LeQuery):
     
     ## @brief Implements an insert query operation, with only one insertion
     # @param new_datas : datas to be inserted
-    def __query(self, datas):
+    def _query(self, datas):
         datas = self._target_class.prepare_datas(datas, True, False)
         nb_inserted = self._rw_datasource.insert(self._target_class,datas)
         if nb_inserted < 0:
@@ -468,7 +468,7 @@ class LeInsertQuery(LeQuery):
     """
     ## @brief Implements an insert query operation, with multiple insertions
     # @param datas : list of **datas to be inserted
-    def __query(self, datas):
+    def _query(self, datas):
         nb_inserted = self._datasource.insert_multi(
             self._target_class,datas_list)
         if nb_inserted < 0:
@@ -525,7 +525,7 @@ target to LeUpdateQuery constructor"
     #@returns the number of updated items
     #@todo change stategy for instance update. Datas should be allowed 
     #for execute method (and query)
-    def __query(self, filters, rel_filters, datas):
+    def _query(self, filters, rel_filters, datas):
         uid_name = self._target_class._uid[0]
         if self.__leobject_instance is not None:
             #Instance update
@@ -575,7 +575,7 @@ class LeDeleteQuery(LeFilteredQuery):
     #@param filters list : see @ref LeFilteredQuery
     #@param rel_filters list : see @ref LeFilteredQuery
     #@returns the number of deleted items
-    def __query(self, filters, rel_filters):
+    def _query(self, filters, rel_filters):
         nb_deleted = self._rw_datasource.delete(
             self._target_class, filters, rel_filters)
         return nb_deleted
@@ -666,7 +666,7 @@ class LeGetQuery(LeFilteredQuery):
 
     ##@brief Implements select query operations
     # @returns a list containing the item(s)
-    def __query(self):
+    def _query(self):
         # select datas corresponding to query_filter
         l_datas=self._ro_datasource.select(  self._target_class,
                                     list(self.field_list),

tests/leapi/test_leobject.py

@@ -59,11 +59,12 @@ class LeObjectDummyTestCase(unittest.TestCase):
     def test_bad_name2class(self):
         """ Testing failures of the class method that returns a dynamic object
             given it's name """
-        badnames = ['foobar', 'LeObject', 'str', str, None, 42]
+        badnames = ['foobar', 'str', str, None, 42]
         callers = [dyncode.Object, dyncode.Person, dyncode.Entitie]
         for caller in callers:
             for badname in badnames:
-                with self.assertRaises(LeApiError):
+                with self.assertRaises(LeApiError, msg="LeApiError not raised \
+but invalid name %s was given" % badname):
                     caller.name2class(badname)
 
     def test_abstract_name2class(self):
@@ -151,7 +152,7 @@ class LeObjectQueryMockTestCase(unittest.TestCase):
                 dyncode.Person, [('lodel_id', '=', 1)], [])
 
     def test_delete_bundle(self):
-        """ Checking that LeObject delete_bundle methid calls LeDeleteQuery
+        """ Checking that LeObject delete_bundle method calls LeDeleteQuery
             correctly """
         with patch.object(
             LeDeleteQuery, '__init__', return_value = None) as mock_init:
@@ -167,4 +168,3 @@ class LeObjectQueryMockTestCase(unittest.TestCase):
             mock_init.assert_called_once_with(
                 dyncode.Person, [('lodel_id', '>', 1)], [])
 
-