Added docstrings comments to tests and fixed "false hidden failure"

Added docstrings comments to tests (for fancy output with -v ).
Fixed strange hidden failure that make tests stops on non failed tests with -f option. Those false failure seems to comes from with self.subTest blocs with functions calls that does assertion.

EditorialModel/test/test_classes.py

@@ -53,6 +53,7 @@ class TestEmClassCreation(ClassesTestCase):
     # test if a table 'testClass' was created
     # should be able to select on the created table
     def test_table_em_classes(self):
+        """ Testing ability of EmClass to crate its associated table """
         conn = sqlutils.getEngine().connect()
         a = sqlutils.meta(conn)
         try:
@@ -67,16 +68,19 @@ class TestEmClassCreation(ClassesTestCase):
 
     # the uid should be 1
     def test_uid(self):
+        """ testing uid """
         cl = EmClass('testClass')
         self.assertEqual(cl.uid, 1)
 
     # the name should be the one given
     def test_classname(self):
+        """ Testing name consistency on instanciation """
         cl = EmClass('testClass')
         self.assertEqual(cl.name, 'testClass')
 
     # the classtype should have the name of the EmClassType
     def test_classtype(self):
+        """ Testing classtype consistency """
         cl = EmClass('testClass')
         self.assertEqual(cl.classtype, EmClassType.entity['name'])
 
@@ -92,6 +96,7 @@ class TestEmClassDeletion(ClassesTestCase):
     
     # test if the table is deleted after a call to delete
     def test_table_delete(self):
+        """ Test associated table deletetion on EmClass deletion """
         dbe = sqlutils.getEngine()
         for i,class_name in enumerate(self.names):
             cur_class = EmClass(class_name)
@@ -108,6 +113,7 @@ class TestEmClassDeletion(ClassesTestCase):
     
     # test if delete refuse to delete if a class had fieldgroups
     def test_table_refuse_delete(self):
+        """ Test delete on an EmClass has fieldgroup """
         test_class = EmClass(self.names[0])
         fieldgroup = EmFieldGroup.create('fooFieldGroup', test_class)
         self.assertFalse(test_class.delete(), "delete method returns True but the class has fieldgroup")
@@ -134,6 +140,7 @@ class TestEmClassFieldgroups(ClassesTestCase):
 
     # test if fieldgroups() return a list of EmFieldGroup
     def test_fieldgroups(self):
+        """ Test if fieldgroups method return the right list of EmFielGroup """
         test_class = EmClass('testClass')
         fg1 = EmFieldGroup.create('fg1', test_class)
         fg2 = EmFieldGroup.create('fg2', test_class)
@@ -145,6 +152,7 @@ class TestEmClassFieldgroups(ClassesTestCase):
 
     # with no fieldgroups fieldgroups() should return an empty list
     def test_no_fieldgroups(self):
+        """ Test fielgroups method on an empty EmClass """
         test_class = EmClass('testClass')
         fieldgroups = test_class.fieldgroups()
         self.assertEqual(fieldgroups, [])
@@ -162,6 +170,7 @@ class TestEmClassTypes(ClassesTestCase):
 
     # test if types() return a list of EmType
     def test_types(self):
+        """ Test if types method return the right list of EmType """
         test_class = EmClass('testClass')
         t1 = EmType.create('t1', test_class)
         t2 = EmType.create('t2', test_class)
@@ -173,6 +182,7 @@ class TestEmClassTypes(ClassesTestCase):
 
     # with no type types() should return an empty list
     def test_no_types(self):
+        """ Test types method on an EmClass with no associated types """
         test_class = EmClass('testClass')
         types = test_class.types()
         self.assertEqual(types, [])
@@ -190,6 +200,7 @@ class TestEmClassFields(ClassesTestCase):
 
     # test if fields() return a list of EmField
     def test_fields(self):
+        """ Testing fields method """
         test_class = EmClass('testClass')
         fg = EmFieldGroup.create('fg', test_class)
         f1 = EmField.create('f1', fg, fieldTypes.EmField_char())
@@ -202,6 +213,7 @@ class TestEmClassFields(ClassesTestCase):
 
     # with no field fields() should return an empty list
     def test_no_fields(self):
+        """ Testing fields method on an EmClass with no associated fields """
         test_class = EmClass('testClass')
         fields = test_class.fields()
         self.assertEqual(fields, [])
@@ -224,6 +236,7 @@ class TestEmClassLinkType(ClassesTestCase):
     # test if a table 'testEntity_keywords' was created
     # should be able to select on the created table
     def test_table_classes_types(self):
+        """ Test if a table 'testEntity_keywords' was created """
         conn = sqlutils.getEngine().connect()
         a = sqlutils.meta(conn)
         try:
@@ -238,6 +251,7 @@ class TestEmClassLinkType(ClassesTestCase):
 
     # test if we can retrieve the linked type
     def test_linked_types(self):
+        """ Test linked_types """
         testEntity = EmClass('testEntity')
         linked_types = testEntity.linked_types()
         self.assertEqual(linked_types[0].name, 'keywords')

EditorialModel/test/test_component.py

@@ -316,40 +316,40 @@ class TestSave(ComponentTestCase):
         time.sleep(2) # We have to sleep 2 secs here, so the update_date will be at least 2 secs more than newval['date_update']
         
         #name change
-        with self.subTest("Save after name change"):
-            newval['name'] = test_comp.name = 'newname'
-            test_comp.save()
-            self._savecheck(test_comp, newval)
+        newval['name'] = test_comp.name = 'newname'
+        test_comp.save()
+        self._savecheck(test_comp, newval)
+        self.assertTrue(True)
 
         #help change
-        with self.subTest("Save after help change"):
-            newval['help'] = '{"fr": "help fr", "en":"help en", "es":"help es"}'
-            test_comp.help = MlString.load(newval['help'])
-            test_comp.save()
-            self._savecheck(test_comp, newval)
-        
+        newval['help'] = '{"fr": "help fr", "en":"help en", "es":"help es"}'
+        test_comp.help = MlString.load(newval['help'])
+        test_comp.save()
+        self._savecheck(test_comp, newval)
+        self.assertTrue(True)
+    
         #string change
-        with self.subTest("Save after string change"):
-            newval['string'] = '{"fr": "string fr", "en":"string en", "es":"string es"}'
-            test_comp.string = MlString.load(newval['string'])
-            test_comp.save()
-            self._savecheck(test_comp, newval)
+        newval['string'] = '{"fr": "string fr", "en":"string en", "es":"string es"}'
+        test_comp.string = MlString.load(newval['string'])
+        test_comp.save()
+        self._savecheck(test_comp, newval)
+        self.assertTrue(True)
 
         #no change
-        with self.subTest("Save without any change"):
-            test_comp.save()
-            self._savecheck(test_comp, newval)
+        test_comp.save()
+        self._savecheck(test_comp, newval)
+        self.assertTrue(True)
 
         #change all
-        with self.subTest("Save after name, help and string change"):
-            test_comp.name = newval['name'] = test_comp.name = 'newnewname'
-            newval['help'] = '{"fr": "help fra", "en":"help eng", "es":"help esp"}'
-            test_comp.help = MlString.load(newval['help'])
-            newval['string'] = '{"fr": "string FR", "en":"string EN", "es":"string ES", "foolang":"foofoobar"}'
-            test_comp.string = MlString.load(newval['string'])
+        test_comp.name = newval['name'] = test_comp.name = 'newnewname'
+        newval['help'] = '{"fr": "help fra", "en":"help eng", "es":"help esp"}'
+        test_comp.help = MlString.load(newval['help'])
+        newval['string'] = '{"fr": "string FR", "en":"string EN", "es":"string ES", "foolang":"foofoobar"}'
+        test_comp.string = MlString.load(newval['string'])
 
-            test_comp.save()
-            self._savecheck(test_comp, newval)
+        test_comp.save()
+        self._savecheck(test_comp, newval)
+        self.assertTrue(True)
 
         pass
 
@@ -360,37 +360,24 @@ class TestSave(ComponentTestCase):
         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("Illegal change of "+prop):
-                test_comp = EmTestComp(val['name'])
-                self.check_equals(val, test_comp, False)
-                
-                with self.assertRaises(TypeError):
-                    setattr(test_comp, prop, changes[prop])
-                test_comp.save()
-    
-                test_comp2 = EmTestComp(val['name'])
-    
-                if prop  == 'date_create':
-                    assertion = self.assertEqualDatetime
-                elif prop == 'date_update':
-                    continue
-                else: #rank
-                    assertion = self.assertEqual
-    
-                assertion(getattr(test_comp,prop), val[prop], "When using setattr the "+prop+" of a component is set : ")
-                assertion(getattr(test_comp2, prop), val[prop], "When using setattr and save the "+prop+" of a loaded component is set : ")
-    
-                # The code block commented bellow uses the values argument of the save method.
-                # soon this argument will not being used anymore
-                """
-                test_comp = EmTestComp(val['name'])
-                self.check_equals(val, test_comp)
-                test_comp.save({ prop: changes['prop'] })
-    
-                test_comp2 = EmTestComp(val['name'])
-                self.assertEqualDatetime(test_comp.date_create, val[prop], "The "+prop+" of the component instance has been changed")
-                self.assertEqualDatetime(test_comp2.date_create, val[prop], "When loaded the "+prop+" has been changed")
-                """
+            test_comp = EmTestComp(val['name'])
+            self.check_equals(val, test_comp, False)
+            
+            with self.assertRaises(TypeError):
+                setattr(test_comp, prop, changes[prop])
+            test_comp.save()
+
+            test_comp2 = EmTestComp(val['name'])
+
+            if prop  == 'date_create':
+                assertion = self.assertEqualDatetime
+            elif prop == 'date_update':
+                continue
+            else: #rank
+                assertion = self.assertEqual
+
+            assertion(getattr(test_comp,prop), val[prop], "When using setattr the "+prop+" of a component is set : ")
+            assertion(getattr(test_comp2, prop), val[prop], "When using setattr and save the "+prop+" of a loaded component is set : ")
         pass
 
 #====================#
@@ -399,40 +386,35 @@ class TestSave(ComponentTestCase):
 class TestCreate(ComponentTestCase):
     
     def test_create(self):
-        
-        with self.subTest("Create with all infos"):
-            vals = {'name': 'created1', 'rank_fam': 'f', 'string': '{"fr":"testcomp"}', 'help': '{"en":"help test", "fr":"test help"}'}
-            tc = EmTestComp.create(**vals)
-            self.check_equals(vals, tc, "The created EmTestComp hasn't the good properties values")
-            tcdb = EmTestComp('created1')
-            self.check_equals(vals, tc, "When fetched from Db the created EmTestComp hasn't the good properties values")
-        
+        """Testing EmComponent.create()"""
+        vals = {'name': 'created1', 'rank_fam': 'f', 'string': '{"fr":"testcomp"}', 'help': '{"en":"help test", "fr":"test help"}'}
+        tc = EmTestComp.create(**vals)
+        self.check_equals(vals, tc, "The created EmTestComp hasn't the good properties values")
+        tcdb = EmTestComp('created1')
+        self.check_equals(vals, tc, "When fetched from Db the created EmTestComp hasn't the good properties values")
+    
         # This test assume that string and help has default values
-        with self.subTest("Create with minimal infos"):
-            vals = { 'name': 'created2', 'rank_fam': 'f' }
-            tc = EmTestComp.create(**vals)
-            self.check_equals(vals, tc, "The created EmTestComp hasn't the good properties values")
-            tcdb = EmTestComp('created1')
-            self.check_equals(vals, tc, "When fetched from Db the created EmTestComp hasn't the good properties values")
+        vals = { 'name': 'created2', 'rank_fam': 'f' }
+        tc = EmTestComp.create(**vals)
+        self.check_equals(vals, tc, "The created EmTestComp hasn't the good properties values")
+        tcdb = EmTestComp('created1')
+        self.check_equals(vals, tc, "When fetched from Db the created EmTestComp hasn't the good properties values")
         pass
 
     def test_create_badargs(self):
-        
-        with self.subTest("Create with illegal arguments"):
-            with self.assertRaises(TypeError, msg="But given a function as argument"):
-                tc = EmTestComp.create(print)
-            with self.assertRaises(TypeError, msg="But values contains date_create and date_update"):
-                vals = { 'name': 'created1', 'rank_fam': 'f', 'string': '{"fr":"testcomp"}', 'help': '{"en" :"help test", "fr":"test help"}', 'rank': 6, 'date_create': 0 , 'date_update': 0 }
-                tc = EmTestComp.create(**vals)
-
-        with self.subTest("Create without mandatory arguments"):
-            with self.assertRaises(TypeError, msg="But no name was given"):
-                vals = { 'rank_fam': 'f', 'string': '{"fr":"testcomp"}', 'help': '{"en" :"help test", "fr":"test help"}', 'rank': 6, 'date_create': 0 , 'date_update': 0 }
-                tc = EmTestComp.create(**vals)
-            with self.assertRaises(TypeError, msg="But no rank_fam was given"):
-                vals = { 'name': 'created1', 'string': '{"fr":"testcomp"}', 'help': '{"en" :"help test", "fr":"test help"}', 'rank': 6, 'date_create': 0 , 'date_update': 0 }
-                tc = EmTestComp.create(**vals)
+        """Testing EmComponent.create() with bad arguments"""
+        with self.assertRaises(TypeError, msg="But given a function as argument"):
+            tc = EmTestComp.create(print)
+        with self.assertRaises(TypeError, msg="But values contains date_create and date_update"):
+            vals = { 'name': 'created1', 'rank_fam': 'f', 'string': '{"fr":"testcomp"}', 'help': '{"en" :"help test", "fr":"test help"}', 'rank': 6, 'date_create': 0 , 'date_update': 0 }
+            tc = EmTestComp.create(**vals)
 
+        with self.assertRaises(TypeError, msg="But no name was given"):
+            vals = { 'rank_fam': 'f', 'string': '{"fr":"testcomp"}', 'help': '{"en" :"help test", "fr":"test help"}', 'rank': 6, 'date_create': 0 , 'date_update': 0 }
+            tc = EmTestComp.create(**vals)
+        with self.assertRaises(TypeError, msg="But no rank_fam was given"):
+            vals = { 'name': 'created1', 'string': '{"fr":"testcomp"}', 'help': '{"en" :"help test", "fr":"test help"}', 'rank': 6, 'date_create': 0 , 'date_update': 0 }
+            tc = EmTestComp.create(**vals)
         pass
 
 #====================#
@@ -476,6 +458,7 @@ class TestDelete(ComponentTestCase):
                     tc = EmTestComp(vals[j]['name'])
                 except EmComponentNotExistError:
                     self.fail('EmComponent should not be deleted')
+        self.assertTrue(True)
         pass
 
 
@@ -559,20 +542,6 @@ class TestModifyRank(ComponentTestCase):
             for j in range(i+1,nmax+1):
                 test_comp = EmTestComp(names[j])
                 self.assertEqual(test_comp.rank, j)
-
-        #Not inverting the list (makes swap but at the end we are in reverse state again)
-        #--------------------------------------------------------------------------------
-        for i in range(nmax,-1,-1):
-            test_comp = EmTestComp(names[i])
-            test_comp.modify_rank(nmax,'=')
-            self.assertEqual(test_comp.rank, nmax)
-            for j in range(i,nmax+1):
-                test_comp = EmTestComp(names[j])
-                self.assertEqual(test_comp.rank, nmax-(j-i), "Excepted rank was '"+str(nmax-(j-i))+"' but got '"+str(test_comp.rank)+"'). Ranks dump : "+self.dump_ranks())
-            for j in range(0,i):
-                test_comp = EmTestComp(names[j])
-                self.assertEqual(test_comp.rank, i-j-1)
-
         pass
 
     def test_modify_rank_relative(self):

EditorialModel/test/test_field.py

@@ -32,6 +32,11 @@ def setUpModule():
     initTestDb(TEST_FIELD_DBNAME)
     setDbConf(TEST_FIELD_DBNAME)
     logging.basicConfig(level=logging.CRITICAL)
+    pass
+
+def tearDownModule():
+    cleanDb(TEST_FIELD_DBNAME)
+    pass
 
 
 ## FieldTestCase (Class)
@@ -111,6 +116,7 @@ class TestField(FieldTestCase):
     #
     # tests the creation process of a field
     def testCreate(self):
+        """ Testing fields creation process """
         '''
         field_values = {
             'name':'testfield1',
@@ -134,6 +140,7 @@ class TestField(FieldTestCase):
         pass
     
     def test_deletion(self):
+        """ Testing fields deletion process """
         field_names = ['field1', 'field2']
         for name in field_names:
             EmField.create(name=name, fieldgroup=self.testFieldgroup, fieldtype = self.testFieldType)

EditorialModel/test/test_fieldgroups.py

@@ -189,6 +189,7 @@ class TestCreate(FieldGroupTestCase):
 class TestFields(FieldGroupTestCase):
 
     def setUp(self):
+        super(TestFields, self).setUp()
         self.fg1 = EmFieldGroup.create('testfg', EmClass('entity1'))
         self.fg2 = EmFieldGroup.create('testfg2', EmClass('entry1'))
         self.fg3 = EmFieldGroup.create('testfg3', EmClass('entry1'))
@@ -225,17 +226,17 @@ class TestFields(FieldGroupTestCase):
         }
 
         for name in tests:
-            with self.subTest("Testing on "+name+" instanciated EmFieldGroups"):
-                fg = tests[name]
-                flist = fg.fields()
-                res = []
-                for f in flist:
-                    res.append(f.uid)
-                self.assertEqual(set(res), set(excepted1))
-
-        with self.subTest("Testing empty fieldgroup"):
-            fg = self.fg3
+            fg = tests[name]
             flist = fg.fields()
-            self.assertEqual(len(flist), 0)
+            res = []
+            for f in flist:
+                res.append(f.uid)
+            self.assertEqual(set(res), set(excepted1))
+
+    def test_empty_fields(self):
+        """ Testing fields method on an empty fieldgroup """
+        fg = self.fg3
+        flist = fg.fields()
+        self.assertEqual(len(flist), 0)
         pass
 

EditorialModel/test/test_types.py

@@ -73,16 +73,19 @@ class TypeTestCase(TestCase):
 
 class TestSelectField(TypeTestCase):
     def testSelectField(self):
+        """ Testing optionnal field selection """
         self.emtype.select_field(self.emfield)
         self.assertIsNotNone(Em_Field_Type(self.emtype.uid, self.emfield.uid))
 
     def testUnselectField(self):
+        """ Testing optionnal field unselection """
         self.emtype.unselect_field(self.emfield)
         self.assertFalse(Em_Field_Type(self.emtype.uid, self.emfield.uid).exists())
 
 class TestLinkedTypes(TypeTestCase):
     @unittest.skip("Not yet implemented")
     def testLinkedtypes(self):
+        """ Testing linked types """
         self.emtype.add_superior(self.emtype2, EmNature.PARENT)
         self.emtype3.add_superior(self.emtype, EmNature.PARENT)
 
@@ -123,6 +126,7 @@ class TestTypeHierarchy(TypeTestCase):
             
 
     def testAddSuperiorParent(self):
+        """ Testing add superior in relation with Parent nature """
         self.emtype.add_superior(self.emtype2, EmNature.PARENT)
         self.check_add_sup(self.emtype, self.emtype2, EmNature.PARENT)
 
@@ -131,6 +135,7 @@ class TestTypeHierarchy(TypeTestCase):
         pass
 
     def testAddSuperiorTranslation(self):
+        """ Testing add superior in relation with Translation nature """
         self.emtype.add_superior(self.emtype, EmNature.TRANSLATION)
         self.check_add_sup(self.emtype, self.emtype, EmNature.TRANSLATION)
 
@@ -139,6 +144,7 @@ class TestTypeHierarchy(TypeTestCase):
         pass
 
     def testAddSuperiorIdentity(self):
+        """ Testing add superior in relation with Identity nature """
         self.emtype6.add_superior(self.emtype6, EmNature.IDENTITY)
         self.check_add_sup(self.emtype6, self.emtype6, EmNature.IDENTITY)
         self.emtype6.add_superior(self.emtype7, EmNature.IDENTITY)
@@ -146,6 +152,7 @@ class TestTypeHierarchy(TypeTestCase):
         pass
 
     def testIllegalSuperior(self):
+        """ Testing invalid add superior """
         illegal_combinations = [
             (self.emtype, self.emtype4, EmNature.PARENT),
             (self.emtype, self.emtype2, EmNature.TRANSLATION),
@@ -163,6 +170,7 @@ class TestTypeHierarchy(TypeTestCase):
         pass
     
     def testDelSuperior(self):
+        """ Testing superior deletion """
         self.emtype.add_superior(self.emtype2, EmNature.PARENT)
         self.emtype.add_superior(self.emtype, EmNature.PARENT)
         self.emtype.add_superior(self.emtype, EmNature.TRANSLATION)
@@ -179,12 +187,14 @@ class TestTypeHierarchy(TypeTestCase):
 
 class TestDeleteTypes(TypeTestCase):
     def testDeleteTypes(self):
+        """ Testing EmType deletion """
         type_name = self.emtype.name
         self.assertTrue(self.emtype.delete(), "delete method returns False but should return True")
         with self.assertRaises(EmComponentNotExistError, msg="Type not deleted"):
             EmType(type_name)
 
     def testUndeletableTypes(self):
+        """ Testing invalid non empty EmType deletion """
         type_name = self.emtype.name
         self.emtype2.add_superior(self.emtype, 'parent')
         self.assertFalse(self.emtype.delete(), "delete return True but should return False")