checked_data_value passed test for datahandler class and derived class

lodel/leapi/datahandlers/base_classes.py

-# -*- coding: utf-8 -*-
+#-*- co:ding: utf-8 -*-
 
 ## @package lodel.leapi.datahandlers.base_classes Define all base/abstract class for data handlers
 #
     def is_primary_key(self):
         return self.primary_key
 
+
     ##@brief checks if a fieldtype is internal
     # @return bool
     def is_internal(self):
         return self.internal is not False
 
-
     def _check_data_value(self, value):
         if value is None:
             if not self.nullable:
-                print(LodelExeption)
                 raise LodelExceptions("None value is forbidden")
-            print(self.nullable, value)
             raise DataNoneValid("None with a nullable. GOTO CHECK")
-        return value, None
+        return value
 
 #
 #    ##@brief calls the data_field defined _check_data_value() method
 #    #@return tuple (value, error|None)
     def check_data_value(self, value):
         try:
-            self._check_data_value(value)
+            value = self._check_data_value(value)
         except DataNoneValid as expt:
             return value, None
-        except LodelExceptions as expt:
+        except (LodelExceptions, FieldValidationError) as expt:
             return None, expt
         return value, None
-
 #
     ##@brief checks if this class can override the given data handler
     # @param data_handler DataHandler
     #@return tuple(value, exception)
     #@todo implement the check when we have LeObject to check value
     def _check_data_value(self, value):
-        super()._check_data_value(value)
+        value= super()._check_data_value(value)
         elt = self.__allowed_classes[0]
         uid = elt.uid_fieldname()[0]# TODO multiple uid is broken
         if (expt is None and not (isinstance(value, LeObject)) or (value is uid)):
             raise FieldValidationError("LeObject instance or id exxpected for a reference field")
+        return value
 
     def construct_data(self, emcomponent, fname, datas, cur_value):
         super().construct_data(emcomponent, fname, datas, cur_value)
     def __init__(self, allowed_classes = None, **kwargs):
         super().__init__(allowed_classes = allowed_classes)
  
-    def check_data_value(self, value):
-        super()._check_data_value(value)
+    def _check_data_value(self, value):
+        value = super()._check_data_value(value)
         if (expt is None and (len(val)>1)):
             raise FieldValidationError("List or string expected for a set field")
+        return value
 
 
 
         self.max_item = max_item
         super().__init__(**kwargs)
 
-        
+       #@TODO  checkig one by one and put error in a list
     def _check_data_value(self, value):
-        super()._check_data_value(value)
+        value = super()._check_data_value(value)
         if not hasattr(value, '__iter__'):
             raise FieldValidationError("MultipleRef has to be an iterable or a string, '%s' found" % value)
         if self.max_item is not None:
             if self.max_item < len(value):
                 raise FieldValidationError("Too many items")
         ref_list = []
+        #Checked reference value one by one . 
         for v in value.items():
             ref_list.append(super()._check_data_value(v))
+        return value
 
     def construct_data(self, emcomponent, fname, datas, cur_value):
         cur_value = super().construct_data(emcomponent, fname, datas, cur_value)

lodel/leapi/datahandlers/datas.py

 import warnings
 import inspect
 from lodel.leapi.datahandlers.datas_base import *
+from lodel.leapi.datahandlers.base_classes import FieldValidationError
 import re
 
 ##@brief Data field designed to handle formated strings
         super(self.__class__, self).__init__(max_length=max_length, **kwargs)
 
     def _check_data_value(self, value):
-        error = None
+        value = super()._check_data_value(value)
         if not self.compiled_re.match(value) or len(value) > self.max_length:
-            value = ''
             msg = '"%s" doesn\'t match the regex "%s"' % (value, self.regex)
-            error = TypeError(msg)
-        return value, error
+            raise FieldValidationError(msg)
+        return value
 
     def can_override(self, data_handler):
         if not super().can_override(data_handler):

lodel/leapi/datahandlers/datas_base.py

 import time
 import os
 
-from lodel.leapi.datahandlers.base_classes import DataField
+from lodel.leapi.datahandlers.base_classes import DataField, FieldValidationError
 
 ##@brief Data field designed to handle boolean values
 class Boolean(DataField):
 
     ##@brief A boolean field
     def __init__(self, **kwargs):
-        if 'check_data_value' not in kwargs:
-            kwargs['check_data_value'] = self.check_data_value
+        #if 'check_data_value' not in kwargs:
+        #    kwargs['check_data_value'] = self._check_data_value
         super().__init__(ftype='bool', **kwargs)
 
     def _check_data_value(self, value):
-        error = None
-        try:
-            if type(value) != bool:
-                raise TypeError()
-        except(ValueError, TypeError):
-            error = TypeError("The value '%s' is not, and will never, be a boolean" % value)
-        return value, error
+        value = super()._check_data_value(value)   
+        if not isinstance(value, bool):
+            raise FieldValidationError("The value '%s' is not, and will never, be a boolean" % value)
+        return value
 
 ##@brief Data field designed to handle integer values
 class Integer(DataField):
     def __init__(self, **kwargs):
         super().__init__( **kwargs)
 
-    def _check_data_value(self, value):
-        error = None
+    def _check_data_value(self, value, strict = False):
+        value = super()._check_data_value(value)
+        if (strict and isinstance(value, int)):
+            raise FieldValidationError("The value '%s' is not a python type integer" % value)
         try:
             value = float(value)
-            if value % 1 == 0:
-                value = int(value)
-            else:
+            if value != int(value):
                 raise TypeError()
         except(ValueError, TypeError):
-            error = TypeError("The value '%s' is not, and will never, be an integer" % value)
-        return value, error
+            raise FieldValidationError("The value '%s' is not, and will never, be an integer" % value)
+        return value
 
 ##@brief Data field designed to handle string
 class Varchar(DataField):
         return True
     
     def _check_data_value(self, value):
-        error = None
-        try:
-            value = str(value)
-            if len(value) > self.max_length:
-                raise ValueError
-        except TypeError:
-            error = TypeError("The value '%s' can't be a str" % value)
-        except ValueError:
-            error = ValueError("The value '%s' is longer than the maximum length of this field (%s)" % (value, self.max_length))
-        return value, error
-
+        value = super()._check_data_value(value)   
+        if not isinstance(value, str):
+            raise FieldValidationError("The value '%s' can't be a str" % value)
+        if len(value) > self.max_length:
+             raise FieldValidationError("The value '%s' is longer than the maximum length of this field (%s)" % (value, self.max_length))
+        return value
 ##@brief Data field designed to handle date & time 
 class DateTime(DataField):
 
         super().__init__(**kwargs)
 
     def _check_data_value(self, value):
-        error = None
+        value = super()._check_data_value(value)
         if isinstance(value,str):
             try:
                 datetime_value = datetime.datetime.fromtimestamp(time.mktime(time.strptime(value, self.datetime_format)))
-            except ValueError:
-                error = ValueError("The value '%s' cannot be converted as a datetime" % value)
+            except ValueError: 
+                raise FieldValidationError("The value '%s' cannot be converted as a datetime" % value)
         elif not isinstance(value, datetime.datetime):
-            error = ValueError("Tue value has to be a string or a datetime")
-        return value, error
+            raise FieldValidationError("Tue value has to be a string or a datetime")
+        else:
+            return value
 
     def _construct_data(self, emcomponent, fname, datas, cur_value):
         if (self.now_on_create and cur_value is None) or self.now_on_update:
         super(self.__class__, self).__init__(ftype='text', **kwargs)
     
     def _check_data_value(self, value):
-        error = None
-        try:
-            value = str(value)
-        except (ValueError, TypeError):
-            error = ValueError("The content passed to this Text field is not a convertible to a string")
-        return value, error
+        value = super()._check_data_value(value)   
+        if not isinstance(value, str):
+            raise FieldValidationError("The content passed to this Text field is not a convertible to a string")
+        return value
 
 ##@brief Data field designed to handle Files
 class File(DataField):
 
     # @todo Add here a check for the validity of the given value (should have a correct path syntax)
     def _check_data_value(self, value):
-        error = None
-        return value, error
+        return super()._check_data_value(value)   
 

lodel/leapi/query.py

                     rel_filters.append((ret, operator, value))
             else:
                 # Casting value given datahandler
-                value, error = field_datahandler._check_data_value(value)
+                value_orig = value
+                value, error = field_datahandler.check_data_value(value)
+                if isinstance(error, Exception):
+                    value = value_orig
                 res_filters.append((field,operator, value))
-        
         if len(err_l) > 0:
             raise LeApiDataCheckErrors(
                                         "Error while preparing filters : ",

tests/datahandlers/test_datetime.py

         test_datetime = DateTime(now_on_create=True, now_on_update=True)
         test_value = '2016-01-01-test'
         _, error = test_datetime.check_data_value(test_value)
-        self.assertIsNotNone(error)
+        self.assertIsNotNone(error)

tests/datahandlers/test_regex.py

                            max_length=15)
         for test_value in ['800.9.10.5', 'test_string_value', '999.999.999.999']:
             value, error = test_regex.check_data_value(test_value)
-            self.assertEqual(value, '')
+            self.assertEqual(value, None)
             self.assertIsNotNone(error)
 
     def test_check_max_length(self):
         for test_value in ['cccccc8', 'ccccccccccccccccccccccccccccccccc8']:
             value, error = test_regex.check_data_value(test_value)
             if len(test_value)>test_max_length:
-                self.assertEqual(value, '')
+                self.assertEqual(value, None)
                 self.assertIsNotNone(error)
             else:
                 self.assertIsNone(error)

tests/datahandlers/test_varchar.py

 import unittest
 
 from lodel.leapi.datahandlers.datas import Varchar, Integer
-
+from lodel.leapi.datahandlers.base_classes import FieldValidationError
 
 class VarcharTestCase(unittest.TestCase):
 
 
         _, error = test_varchar.check_data_value("c" * 11)
         self.assertIsNotNone(error)
-        self.assertIsInstance(error, ValueError)
+        self.assertIsInstance(error, FieldValidationError)
 
     def test_can_override(self):
         test_varchar1 = Varchar()
         test_varchar2 = Varchar()
 
         self.assertFalse(test_varchar1.can_override(test_integer))
-        self.assertTrue(test_varchar1.can_override(test_varchar2))
+        self.assertTrue(test_varchar1.can_override(test_varchar2))