issue #16 - fix the pytest hanging after test main thread exits

tests/adapter/test_backpressure_handler.py

@@ -274,9 +274,7 @@ class TestBackpressureHandler:
         """
         return AMQConfiguration("")
 
-    def test_backpressure_handler_initialization(
-        self, mock_channel, mock_loop, mock_config
-    ):
+    def test_backpressure_handler_initialization(self, mock_channel, mock_loop, mock_config):
         """
         Test that the BackpressureHandler object is initialized correctly.
         """
@@ -334,14 +332,13 @@ class TestBackpressureHandler:
         Test the start_backpressure_monitor method.
         """
         handler = BackpressureHandler(mock_channel, mock_loop, mock_config)
+        handler.do_loop = 1  # allow only 1 execution of the loop and then exit the thread, else tests will never end
         thread = handler.start_backpressure_monitor()
         assert isinstance(thread, Thread)
         assert handler.thread == thread
 
     @pytest.mark.asyncio
-    async def test_check_overload_condition_no_overload(
-        self, mock_channel, mock_loop, mock_config
-    ):
+    async def test_check_overload_condition_no_overload(self, mock_channel, mock_loop, mock_config):
         """
         Test the check_overload_condition method when there is no overload.
         """
@@ -349,25 +346,19 @@ class TestBackpressureHandler:
         handler.current_parallel_executions = 1
         handler.parallel_workers = 5
         handler.last_backpressure_event = ScalingRequestAlert.UPDATE
-        with patch.object(
-            handler, "handle_backpressure_overload_event"
-        ) as mock_handle_overload:
+        with patch.object(handler, "handle_backpressure_overload_event") as mock_handle_overload:
             await handler.check_overload_condition()
             mock_handle_overload.assert_not_called()
 
     @pytest.mark.asyncio
-    async def test_check_overload_condition_overload(
-        self, mock_channel, mock_loop, mock_config
-    ):
+    async def test_check_overload_condition_overload(self, mock_channel, mock_loop, mock_config):
         """
         Test the check_overload_condition method when there is an overload.
         """
         handler = BackpressureHandler(mock_channel, mock_loop, mock_config)
         handler.current_parallel_executions = 9  # Assuming parallel_workers is 10
         handler.last_backpressure_event = ScalingRequestAlert.UPDATE
-        with patch.object(
-            handler, "handle_backpressure_overload_event"
-        ) as mock_handle_overload:
+        with patch.object(handler, "handle_backpressure_overload_event") as mock_handle_overload:
             with patch("time.time") as mock_time:
                 mock_time.return_value = 12345
                 await handler.check_overload_condition()
@@ -385,9 +376,7 @@ class TestBackpressureHandler:
         handler = BackpressureHandler(mock_channel, mock_loop, mock_config)
         handler.current_parallel_executions = 10
         handler.last_backpressure_event = ScalingRequestAlert.OVERLOAD
-        with patch.object(
-            handler, "handle_backpressure_overload_event"
-        ) as mock_handle_overload:
+        with patch.object(handler, "handle_backpressure_overload_event") as mock_handle_overload:
             await handler.check_overload_condition()
             mock_handle_overload.assert_not_called()
 
@@ -396,9 +385,7 @@ class TestBackpressureHandler:
     # you might approach testing it, focusing on verifying that the correct methods
     # are called under specific conditions.  This is NOT a complete, runnable test.
     @pytest.mark.asyncio
-    async def test_backpressure_monitor_loop(
-        self, mock_channel, mock_loop, mock_config
-    ):
+    async def test_backpressure_monitor_loop(self, mock_channel, mock_loop, mock_config):
         """
         Test the backpressure_monitor_loop method (outline).
         """
@@ -406,9 +393,7 @@ class TestBackpressureHandler:
         handler.average_cpu_usage = RunningAverage(
             100, initial_value=99
         )  # Mock the RunningAverage in OVERLOAD state
-        handler.average_cpu_usage.is_filled = (
-            True  # Together with 0 values ensures OVERLOAD state
-        )
+        handler.average_cpu_usage.is_filled = True  # Together with 0 values ensures OVERLOAD state
         # Setup mocks for dependent methods
         handler.handle_backpressure_overload_event = AsyncMock()
         handler._handle_backpressure_idle_event = AsyncMock()
@@ -428,9 +413,7 @@ class TestBackpressureHandler:
         handler.average_cpu_usage = RunningAverage(
             100, initial_value=0
         )  # Mock the RunningAverage in IDLE state
-        handler.average_cpu_usage.is_filled = (
-            True  # Together with 0 values ensures IDLE state
-        )
+        handler.average_cpu_usage.is_filled = True  # Together with 0 values ensures IDLE state
         handler.last_backpressure_event_time = 0
         handler.last_data_message_time = 0
         handler.do_loop = 1
@@ -441,9 +424,7 @@ class TestBackpressureHandler:
         handler._handle_backpressure_idle_event.assert_called_once()
 
         # 3. Simulate neither idle nor overload, but time_window passed
-        handler.average_cpu_usage = RunningAverage(
-            100
-        )  # Mock the RunningAverage in pritine state
+        handler.average_cpu_usage = RunningAverage(100)  # Mock the RunningAverage in pritine state
         handler.last_backpressure_event_time = 0
         handler.last_data_message_time = 0
         handler.do_loop = 1
@@ -451,9 +432,7 @@ class TestBackpressureHandler:
         handler.publish_backpressure_request.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_handle_backpressure_overload_event(
-        self, mock_channel, mock_loop, mock_config
-    ):
+    async def test_handle_backpressure_overload_event(self, mock_channel, mock_loop, mock_config):
         """
         Test the handle_backpressure_overload_event method.
         """
@@ -466,9 +445,7 @@ class TestBackpressureHandler:
         assert handler.last_data_message_time == 12345
 
     @pytest.mark.asyncio
-    async def test_handle_backpressure_idle_event(
-        self, mock_channel, mock_loop, mock_config
-    ):
+    async def test_handle_backpressure_idle_event(self, mock_channel, mock_loop, mock_config):
         """
         Test the _handle_backpressure_idle_event method.
         """
@@ -493,9 +470,7 @@ class TestBackpressureHandler:
             mock_async_run.return_value = asyncio.Future()
             mock_async_run.return_value.set_result(None)
             await handler.publish_backpressure_request(
-                ScaleRequestV1(
-                    "test_service", "test_task", 100, 50, ScalingRequestAlert.UPDATE
-                )
+                ScaleRequestV1("test_service", "test_task", 100, 50, ScalingRequestAlert.UPDATE)
             )
         assert mock_async_run.call_count == 1
         # handler.exchange.publish.assert_called_once()
@@ -519,9 +494,7 @@ class TestBackpressureHandler:
                 mock_exchange
             )  # Make it return the mock exchange
             await handler.publish_backpressure_request(
-                ScaleRequestV1(
-                    "test_service", "test_task", 100, 50, ScalingRequestAlert.UPDATE
-                )
+                ScaleRequestV1("test_service", "test_task", 100, 50, ScalingRequestAlert.UPDATE)
             )
             assert mock_async_run.call_count == 2