[cueman] Add Comprehensive Unit Tests for Job Termination Logic in cueman (#1950)

Create unit tests for the terminateJobs() function covering batch termination, reason logging, and exception handling.

Tests added to /cueman/tests/test_main.py:
- Single and batch job termination with reason tracking
- Kill reason formatting with username from getpass.getuser()
- Empty job list handling
- Exception propagation during kill operations
- Logging output verification with proper logger mocking
- Termination across various job states (RUNNING, WAITING, DEAD,
SUCCEEDED)

Implementation notes:
- Removed tests for non-existent confirm_termination function
- Removed tests for unsupported force parameter
- Updated all mocking to match actual terminateJobs implementation
- Mock job.kill(), getpass.getuser(), and logger for proper isolation

Add pytest to main dependencies for improved testing workflow
- Move pytest from optional test dependencies to main dependencies
- Ensures pytest is available when cueman is installed
- Simplifies test execution without requiring separate test dependency
installation

**Link the Issue(s) this Pull Request is related to.**
#1935 

Co-authored-by: Aniket Singh Yadav <[email protected]>
Co-authored-by: Ramon Figueiredo <[email protected]>

Author: Aniketsy

cueman/pyproject.toml

@@ -9,7 +9,10 @@ name = "opencue_cueman"
 dynamic = ["version"]
 dependencies = [
     "opencue_pycue",
-    "opencue_cueadmin"
+    "opencue_cueadmin",
+    "mock>=2.0.0",
+    "pyfakefs>=5.2.3",
+    "pytest>=6.0"
 ]
 requires-python = ">3.7"
 description = "Cueman is a command-line job management tool for OpenCue that provides efficient job control operations. It offers a streamlined interface for managing jobs, frames, and processes with advanced filtering and batch operation capabilities."

cueman/tests/test_main.py

@@ -39,6 +39,7 @@
     except ImportError:
         # Create a mock module for testing if proto isn't available
         import types
+
         job_pb2 = types.ModuleType('job_pb2')
         job_pb2.RUNNING = 'RUNNING'
         job_pb2.WAITING = 'WAITING'
@@ -93,7 +94,7 @@ def test_buildFrameSearch_default(self):
         with mock.patch('cueadmin.common.handleIntCriterion') as mock_handle:
             mock_handle.side_effect = [
                 [mock.Mock(value=10485)],  # memory conversion
-                [mock.Mock(value=36)]      # duration conversion
+                [mock.Mock(value=36)]  # duration conversion
             ]
             result = main.buildFrameSearch(args)
 
@@ -256,6 +257,103 @@ def test_terminateJobs(self, mock_getuser):
         mock_job1.kill.assert_called_once_with(reason=main.KILL_REASON)
         mock_job2.kill.assert_called_once_with(reason=main.KILL_REASON)
 
+    @mock.patch('getpass.getuser')
+    @mock.patch('cueman.main.logger')
+    def test_terminateJobs_reason_includes_username(self, mock_logger, mock_getuser):
+        """Test that the kill reason includes the username."""
+        mock_getuser.return_value = "specialuser"
+        mock_job = mock.Mock()
+        mock_job.name.return_value = "test_job"
+        jobs = [mock_job]
+
+        main.terminateJobs(jobs)
+
+        # The KILL_REASON template is "Opencueman Terminate Job %s by user %s"
+        # terminateJobs uses it directly as the reason parameter
+        mock_job.kill.assert_called_once_with(reason=main.KILL_REASON)
+
+        # Verify logging includes username
+        mock_logger.info.assert_any_call(main.KILL_REASON, "test_job", "specialuser")
+
+    @mock.patch('cueman.main.logger')
+    def test_terminateJobs_multiple_jobs_batch(self, mock_logger):
+        """Test batch termination of multiple jobs."""
+        mock_job1 = mock.Mock()
+        mock_job1.name.return_value = "job1"
+        mock_job2 = mock.Mock()
+        mock_job2.name.return_value = "job2"
+        mock_job3 = mock.Mock()
+        mock_job3.name.return_value = "job3"
+
+        jobs = [mock_job1, mock_job2, mock_job3]
+
+        main.terminateJobs(jobs)
+
+        # Verify all jobs were killed
+        for job in jobs:
+            job.kill.assert_called_once_with(reason=main.KILL_REASON)
+
+    @mock.patch('cueman.main.logger')
+    def test_terminateJobs_empty_list(self, mock_logger):
+        """Test terminateJobs with empty job list."""
+        jobs = []
+
+        # Should not raise any exceptions
+        try:
+            main.terminateJobs(jobs)
+        except Exception as e:
+            self.fail(f"terminateJobs raised {e} with empty job list")
+
+        # Logger should not be called for empty list
+        mock_logger.info.assert_not_called()
+
+    @mock.patch('cueman.main.logger')
+    def test_terminateJobs_handles_kill_exception(self, mock_logger):
+        """Test that terminateJobs handles exceptions during kill operation."""
+        mock_job = mock.Mock()
+        mock_job.name.return_value = "failing_job"
+        mock_job.kill.side_effect = Exception("Kill failed")
+        jobs = [mock_job]
+
+        # terminateJobs doesn't catch exceptions, so it should propagate
+        with self.assertRaises(Exception) as context:
+            main.terminateJobs(jobs)
+
+        self.assertEqual(str(context.exception), "Kill failed")
+
+    @mock.patch('getpass.getuser')
+    @mock.patch('cueman.main.logger')
+    def test_terminateJobs_logs_output(self, mock_logger, mock_getuser):
+        """Test that terminateJobs produces expected log output."""
+        mock_getuser.return_value = "testuser"
+        mock_job = mock.Mock()
+        mock_job.name.return_value = "test_job"
+        jobs = [mock_job]
+
+        main.terminateJobs(jobs)
+
+        # Verify logging calls
+        mock_logger.info.assert_any_call(main.KILL_REASON, "test_job", "testuser")
+        mock_logger.info.assert_any_call("---")
+
+    @mock.patch('getpass.getuser')
+    @mock.patch('cueman.main.logger')
+    def test_terminateJobs_various_states(self, mock_logger, mock_getuser):
+        """Test termination of jobs in various states."""
+        mock_getuser.return_value = "testuser"
+
+        for state in ["RUNNING", "WAITING", "DEAD", "SUCCEEDED"]:
+            mock_job = mock.Mock()
+            mock_job.name.return_value = f"job_{state}"
+            mock_job.state = state
+            jobs = [mock_job]
+
+            main.terminateJobs(jobs)
+
+            # Verify job was killed regardless of state
+            mock_job.kill.assert_called_once_with(reason=main.KILL_REASON)
+            mock_job.reset_mock()
+
 
 class TestCuemanHandleArgs(unittest.TestCase):
     """Test cases for handleArgs function."""