Cleaned tests

tests/datahandlers/test_concat.py

 class ConcatTestCase(unittest.TestCase):
     
     
-    def test_has_base_type_property(self):
-        self.assertTrue(hasattr(Testee, 'base_type'))
-        
-        
     def test_base_type_is_char(self):
         self.assertEqual(Testee.base_type, 'char')
         
         
-    def test_has_help_property(self):
-        self.assertTrue(hasattr(Testee, 'help'))
-        
-        
     def test_help_property_str_is_set(self):
         self.assertEqual(type(Testee.help), str)
         
     
-    def test_sets_correct_format_string(self):
+    def test_correctly_sets_format_string(self):
         separator = '-'
         field_list  = ['', '', '']
         testee = Testee(field_list, separator)

tests/datahandlers/test_formatstring.py

 import unittest
 
-from lodel.leapi.datahandlers.datas import FormatString as Testee
+from lodel.leapi.datahandlers.datas import FormatString
 from lodel.editorial_model.components import EmClass
 
-class TesteeTestCase(unittest.TestCase):
-    regex = '%s-%s'
-    dummyEmClass = EmClass('testing')
-    fone_name = 'field1'
-    ftwo_name = 'field2'
-    dummyEmClass.new_field(fone_name, 'varchar')
-    dummyEmClass.new_field(ftwo_name, 'varchar')
-    field_one_value = 'field one value'
-    field_two_value = 'field two value'
-    field_value_dict = {fone_name: field_one_value, ftwo_name: field_two_value}
-    field_list = [fone_name, ftwo_name]
-    
-    test_Testee = Testee(regex,[fone_name, ftwo_name])
-    
-    max_length = round(len(regex % (field_one_value, field_two_value)) / 2)
-
+class FormatStringTestCase(unittest.TestCase):
 
-    def test_has_base_type_property(self):
-        self.assertTrue(hasattr(Testee, 'base_type'))
-        
         
     def test_base_type_is_char(self):
-        self.assertEqual(Testee.base_type, 'char')
-        
-        
-    def test_has_help_property(self):
-        self.assertTrue(hasattr(Testee, 'help'))
+        self.assertEqual(FormatString.base_type, 'char')
         
         
     def test_help_property_str_is_set(self):
-        self.assertEqual(type(Testee.help), str)
+        self.assertEqual(type(FormatString.help), str)
 
 
     def test_string_formatting_output(self):
+        testee = FormatString(self.regex,[self.fone_name, self.ftwo_name])
+        
         expected_result = self.regex % (self.field_one_value, self.field_two_value)
-        actual_result = self.test_Testee.construct_data(self.dummyEmClass, None, self.field_value_dict, None)
+        actual_result = testee.construct_data(self.dummyEmClass, None, self.field_value_dict, None)
 
         self.assertEqual(actual_result, expected_result)
         
         
     def test_throws_user_warning_on_exceeding_string(self):
         max_length = len(self.regex % (self.field_one_value, self.field_two_value)) / 2
-        testee = Testee(self.regex, self.field_list, max_length=self.max_length)
+        testee = FormatString(self.regex, self.field_list, max_length=self.max_length)
         
-        with self.assertWarns(UserWarning):
-            testee.construct_data(self.dummyEmClass, None, self.field_value_dict, None)
+        self.assertWarns(
+            UserWarning,
+            testee.construct_data,
+            self.dummyEmClass, None, self.field_value_dict, None
+        )
             
             
     def test_exceeding_string_length_is_truncated(self):
         max_length = 2
-        testee = Testee(self.regex, self.field_list, max_length=self.max_length)
+        testee = FormatString(self.regex, self.field_list, max_length=self.max_length)
         result_string = testee._construct_data(self.dummyEmClass, None, self.field_value_dict, None)
         
         self.assertEqual(self.max_length, len(result_string))
         
             
     def test_thrown_exceeding_str_warning_message_composition(self):
-        testee = Testee(self.regex, self.field_list, max_length=self.max_length)
+        testee = FormatString(self.regex, self.field_list, max_length=self.max_length)
+        
+        self.assertWarnsRegex(
+            UserWarning,
+            '[T|t]runcat[a-z]+',
+            testee.construct_data,
+            self.dummyEmClass, None, self.field_value_dict, None
+        )
+            
+    
+    def setUp(self):
+        self.regex = '%s-%s'
+        self.dummyEmClass = EmClass('testing')
+        self.fone_name = 'field1'
+        self.ftwo_name = 'field2'
+        self.dummyEmClass.new_field(self.fone_name, 'varchar')
+        self.dummyEmClass.new_field(self.ftwo_name, 'varchar')
+        self.field_one_value = 'field one value'
+        self.field_two_value = 'field two value'
+        self.field_value_dict = {self.fone_name: self.field_one_value, self.ftwo_name: self.field_two_value}
+        self.field_list = [self.fone_name, self.ftwo_name]
         
-        with self.assertWarnsRegex(UserWarning, '[T|t]runcat[a-z]+'):
-            testee.construct_data(self.dummyEmClass, None, self.field_value_dict, None)
+        self.max_length = round(len(self.regex % (self.field_one_value, self.field_two_value)) / 2)
+        

tests/datahandlers/test_leobjectidentifier.py

 import unittest
 import inspect
-from unittest import mock 
-from unittest.mock import patch
-
-import leapi_dyncode as dyncode
-
-from types import *
 
+from unittest import mock
 from lodel.leapi.datahandlers.datas import LeobjectSubclassIdentifier as Testee
 
 
 class LeresultectSubclassIdentifierTestCase(unittest.TestCase):        
         
-    def test_has_base_type_property(self):
-        self.assertTrue(hasattr(Testee, 'base_type'))
-        
         
     def test_base_type_is_varchar(self):
         self.assertEqual(Testee.base_type, 'varchar')
         
         
-    def test_has_help_property(self):
-        self.assertTrue(hasattr(Testee, 'help'))
-        
-        
     def test_help_property_str_is_set(self):
         self.assertEqual(type(Testee.help), str)
         
     def test_passing_class_returns_class_name(self):
         result = Testee.construct_data(None, object, None, None, None)
         
-        self.assertEqual(result, object .__name__)
+        self.assertEqual(result, object.__name__)
         
         
     def test_passing_instance_returns_class_name(self):
         
         
     def test_passing_instance_and_class_same_result(self):
-        objResult = Testee.construct_data(None,  Testee(), None, None, None)
+        objResult = Testee.construct_data(None, Testee(), None, None, None)
         clsResult = Testee.construct_data(None, Testee, None, None, None)
         
         self.assertEqual(objResult, clsResult)

tests/datahandlers/test_password.py

 import unittest
-from unittest import mock 
-from unittest.mock import patch
-
-import leapi_dyncode as dyncode
-
 from lodel.leapi.datahandlers.datas import Password as Testee
 
 
 class PasswordTestCase(unittest.TestCase):
         
         
-    def test_has_base_type_property(self):
-        self.assertTrue(hasattr(Testee, 'base_type'))
-        
-        
-    def test_base_type_is_password(self):
+    def test_base_type_property_value_equals_password(self):
         self.assertEqual(Testee.base_type, 'password')
         
         
-    def test_has_help_property(self):
-        self.assertTrue(hasattr(Testee, 'help'))
-        
-        
-    def test_help_property_str_is_set(self):
+    def test_help_property_string_is_set(self):
         self.assertEqual(type(Testee.help), str)

tests/datahandlers/test_uniqid.py

 class UniqIDTestCase(unittest.TestCase):
         
         
-    def test_has_base_type_property(self):
-        self.assertTrue(hasattr(Testee, 'base_type'))
-        
-        
-    def test_base_type_is_int(self):
+    def test_base_type_is_set_to_int(self):
         self.assertEqual(Testee.base_type, 'int')
         
         
-    def test_has_help_property(self):
-        self.assertTrue(hasattr(Testee, 'help'))
-        
-        
     def test_help_property_str_is_set(self):
         self.assertEqual(type(Testee.help), str)
         
         
     
     def test_construct_data_sets_new_uid_if_none(self):
-        sent_uid = None
+        set_uid = None
         mocked_returned_uid = 987654321
         
         with patch.object(DummyDatasource, 'new_numeric_id', return_value=mocked_returned_uid) as mock_method:
-            returned_uid = Testee.construct_data(None, dyncode.Object, None, None, sent_uid)
+            returned_uid = Testee.construct_data(None, dyncode.Object, None, None, set_uid)
             
             mock_method.assert_called_once_with(dyncode.Object)
             self.assertEqual(returned_uid, mocked_returned_uid)
             
 
     def test_construct_data_returns_already_set_uid(self):
-        sent_uid = 123456789
+        set_uid = 123456789
+        mocked_returned_uid = 987654321
+        
+        with patch.object(DummyDatasource, 'new_numeric_id', return_value=mocked_returned_uid) as mock_method:
+            returned_uid = Testee.construct_data(None, dyncode.Object, None, None, set_uid)
+
+            self.assertEqual(returned_uid, set_uid)
+            
+    
+    def test_construct_data_does_not_call_new_numeric_id_if_id_is_set(self):
+        set_uid = 123456789
         mocked_returned_uid = 987654321
         
         with patch.object(DummyDatasource, 'new_numeric_id', return_value=mocked_returned_uid) as mock_method:
-            returned_uid = Testee.construct_data(None, dyncode.Object, None, None, sent_uid)
+            returned_uid = Testee.construct_data(None, dyncode.Object, None, None, set_uid)
 
-            self.assertEqual(returned_uid, sent_uid)
             mock_method.assert_not_called()