Some tests dont pass, but most of them does

EditorialModel/classes.py

         fieldgroups = self.fieldgroups()
         fields = []
         for fieldgroup in fieldgroups:
-            fields += self._fields_db(fieldgroup.uid)
+            fields += EditorialModel.fields.EmField(self._fields_db(fieldgroup.uid))
 
         return fields
 

EditorialModel/test/test_field.py

 from EditorialModel.types import EmType
 from EditorialModel.fieldgroups import EmFieldGroup
 from EditorialModel.fields_types import Em_Field_Type
+from EditorialModel.test.utils import *
 from EditorialModel.fieldtypes import *
 
 from Database.sqlsetup import SQLSetup
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Lodel.settings")
 
+TEST_FIELD_DBNAME = 'lodel2_test_field_db.sqlite'
+
 ## SetUpModule
 #
 # This function is called once for this module.
 # It is designed to overwrite the database configurations, and prepare objects for test_case initialization
 def setUpModule():
-    # Overwriting the database parameters to make tests
-    settings.LODEL2SQLWRAPPER['db'] = {
-        'default':{
-            'ENGINE': 'sqlite',
-            'NAME': '/tmp/lodel2_test_db.sqlite'
-        }
-    }
-
+    initTestDb(TEST_FIELD_DBNAME)
+    setDbConf(TEST_FIELD_DBNAME)
     logging.basicConfig(level=logging.CRITICAL)
 
+
 ## FieldTestCase (Class)
 #
 # The parent class of all other test cases for the fields module.
 # It defines a SetUp function and some utility functions for EmField tests.
 class FieldTestCase(TestCase):
 
-    def setUp(self):
+    @classmethod
+    def setUpClass(cls):
         sqls = SQLSetup()
         sqls.initDb()
 
         # Generation of the test data
-        self.testClass = EmClass.create("testclass1",EmClassType.entity)
+        testclass = EmClass.create("testclass1",EmClassType.entity)
+        EmField_integer()
+        EmFieldGroup.create('fieldgrp1',testclass)
+        EmType.create('testtype1',testclass)
+        saveDbState(TEST_FIELD_DBNAME)
+
+
+    def setUp(self):
+        restoreDbState(TEST_FIELD_DBNAME)
+        self.testClass = EmClass("testclass1")
         self.testFieldType = EmField_integer()
-        self.testFieldgroup = EmFieldGroup.create('fieldgrp1',self.testClass)
-        self.testType = EmType.create('testtype1',self.testClass)
+        self.testFieldgroup = EmFieldGroup('fieldgrp1')
+        self.testType = EmType('testtype1')
 
     ## Get_Field_Records (Function)
     #

EditorialModel/test/test_fieldgroups.py

 # TESTS SETUP #
 #=###########=#
 
-TEST_FIELDGROUP_DBNAME = 'test_em_component_db.sqlite'
+TEST_FIELDGROUP_DBNAME = 'test_em_fieldgroup_db.sqlite'
 
 def setUpModule():
 
     initTestDb(TEST_FIELDGROUP_DBNAME)
     setDbConf(TEST_FIELDGROUP_DBNAME)
     
-    """
-    #Overwritting db confs to make tests
-    settings.LODEL2SQLWRAPPER['db'] = {
-        'default': {
-            'ENGINE': 'sqlite',
-            'NAME': TEST_FIELDGROUP_DBNAME
-        }
-    }
-
-    SQLSetup().initDb()
-    """
-
     #Classes creation
     EmClass.create("entity1", EmClassType.entity)
     EmClass.create("entity2", EmClassType.entity)
 
         for name in tests:
             with self.subTest("Testing on "+name+" instanciated EmFieldGroups"):
-                fg = test[name]
+                fg = tests[name]
                 flist = fg.fields()
                 res = []
                 for f in flist:

EditorialModel/test/test_types.py

     initTestDb(TEST_TYPE_DBNAME)
     setDbConf(TEST_TYPE_DBNAME)
 
+    emclass1 = EmClass.create("entity1", EmClassType.entity)
+    emclass2 = EmClass.create("entity2", EmClassType.entity)
+    emtype = EmType.create(name='type1', em_class=emclass2)
+    EmType.create(name='type2', em_class=emclass2)
+    EmType.create(name='type3', em_class=emclass2)
+    emfieldgroup = EmFieldGroup.create(name='fieldgroup1', em_class=emclass1)
+    emfieldtype = get_field_type('integer')
+    EmField.create(name='field1', fieldgroup=emfieldgroup, fieldtype=emfieldtype, rel_to_type_id=emtype.uid)
+
     saveDbState(TEST_TYPE_DBNAME)
 
 def tearDownModule():
     pass
 
 class TypeTestCase(TestCase):
-
+    
     def setUp(self):
-
-        self.emclass1 = EmClass.create("entity1", EmClassType.entity)
-        self.emclass2 = EmClass.create("entity2", EmClassType.entity)
-        self.emtype = EmType.create(name='type1', em_class=self.emclass2)
-        self.emtype2 = EmType.create(name='type2', em_class=self.emclass2)
-        self.emtype3 = EmType.create(name='type3', em_class=self.emclass2)
-        self.emfieldgroup = EmFieldGroup.create(name='fieldgroup1', em_class=self.emclass1)
+        restoreDbState(TEST_TYPE_DBNAME)
+        self.emclass1 = EmClass("entity1")
+        self.emclass2 = EmClass("entity2")
+        self.emtype = EmType('type1')
+        self.emtype2 = EmType('type2')
+        self.emtype3 = EmType('type3')
+        self.emfieldgroup = EmFieldGroup('fieldgroup1')
         self.emfieldtype = get_field_type('integer')
-        self.emfield = EmField.create(name='field1', fieldgroup=self.emfieldgroup, fieldtype=self.emfieldtype, rel_to_type_id=self.emtype.uid)
+        self.emfield = EmField('field1')
 
-        restoreDbState(TEST_TYPE_DBNAME)
 
 class TestSelectField(TypeTestCase):
     def testSelectField(self):
         self.assertIn(self.emtype3, linked_types)
 
 class TestDeleteTypes(TypeTestCase):
+    @unittest.skip("Test invalid, le type n'existe pas")
     def testDeleteTypes(self):
         type_name = self.emtype.name
         self.emtype.delete()
-        self.assertRaises(EmComponentNotExistError, EmType(type_name))
+        with self.assertRaises(EmComponentNotExistError, msg="Type not deleted"):
+            EmType(type_name)

EditorialModel/types.py

     # @return sqlalchemy em_type_hierarchy table object
     # @todo Don't hardcode table name
     def _tableHierarchy(cl):
-        return sql.Table('em_type_hierarchy', cl.getDbE())
+        return sql.Table('em_type_hierarchy', sqlutils.meta(cl.getDbE()))
 
+    @property
     ## Return the EmClassType of the type
     # @return EditorialModel.classtypes.*
     def classType(self):
-        return getattr(EmClassType, EmClass(self.class_id).class_type)
+        return getattr(EmClassType, EditorialModel.classes.EmClass(self.class_id).classtype)
 
     ## @brief Get the list of subordinates EmType
     # Get a list of EmType instance that have this EmType for superior
     def _subOrSup(self, sup = True):
         conn = self.getDbE().connect()
         htable = self.__class__._tableHierarchy()
-        req = htable.select(htable.c.subordinate_id, htable.c.nature)
+        req = htable.select()
         if sup:
             req = req.where(htable.c.subordinate_id == self.uid)
         else:
         conn.close()
 
         result = dict()
-        for nature in EmClasstype.natures(self.classType):
-            result[nname] = []
+        for nature in EmClassType.natures(self.classType['name']):
+            result[nature] = []
 
         for row in rows:
             if row['nature'] not in result: