Tests + bugfixes on LeCrud LeObject LeClass and LeType delete and get methods

leapi/lecrud.py

@@ -21,9 +21,6 @@ class LeApiErrors(Exception):
             msg += " {expt_name}:{expt_msg}; ".format(expt_name=expt.__class__.__name__, expt_msg=str(expt))
         return msg
 
-    def __repr__(self):
-        return str(self)
-
 
 ## @brief When an error concern a query
 class LeApiQueryError(LeApiErrors): pass
@@ -82,11 +79,13 @@ class _LeCrud(object):
     def fieldlist(cls):
         return cls.fieldtypes().keys()
     
-    ## @return a dict of fieldname : value
-    def datas(self):
+    ## @brief Returns object datas
+    # @param
+    # @return a dict of fieldname : value
+    def datas(self, internal = False):
         res = dict()
-        for fname in self.fieldtypes().keys():
-            if hasattr(self, fname):
+        for fname, ftt in self.fieldtypes().items():
+            if (internal or (not internal and ftt.is_internal)) and hasattr(self, fname):
                 res[fname] = getattr(self, fname)
     
     ## @brief Update a component in DB
@@ -105,13 +104,12 @@ class _LeCrud(object):
             #ERROR HANDLING
             return False
     
-    ## @brief Delete a component
+    ## @brief Delete a component (instance method)
     # @return True if success
     # @todo better error handling
-    def delete(self):
+    def _delete(self):
         filters = [self._id_filter()]
-        rel_filters = []
-        ret = self._datasource.delete(self.__class__, filters, rel_filters)
+        ret = _LeCrud.delete(self.__class__, filters)
         if ret == 1:
             return True
         else:
@@ -157,6 +155,14 @@ class _LeCrud(object):
         if len(err_l) > 0:
             raise LeApiDataCheckError("Error while checking datas", err_l)
         return checked_datas
+    
+    ## @brief Given filters delete editorial components
+    # @param filters list : 
+    # @return The number of deleted components
+    @staticmethod
+    def delete(cls, filters):
+        filters, rel_filters = cls._prepare_filters(filters)
+        return cls._datasource.delete(cls, filters, rel_filters)
 
     ## @brief Retrieve a collection of lodel editorial components
     #
@@ -166,39 +172,28 @@ class _LeCrud(object):
     # @todo think about LeObject and LeClass instanciation (partial instanciation, etc)
     @classmethod
     def get(cls, query_filters, field_list = None):
-        if not(isinstance(cls, cls.name2class('LeObject'))) and not(isinstance(cls, cls.name2class('LeRelation'))):
-            raise NotImplementedError("Cannot call get with LeCrud")
-
         if field_list is None or len(field_list) == 0:
             #default field_list
-            field_list = cls.default_fieldlist()
+            field_list = cls.fieldlist()
 
-        field_list = cls.prepare_field_list(field_list) #Can raise LeApiDataCheckError
+        field_list = cls._prepare_field_list(field_list) #Can raise LeApiDataCheckError
 
         #preparing filters
-        filters, relational_filters = cls._prepare_filters(field_list)
+        filters, relational_filters = cls._prepare_filters(query_filters)
 
         #Fetching datas from datasource
-        db_datas = cls._datasource.get(cls, filters, relational_filters)
+        db_datas = cls._datasource.select(cls, field_list, filters, relational_filters)
 
         return [ cls(**datas) for datas in db_datas]
     
-    ## @brief Given filters delete components
-    # @param filters list : list of string of query filters (or tuple (FIELD, OPERATOR, VALUE) ) see @ref leobject_filters
-    # @return the number of deleted components
-    # @todo Check for Abstract calls (with cls == LeCrud)
-    @classmethod
-    def delete_multi(cls, filters):
-        filters, rel_filters = cls._prepare_filters(filters)
-        return cls._datasource.delete(cls, filters, rel_filters)
-    
     ## @brief Insert a new component
     # @param datas dict : The value of object we want to insert
     # @return A new id if success else False
     @classmethod
-    def insert(cls, datas):
-        insert_datas = cls.prepare_datas(datas, complete = True, allow_internal = False)
-        return cls._datasource.insert(cls, **insert_datas)
+    def insert(cls, datas = datas, classname = None):
+        callcls = cls if classname is None else cls.name2class(classname)
+        insert_datas = callcls.prepare_datas(datas, complete = True, allow_internal = False)
+        return callcls._datasource.insert(callcls, **insert_datas)
     
     ## @brief Check and prepare datas
     # 
@@ -213,6 +208,8 @@ class _LeCrud(object):
         if not complete:
             warnings.warn("Actual implementation can make datas construction and consitency checks fails when datas are not complete")
         ret_datas = cls.check_datas_value(datas, complete, allow_internal)
+        if isinstance(ret_datas, Exception):
+            raise ret_datas
         ret_datas = cls._construct_datas(ret_datas)
         cls._check_datas_consistency(ret_datas)
         return ret_datas
@@ -225,7 +222,7 @@ class _LeCrud(object):
     # @warning assert that the uid is not composed with multiple fieldtypes
     # @return A filter of the form tuple(UID, '=', self.UID)
     def _id_filter(self):
-        id_name = self._uid_fieldtype.keys()[0]
+        id_name = list(self._uid_fieldtype.keys())[0]
         return ( id_name, '=', getattr(self, id_name) )
 
     ## @brief Construct datas values
@@ -266,6 +263,7 @@ class _LeCrud(object):
     # @throw LeApiDataCheckError if invalid field given
     @classmethod
     def _prepare_field_list(cls, field_list):
+        err_l = list()
         ret_field_list = list()
         for field in field_list:
             if cls._field_is_relational(field):
@@ -316,6 +314,7 @@ class _LeCrud(object):
         res_filters = list()
         rel_filters = list()
         err_l = list()
+        #Splitting in tuple if necessary
         for fil in filters_l:
             if len(fil) == 3 and not isinstance(fil, str):
                 filters.append(tuple(fil))

leapi/leobject.py

@@ -11,6 +11,7 @@
 # @note LeObject will be generated by leapi.lefactory.LeFactory
 
 import re
+import copy
 import warnings
 
 import leapi
@@ -56,9 +57,50 @@ class _LeObject(_LeCrud):
             cls._fieldtypes_all.update(cls._leo_fieldtypes)
         return cls._fieldtypes_all
 
+    @classmethod
+    def typefilter(cls):
+        if hasattr(cls, '_type_id'):
+            return ('type_id','=', cls._type_id)
+        elif hasattr(cls, '_class_id'):
+            return ('class_id', '=', cls._class_id)
+        else:
+            raise ValueError("Cannot generate a typefilter with %s class"%cls.__name__)
+    
+    ## @brief Delete LeObjects from db given filters and a classname
+    # @note if no classname given, take the caller class
+    # @param filters list : 
+    # @param classname None|str : the classname or None
+    # @return number of deleted LeObjects
+    # @see leapi.lecrud._LeCrud.delete()
+    @classmethod
+    def delete(cls, filters, classname = None):
+        ccls = cls if classname is None else cls.name2class(classname)
+        new_filters = copy.copy(filters)
+        new_filters.append(ccls.typefilter())
+        return _LeCrud.delete(ccls, new_filters)
+
+    ## @brief Check that a relational field is valid
+    # @param field str : a relational field
+    # @return a nature
+    @staticmethod
+    def _prepare_relational_field(field):
+        spl = field.split('.')
+        if len(spl) != 2:
+            return ValueError("The relationalfield '%s' is not valid"%field)
+        nature = spl[-1]
+        if nature not in EditorialModel.classtypes.EmNature.getall():
+            return ValueError("'%s' is not a valid nature in the field %s"%(nature, field))
+        
+        if spl[0] == 'superior':
+            return (REL_SUP, nature)
+        elif spl[0] == 'subordinate':
+            return (REL_SUB, nature)
+        else:
+            return ValueError("Invalid preffix for relationnal field : '%s'"%spl[0])
+
     ## @brief Check if a LeType is a hierarchy root
     @staticmethod
-    def is_root(leo):
+    def ___is_root(leo):
         if isinstance(leo, leapi.letype.LeType):
             return False
         elif isinstance(leo, LeRoot):
@@ -67,33 +109,9 @@ class _LeObject(_LeCrud):
     
     ## @brief Return a LeRoot instance
     @staticmethod
-    def get_root():
+    def ___get_root():
         return LeRoot()
 
-    ## @brief Delete LeObjects given filters
-    # @param cls
-    # @param letype LeType|str : LeType child class or name
-    # @param leclass LeClass|str : LeClass child class or name
-    # @param filters list : list of filters (see @ref leobject_filters)
-    # @return bool
-    @classmethod
-    def delete(cls, letype, filters):
-        filters,relationnal_filters = cls._prepare_filters(filters)
-        return cls._datasource.delete(letype, leclass, filters, relationnal_filters)
-    
-    ## @brief Update LeObjects given filters and datas
-    # @param cls
-    # @param letype LeType|str : LeType child class or name
-    # @param filters list : list of filters (see @ref leobject_filters)
-    @classmethod
-    def update(cls, letype, filters, datas):
-        letype, leclass = cls._prepare_targets(letype)
-        filters,relationnal_filters = cls._prepare_filters(filters, letype, leclass)
-        if letype is None:
-            raise ValueError("Argument letype cannot be None")
-        letype.prepare_data(datas, False)
-        return cls._datasource.update(letype, leclass, filters, relationnal_filters, datas)
-
     ## @brief Link two leobject together using a rel2type field
     # @param lesup LeType : LeType child class instance linked as superior
     # @param lesub LeType : LeType child class instance linked as subordinate
@@ -107,7 +125,7 @@ class _LeObject(_LeCrud):
     # @todo Code factorisation on relation check
     # @todo unit tests
     @classmethod
-    def link_together(cls, lesup, lesub, rank = 'last', **rel_attr):
+    def ___link_together(cls, lesup, lesub, rank = 'last', **rel_attr):
         if lesub.__class__ not in lesup._linked_types.keys():
             raise LeObjectError("Relation error : %s cannot be linked with %s"%(lesup.__class__.__name__, lesub.__class__.__name__))
 
@@ -135,7 +153,7 @@ class _LeObject(_LeCrud):
     # @todo Code factorisation on relation check
     # @todo unit tests
     @classmethod
-    def linked_together(cls, leo, letype, leo_is_superior = True):
+    def ___linked_together(cls, leo, letype, leo_is_superior = True):
         valid_link = letype in leo._linked_types.keys() if leo_is_superior else leo.__class__ in letype._linked_types.keys()
 
         if not valid_link:
@@ -151,13 +169,13 @@ class _LeObject(_LeCrud):
     # @return a tuple(lesup, lesub, dict_attr) or False if no relation exists with this id
     # @throw Exception if the relation is not a rel2type relation
     @classmethod
-    def link_get(cls, id_relation):
+    def ___link_get(cls, id_relation):
         return cls._datasource.get_relation(id_relation)
     
     ## @brief Fetch all relations for an objects
     # @param leo LeType : LeType child class instance
     # @return a list of tuple (lesup, lesub, dict_attr)
-    def links_get(cls, leo):
+    def ___links_get(cls, leo):
         return cls._datasource.get_relations(leo)
     
     ## @brief Remove a link (and attributes) between two LeObject
@@ -168,7 +186,7 @@ class _LeObject(_LeCrud):
     # @todo Code factorisation on relation check
     # @todo unit tests
     @classmethod
-    def link_remove(cls, id_relation):
+    def ___link_remove(cls, id_relation):
         if lesub.__class__ not in lesup._linked_types.keys():
             raise LeObjectError("Relation errorr : %s cannot be linked with %s"%(lesup.__class__.__name__, lesub.__class__.__name__))
 
@@ -183,7 +201,7 @@ class _LeObject(_LeCrud):
     # @return The relation ID or False if fails
     # @throw LeObjectQueryError replace_if_exists == False and there is a superior
     @classmethod
-    def hierarchy_add(cls, lesup, lesub, nature, rank = 'last', replace_if_exists = False):
+    def ___hierarchy_add(cls, lesup, lesub, nature, rank = 'last', replace_if_exists = False):
         #Arguments check
         if nature not in EditorialModel.classtypes.EmClassType.natures(lesub._classtype):
             raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
@@ -216,7 +234,7 @@ class _LeObject(_LeCrud):
     # @return True if deletion done successfully
     # @throw ValueError when bad arguments given
     @classmethod
-    def hierarchy_del(cls, lesup, lesub, nature):
+    def ___hierarchy_del(cls, lesup, lesub, nature):
         if nature not in EditorialModel.classtypes.EmClassType.natures(lesub._classtype):
             raise ValueError("Invalid nature '%s' for %s"%(nature, lesup.__class__.__name__))
 
@@ -239,7 +257,7 @@ class _LeObject(_LeCrud):
     # @param leo_is_sup bool : if True leo is the superior and we want to fetch the subordinates else its the oposite
     # @return A list of LeObject ordered by depth if leo_is_sup, else a list of subordinates
     @classmethod
-    def hierarchy_get(cls, leo, nature, leo_is_sup = True):
+    def ___hierarchy_get(cls, leo, nature, leo_is_sup = True):
         #Checking arguments
         if not (nature is None) and not cls.is_root(leo):
             if nature not in EditorialModel.classtypes.EmClassType.natures(leo._classtype):
@@ -262,7 +280,7 @@ class _LeObject(_LeCrud):
     # @param leclass LeClass|str|None : LeClass child instant or its name
     # @return a tuple with 2 python classes (LeTypeChild, LeClassChild)
     @classmethod
-    def _prepare_targets(cls, letype = None , leclass = None):
+    def ___prepare_targets(cls, letype = None , leclass = None):
         warnings.warn("_LeObject._prepare_targets is deprecated", DeprecationWarning)
         raise ValueError()
         if not(leclass is None):
@@ -286,56 +304,6 @@ class _LeObject(_LeCrud):
 
         return (letype, leclass)
 
-    ## @brief Check if a fieldname is valid
-    # @warning This method assume that letype and leclass are returned from _LeObject._prepare_targets() method
-    # @param letype LeType|None : The concerned type (or None)
-    # @param leclass LeClass|None : The concerned class (or None)
-    # @param fields list : List of string representing fields
-    # @throw LeObjectQueryError if their is some problems
-    # @throw AttributeError if letype is not from the leclass class
-    # @todo Delete the checks of letype and leclass and ensure that this method is called with letype and leclass arguments from _prepare_targets()
-    #
-    # @see @ref leobject_filters
-    # @todo delete me
-    @staticmethod
-    def _check_fields(letype, leclass, fields):
-        warnings.warn("deprecated", DeprecationWarning)
-        #Checking that fields in the query_filters are correct
-        if letype is None and leclass is None:
-            #Only fields from the object table are allowed
-            for field in fields:
-                if field not in EditorialModel.classtypes.common_fields.keys():
-                    raise LeObjectQueryError("Not typename and no classname given, but the field %s is not in the common_fields list"%field)
-        else:
-            if letype is None:
-                field_l = leclass._fieldtypes.keys()
-            else:
-                field_l = letype._fields
-            #Checks that fields are in this type
-            for field in fields:
-                if field not in field_l:
-                    raise LeObjectQueryError("No field named '%s' in '%s'"%(field, letype.__name__))
-        pass
-    
-    ## @brief Check that a relational field is valid
-    # @param field str : a relational field
-    # @return a nature
-    @staticmethod
-    def _prepare_relational_field(field):
-        spl = field.split('.')
-        if len(spl) != 2:
-            return ValueError("The relationalfield '%s' is not valid"%field)
-        nature = spl[-1]
-        if nature not in EditorialModel.classtypes.EmNature.getall():
-            return ValueError("'%s' is not a valid nature in the field %s"%(nature, field))
-        
-        if spl[0] == 'superior':
-            return (REL_SUP, nature)
-        elif spl[0] == 'subordinate':
-            return (REL_SUB, nature)
-        else:
-            return ValueError("Invalid preffix for relationnal field : '%s'"%spl[0])
-
 ## @brief Class designed to represent the hierarchy roots
 # @see _LeObject.get_root() _LeObject.is_root()
 class LeRoot(object):

leapi/letype.py

@@ -11,6 +11,7 @@
 # @note LeObject will be generated by leapi.lefactory.LeFactory
 
 import leapi
+from leapi.lecrud import _LeCrud
 from leapi.leclass import _LeClass
 from leapi.leobject import LeObjectError
 
@@ -48,7 +49,7 @@ class _LeType(_LeClass):
             if name not in self._fields:
                 raise AttributeError("No such field '%s' for %s"%(name, self.__class__.__name__))
             setattr(self, name, value)
-    
+
     @classmethod
     def fieldlist(cls):
         return cls._fields
@@ -62,15 +63,15 @@ class _LeType(_LeClass):
     def populate(self, field_list=None):
         if field_list == None:
             field_list = [ fname for fname in self._fields if not hasattr(self, fname) ]
-        filters, rel_filters = self._prepare_filters(['lodel_id = %d'%(self.lodel_id)], self.__class__, self._leclass)
+        filters = [self._id_filter()]
+        rel_filters = []
 
-        fdatas = self._datasource.get(self._leclass, self.__class__, field_list, filters, rel_filters)
+        fdatas = self._datasource.select(self.__class__, field_list, filters, rel_filters)
         for fname, fdats in fdatas[0].items():
             setattr(self, name, value)
 
     ## @brief Get a fieldname:value dict
     # @return A dict with field name as key and the field value as value
-    @property
     def datas(self):
         return { fname: getattr(self, fname) for fname in self._fields if hasattr(self,fname) }
     
@@ -79,18 +80,17 @@ class _LeType(_LeClass):
     # @warning Can represent a performance issue
     def all_datas(self):
         self.populate()
-        return self.datas
-    
-    ## @brief Delete the LeType from Db
-    # @note equivalent to LeType::delete(filters=['lodel_id = %s'%self.lodel_id)
-    def db_delete(self):
-        return self.delete([('lodel_id','=',repr(self.lodel_id))])
+        return self.datas()
     
+    ## @brief Delete current instance from DB
+    def delete(self):
+        _LeCrud._delete(self)
+
     ## @brief Get the linked objects lodel_id
     # @param letype LeType : Filter the result with LeType child class (not instance) 
     # @return a dict with LeType instance as key and dict{attr_name:attr_val...} as value
     # @todo unit tests
-    def linked(self, letype):
+    def ___linked(self, letype):
         if leapi.letype.LeType not in letype.__bases__:
             raise ValueError("letype has to be a child class of LeType (not an instance) but %s found"%type(letype))
         
@@ -113,7 +113,7 @@ class _LeType(_LeClass):
     # @throw AttributeError if an non existing relation attribute is given as argument
     # @throw ValueError if the relation attrivute value check fails
     # @see leapi.lefactory.LeFactory.link_together()
-    def link(self, leo, **rel_attr):
+    def ___link(self, leo, **rel_attr):
         return leapi.lefactory.LeFactory.leobj_from_name('LeObject').link_together(self, leo, **rel_attr)
     
     ## @brief Returns linked subordinates in a rel2type given a wanted LeType child class
@@ -121,20 +121,20 @@ class _LeType(_LeClass):
     # @return A dict with LeType child class instance as key and dict {'id_relation':id, rel_attr_name:rel_attr_value, ...}
     # @throw LeObjectError if the relation is not possible
     # @see leapi.lefactory.LeFactory.linked_together()
-    def linked_subordinates(self, letype):
+    def ___linked_subordinates(self, letype):
         return leapi.lefactory.LeFactory.leobj_from_name('LeObject').linked_together(self, letype, True)
 
     ## @brief Remove a link with a subordinate
     # @param leo LeType : LeType child instance
     # @return True if a link has been deleted
     # @throw LeObjectError if the relation do not concern the current LeType
-    def unlink_subordinate(self, id_relation):
+    def ___unlink_subordinate(self, id_relation):
         return leapi.lefactory.LeFactory.leobj_from_name('LeObject').linked_together(self, leo)
 
     ## @brief Remove a link bewteen this object and another
     # @param leo LeType : LeType child class instance
     # @todo unit tests
-    def unlink(self, leo):
+    def ___unlink(self, leo):
         if leo.__class__ in self._linked_types.keys():
             sup = self
             sub = leo
@@ -150,46 +150,27 @@ class _LeType(_LeClass):
     # @param rank str|int :  The relation rank. Can be 'last', 'first' or an integer
     # @param replace_if_exists bool : if True delete the old superior and set the new one. If False and there is a superior raise an LeObjectQueryError
     # @return The relation ID or False if fails
-    def superior_add(self, leo, nature, rank = 'last', replace_if_exists = False):
+    def ___superior_add(self, leo, nature, rank = 'last', replace_if_exists = False):
         return leapi.lefactory.LeFactory.leobj_from_name('LeObject').hierarchy_add(leo, self, nature, rank, replace_if_exists)
 
     ## @brief Delete a superior given a relation's natue
     # @param leo LeType | LeRoot : The superior to delete
     # @param nature str : The nature of the relation @ref EditorialModel.classtypes
     # @return True if deletion is a success
-    def superior_del(self, leo, nature):
+    def ___superior_del(self, leo, nature):
         return leapi.lefactory.leobj_from_name('LeObject').hierarchy_del(leo, self, nature)
     
     ## @brief Fetch superiors by depth
     # @return A list of LeObject ordered by depth (the first is the one with the bigger depth)
-    def superiors(self):
+    def ___superiors(self):
         return leapi.lefactory.leobj_from_name('LeObject').hierarchy_get(self,nature, leo_is_sup = False)
 
     ## @brief Fetch subordinates ordered by rank
     # @return A list of LeObject ordered by rank
-    def subordinates(self):
+    def ___subordinates(self):
         return leapi.lefactory.leobj_from_name('LeObject').hierarchy_get(self,nature, leo_is_sup = True)
     
-    ## @brief Delete a LeType from the datasource
-    # @param filters list : list of filters (see @ref leobject_filters)
-    # @param cls
-    # @return True if deleted False if not existing
-    # @throw InvalidArgumentError if invalid parameters
-    # @throw Leo exception if the lodel_id identify an object from another type
-    @classmethod
-    def delete(cls, filters):
-        return leapi.lefactory.LeFactory.leobject().delete(cls, filters)
-        
     ## @brief Update a LeType in db
-    def db_update(self):
+    def ___db_update(self):
         return self.update(filters=[('lodel_id', '=', repr(self.lodel_id))], datas = self.datas)
         
-    @classmethod
-    ## @brief Update some LeType in db
-    # @param datas : keys are lodel_id and value are dict of fieldname => value
-    # @param filters list : list of filters (see @ref leobject_filters)
-    # @param cls
-    # return bool
-    def update(cls, filters, datas):
-        return leapi.lefactory.LeFactory.leobject().update(letype = cls, filters = filters, datas = datas)
-        

leapi/test/test_lecrud.py

@@ -179,5 +179,65 @@ class LeCrudTestCase(TestCase):
         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)
+                assert not dsmock.called
         pass
+    
+    ## @todo test invalid get
+    @patch('leapi.datasources.dummy.DummyDatasource.select')
+    def test_get(self, dsmock):
+        from dyncode import Publication, Numero, LeObject, Textes
+        
+        args = [
+            (
+                Numero,
+                ['lodel_id', 'superior.parent'],
+                ['titre != "foobar"'],
+
+                ['lodel_id', (leapi.leobject.REL_SUP, 'parent')],
+                [('titre','!=', '"foobar"')],
+                []
+            ),
+            (
+                Numero,
+                ['lodel_id', 'titre', 'superior.parent', 'subordinate.translation'],
+                ['superior.parent in  [1,2,3,4,5]'],
+
+                ['lodel_id', 'titre', (leapi.leobject.REL_SUP,'parent'), (leapi.leobject.REL_SUB, 'translation')],
+                [],
+                [( (leapi.leobject.REL_SUP, 'parent'), ' in ', '[1,2,3,4,5]')]
+            ),
+            (
+                Numero,
+                [],
+                [],
+
+                Numero._fields,
+                [],
+                []
+            ),
+            (
+                Textes,
+                ['lodel_id', 'titre', 'soustitre', 'superior.parent'],
+                ['titre != "foobar"'],
+
+                ['lodel_id', 'titre', 'soustitre', (leapi.leobject.REL_SUP, 'parent')],
+                [('titre','!=', '"foobar"')],
+                [],
+            ),
+            (
+                LeObject,
+                ['lodel_id'],
+                [],
+
+                ['lodel_id'],
+                [],
+                [],
+            ),
+        ]
+
+        for callcls, field_list, filters, fl_ds, filters_ds, rfilters_ds in args:
+            callcls.get(filters, field_list)
+            dsmock.assert_called_with(callcls, fl_ds, filters_ds, rfilters_ds)
+            dsmock.reset_mock()
+
 

leapi/test/test_leobject.py

@@ -18,6 +18,7 @@ class LeObjectTestCase(TestCase):
     def setUpClass(cls):
         """ Write the generated code in a temporary directory and import it """
         cls.tmpdir = leapi.test.utils.tmp_load_factory_code()
+
     @classmethod
     def tearDownClass(cls):
         """ Remove the temporary directory created at class setup """
@@ -90,24 +91,6 @@ class LeObjectTestCase(TestCase):
         for (leclass, letype) in test_v:
             with self.assertRaises(ValueError):
                 LeObject._prepare_targets(letype, leclass)
-    @unittest.skip("Obsolete, the method should be deleted soon")
-    def test_check_fields(self):
-        """ Testing the _check_fields() method """
-        from dyncode import Publication, Numero, LeObject, Personnes
-        
-        #Valid fields given
-        LeObject._check_fields(None, Publication, Publication._fieldtypes.keys())
-        LeObject._check_fields(Numero, None, Numero._fields)
-
-        #Specials fields
-        LeObject._check_fields(Numero, Publication,  ['lodel_id'])
-        #Common fields
-        LeObject._check_fields(None, None, EditorialModel.classtypes.common_fields.keys())
-
-        #Invalid fields
-        with self.assertRaises(leapi.leobject.LeObjectQueryError):
-            LeObject._check_fields(None, None, Numero._fields)
-
 
 class LeObjectMockDatasourceTestCase(TestCase):
     """ Testing _LeObject using a mock on the datasource """
@@ -121,24 +104,24 @@ class LeObjectMockDatasourceTestCase(TestCase):
         """ Remove the temporary directory created at class setup """
         leapi.test.utils.cleanup(cls.tmpdir)
     
-    @unittest.skip("Wait reimplementation in lecrud")
     @patch('leapi.datasources.dummy.DummyDatasource.insert')
     def test_insert(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         ndatas = [
-            [{'titre' : 'FooBar'}],
-            [{'titre':'hello'},{'titre':'world'}],
+            {'titre' : 'FooBar'},
+            {'titre':'hello'},
+            {'titre':'world'},
         ]
         for ndats in ndatas:
-            LeObject.insert(Numero,ndats)
-            dsmock.assert_called_once_with(Numero, Publication, ndats)
+            Publication.insert(ndats, classname='Numero')
+            dsmock.assert_called_once_with(Numero, **ndats)
             dsmock.reset_mock()
 
-            LeObject.insert('Numero',ndats)
-            dsmock.assert_called_once_with(Numero, Publication, ndats)
+            LeObject.insert(ndats, classname = 'Numero')
+            dsmock.assert_called_once_with(Numero, **ndats)
             dsmock.reset_mock()
 
-    @unittest.skip("Wait reimplementation in lecrud")
+    @unittest.skip("Wait FieldTypes modification (cf. #90) and classmethod capabilities for update")
     @patch('leapi.datasources.dummy.DummyDatasource.update')
     def test_update(self, dsmock):
         from dyncode import Publication, Numero, LeObject
@@ -165,129 +148,34 @@ class LeObjectMockDatasourceTestCase(TestCase):
             dsmock.assert_called_once_with(Numero, Publication, ds_filters, ds_relfilters, datas)
             dsmock.reset_mock()
     
-    @unittest.skip("Wait reimplementation in lecrud")
     @patch('leapi.datasources.dummy.DummyDatasource.delete')
     def test_delete(self, dsmock):
-        from dyncode import Publication, Numero, LeObject
+        from dyncode import Publication, Numero, LeObject, LeType
 
         args = [
             (
+                'Numero',
                 ['lodel_id=1'],
-                [('lodel_id', '=', '1')],
+                [('lodel_id', '=', '1'), ('type_id', '=', Numero._type_id)],
                 []
             ),
             (
+                'Publication',
                 ['subordinate.parent not in [1,2,3]', 'titre = "titre nul"'],
-                [('titre','=', '"titre nul"')],
+                [('titre','=', '"titre nul"'), ('class_id', '=', Publication._class_id)],
                 [( (leapi.leobject.REL_SUB, 'parent'), ' not in ', '[1,2,3]')]
             ),
         ]
 
-        for filters, ds_filters, ds_relfilters in args:
-            LeObject.delete(Numero, filters)
-            dsmock.assert_called_once_with(Numero, Publication, ds_filters, ds_relfilters)
-            dsmock.reset_mock()
+        for classname, filters, ds_filters, ds_relfilters in args:
+            ccls = LeObject.name2class(classname)
 
-            LeObject.delete('Numero', filters)
-            dsmock.assert_called_once_with(Numero, Publication, ds_filters, ds_relfilters)
+            LeObject.delete(filters, classname)
+            dsmock.assert_called_once_with(ccls, ds_filters, ds_relfilters)
             dsmock.reset_mock()
+            
+            if not (LeType in ccls.__bases__): #tests for calls with a LeClass child
+                ccls.delete(filters)
+                dsmock.assert_called_once_with(ccls, ds_filters, ds_relfilters)
+                dsmock.reset_mock()
         
-    @patch('leapi.datasources.dummy.DummyDatasource.get')
-    @unittest.skip('Dummy datasource doesn\'t fit anymore')
-    def test_get(self, dsmock):
-        from dyncode import Publication, Numero, LeObject
-        
-        args = [
-            (
-                ['lodel_id', 'superior.parent'],
-                ['titre != "foobar"'],
-
-                ['lodel_id', (leapi.leobject.REL_SUP, 'parent')],
-                [('titre','!=', '"foobar"')],
-                []
-            ),
-            (
-                ['lodel_id', 'titre', 'superior.parent', 'subordinate.translation'],
-                ['superior.parent in  [1,2,3,4,5]'],
-
-                ['lodel_id', 'titre', (leapi.leobject.REL_SUP,'parent'), (leapi.leobject.REL_SUB, 'translation')],
-                [],
-                [( (leapi.leobject.REL_SUP, 'parent'), ' in ', '[1,2,3,4,5]')]
-            ),
-            (
-                [],
-                [],
-
-                Numero._fields,
-                [],
-                []
-            ),
-        ]
-
-        for field_list, filters, fl_ds, filters_ds, rfilters_ds in args:
-            LeObject.get(filters, field_list, Numero)
-            dsmock.assert_called_with(Publication, Numero, fl_ds, filters_ds, rfilters_ds)
-            dsmock.reset_mock()
-
-    @patch('leapi.datasources.dummy.DummyDatasource.get')
-    @unittest.skip('Dummy datasource doesn\'t fit anymore')
-    def test_get_incomplete_target(self, dsmock):
-        """ Testing LeObject.get() method with partial target specifier """
-        from dyncode import Publication, Numero, LeObject
-
-        args = [
-            (
-                ['lodel_id'],
-                [],
-                None,
-                None,
-
-                ['lodel_id', 'type_id'],
-                [],
-                [],
-                None,
-                None
-            ),
-            (
-                [],
-                [],
-                None,
-                None,
-
-                list(EditorialModel.classtypes.common_fields.keys()),
-                [],
-                [],
-                None,
-                None
-            ),
-            (
-                ['lodel_id'],
-                [],
-                None,
-                Publication,
-
-                ['lodel_id', 'type_id'],
-                [],
-                [],
-                None,
-                Publication
-            ),
-            (
-                [],
-                [],
-                Numero,
-                None,
-
-                Numero._fields,
-                [],
-                [],
-                Numero,
-                Publication
-            ),
-        ]
-
-        for field_list, filters, letype, leclass, fl_ds, filters_ds, rfilters_ds, letype_ds, leclass_ds in args:
-            LeObject.get(filters, field_list, letype, leclass)
-            dsmock.assert_called_with(leclass_ds, letype_ds, fl_ds, filters_ds, rfilters_ds)
-            dsmock.reset_mock()
-

leapi/test/test_letype.py

@@ -50,7 +50,7 @@ class LeTypeTestCase(TestCase):
         """ Testing the datas @property method """
         from dyncode import Publication, Numero, LeObject
         num = Numero(42, titre = 'foofoo')
-        self.assertEqual({'lodel_id' : 42, 'titre': 'foofoo'}, num.datas)
+        self.assertEqual({'lodel_id' : 42, 'titre': 'foofoo'}, num.datas())
         num.all_datas
         dsmock.assert_called_once()
 
@@ -66,49 +66,31 @@ class LeTypeMockDsTestCase(TestCase):
         """ Remove the temporary directory created at class setup """
         leapi.test.utils.cleanup(cls.tmpdir)
 
-    @unittest.skip('Dummy datasource doesn\'t fit anymore')
-    @patch('leapi.datasources.dummy.DummyDatasource.get')
+    @patch('leapi.datasources.dummy.DummyDatasource.select')
     def test_populate(self, dsmock):
         from dyncode import Publication, Numero, LeObject
 
         num = Numero(1, type_id = Numero._type_id)
         missing_fields = [f for f in Numero._fields if not (f in ['lodel_id', 'type_id'])]
         num.populate()
-        dsmock.assert_called_once_with(Publication, Numero, missing_fields, [('lodel_id','=','1')],[])
+        dsmock.assert_called_once_with(Numero, missing_fields, [('lodel_id','=',1)],[])
 
-    @unittest.skip("Waiting for reimplementation in LeCrud")
     @patch('leapi.datasources.dummy.DummyDatasource.update')
     def test_update(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         
-        datas = { 'titre' : 'foobar', 'string': 'wow' }
-
-        Numero.update(['lodel_id = 1'], datas)
-        dsmock.assert_called_once_with(Numero, Publication, [('lodel_id','=','1')], [], datas)
+        datas = { 'titre' : 'foobar' }
+        
+        #Testing as instance method
+        num = Numero(lodel_id = 1)
+        num.update(datas)
+        dsmock.assert_called_once_with(Numero, [('lodel_id','=',1)], [], datas)
     
-    @unittest.skip("Waiting for reimplementation in LeCrud")
     @patch('leapi.datasources.dummy.DummyDatasource.delete')
     def test_delete(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         
-        Numero.delete(['lodel_id = 1'])
-        dsmock.assert_called_once_with(Numero, Publication, [('lodel_id','=','1')], [])
-
-    @unittest.skip("Waiting for reimplementation in LeCrud")
-    @patch('leapi.datasources.dummy.DummyDatasource.update')
-    def test_db_update(self, dsmock):
-        from dyncode import Publication, Numero, LeObject
-        
-        num = Numero(1, type_id = Numero._type_id, class_id = Numero._class_id, titre = 'Hello world !')
-        num.db_update()
-        dsmock.assert_called_once_with(Numero, Publication, [('lodel_id','=','1')], [], num.datas)
-
-    @unittest.skip("Waiting for reimplementation in LeCrud")
-    @patch('leapi.datasources.dummy.DummyDatasource.delete')
-    def test_db_delete(self, dsmock):
-        from dyncode import Publication, Numero, LeObject
-
-        num = Numero(1, type_id = Numero._type_id, class_id = Numero._class_id, titre = 'Hello world !')
-        num.db_delete()
-        dsmock.assert_called_once_with(Numero, Publication, [('lodel_id','=','1')], [])
+        num = Numero(lodel_id = 1)
+        num.delete()
+        dsmock.assert_called_once_with(Numero, [('lodel_id','=',1)], [])