Add tests for LeObject + bufix

leobject/lefactory.py

 class LeFactory(object):
     
     output_file = 'dyn.py'
+    modname = None
 
     def __init__(LeFactory):raise NotImplementedError("Not designed (yet?) to be implemented")
 
     # @return a python class or False
     @staticmethod
     def leobj_from_name(name):
-        mod = importlib.import_module('leobject.'+LeFactory.output_file.split('.')[-1])
+        if LeFactory.modname is None:
+            modname = 'leobject.'+LeFactory.output_file.split('.')[1]
+        else:
+            modname = LeFactory.modname
+        mod = importlib.import_module(modname)
         try:
             res = getattr(mod, name)
         except AttributeError:
             result += LeFactory.emtype_pycode(model, emtype)
 
         #Populating LeObject._me_uid dict for a rapid fetch of LeType and LeClass given an EM uid
+        me_uid = { comp.uid:LeFactory.name2classname(comp.name) for comp in emclass_l + emtype_l }
         result += """
 ## @brief Dict for getting LeClass and LeType child classes given an EM uid
 LeObject._me_uid = %s
-"""%repr({ comp.uid:LeFactory.name2classname(comp.name) for comp in emclass_l + emtype_l })
-            
+"""%"{"+(','.join([ '%s:%s'%(k,v) for k,v in me_uid.items()]))+"}"       
         return result
 

leobject/leobject.py

 # @note LeObject will be generated by leobject.lefactory.LeFactory
 
 import re
+
+import leobject
+import EditorialModel
 from EditorialModel.types import EmType
 
 ## @brief Main class to handle objects defined by the types of an Editorial Model
     ## @brief Given a ME uid return the corresponding LeClass or LeType class
     # @return a LeType or LeClass child class
     # @throw KeyError if no corresponding child classes
+    @classmethod
     def uid2leobj(cls, uid):
         uid = int(uid)
         if uid not in cls._me_uid:
         if not(leclass is None):
             if isinstance(leclass, str):
                 leclass = leobject.lefactory.LeFactory.leobj_from_name(leclass)
-
-            if not isinstance(leclass, LeClass) or leclass.__class__ == leobject.leclass.LeClass:
-                raise ValueError("None | str | LeType child class excpected, but got : %s"%type(letype))
+            
+            if not isinstance(leclass, type) or not (leobject.leclass.LeClass in leclass.__bases__) or leclass.__class__ == leobject.leclass.LeClass:
+                raise ValueError("None | str | LeType child class excpected, but got : '%s' %s"%(leclass,type(leclass)))
 
         if not(letype is None):
             if isinstance(letype, str):
                 letype = leobject.lefactory.LeFactory.leobj_from_name(letype)
 
-            if not isinstance(letype, LeType) or letype.__class__ == leobject.letype.LeType:
+            if not isinstance(letype, type) or not leobject.letype.LeType in letype.__bases__ or letype.__class__ == leobject.letype.LeType:
                 raise ValueError("None | str | LeType child class excpected, but got : %s"%type(letype))
 
             if leclass is None:
                 leclass = letype._leclass
             elif leclass != letype._leclass:
-                raise ValueError("LeType child class %s does'nt inherite from LeClass %s"%(letype.__name__, leclass.__name))
+                raise ValueError("LeType child class %s does'nt inherite from LeClass %s"%(letype.__name__, leclass.__name__))
 
         return (letype, leclass)
 
     # @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()
     @staticmethod
     def _check_fields(letype, leclass, fields):
         #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.classtype.common_fields.keys():
+                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 = letype._fields
             #Checks that fields are in this type
             for field in fields:
-                if field not in fields_l:
+                if field not in field_l:
                     raise LeObjectQueryError("No field named '%s' in '%s'"%(field, typename))
         pass
 
                 filters.append(_LeObject._split_filter(fil))
 
         #Checking relational filters (for the moment fields like superior.NATURE)
-        relational_filters = [ (LeFactory._nature_from_relational_field(field), operator, value) for field, operator, value in filters if LeFactory._field_is_relational(field)]
-        filters = [f for f in filters if not self._field_is_relational(f[0])]
+        relational_filters = [ (_LeObject._nature_from_relational_field(field), operator, value) for field, operator, value in filters if _LeObject._field_is_relational(field)]
+        filters = [f for f in filters if not _LeObject._field_is_relational(f[0])]
         #Checking the rest of the fields
-        LeFactory._check_fields(letype, leclass, [ f[0] for f in filters ])
+        _LeObject._check_fields(letype, leclass, [ f[0] for f in filters ])
         
-        return (filters, relationnal_filters)
+        return (filters, relational_filters)
 
 
     ## @brief Check if a field is relational or not
     # @return True if the field is relational else False
     @staticmethod
     def _field_is_relational(field):
-        return field.startwith('superior.')
+        return field.startswith('superior.')
     
     ## @brief Check that a relational field is valid
     # @param field str : a relational field

leobject/test/test_leobject.py

 import unittest
 from unittest import TestCase
 
+import EditorialModel
+import leobject
+import leobject.test.utils
 from leobject.leobject import _LeObject
 
+## Testing static methods that don't need the generated code
 class _LeObjectTestCase(TestCase):
     
     def test_split_query_filter(self):
         for query in invalid_queries:
             with self.assertRaises(ValueError, msg='But the query was not valid : "%s"'%query):
                 _LeObject._split_filter(query)
+
+## Testing methods that need the generated code
+# @todo mock the datasource to test the get, update, delete and insert methods
+class LeObjectTestCase(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """ Write the generated code in a temporary directory and import it """
+        cls.tmpdir = leobject.test.utils.tmp_load_factory_code()
+    @classmethod
+    def tearDownClass(cls):
+        """ Remove the temporary directory created at class setup """
+        leobject.test.utils.cleanup(cls.tmpdir)
+
+    def test_uid2leobj(self):
+        """ Testing _Leobject.uid2leobj() """
+        import dyncode
+        for i in dyncode.LeObject._me_uid.keys():
+            cls = dyncode.LeObject.uid2leobj(i)
+            if leobject.letype.LeType in cls.__bases__:
+                self.assertEqual(i, cls._type_id)
+            elif leobject.leclass.LeClass in cls.__bases__:
+                self.assertEqual(i, cls._class_id)
+            else:
+                self.fail("Bad value returned : '%s'"%cls)
+        i=10
+        while i in dyncode.LeObject._me_uid.keys():
+            i+=1
+        with self.assertRaises(KeyError):
+            dyncode.LeObject.uid2leobj(i)
+    
+    def test_prepare_targets(self):
+        """ Testing _prepare_targets() method """
+        from dyncode import Publication, Numero, LeObject
+
+        test_v = {
+            (None, None) : (None, None),
+
+            (Publication, Numero): (Publication, Numero),
+            (Publication, None): (Publication, None),
+            (None, Numero): (Publication, Numero),
+
+            (Publication,'Numero'): (Publication, Numero),
+            ('Publication', Numero): (Publication, Numero),
+
+            ('Publication', 'Numero'): (Publication, Numero),
+            ('Publication', None): (Publication, None),
+            (None, 'Numero'): (Publication, Numero),
+        }
+
+        for (leclass, letype), (rleclass, rletype) in test_v.items():
+            self.assertEqual((rletype,rleclass), LeObject._prepare_targets(letype, leclass))
+
+    def test_invalid_prepare_targets(self):
+        """ Testing _prepare_targets() method with invalid arguments """
+        from dyncode import Publication, Numero, LeObject, Personnes
+        
+        test_v = [
+            ('',''),
+            (Personnes, Numero),
+            (leobject.leclass.LeClass, Numero),
+            (Publication, leobject.letype.LeType),
+            ('foobar', Numero),
+            (Publication, 'foobar'),
+            (Numero, Numero),
+            (Publication, Publication),
+            (None, Publication),
+            ('foobar', 'foobar'),
+            (42,1337),
+            (type, Numero),
+            (LeObject, Numero),
+            (LeObject, LeObject),
+            (Publication, LeObject),
+        ]
+
+        for (leclass, letype) in test_v:
+            with self.assertRaises(ValueError):
+                LeObject._prepare_targets(letype, leclass)
+
+    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(leobject.leobject.LeObjectQueryError):
+            LeObject._check_fields(None, None, Numero._fields)
+
+    def test_prepare_filters(self):
+        """ Testing the _prepare_filters() method """
+        from dyncode import Publication, Numero, LeObject, Personnes
+        
+        #Simple filters
+        filters = [
+            'lodel_id = 1',
+            'superior.parent  > 2'
+        ]
+
+        filt, rfilt = LeObject._prepare_filters(filters, Numero, None)
+        self.assertEqual(filt, [('lodel_id', '=', '1')])
+        self.assertEqual(rfilt, [('parent', '>', '2')])
+        
+        #All fields, no relationnal and class given
+        filters = []
+        res_filt = []
+        for field in Numero._fields:
+            filters.append('%s=1'%field)
+            res_filt.append((field, '=', '1'))
+
+        filt, rfilt = LeObject._prepare_filters(filters, None, Publication)
+        self.assertEqual(rfilt, [])
+        self.assertEqual(filt, res_filt)
+        
+        #Mixed type filters (tuple and string)
+        filters = [
+            ('lodel_id', '<=', '0'),
+            'superior.parent = 2',
+        ]
+        
+        filt, rfilt = LeObject._prepare_filters(filters, Numero, None)
+        self.assertEqual(filt, [('lodel_id', '<=', '0')])
+        self.assertEqual(rfilt, [('parent', '=', '2')])
+
+    def test_prepare_filters_invalid(self):
+        """ Testing the _prepare_filters() method """
+        from dyncode import Publication, Numero, LeObject, Personnes
+
+        #Numero fields filters but no letype nor leclass given
+        filters = []
+        res_filt = []
+        for field in Numero._fields:
+            filters.append('%s=1'%field)
+            res_filt.append((field, '=', '1'))
+        
+        with self.assertRaises(leobject.leobject.LeObjectQueryError):
+            LeObject._prepare_filters(filters, None, None)
+
+
+        #simply invalid filters
+        filters = ['hello world !']
+        with self.assertRaises(ValueError):
+            LeObject._prepare_filters(filters, None, None)
+