orionis 0.406.0__py3-none-any.whl → 0.407.0__py3-none-any.whl

tests/services/system/test_services_system_workers.py

@@ -3,88 +3,129 @@ from orionis.services.system.workers import Workers
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestServicesSystemWorkers(AsyncTestCase):
-    """
-    Unit tests for the Workers class.
-
-    This test suite verifies the correct calculation of the number of workers
-    based on available CPU and RAM resources.
-
-    Methods
-    -------
-    testCalculateCpuLimited()
-        Test when the number of workers is limited by CPU count.
-    testCalculateRamLimited()
-        Test when the number of workers is limited by available RAM.
-    testCalculateExactFit()
-        Test when CPU and RAM allow for the same number of workers.
-    testCalculateLowRam()
-        Test when low RAM restricts the number of workers to less than CPU count.
-    """
 
     @patch('multiprocessing.cpu_count', return_value=8)
     @patch('psutil.virtual_memory')
     def testCalculateCpuLimited(self, mockVm, mockCpuCount):
         """
-        Test when the number of workers is limited by CPU count.
+        Tests worker calculation when CPU count is the limiting factor.
 
-        Simulates 8 CPUs and 16 GB RAM, with ram_per_worker=1.
-        RAM allows 16 workers, but CPU only allows 8.
+        Simulates a system with 8 CPUs and 16 GB RAM, where each worker requires 1 GB of RAM.
+        Although the available RAM could support up to 16 workers, the CPU count restricts the number
+        of workers to 8.
+
+        Parameters
+        ----------
+        mockVm : unittest.mock.Mock
+            Mock object for `psutil.virtual_memory`.
+        mockCpuCount : unittest.mock.Mock
+            Mock object for `multiprocessing.cpu_count`.
 
         Returns
         -------
         None
+            Asserts that the calculated number of workers is limited by CPU count.
         """
+
+        # Set the mocked total RAM to 16 GB
         mockVm.return_value.total = 16 * 1024 ** 3
+
+        # Create Workers instance with 1 GB RAM required per worker
         workers = Workers(ram_per_worker=1)
+
+        # Assert that the number of workers is limited to 8 by CPU count
         self.assertEqual(workers.calculate(), 8)
 
     @patch('multiprocessing.cpu_count', return_value=32)
     @patch('psutil.virtual_memory')
     def testCalculateRamLimited(self, mockVm, mockCpuCount):
         """
-        Test when the number of workers is limited by available RAM.
+        Tests worker calculation when RAM is the limiting factor.
 
-        Simulates 32 CPUs and 4 GB RAM, with ram_per_worker=1.
-        RAM allows only 4 workers.
+        Simulates a system with 32 CPUs and 4 GB RAM, where each worker requires 1 GB of RAM.
+        Although the CPU count could support up to 32 workers, the available RAM restricts the number
+        of workers to 4.
+
+        Parameters
+        ----------
+        mockVm : unittest.mock.Mock
+            Mock object for `psutil.virtual_memory`.
+        mockCpuCount : unittest.mock.Mock
+            Mock object for `multiprocessing.cpu_count`.
 
         Returns
         -------
         None
+            Asserts that the calculated number of workers is limited by available RAM.
         """
+
+        # Set the mocked total RAM to 4 GB
         mockVm.return_value.total = 4 * 1024 ** 3
+
+        # Create Workers instance with 1 GB RAM required per worker
         workers = Workers(ram_per_worker=1)
+
+        # Assert that the number of workers is limited to 4 by available RAM
         self.assertEqual(workers.calculate(), 4)
 
     @patch('multiprocessing.cpu_count', return_value=4)
     @patch('psutil.virtual_memory')
     def testCalculateExactFit(self, mockVm, mockCpuCount):
         """
-        Test when CPU and RAM allow for the same number of workers.
+        Tests worker calculation when both CPU count and available RAM allow for the same number of workers.
 
-        Simulates 4 CPUs and 2 GB RAM, with ram_per_worker=0.5.
-        RAM allows 4 workers.
+        Simulates a system with 4 CPUs and 2 GB RAM, where each worker requires 0.5 GB of RAM.
+        Both CPU and RAM resources permit exactly 4 workers, so the calculation should return 4.
+
+        Parameters
+        ----------
+        mockVm : unittest.mock.Mock
+            Mock object for `psutil.virtual_memory`.
+        mockCpuCount : unittest.mock.Mock
+            Mock object for `multiprocessing.cpu_count`.
 
         Returns
         -------
         None
+            Asserts that the calculated number of workers is 4, matching both CPU and RAM constraints.
         """
+        # Set the mocked total RAM to 2 GB
         mockVm.return_value.total = 2 * 1024 ** 3
+
+        # Create Workers instance with 0.5 GB RAM required per worker
         workers = Workers(ram_per_worker=0.5)
+
+        # Assert that the number of workers is limited to 4 by both CPU and RAM
         self.assertEqual(workers.calculate(), 4)
 
     @patch('multiprocessing.cpu_count', return_value=2)
     @patch('psutil.virtual_memory')
     def testCalculateLowRam(self, mockVm, mockCpuCount):
         """
-        Test when low RAM restricts the number of workers to less than CPU count.
+        Tests worker calculation when available RAM is lower than CPU count, restricting the number of workers.
+
+        Simulates a system with 2 CPUs and 0.7 GB RAM, where each worker requires 0.5 GB of RAM.
+        Although the CPU count could support up to 2 workers, the available RAM restricts the number
+        of workers to 1.
 
-        Simulates 2 CPUs and 0.7 GB RAM, with ram_per_worker=0.5.
-        RAM allows only 1 worker.
+        Parameters
+        ----------
+        mockVm : unittest.mock.Mock
+            Mock object for `psutil.virtual_memory`.
+        mockCpuCount : unittest.mock.Mock
+            Mock object for `multiprocessing.cpu_count`.
 
         Returns
         -------
         None
+            Asserts that the calculated number of workers is limited to 1 by available RAM.
         """
+
+        # Set the mocked total RAM to 0.7 GB
         mockVm.return_value.total = 0.7 * 1024 ** 3
+
+        # Create Workers instance with 0.5 GB RAM required per worker
         workers = Workers(ram_per_worker=0.5)
-        self.assertEqual(workers.calculate(), 1)
+
+        # Assert that the number of workers is limited to 1 by available RAM
+        self.assertEqual(workers.calculate(), 1)