Unskip, delete and fix some tests

DataSource/MySQL/test/test_datasource.py

             DataSource(conn_args = conn_args)
             mock_db.assert_called_once_with(pymysql, **conn_args)
     
-    @unittest.skip("Broken because of multivalue fields")
     def test_insert_leobject(self):
         """ Test the insert method on LeObjects """
         from dyncode import Article, Personne, Rubrique
 
             sql_query = 'SELECT wow FROM splendid_table'
 
-            class_table_datas = { fname: random.randint(42,1337) for fname in letype.fieldlist(complete = False) }
-            for fname in class_table_datas:
+            class_table_datas = {
+                fname: random.randint(42,1337)
+                for fname in letype.fieldlist(complete = False)
+                if not isinstance(letype.fieldtypes()[fname], MultiValueFieldType)
+            }
+            i18n = dict()
+            for fname in letype.fieldlist():
                 if isinstance(letype.fieldtypes()[fname], MultiValueFieldType):
-                    class_table_datas[fname] = {'fre': 'bonjour', 'eng': 'hello'}
-            #class_table_datas = { 'title': 'foo', 'number': 42 }
+                    i18n[fname] = {'fre': 'bonjour', 'eng': 'hello'}
+                    class_table_datas[fname] = i18n[fname]
             object_table_datas = { 'string': random.randint(-42,42) }
             
             # build the insert datas argument
                     object_table_datas['type_id'] = letype._type_id
                     # construct expected datas used in class table insert
                     class_table_datas['lodel_id'] = lodel_id
+                    for fname in i18n:
+                        del(class_table_datas[fname])
 
                     expected_calls = [
                         # insert in object table call
                             class_table_datas
                         ),
                     ]
-
+                    i18n_calls = dict()
+                    for fname, fval in i18n.items():
+                        keyname = letype.fieldtypes()[fname].keyname
+                        if not keyname in i18n_calls:
+                            i18n_calls[keyname] = dict()
+                        for lang, val in fval.items():
+                            if not lang in i18n_calls[keyname]:
+                                i18n_calls[keyname][lang] = dict()
+                            i18n_calls[keyname][lang][fname] = val
+                    real_i18n_calls = []
+                    for keyname, kval in i18n_calls.items():
+                        table_name = db_utils.multivalue_table_name(
+                            db_utils.object_table_name(letype._leclass.__name__),
+                            keyname
+                        )
+                        for lang, value in kval.items():
+                            value[keyname] = lang
+                            value[letype.uidname()] = lodel_id
+                            expected_calls.append(call(
+                                    table_name,
+                                    value
+                                )
+                            )
                     expected_utils_query_calls = [
                         call(datasource.connection, sql_query),
                         call(datasource.connection, sql_query),

leapi/lerelation.py

     def object_from_data(cls, datas):
         return cls.name2class('LeHierarch')(**datas)
 
+    ## @warning Abastract method
+    def update(self):
+        raise NotImplementedError("Abstract method")
+        
+
 ## @brief Abstract class to handle rel2type relations
 class _LeRel2Type(_LeRelation):
     ## @brief Stores the list of fieldtypes handling relations attributes

leapi/test/test_leobject.py

         with self.assertRaises(KeyError):
             dyncode.LeObject.uid2leobj(i)
     
-    @unittest.skip("Obsolete but may be usefull for datasources tests")
-    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))
-
-    @unittest.skip("Obsolete but may be usefull for datasources tests")
-    def test_invalid_prepare_targets(self):
-        """ Testing _prepare_targets() method with invalid arguments """
-        from dyncode import Publication, Numero, LeObject, Personnes
-        
-        test_v = [
-            ('',''),
-            (Personnes, Numero),
-            (leapi.leclass.LeClass, Numero),
-            (Publication, leapi.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)
-
 class LeObjectMockDatasourceTestCase(TestCase):
     """ Testing _LeObject using a mock on the datasource """
 

leapi/test/test_lerelation.py

         dsmock.assert_called_once_with(LeHierarch, 10)
         
     
-    @unittest.skip("Wait for LeRelation.update() to unskip")
     @patch('DataSource.dummy.leapidatasource.DummyDatasource.update')
     def test_update(self, dsmock):
         """ test LeHierach update method"""

leapi/test/test_letype.py

 import leapi
 import DataSource.dummy
 import leapi.test.utils
+from leapi.lecrud import _LeCrud
 
 class LeTypeTestCase(TestCase):
     
             dsmock.assert_called_once_with(Numero, missing_fields, [('lodel_id','=',1)],[])
 
     @patch('DataSource.dummy.leapidatasource.DummyDatasource.update')
-    @unittest.skip('must verify that populate is called')
     def test_update(self, dsmock):
         from dyncode import Publication, Numero, LeObject
         
         
         #Testing as instance method
         num = Numero(lodel_id = 1)
-        num.update(datas)
-        dsmock.assert_called_once_with(Numero, [('lodel_id','=',1)], [], **datas)
+        with patch.object(_LeCrud, 'populate', return_value=None) as mock_populate:
+            num.update(datas)
+            mock_populate.assert_called_once_with()
+            dsmock.assert_called_once_with(Numero, num.uidget(), **datas)
     
     @patch('DataSource.dummy.leapidatasource.DummyDatasource.delete')
     def test_delete(self, dsmock):