port-ocean 0.18.5__py3-none-any.whl → 0.18.7__py3-none-any.whl

port_ocean/ocean.py

@@ -26,6 +26,7 @@ from port_ocean.utils.repeat import repeat_every
 from port_ocean.utils.signal import signal_handler
 from port_ocean.version import __integration_version__
 from port_ocean.utils.misc import IntegrationStateStatus
+from port_ocean.core.handlers.webhook.processor_manager import WebhookProcessorManager
 
 
 class Ocean:
@@ -53,6 +54,10 @@ class Ocean:
         )
         self.integration_router = integration_router or APIRouter()
 
+        self.webhook_manager = WebhookProcessorManager(
+            self.integration_router, signal_handler
+        )
+
         self.port_client = PortClient(
             base_url=self.config.port.base_url,
             client_id=self.config.port.client_id,
@@ -120,6 +125,7 @@ class Ocean:
         async def lifecycle(_: FastAPI) -> AsyncIterator[None]:
             try:
                 await self.integration.start()
+                await self.webhook_manager.start_processing_event_messages()
                 await self._setup_scheduled_resync()
                 yield None
             except Exception:
@@ -127,7 +133,7 @@ class Ocean:
                 logger.complete()
                 sys.exit("Server stopped")
             finally:
-                signal_handler.exit()
+                await signal_handler.exit()
 
         self.fast_api_app.router.lifespan_context = lifecycle
         self.app_initialized = True

port_ocean/tests/core/handlers/entities_state_applier/test_applier.py

@@ -0,0 +1,86 @@
+from unittest.mock import Mock, patch
+import pytest
+from port_ocean.core.handlers.entities_state_applier.port.applier import (
+    HttpEntitiesStateApplier,
+)
+from port_ocean.core.models import Entity
+from port_ocean.core.ocean_types import EntityDiff
+from port_ocean.clients.port.types import UserAgentType
+
+
+@pytest.mark.asyncio
+async def test_delete_diff_no_deleted_entities() -> None:
+    applier = HttpEntitiesStateApplier(Mock())
+    entities = EntityDiff(
+        before=[Entity(identifier="1", blueprint="test")],
+        after=[Entity(identifier="1", blueprint="test")],
+    )
+
+    with patch.object(applier, "_safe_delete") as mock_safe_delete:
+        await applier.delete_diff(entities, UserAgentType.exporter)
+
+    mock_safe_delete.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_diff_below_threshold() -> None:
+    applier = HttpEntitiesStateApplier(Mock())
+    entities = EntityDiff(
+        before=[
+            Entity(identifier="1", blueprint="test"),
+            Entity(identifier="2", blueprint="test"),
+            Entity(identifier="3", blueprint="test"),
+        ],
+        after=[
+            Entity(identifier="1", blueprint="test"),
+            Entity(identifier="2", blueprint="test"),
+        ],
+    )
+
+    with patch.object(applier, "_safe_delete") as mock_safe_delete:
+        await applier.delete_diff(
+            entities, UserAgentType.exporter, entity_deletion_threshold=0.9
+        )
+
+    mock_safe_delete.assert_called_once()
+    assert len(mock_safe_delete.call_args[0][0]) == 1
+    assert mock_safe_delete.call_args[0][0][0].identifier == "3"
+
+
+@pytest.mark.asyncio
+async def test_delete_diff_above_default_threshold() -> None:
+    applier = HttpEntitiesStateApplier(Mock())
+    entities = EntityDiff(
+        before=[
+            Entity(identifier="1", blueprint="test"),
+            Entity(identifier="2", blueprint="test"),
+            Entity(identifier="3", blueprint="test"),
+        ],
+        after=[],
+    )
+
+    with patch.object(applier, "_safe_delete") as mock_safe_delete:
+        await applier.delete_diff(
+            entities, UserAgentType.exporter, entity_deletion_threshold=0.9
+        )
+
+    mock_safe_delete.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_delete_diff_custom_threshold_above_threshold_not_deleted() -> None:
+    applier = HttpEntitiesStateApplier(Mock())
+    entities = EntityDiff(
+        before=[
+            Entity(identifier="1", blueprint="test"),
+            Entity(identifier="2", blueprint="test"),
+        ],
+        after=[],
+    )
+
+    with patch.object(applier, "_safe_delete") as mock_safe_delete:
+        await applier.delete_diff(
+            entities, UserAgentType.exporter, entity_deletion_threshold=0.5
+        )
+
+    mock_safe_delete.assert_not_called()

port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -435,66 +435,63 @@ async def test_register_raw(
     mock_sync_raw_mixin_with_jq_processor: SyncRawMixin,
     mock_resource_config: ResourceConfig,
 ) -> None:
-    # Mock the integration settings with skip_check_diff
-    with patch.object(ocean.config.integration, "skip_check_diff", False):
-        kind = "service"
-        user_agent_type = UserAgentType.exporter
-        raw_entity = [
-            {"id": "entity_1", "name": "entity_1", "web_url": "https://example.com"},
-        ]
-        expected_result = [
-            {
-                "identifier": "entity_1",
-                "blueprint": "service",
-                "name": "entity_1",
-                "properties": {},
-            },
-        ]
 
-        async with event_context(
-            EventType.HTTP_REQUEST, trigger_type="machine"
-        ) as event:
-            # Use patch to mock the method instead of direct assignment
+    kind = "service"
+    user_agent_type = UserAgentType.exporter
+    raw_entity = [
+        {"id": "entity_1", "name": "entity_1", "web_url": "https://example.com"},
+    ]
+    expected_result = [
+        {
+            "identifier": "entity_1",
+            "blueprint": "service",
+            "name": "entity_1",
+            "properties": {"url": "https://example.com"},
+        },
+    ]
+
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="machine") as event:
+        # Use patch to mock the method instead of direct assignment
+        with patch.object(
+            mock_sync_raw_mixin_with_jq_processor.port_app_config_handler,
+            "get_port_app_config",
+            return_value=PortAppConfig(
+                enable_merge_entity=True,
+                delete_dependent_entities=True,
+                create_missing_related_entities=False,
+                resources=[mock_resource_config],
+            ),
+        ):
+            # Ensure the event.port_app_config is set correctly
+            event.port_app_config = await mock_sync_raw_mixin_with_jq_processor.port_app_config_handler.get_port_app_config(
+                use_cache=False
+            )
+
+            def upsert_side_effect(
+                entities: list[Entity], user_agent_type: UserAgentType
+            ) -> list[Entity]:
+                # Simulate returning the passed entities
+                return entities
+
+            # Patch the upsert method with the side effect
             with patch.object(
-                mock_sync_raw_mixin_with_jq_processor.port_app_config_handler,
-                "get_port_app_config",
-                return_value=PortAppConfig(
-                    enable_merge_entity=True,
-                    delete_dependent_entities=True,
-                    create_missing_related_entities=False,
-                    resources=[mock_resource_config],
-                ),
+                mock_sync_raw_mixin_with_jq_processor.entities_state_applier,
+                "upsert",
+                side_effect=upsert_side_effect,
             ):
-                # Ensure the event.port_app_config is set correctly
-                event.port_app_config = await mock_sync_raw_mixin_with_jq_processor.port_app_config_handler.get_port_app_config(
-                    use_cache=False
-                )
-
-                def upsert_side_effect(
-                    entities: list[Entity], user_agent_type: UserAgentType
-                ) -> list[Entity]:
-                    # Simulate returning the passed entities
-                    return entities
-
-                # Patch the upsert method with the side effect
-                with patch.object(
-                    mock_sync_raw_mixin_with_jq_processor.entities_state_applier,
-                    "upsert",
-                    side_effect=upsert_side_effect,
-                ):
-                    # Call the register_raw method
-                    registered_entities = (
-                        await mock_sync_raw_mixin_with_jq_processor.register_raw(
-                            kind, raw_entity, user_agent_type
-                        )
+                # Call the register_raw method
+                registered_entities = (
+                    await mock_sync_raw_mixin_with_jq_processor.register_raw(
+                        kind, raw_entity, user_agent_type
                     )
+                )
 
-                    # Assert that the registered entities match the expected results
-                    assert len(registered_entities) == len(expected_result)
-                    for entity, result in zip(registered_entities, expected_result):
-                        assert entity.identifier == result["identifier"]
-                        assert entity.blueprint == result["blueprint"]
-                        assert entity.properties == result["properties"]
+                # Assert that the registered entities match the expected results
+                assert len(registered_entities) == len(expected_result)
+                for entity, result in zip(registered_entities, expected_result):
+                    assert entity.identifier == result["identifier"]
+                    assert entity.blueprint == result["blueprint"]
+                    assert entity.properties == result["properties"]
 
 
 @pytest.mark.asyncio
@@ -689,30 +686,26 @@ async def test_register_resource_raw_no_changes_upsert_not_called_entitiy_is_ret
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
 ) -> None:
-    # Mock the integration settings with skip_check_diff
-    with patch.object(ocean.config.integration, "skip_check_diff", False):
-        entity = Entity(identifier="1", blueprint="service")
-        mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
-        mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
-        mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
-
-        async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-            event.port_app_config = mock_port_app_config
-
-            # Test execution
-            result = await mock_sync_raw_mixin._register_resource_raw(
-                mock_port_app_config.resources[
-                    0
-                ],  # Use the first resource from the config
-                [{"some": "data"}],
-                UserAgentType.exporter,
-            )
+    entity = Entity(identifier="1", blueprint="service")
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
+    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+
+        # Test execution
+        result = await mock_sync_raw_mixin._register_resource_raw(
+            mock_port_app_config.resources[0],  # Use the first resource from the config
+            [{"some": "data"}],
+            UserAgentType.exporter,
+        )
 
-            # Assertions
-            assert len(result.entity_selector_diff.passed) == 1
-            mock_sync_raw_mixin._calculate_raw.assert_called_once()
-            mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
-            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
+        # Assertions
+        assert len(result.entity_selector_diff.passed) == 1
+        mock_sync_raw_mixin._calculate_raw.assert_called_once()
+        mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
+        mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
 
 
 @pytest.mark.asyncio
@@ -720,57 +713,89 @@ async def test_register_resource_raw_with_changes_upsert_called_and_entities_are
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
 ) -> None:
-    # Mock the integration settings with skip_check_diff
-    with patch.object(ocean.config.integration, "skip_check_diff", False):
-        entity = Entity(identifier="1", blueprint="service")
-        mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
-        mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([entity]))  # type: ignore
-        mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
-
-        async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-            event.port_app_config = mock_port_app_config
-
-            # Test execution
-            result = await mock_sync_raw_mixin._register_resource_raw(
-                mock_port_app_config.resources[0],
-                [{"some": "data"}],
-                UserAgentType.exporter,
-            )
+    entity = Entity(identifier="1", blueprint="service")
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([entity]))  # type: ignore
+    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+
+        # Test execution
+        result = await mock_sync_raw_mixin._register_resource_raw(
+            mock_port_app_config.resources[0],
+            [{"some": "data"}],
+            UserAgentType.exporter,
+        )
 
-            # Assertions
-            assert len(result.entity_selector_diff.passed) == 1
-            mock_sync_raw_mixin._calculate_raw.assert_called_once()
-            mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()
-            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
+        # Assertions
+        assert len(result.entity_selector_diff.passed) == 1
+        mock_sync_raw_mixin._calculate_raw.assert_called_once()
+        mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()
+        mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
 
 
 @pytest.mark.asyncio
 async def test_register_resource_raw_with_errors(
     mock_sync_raw_mixin: SyncRawMixin, mock_port_app_config: PortAppConfig
 ) -> None:
-    # Mock the integration settings with skip_check_diff
-    with patch.object(ocean.config.integration, "skip_check_diff", False):
-        failed_entity = Entity(identifier="1", blueprint="service")
-        error = Exception("Test error")
-        mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[], failed=[failed_entity]), errors=[error], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
-        mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
-        mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
-
-        async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-            event.port_app_config = mock_port_app_config
-
-            # Test execution
-            result = await mock_sync_raw_mixin._register_resource_raw(
-                mock_port_app_config.resources[0],
-                [{"some": "data"}],
-                UserAgentType.exporter,
-            )
+    failed_entity = Entity(identifier="1", blueprint="service")
+    error = Exception("Test error")
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[], failed=[failed_entity]), errors=[error], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
+    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+
+        # Test execution
+        result = await mock_sync_raw_mixin._register_resource_raw(
+            mock_port_app_config.resources[0],
+            [{"some": "data"}],
+            UserAgentType.exporter,
+        )
+
+        # Assertions
+        assert len(result.entity_selector_diff.passed) == 0
+        assert len(result.entity_selector_diff.failed) == 1
+        assert len(result.errors) == 1
+        assert result.errors[0] == error
+        mock_sync_raw_mixin._calculate_raw.assert_called_once()
+        mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
+        mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_register_resource_raw_skip_event_type_http_request_upsert_called_and_no_entitites_diff_calculation(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_port_app_config: PortAppConfig,
+    mock_context: PortOceanContext,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Mock dependencies
+    entity = Entity(identifier="1", blueprint="service")
+    calculation_result = CalculationResult(
+        entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]),
+        errors=[],
+        misconfigurations=[],
+        misonfigured_entity_keys=[],
+    )
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[calculation_result])  # type: ignore
+    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock()  # type: ignore
+    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
+
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+
+        # Test execution
+        result = await mock_sync_raw_mixin._register_resource_raw(
+            mock_port_app_config.resources[0],
+            [{"some": "data"}],
+            UserAgentType.exporter,
+        )
 
-            # Assertions
-            assert len(result.entity_selector_diff.passed) == 0
-            assert len(result.entity_selector_diff.failed) == 1
-            assert len(result.errors) == 1
-            assert result.errors[0] == error
-            mock_sync_raw_mixin._calculate_raw.assert_called_once()
-            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
-            mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
+        # Assertions
+        assert len(result.entity_selector_diff.passed) == 1
+        mock_sync_raw_mixin._calculate_raw.assert_called_once()
+        mock_sync_raw_mixin._map_entities_compared_with_port.assert_not_called()
+        mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()

port_ocean/tests/core/handlers/queue/test_local_queue.py

@@ -0,0 +1,90 @@
+import asyncio
+import pytest
+from dataclasses import dataclass
+
+from port_ocean.core.handlers.queue.local_queue import LocalQueue
+
+
+@dataclass
+class MockMessage:
+    """Example message type for testing"""
+
+    id: str
+    data: str
+    processed: bool = False
+
+
+class TestLocalQueue:
+    """
+    Test suite for LocalQueue implementation
+    This can serve as an example for testing other Queue implementations
+    """
+
+    @pytest.fixture
+    def queue(self) -> LocalQueue[MockMessage]:
+        return LocalQueue[MockMessage]()
+
+    async def test_basic_queue_operations(self, queue: LocalQueue[MockMessage]) -> None:
+        """Test basic put/get operations"""
+        message = MockMessage(id="1", data="test")
+
+        # Put item in queue
+        await queue.put(message)
+
+        # Get item from queue
+        received = await queue.get()
+
+        assert received.id == message.id
+        assert received.data == message.data
+
+        # Mark as processed
+        await queue.commit()
+
+    async def test_fifo_order(self, queue: LocalQueue[MockMessage]) -> None:
+        """Demonstrate and test FIFO (First In, First Out) behavior"""
+        messages = [
+            MockMessage(id="1", data="first"),
+            MockMessage(id="2", data="second"),
+            MockMessage(id="3", data="third"),
+        ]
+
+        # Put items in queue
+        for msg in messages:
+            await queue.put(msg)
+
+        # Verify order
+        for expected in messages:
+            received = await queue.get()
+            assert received.id == expected.id
+            await queue.commit()
+
+    async def test_wait_for_completion(self, queue: LocalQueue[MockMessage]) -> None:
+        """Example of waiting for all messages to be processed"""
+        processed_count = 0
+
+        async def slow_processor() -> None:
+            nonlocal processed_count
+            while True:
+                try:
+                    await asyncio.wait_for(queue.get(), timeout=0.1)
+                    # Simulate processing time
+                    await asyncio.sleep(0.1)
+                    processed_count += 1
+                    await queue.commit()
+                except asyncio.TimeoutError:
+                    break
+
+        # Add messages
+        message_count = 5
+        for i in range(message_count):
+            await queue.put(MockMessage(id=str(i), data=f"test_{i}"))
+
+        # Start processor
+        processor = asyncio.create_task(slow_processor())
+
+        # Wait for completion
+        await queue.teardown()
+
+        await processor
+
+        assert processed_count == message_count

port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py

@@ -0,0 +1,114 @@
+from fastapi import APIRouter
+import pytest
+
+from port_ocean.core.handlers.webhook.abstract_webhook_processor import (
+    AbstractWebhookProcessor,
+)
+from port_ocean.exceptions.webhook_processor import RetryableError
+from port_ocean.core.handlers.webhook.webhook_event import (
+    EventHeaders,
+    EventPayload,
+    WebhookEvent,
+)
+from port_ocean.core.handlers.webhook.processor_manager import WebhookProcessorManager
+from port_ocean.utils.signal import SignalHandler
+
+
+class MockWebhookHandler(AbstractWebhookProcessor):
+    """Concrete implementation for testing."""
+
+    def __init__(
+        self,
+        event: WebhookEvent,
+        should_fail: bool = False,
+        fail_count: int = 0,
+        max_retries: int = 3,
+    ) -> None:
+        super().__init__(event)
+        self.authenticated = False
+        self.validated = False
+        self.handled = False
+        self.should_fail = should_fail
+        self.fail_count = fail_count
+        self.current_fails = 0
+        self.error_handler_called = False
+        self.cancelled = False
+        self.max_retries = max_retries
+
+    async def authenticate(self, payload: EventPayload, headers: EventHeaders) -> bool:
+        self.authenticated = True
+        return True
+
+    async def validate_payload(self, payload: EventPayload) -> bool:
+        self.validated = True
+        return True
+
+    async def handle_event(self, payload: EventPayload) -> None:
+        if self.should_fail and self.current_fails < self.fail_count:
+            self.current_fails += 1
+            raise RetryableError("Temporary failure")
+        self.handled = True
+
+    async def cancel(self) -> None:
+        self.cancelled = True
+
+    async def on_error(self, error: Exception) -> None:
+        self.error_handler_called = True
+        await super().on_error(error)
+
+
+class TestAbstractWebhookHandler:
+    @pytest.fixture
+    def webhook_event(self) -> WebhookEvent:
+        return WebhookEvent(
+            trace_id="test-trace",
+            payload={"test": "data"},
+            headers={"content-type": "application/json"},
+        )
+
+    @pytest.fixture
+    def processor_manager(self) -> WebhookProcessorManager:
+        return WebhookProcessorManager(APIRouter(), SignalHandler())
+
+    @pytest.fixture
+    def processor(self, webhook_event: WebhookEvent) -> MockWebhookHandler:
+        return MockWebhookHandler(webhook_event)
+
+    async def test_successful_processing(
+        self, processor: MockWebhookHandler, processor_manager: WebhookProcessorManager
+    ) -> None:
+        """Test successful webhook processing flow."""
+        await processor_manager._process_webhook_request(processor)
+
+        assert processor.authenticated
+        assert processor.validated
+        assert processor.handled
+        assert not processor.error_handler_called
+
+    async def test_retry_mechanism(
+        self, webhook_event: WebhookEvent, processor_manager: WebhookProcessorManager
+    ) -> None:
+        """Test retry mechanism with temporary failures."""
+        processor = MockWebhookHandler(webhook_event, should_fail=True, fail_count=2)
+
+        await processor_manager._process_webhook_request(processor)
+
+        assert processor.handled
+        assert processor.current_fails == 2
+        assert processor.retry_count == 2
+        assert processor.error_handler_called
+
+    async def test_max_retries_exceeded(
+        self, webhook_event: WebhookEvent, processor_manager: WebhookProcessorManager
+    ) -> None:
+        """Test behavior when max retries are exceeded."""
+        processor = MockWebhookHandler(
+            webhook_event, should_fail=True, fail_count=2, max_retries=1
+        )
+
+        with pytest.raises(RetryableError):
+            await processor_manager._process_webhook_request(processor)
+
+        assert processor.retry_count == processor.max_retries
+        assert processor.error_handler_called
+        assert not processor.handled