Feat #58 - fix backpressure logic and update tests

tests/adapter/test_backpressure_handler.py

@@ -13,6 +13,9 @@ from aio_pika import Exchange
 from aio_pika.abc import AbstractRobustChannel
 
 from amqp.adapter.backpressure_handler import (
+    RESOURCE_ACTIVE,
+    RESOURCE_OVERLOAD,
+    RESOURCE_UNSET,
     BackpressureHandler,
     RunningAverage,
     ScaleRequestV1,
@@ -463,6 +466,98 @@ class TestBackpressureHandler:
         assert handler.publish_backpressure_request.call_count == 1
         assert handler.last_data_message_time == 12345
 
+    @pytest.mark.asyncio
+    async def test_check_resource_availability_overload(self, mock_channel, mock_loop, mock_config):
+        """
+        Test the check_resource_availability method when resource usage is in OVERLOAD state.
+        """
+        handler = BackpressureHandler(mock_channel, mock_loop, mock_config)
+        handler.handle_backpressure_overload_event = AsyncMock()
+        handler._handle_backpressure_idle_event = AsyncMock()
+        handler.publish_backpressure_request = AsyncMock()
+
+        # Set up initial state
+        handler.last_backpressure_event = ScalingRequestAlert.UPDATE
+        handler.last_backpressure_event_time = 0
+        handler._resource_usage_state = RESOURCE_ACTIVE  # Start with ACTIVE state
+        handler._resource_usage_changed = 0
+
+        with patch("time.time") as mock_time:
+            mock_time.return_value = 100
+            # Call with resource usage above OVERLOAD threshold (90% of maximum)
+            await handler.check_resource_availability(95, 100)
+
+            # Debug output
+            print(f"Resource usage state: {handler._resource_usage_state}")
+            print(f"Last backpressure event: {handler.last_backpressure_event}")
+            print(f"Last backpressure event time: {handler.last_backpressure_event_time}")
+            print(f"Time window: {mock_config.backpressure.time_window}")
+            print("Resource usage: 95, Maximum: 100")
+            print(f"Overload threshold calculation: {round(0.9 * 100)}")
+
+        # Verify OVERLOAD event was triggered
+        handler.handle_backpressure_overload_event.assert_called_once()
+        assert handler.last_backpressure_event == ScalingRequestAlert.OVERLOAD
+        assert handler.last_backpressure_event_time == 100
+        assert handler._resource_usage_state == RESOURCE_OVERLOAD
+
+    @pytest.mark.asyncio
+    async def test_check_resource_availability_idle(self, mock_channel, mock_loop, mock_config):
+        """
+        Test the check_resource_availability method when resource usage is in IDLE state.
+        """
+        handler = BackpressureHandler(mock_channel, mock_loop, mock_config)
+        handler._handle_backpressure_idle_event = AsyncMock()
+        handler.handle_backpressure_overload_event = AsyncMock()
+        handler.publish_backpressure_request = AsyncMock()
+
+        # Set up initial state
+        handler.last_backpressure_event = ScalingRequestAlert.UPDATE
+        handler.last_backpressure_event_time = 0
+        handler._resource_usage_state = RESOURCE_UNSET  # Start with UNSET state
+        handler._resource_usage_changed = 0
+
+        with patch("time.time") as mock_time:
+            # First call to set state to IDLE
+            mock_time.return_value = 50
+            await handler.check_resource_availability(10, 100)
+
+            # Second call after idle_duration has passed
+            mock_time.return_value = 50 + mock_config.backpressure.idle_duration + 1
+            await handler.check_resource_availability(10, 100)
+
+        # Verify IDLE event was triggered
+        handler._handle_backpressure_idle_event.assert_called_once()
+        assert handler.last_backpressure_event == ScalingRequestAlert.IDLE
+        assert (
+            handler.last_backpressure_event_time == 50 + mock_config.backpressure.idle_duration + 1
+        )
+
+    @pytest.mark.asyncio
+    async def test_check_resource_availability_update(self, mock_channel, mock_loop, mock_config):
+        """
+        Test the check_resource_availability method when resource usage is in ACTIVE state.
+        """
+        handler = BackpressureHandler(mock_channel, mock_loop, mock_config)
+        handler.publish_backpressure_request = AsyncMock()
+        handler.handle_backpressure_overload_event = AsyncMock()
+        handler._handle_backpressure_idle_event = AsyncMock()
+
+        # Set up initial state
+        handler.last_backpressure_event = ScalingRequestAlert.IDLE
+        handler.last_backpressure_event_time = 0
+
+        with patch("time.time") as mock_time:
+            mock_time.return_value = 100
+            # Call with resource usage between thresholds
+            await handler.check_resource_availability(50, 100)
+
+        # Verify UPDATE event was triggered
+        assert handler.publish_backpressure_request.call_count == 1
+        assert handler.last_backpressure_event == ScalingRequestAlert.UPDATE
+        assert handler.last_backpressure_event_time == 100
+        assert handler._resource_usage_state == RESOURCE_ACTIVE
+
     @pytest.mark.asyncio
     async def test_publish_backpressure_request_exchange_exists(
         self, mock_channel, mock_loop, mock_config