Bugfix + added some tests to LeCrud

EditorialModel/fieldtypes/generic.py

@@ -63,6 +63,10 @@ class GenericFieldType(object):
     @property
     def name(self):
         return self.__module__.split('.')[-1]
+    
+    ## @return True if a field is internal, else returns False
+    def is_internal(self):
+        return hasattr(self, 'internal') and self.internal
 
     ## @brief Check if a Value is correct else return a check fail reason
     # @param value * : The value to check

leapi/lecrud.py

@@ -9,13 +9,29 @@ import importlib
 import re
 
 import leapi.leobject
-import EditorialModel.fieldtypes.generic
+
+class LeApiErrors(Exception):
+    ## @brief Instanciate a new exceptions handling multiple exceptions
+    # @param expt_l list : A list of data check Exception
+    def __init__(self, msg = "Unknow error", exceptions = None):
+        self._msg = msg
+        self._exceptions = list() if exceptions is None else exceptions
+
+    def __str__(self):
+        msg = self._msg
+        for expt in self._exceptions:
+            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(EditorialModel.fieldtypes.generic.FieldTypeDataCheckError): pass
+class LeApiQueryError(LeApiErrors): pass
 
 ## @brief When an error concerns a datas
-class LeApiDataCheckError(EditorialModel.fieldtypes.generic.FieldTypeDataCheckError): pass
+class LeApiDataCheckError(LeApiErrors): pass
     
 
 ## @brief Main class to handler lodel editorial components (relations and objects)
@@ -109,7 +125,7 @@ class _LeCrud(object):
         correct = [] #Valid fields name
         mandatory = [] #mandatory fields name
         for fname, ftt in cls.fieldtypes().items():
-            if allow_internal and not ftt.is_internal():
+            if allow_internal or not ftt.is_internal():
                 correct.append(fname)
                 if complete and not hasattr(ftt, 'default'):
                     mandatory.append(fname)
@@ -118,6 +134,7 @@ class _LeCrud(object):
         provided = set(datas.keys())
 
         #searching unknow fields
+        print("provided", provided, "correct", correct)
         unknown = provided - correct
         for u_f in unknown:
             #here we can check if the field is unknown or rejected because it is internal
@@ -134,7 +151,7 @@ class _LeCrud(object):
                 err_l.append(err)
 
         if len(err_l) > 0:
-            raise LeApiDataCheckError("The argument complete was %s but some fields are missing : %s" % (complete, err_l))
+            raise LeApiDataCheckError("Error while checking datas", err_l)
         return checked_datas
 
     ## @brief Retrieve a collection of lodel editorial components

leapi/letype.py

@@ -55,7 +55,7 @@ class LeType(object):
 
     @classmethod
     def fieldtypes(cls):
-        return { fname: ftype for fname,ftype in [ (fname, cls._fieldtypes[fname]) for fname in cls._fieldtypes if fname in cls._fields ] }
+        return { fname: cls._fieldtypes[fname] for fname in cls._fieldtypes if fname in cls._fields }
 
     ## @brief Populate the LeType wih datas from DB
     # @param field_list None|list : List of fieldname to fetch. If None fetch all the missing datas

leapi/test/test_lecrud.py

@@ -0,0 +1,142 @@
+"""
+    Tests for _LeObject and LeObject
+"""
+
+import unittest
+from unittest import TestCase
+from unittest.mock import patch
+
+import EditorialModel
+import leapi
+import leapi.test.utils
+from leapi.lecrud import _LeCrud
+
+class LeCrudTestCase(TestCase):
+    @classmethod
+    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 """
+        leapi.test.utils.cleanup(cls.tmpdir)
+
+    def test_split_query_filter(self):
+        """ Tests the _split_filter() classmethod """
+        import dyncode
+        query_results = {
+            'Hello = world' : ('Hello', '=', 'world'),
+            'hello <= "world"': ('hello', '<=', '"world"'),
+            '_he42_ll-o >= \'world"': ('_he42_ll-o', '>=', '\'world"'),
+            'foo in ["foo", 42, \'bar\']': ('foo', ' in ', '["foo", 42, \'bar\']'),
+            ' bar42              < 42': ('bar42', '<', '42'),
+            ' _hidden > 1337': ('_hidden', '>', '1337'),
+            '_42 not in foobar': ('_42', ' not in ', 'foobar'),
+            'hello                       in      foo':('hello', ' in ', 'foo'),
+            "\t\t\thello\t\t\nin\nfoo\t\t\n\t":('hello', ' in ', 'foo'),
+            "hello \nnot\tin \nfoo":('hello', ' not in ', 'foo'),
+            'hello != bar':('hello', '!=', 'bar'),
+            'hello = "world>= <= != in not in"': ('hello', '=', '"world>= <= != in not in"'),
+            'superior.parent = 13': ('superior.parent', '=', '13'),
+        }
+        for query, result in query_results.items():
+            res = dyncode.LeCrud._split_filter(query)
+            self.assertEqual(res, result, "When parsing the query : '%s' the returned value is different from the expected '%s'"%(query, result))
+
+    def test_invalid_split_query_filter(self):
+        """ Testing the _split_filter() method with invalid queries """
+        import dyncode
+        invalid_queries = [
+            '42 = 42',
+            '4hello = foo',
+            'foo == bar',
+            'hello >> world',
+            'hello =    ',
+            ' = world',
+            '=',
+            '42',
+            '"hello" = world',
+            'foo.bar = 15',
+        ]
+        for query in invalid_queries:
+            with self.assertRaises(ValueError, msg='But the query was not valid : "%s"'%query):
+                dyncode.LeCrud._split_filter(query)
+
+    def test_field_is_relational(self):
+        """ Testing the test to check if a field is relational """
+        from dyncode import LeCrud
+
+        test_fields = {
+            'superior.parent': True,
+            'subordinate.parent': True,
+            'foofoo.foo': False,
+        }
+
+        for field, eres in test_fields.items():
+            self.assertEqual(LeCrud._field_is_relational(field), eres)
+
+    def test_check_datas(self):
+        """ testing the check_datas* methods """
+        from dyncode import Publication, Numero, LeObject
+
+        datas = { 'titre':'foobar' }
+        Numero.check_datas_value(datas, False, False)
+        Numero.check_datas_value(datas, True, False)
+        with self.assertRaises(leapi.lecrud.LeApiDataCheckError):
+            Numero.check_datas_value({}, True)
+
+    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 = Numero._prepare_filters(filters)
+        self.assertEqual(filt, [('lodel_id', '=', '1')])
+        self.assertEqual(rfilt, [((leapi.leobject.REL_SUP,'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 = Publication._prepare_filters(filters)
+        self.assertEqual(rfilt, [])
+        self.assertEqual(filt, res_filt)
+        
+        #Mixed type filters (tuple and string)
+        filters = [
+            ('lodel_id', '<=', '0'),
+            'subordinate.parent = 2',
+        ]
+        
+        filt, rfilt = Numero._prepare_filters(filters)
+        self.assertEqual(filt, [('lodel_id', '<=', '0')])
+        self.assertEqual(rfilt, [((leapi.leobject.REL_SUB,'parent'), '=', '2')])
+ 
+    def test_prepare_filters_invalid(self):
+        """ Testing the _prepare_filters() method """
+        from dyncode import LeCrud, Publication, Numero, Personnes, LeObject
+
+        #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(leapi.lecrud.LeApiDataCheckError):
+            LeObject._prepare_filters(filters)
+
+
+        #simply invalid filters
+        filters = ['hello world !']
+        with self.assertRaises(ValueError):
+            Personnes._prepare_filters(filters)
+

leapi/test/test_letype.py

@@ -45,18 +45,6 @@ class LeTypeTestCase(TestCase):
             with self.assertRaises(expect_e, msg="Invalid argument given %s"%badarg):
                 Numero(**badarg)
     
-    ## @todo when we will have a field in a type that has a check_function try to make check_datas_or_raise raise with invalid value
-    @unittest.skip("Waiting for EmFieldType full implementation")
-    def test_check_datas(self):
-        """ testing the check_datas* methods """
-        from dyncode import Publication, Numero, LeObject
-
-        datas = { 'titre':'foobar' }
-        Numero.check_datas_value(datas, False, False)
-        Numero.check_datas_value(datas, True, False)
-        with self.assertRaises(leapi.leobject.LeObjectError):
-            Numero.check_datas_value({}, True)
-
     @patch('leapi.letype.LeType.populate')
     def test_datas(self, dsmock):
         """ Testing the datas @property method """