Additional test cases for run.py:

- Additional tests to cover the creation of the folders
 - Test to ensure a job folder is created when the directory is empty
 - Test to ensure the correct job folder is created if there are existing folders
 - Test to ensure job folder is created correctly when non job folders are present
 - Test to ensure job folder is created with mixed job folders and other folders
 - Test to ensure job folders with the wrong suffix are ignored

Author: harryswift01

CodeEntropy/run.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import pickle
-import re
 
 import MDAnalysis as mda
 from MDAnalysis.analysis.base import AnalysisFromFunction
@@ -52,33 +51,38 @@ def create_job_folder():
         folders.
         """
         # Get the current working directory
-        base_dir = os.getcwd()
-
-        # List all folders in the base directory
-        existing_folders = [
-            f for f in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, f))
-        ]
-
-        # Filter folders that match the pattern 'jobXXX'
-        job_folders = [f for f in existing_folders if re.match(r"job\d{3}", f)]
-
-        # Determine the next job number
-        if job_folders:
-            max_job_number = max(
-                [int(re.search(r"\d{3}", f).group()) for f in job_folders]
-            )
-            next_job_number = max_job_number + 1
-        else:
+        current_dir = os.getcwd()
+
+        # Get a list of existing folders that start with "job"
+        existing_folders = [f for f in os.listdir(current_dir) if f.startswith("job")]
+
+        # Extract numbers from existing folder names
+        job_numbers = []
+        for folder in existing_folders:
+            try:
+                # Assuming folder names are in the format "jobXXX"
+                job_number = int(folder[3:])  # Get the number part after "job"
+                job_numbers.append(job_number)
+            except ValueError:
+                continue  # Ignore any folder names that don't follow the pattern
+
+        # If no folders exist, start with job001
+        if not job_numbers:
             next_job_number = 1
+        else:
+            next_job_number = max(job_numbers) + 1
 
-        # Format the new job folder name
+        # Create the new job folder name
         new_job_folder = f"job{next_job_number:03d}"
-        new_job_folder_path = os.path.join(base_dir, new_job_folder)
 
-        # Create the new job folder
-        os.makedirs(new_job_folder_path, exist_ok=True)
+        # Create the full path to the new folder
+        new_folder_path = os.path.join(current_dir, new_job_folder)
+
+        # Create the directory
+        os.makedirs(new_folder_path, exist_ok=True)
 
-        return new_job_folder_path
+        # Return the path of the newly created folder
+        return new_folder_path
 
     def run_entropy_workflow(self):
         """

tests/test_CodeEntropy/test_run.py

@@ -0,0 +1,105 @@
+import os
+import shutil
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from CodeEntropy.run import RunManager
+
+
+class TestRunManager(unittest.TestCase):
+    """
+    Unit tests for the RunManager class. These tests verify the
+    correct behavior of run manager.
+    """
+
+    def setUp(self):
+        """
+        Set up a temporary directory as the working directory before each test.
+        """
+        self.test_dir = tempfile.mkdtemp(prefix="CodeEntropy_")
+        self._orig_dir = os.getcwd()
+        os.chdir(self.test_dir)
+
+    def tearDown(self):
+        """
+        Clean up by removing the temporary directory and restoring the original working
+        directory.
+        """
+        os.chdir(self._orig_dir)
+        shutil.rmtree(self.test_dir)
+
+    @patch("os.makedirs")
+    @patch("os.listdir")
+    def test_create_job_folder_empty_directory(self, mock_listdir, mock_makedirs):
+        """
+        Test that 'job001' is created when the directory is initially empty.
+        """
+        mock_listdir.return_value = []
+        new_folder_path = RunManager.create_job_folder()
+        expected_path = os.path.join(self.test_dir, "job001")
+        self.assertEqual(new_folder_path, expected_path)
+        mock_makedirs.assert_called_once_with(expected_path, exist_ok=True)
+
+    @patch("os.makedirs")
+    @patch("os.listdir")
+    def test_create_job_folder_with_existing_folders(self, mock_listdir, mock_makedirs):
+        """
+        Test that the next sequential job folder (e.g., 'job004') is created when
+        existing folders 'job001', 'job002', and 'job003' are present.
+        """
+        mock_listdir.return_value = ["job001", "job002", "job003"]
+        new_folder_path = RunManager.create_job_folder()
+        expected_path = os.path.join(self.test_dir, "job004")
+        self.assertEqual(new_folder_path, expected_path)
+        mock_makedirs.assert_called_once_with(expected_path, exist_ok=True)
+
+    @patch("os.makedirs")
+    @patch("os.listdir")
+    def test_create_job_folder_with_non_matching_folders(
+        self, mock_listdir, mock_makedirs
+    ):
+        """
+        Test that 'job001' is created when the directory contains only non-job-related
+        folders.
+        """
+        mock_listdir.return_value = ["folderA", "another_one"]
+        new_folder_path = RunManager.create_job_folder()
+        expected_path = os.path.join(self.test_dir, "job001")
+        self.assertEqual(new_folder_path, expected_path)
+        mock_makedirs.assert_called_once_with(expected_path, exist_ok=True)
+
+    @patch("os.makedirs")
+    @patch("os.listdir")
+    def test_create_job_folder_mixed_folder_names(self, mock_listdir, mock_makedirs):
+        """
+        Test that the correct next job folder (e.g., 'job003') is created when both
+        job and non-job folders exist in the directory.
+        """
+        mock_listdir.return_value = ["job001", "abc", "job002", "random"]
+        new_folder_path = RunManager.create_job_folder()
+        expected_path = os.path.join(self.test_dir, "job003")
+        self.assertEqual(new_folder_path, expected_path)
+        mock_makedirs.assert_called_once_with(expected_path, exist_ok=True)
+
+    @patch("os.makedirs")
+    @patch("os.listdir")
+    def test_create_job_folder_with_invalid_job_suffix(
+        self, mock_listdir, mock_makedirs
+    ):
+        """
+        Test that invalid job folder names like 'jobABC' are ignored when determining
+        the next job number.
+        """
+        # Simulate existing folders, one of which is invalid
+        mock_listdir.return_value = ["job001", "jobABC", "job002"]
+
+        new_folder_path = RunManager.create_job_folder()
+        expected_path = os.path.join(self.test_dir, "job003")
+
+        self.assertEqual(new_folder_path, expected_path)
+        mock_makedirs.assert_called_once_with(expected_path, exist_ok=True)
+
+
+if __name__ == "__main__":
+    unittest.main()