refactor: improve test class names and docstrings for clarity, ruff formatting

Author: MaxRocamora

tests/test_cache.py

@@ -9,15 +9,14 @@
 from backpack.cache import timed_lru_cache
 
 
-class Test_Cache(unittest.TestCase):
-
+class TestCache(unittest.TestCase):
     @timed_lru_cache(seconds=1)
     def test_function(self):
-        # some heavy process here to be cached
+        """Some heavy process here to be cached."""
         return True
 
     def test_cache(self):
-        ''' testing module '''
+        """Testing module."""
         self.assertTrue(self.test_function())
         self.assertEqual(True, self.test_function(force_clear=True))
         self.assertEqual(True, self.test_function(force_clear=True, show_log=True))

tests/test_errors.py

@@ -8,41 +8,39 @@
 import sys
 import unittest
 
-from backpack.custom_errors import EnvironmentVariableNotFound
-from backpack.custom_errors import ApplicationNotFound
+from backpack.custom_errors import ApplicationNotFoundError, EnvironmentVariableNotFoundError
 
 mod_path = os.path.dirname(__file__)
 if mod_path not in sys.path:
     sys.path.append(mod_path)
 
 
 def get_env_var(name: str):
-    ''' call for an env var or raise EnvironmentVariableNotFound '''
+    """Call for an env var or raise EnvironmentVariableNotFoundError."""
     try:
         value = os.environ[name]
     except KeyError as e:
-        raise EnvironmentVariableNotFound(name) from e
+        raise EnvironmentVariableNotFoundError(name) from e
     return value
 
 
 def get_app(name: str):
-    ''' raisers error '''
-    raise ApplicationNotFound(f'Background executable not found {name}')
+    """Raisers error."""
+    raise ApplicationNotFoundError(f'Background executable not found {name}')
 
 
-class Test_Errors(unittest.TestCase):
-
+class TestErrors(unittest.TestCase):
     def test_env_var_error(self):
-        ''' testing module '''
-        self.assertRaises(EnvironmentVariableNotFound, get_env_var, 'my_env_var')
-        error = EnvironmentVariableNotFound('my_env_var')
+        """Testing module."""
+        self.assertRaises(EnvironmentVariableNotFoundError, get_env_var, 'my_env_var')
+        error = EnvironmentVariableNotFoundError('my_env_var')
         self.assertEqual(str(error), error.message)
 
     def test_env_app_error(self):
-        ''' testing module '''
-        self.assertRaises(ApplicationNotFound, get_app, 'my_app.exe')
+        """Testing module."""
+        self.assertRaises(ApplicationNotFoundError, get_app, 'my_app.exe')
 
-        error = ApplicationNotFound('my_app.exe')
+        error = ApplicationNotFoundError('my_app.exe')
         self.assertEqual(str(error), error.message)
 
 

tests/test_file_utils.py

@@ -5,12 +5,11 @@
 # ----------------------------------------------------------------------------------------
 
 import os
+import shutil
 import sys
 import unittest
-import shutil
 
-from backpack.file_utils import replace_strings_in_file, remove_line_from_file
-from backpack.file_utils import file_is_writeable
+from backpack.file_utils import file_is_writeable, remove_line_from_file, replace_strings_in_file
 
 mod_path = os.path.dirname(__file__)
 if mod_path not in sys.path:
@@ -26,21 +25,21 @@
 NO_FILE = os.path.join(mod_path, 'test_files', 'no_file.txt')
 
 
-class Test_Errors(unittest.TestCase):
-
+class TestErrors(unittest.TestCase):
     def test_replace_strings_in_file(self):
-        ''' testing module '''
+        """Testing module."""
         shutil.copy(BASE_FILE, EDITED_FILE)
         replace_strings_in_file(EDITED_FILE, STRINGS, NEW_STRING)
 
     def test_remove_line_from_file(self):
-        ''' testing module '''
+        """Testing module."""
         source_file = os.path.join(mod_path, 'test_files', 'origin_remove.txt')
         test_file = os.path.join(mod_path, 'test_files', 'edited_remove.txt')
         shutil.copy(source_file, test_file)
         remove_line_from_file(test_file, ['REMOVE_ME', 'to be replaced!'])
 
     def test_locked_file(self):
+        """Testing module."""
         self.assertTrue(file_is_writeable(UNLOCKED_FILE))
         self.assertFalse(file_is_writeable(NO_FILE))
 

tests/test_folder_utils.py

@@ -7,37 +7,40 @@
 import os
 import sys
 import unittest
+
 import mock
 
-from backpack.folder_utils import create_folders, browse_folder, create_folder
-from backpack.folder_utils import remove_files_in_dir, recursive_dir_copy
+from backpack.folder_utils import (
+    browse_folder,
+    create_folder,
+    create_folders,
+    recursive_dir_copy,
+    remove_files_in_dir,
+)
 
 mod_path = os.path.dirname(__file__)
 if mod_path not in sys.path:
     sys.path.append(mod_path)
 
 # test folders
 BASE_PATH = os.path.join(mod_path, 'test_folder')
-FOLDERS = [os.path.join(BASE_PATH, 'ALPHA'),
-           os.path.join(BASE_PATH, 'BETA'),
-           ]
+FOLDERS = [
+    os.path.join(BASE_PATH, 'ALPHA'),
+    os.path.join(BASE_PATH, 'BETA'),
+]
 FOLDER_FILES = os.path.join(BASE_PATH, 'files')
 FILES = ['readme.txt']
 
 
 def create_file(path):
-    ''' creates a temp txt file '''
+    """Creates a temp txt file."""
     with open(os.path.join(path, 'temp.txt'), 'w'):
         pass
 
 
-class Test_Errors(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
+class TestErrors(unittest.TestCase):
     def test_create_folders(self):
-        ''' testing module '''
+        """Testing module."""
         create_folders(FOLDERS, verbose=True)
         # check folders and files exists
         for f in FOLDERS:
@@ -63,21 +66,22 @@ def test_create_folders(self):
 
     @mock.patch('subprocess.Popen')
     def test_browse(self, mock_browse):
+        """Testing module."""
         # mocked Popen, create folder, browse, delete
         create_folder(FOLDERS[0])
         browse_folder(FOLDERS[0])
         # force false
         browse_folder(None)
 
     def test_remove_dir(self):
-        ''' creates a folder with files and remove it '''
+        """Creates a folder with files and remove it."""
         test_dir = os.path.join(BASE_PATH, 'remove_dir')
         create_folder(test_dir)
         create_file(test_dir)
         remove_files_in_dir(test_dir)
 
     def test_recursive_dir(self):
-        ''' creates a dir with sub dirs and files and copy them '''
+        """Creates a dir with sub dirs and files and copy them."""
         test_dir = os.path.join(BASE_PATH, 'recursive_dir')
         create_folder(test_dir)
         create_file(test_dir)

tests/test_json_user_settings.py

@@ -5,11 +5,11 @@
 # ----------------------------------------------------------------------------------------
 
 import contextlib
-from backpack.json_user_settings import JsonUserSettings
-
-import unittest
 import os
 import sys
+import unittest
+
+from backpack.json_user_settings import JsonUserSettings
 
 mod_path = os.path.dirname(__file__)
 if mod_path not in sys.path:
@@ -21,55 +21,53 @@
 TEST_FOLDER = os.path.join(os.path.expanduser('~'), FOLDER)
 
 
-class Test_windows(unittest.TestCase):
-
+class TestWindows(unittest.TestCase):
     @classmethod
     def setUp(cls):
-        # remove test files
+        """Remove test files."""
         with contextlib.suppress(OSError):
             os.remove(TEST_FOLDER)
 
     @classmethod
     def tearDownClass(cls):
-        # remove test files
+        """Remove test files."""
         with contextlib.suppress(OSError):
             os.remove(TEST_FOLDER)
 
     def test_json_user_settings(self):
-
-        # make sure folder does not exist
+        """Make sure folder does not exist."""
         with contextlib.suppress(PermissionError, OSError):
             if os.path.exists(TEST_FOLDER):
                 os.removedirs(TEST_FOLDER)
 
         # class and properties
         js = JsonUserSettings(FOLDER, 'user')
-        assert (js.filepath)
-        assert (os.path.exists(js.os_user_folder))
-        assert (isinstance(js.user_data, dict))
+        assert js.filepath
+        assert os.path.exists(js.os_user_folder)
+        assert isinstance(js.user_data, dict)
 
         # load from a missing file
         js.filename = 'random_file'
         self.assertFalse(js.load_settings())
 
     def test_json_settings_save(self):
-        ''' test json settings: save '''
+        """Test json settings: save."""
 
         # save a setting
         js = JsonUserSettings(FOLDER, 'tox')
         data = {'age': 99}
-        assert (js.save_settings(data))
+        assert js.save_settings(data)
 
         # load it back
         js = JsonUserSettings(FOLDER, 'tox')
         data = js.load_settings()
-        assert (data['age'] == 99)
+        assert data['age'] == 99
         # save custom setting
         js.user_data = {'custom': 'value'}
-        assert (js.save_settings())
+        assert js.save_settings()
         # load it back
         data = js.load_settings()
-        assert (data['custom'] == 'value')
+        assert data['custom'] == 'value'
 
 
 if __name__ == '__main__':

tests/test_json_utils.py

@@ -21,16 +21,17 @@
 BROKEN_JSON_FILE = os.path.join(mod_path, 'test_json', 'data_broken.json')
 
 
-class Test_Errors(unittest.TestCase):
-
+class TestErrors(unittest.TestCase):
     def test_json_load(self):
+        """Test json_load function."""
         data = json_load(JSON_LOAD_FILE)
         self.assertTrue(type(data), dict)
         self.assertTrue(data.get('user'), 'Max')
         self.assertRaises(OSError, json_load, NO_FILE)
         self.assertRaises(OSError, json_load, BROKEN_JSON_FILE)
 
     def test_json_save(self):
+        """Test json_save function."""
         data = {'name': 'max'}
         r = json_save(data, JSON_SAVE_FILE)
         self.assertTrue(r)

tests/test_jsonmd.py

@@ -5,11 +5,11 @@
 # ----------------------------------------------------------------------------------------
 
 import contextlib
-from backpack.json_metadata import JsonMetaFile
-
-import unittest
 import os
 import sys
+import unittest
+
+from backpack.json_metadata import JsonMetaFile
 
 mod_path = os.path.dirname(__file__)
 if mod_path not in sys.path:
@@ -23,18 +23,17 @@
 ATTRIBUTES = ['foo', 'bar']
 
 
-class Test_windows(unittest.TestCase):
-
+class TestWindows(unittest.TestCase):
     @classmethod
     def tearDownClass(cls):
-        # remove test files
+        """Remove test files."""
         with contextlib.suppress(OSError):
             # os.remove(temp_update_json_test_file)
             # os.remove(test_json_file)
             pass
 
     def test_metadata(self):
-        ''' testing module '''
+        """Testing module."""
         meta = JsonMetaFile(NAME, TEST_PATH)
 
         # test properties
@@ -65,22 +64,22 @@ def test_metadata(self):
         meta.save()
 
         # load
-        metaObj = meta.load_as_class()
-        self.assertEqual(type(metaObj), type)
-        self.assertEqual(hasattr(metaObj, 'items'), True)
-        self.assertEqual(metaObj.items, ATTRIBUTES)
+        meta_obj = meta.load_as_class()
+        self.assertEqual(type(meta_obj), type)
+        self.assertEqual(hasattr(meta_obj, 'items'), True)
+        self.assertEqual(meta_obj.items, ATTRIBUTES)
 
         # load class
         meta = JsonMetaFile(NAME, TEST_PATH)
         meta.load()
 
     def test_create_from_class(self):
-        ''' save_from_a_class '''
+        """save_from_a_class."""
         meta = JsonMetaFile(NAME, TEST_PATH)
         self.assertEqual(meta.name, NAME)
 
-        proxyClass = type('Proxy', (), {'foo': 12, 'items': ATTRIBUTES})
-        meta.insert_class(proxyClass)
+        proxy_class = type('Proxy', (), {'foo': 12, 'items': ATTRIBUTES})
+        meta.insert_class(proxy_class)
         self.assertEqual(meta._data['foo'], 12)
         self.assertEqual(meta._data['items'], ATTRIBUTES)
         meta.save()