Bugfixes on EmComponent

- Now except for the modify_rank tests test_component didn't fails
- Added simple integer operation capabilities to EmFieldType_integer ( int cast, +=, -=, *=, /=, +, -, *, /, %, ...)

EditorialModel/components.py

     ## Used by EmComponent::modify_rank
     ranked_in = None
 
+    ##Read only properties
+    _ro_properties = [ 'date_update', 'date_create', 'uid', 'rank']
+
     ## Instaciate an EmComponent
     # @param id_or_name int|str: name or id of the object
     # @throw TypeError if id_or_name is not an integer nor a string
 
         # populate
         if isinstance(id_or_name, int):
-            self.uid = id_or_name
-            self.name = None
+            self._fields['uid'].value = id_or_name #read only propertie set
         elif isinstance(id_or_name, str):
-            self.uid = None
             self.name = id_or_name
         else:
             raise TypeError('Bad argument: expecting <int> or <str> but got : '+str(type(id_or_name)))
     # @param name str: The propertie name
     # @param value *: The value
     def __setattr__(self, name, value):
+        if name in  self.__class__._ro_properties:
+            raise TypeError("Propertie '"+name+"' is readonly")
+
         if name != '_fields' and hasattr(self, '_fields') and name in object.__getattribute__(self, '_fields'):
             self._fields[name].from_python(value)
         else:
     # @todo Check that the query didn't failed
     # @todo Check that every mandatory _fields are given in args
     # @todo Put a real rank at creation
+    # @todo Stop using datetime.datetime.utcnow() for date_update and date_create init
     @classmethod
     def create(cl, **kwargs):
         for argname in kwargs:
 
     ## Write the representation of the component in the database
     # @return bool
+    # @todo stop using datetime.datetime.utcnow() for date_update update
     def save(self):
         values = {}
         for name, field in self._fields.items():
             values[name] = field.to_sql()
 
         #Don't allow creation date overwritting
+        """
         if 'date_create' in values:
             del values['date_create']
             logger.warning("date_create supplied for save, but overwritting of date_create not allowed, the date will not be changed")
+        """
+        values['date_update'] = datetime.datetime.utcnow()
 
         self._saveDb(values)
     
                         c.execute(req, vals)
                         c.close()
 
-                        self.rank = new_rank
+                        self._fields['rank'].value = new_rank
 
                     else:
                         logger.error("Bad argument")
                             req = component.update().where(component.c.uid == sql.bindparam('id')).values(rank = sql.bindparam('rank'))
                             c.execute(req, vals)
                             c.close()
-
-                            self.rank += new_rank
+                            
+                            self._fields['rank'] += new_rank
                         else:
                             logger.error("Bad argument")
                             raise ValueError('Excepted a positive int not a null. new_rank = '+str((new_rank)))
                             c.execute(req, vals)
                             c.close()
 
-                            self.rank -= new_rank
+                            self._fields['rank'] -= new_rank
                         else:
                             logger.error("Bad argument")
                             raise ValueError('Excepted a positive int not a null. new_rank = '+str((new_rank)))
     ## Register a new component in UID table
     # 
     # Use the class property table
+    # @return A new uid (an integer)
     def newUid(cl):
-        """ This function register a new component in uids table
-            @return The new uid
-        """
+        if cl.table == None:
+            raise NotImplementedError("Abstract method")
+
         dbe = cl.getDbE()
 
         uidtable = sql.Table('uids', sqlutils.meta(dbe))

EditorialModel/fieldtypes.py

             value = self.value
         return value
 
+    def __int__(self):
+        return self.value
+
+    def __add__(self, other):
+        return self.value + other
+
+    def __sub__(self, other):
+        return self.value - other
+
+    def __mul__(self, other):
+        return self.value * other
+
+    def __div__(self, other):
+        return self.value / other
+
+    def __mod__(self, other):
+        return self.value % other
+
+    def __iadd__(self, other):
+        self.value = int(self.value + other)
+        return self
+
+    def __isub__(self, other):
+        self.value = int(self.value - other)
+        return self
+
+    def __imul__(self, other):
+        self.value = int(self.value * other)
+        return self
+
+    def __idiv__(self, other):
+        self.value = int(self.value / other)
+        return self
+
     def sql_column(self):
         return "int(11) NOT NULL"
 

EditorialModel/test/test_component.py

             elif vname in ['date_create', 'date_update']:
                 # Datetime comparison
                 if check_date:
-                    self.assertEqualDatetime(val[vname], getattr(test_comp, vname), msg)
+                    self.assertEqualDatetime(val[vname], getattr(test_comp, vname), vname+" assertion error : "+msg)
             else:
                 prop = vname
                 self.assertEqual(getattr(test_comp, prop), val[vname], msg+"Inconsistency for "+prop+" property")
 
     def test_component_abstract_init(self):
         """ Test not valid call (from EmComponent) of __init__ """
-        with self.assertRaises(EnvironmentError):
+        with self.assertRaises(NotImplementedError):
             test_comp = EmComponent(2)
-        with self.assertRaises(EnvironmentError):
+        with self.assertRaises(NotImplementedError):
             test_comp = EmComponent('name')
         pass
 
         for prop in ['name', 'help', 'string', 'date_update', 'date_create', 'rank' ]:
             if prop in ['string', 'help']:
                 assertion = self.assertEqualMlString
-            elif prop in ['date_update', 'date_create']:
+            elif prop == 'date_create':
                 assertion = self.assertEqualDatetime
+            elif prop == 'date_update':
+                assertion = self.assertLess
             else:
                 assertion = self.assertEqual
 
-            assertion(getattr(test_comp, prop), getattr(test_comp2, prop), "Save don't propagate modification properly. The '"+prop+"' property differs between the modified instance and a new one fetch from Db : ")
+            assertion(getattr(test_comp, prop), getattr(test_comp2, prop), "Save don't propagate modification properly. The '"+prop+"' property hasn't the exepted value in instance fetched from Db : ")
         pass
 
     def test_component_save_setattr(self):
 
         pass
 
-    @unittest.skip("Soon we will not use anymore the values argument of the savec method")
-    def test_component_save(self):
-        """ Checking save method after different changes using values arg of save method """
-        val = self.test_values[0]
-        test_comp = EmTestComp(val['name'])
-        self.check_equals(val, test_comp)
-
-        save_args = [
-            { 'name': 'foonewname' },
-            { 'name': 'foo new name'},
-            { 'help': '{"fr": "strhelp fr", "en":"strhelp en", "es":"strhelp es"}'},
-            { 'string': '{"fr": "helpstr fr", "en":"helpstr en", "es":"helpstr es"}'},
-            { 'name': 'oldname', 'help':'{"fr": "help fra", "en":"help eng", "es":"help esp"}', 'string':'{"fr": "string FR", "en":"string EN", "es":"string ES", "foolang":"foofoobar"}'},
-            { 'help': '{}', 'string':'{}'},
-        ]
-        for values in save_args:
-            for vname in values:
-                val[vname] = values[vname]
-
-            v = values.copy()
-            #WARNING : v is set by save
-            test_comp.save(v)
-            
-            print(val,"\n" ,values)
-            self._savecheck(test_comp, val)
-
     def test_component_save_illegalchanges(self):
         """ checking that the save method forbids some changes """
         val = self.test_values[1]
         changes = { 'date_create': datetime.datetime(1982,4,2,13,37), 'date_update': datetime.datetime(1982,4,2,22,43), 'rank': 42 }
 
         for prop in changes:
-            with self.subTest("Illega change of "+prop):
+            with self.subTest("Illegal change of "+prop):
                 test_comp = EmTestComp(val['name'])
-                self.check_equals(val, test_comp)
+                self.check_equals(val, test_comp, False)
                 
-                setattr(test_comp, prop, changes[prop])
+                with self.assertRaises(TypeError):
+                    setattr(test_comp, prop, changes[prop])
                 test_comp.save()
     
                 test_comp2 = EmTestComp(val['name'])
 
             for j in range(1,i+1):
                 test_comp2 = EmTestComp(names[j])
-                self.assertEqual(test_comp2.rank, j-1)
+                self.assertEqual(test_comp2.rank, j-1, self.dump_ranks())
             for j in range(i+1,nmax+1):
                 test_comp2 = EmTestComp(names[j])
-                self.assertEqual(test_comp2.rank, j)
+                self.assertEqual(test_comp2.rank, j, self.dump_ranks())
 
             test_comp.modify_rank(i,'-')
             self.assertEqual(test_comp.rank, 0, "The instance on wich we applied the modify_rank -"+str(i)+" doesn't have excepted rank : excepted '0' but got '"+str(test_comp.rank)+"'")
 
             for j in range(1,nmax+1):
                 test_comp2 = EmTestComp(names[j])
-                self.assertEqual(test_comp2.rank, j)
+                self.assertEqual(test_comp2.rank, j, self.dump_ranks())
 
         test_comp = EmTestComp(names[3])
         test_comp.modify_rank(2,'+')