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

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

@@ -0,0 +1,391 @@
+import asyncio
+import pytest
+from fastapi import APIRouter
+from typing import Dict, Any
+
+from port_ocean.exceptions.webhook_processor import RetryableError
+from port_ocean.core.handlers.webhook.processor_manager import WebhookProcessorManager
+from port_ocean.core.handlers.webhook.abstract_webhook_processor import (
+    AbstractWebhookProcessor,
+)
+from port_ocean.core.handlers.webhook.webhook_event import (
+    WebhookEvent,
+)
+from port_ocean.core.handlers.queue import LocalQueue
+from port_ocean.utils.signal import SignalHandler
+
+
+class MockWebhookProcessor(AbstractWebhookProcessor):
+    def __init__(self, event: WebhookEvent) -> None:
+        super().__init__(event)
+        self.processed = False
+        self.cancel_called = False
+        self.error_to_raise: Exception | asyncio.CancelledError | None = None
+        self.retry_count = 0
+        self.max_retries = 3
+
+    async def authenticate(
+        self, payload: Dict[str, Any], headers: Dict[str, str]
+    ) -> bool:
+        return True
+
+    async def validate_payload(self, payload: Dict[str, Any]) -> bool:
+        return True
+
+    async def handle_event(self, payload: Dict[str, Any]) -> None:
+        if self.error_to_raise:
+            raise self.error_to_raise
+        self.processed = True
+
+    async def cancel(self) -> None:
+        self.cancel_called = True
+
+
+class RetryableProcessor(MockWebhookProcessor):
+    def __init__(self, event: WebhookEvent) -> None:
+        super().__init__(event)
+        self.attempt_count = 0
+
+    async def handle_event(self, payload: Dict[str, Any]) -> None:
+        self.attempt_count += 1
+        if self.attempt_count < 3:  # Succeed on third attempt
+            raise RetryableError("Temporary failure")
+        self.processed = True
+
+
+class TestableWebhookProcessorManager(WebhookProcessorManager):
+    __test__ = False
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.running_processors: list[AbstractWebhookProcessor] = []
+        self.no_matching_processors: bool = False
+
+    def _extract_matching_processors(
+        self, event: WebhookEvent, path: str
+    ) -> list[AbstractWebhookProcessor]:
+        try:
+            return super()._extract_matching_processors(event, path)
+        except ValueError:
+            self.no_matching_processors = True
+            raise
+
+    async def _process_single_event(
+        self, processor: AbstractWebhookProcessor, path: str
+    ) -> None:
+        self.running_processors.append(processor)
+        await super()._process_single_event(processor, path)
+
+
+class TestWebhookProcessorManager:
+    @pytest.fixture
+    def router(self) -> APIRouter:
+        return APIRouter()
+
+    @pytest.fixture
+    def signal_handler(self) -> SignalHandler:
+        return SignalHandler()
+
+    @pytest.fixture
+    def processor_manager(
+        self, router: APIRouter, signal_handler: SignalHandler
+    ) -> TestableWebhookProcessorManager:
+        return TestableWebhookProcessorManager(router, signal_handler)
+
+    @pytest.fixture
+    def mock_event(self) -> WebhookEvent:
+        return WebhookEvent.from_dict(
+            {
+                "payload": {"test": "data"},
+                "headers": {"content-type": "application/json"},
+                "trace_id": "test-trace",
+            }
+        )
+
+    @staticmethod
+    def assert_event_processed_successfully(
+        processor: MockWebhookProcessor,
+    ) -> None:
+        """Assert that a processor's event was processed successfully"""
+        assert processor.processed, "Event was not processed successfully"
+
+    @staticmethod
+    def assert_event_processed_with_error(processor: MockWebhookProcessor) -> None:
+        """Assert that an event was processed with an error"""
+        assert not processor.processed, "Event did not fail as expected"
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_register_handler(
+        self, processor_manager: TestableWebhookProcessorManager
+    ) -> None:
+        """Test registering a processor for a path."""
+        processor_manager.register_processor("/test", MockWebhookProcessor)
+        assert "/test" in processor_manager._processors
+        assert len(processor_manager._processors["/test"]) == 1
+        assert isinstance(processor_manager._event_queues["/test"], LocalQueue)
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_register_multiple_handlers_with_filters(
+        self, processor_manager: TestableWebhookProcessorManager
+    ) -> None:
+        """Test registering multiple processors with different filters."""
+
+        def filter1(e: WebhookEvent) -> bool:
+            return e.payload.get("type") == "type1"
+
+        def filter2(e: WebhookEvent) -> bool:
+            return e.payload.get("type") == "type2"
+
+        processor_manager.register_processor("/test", MockWebhookProcessor, filter1)
+        processor_manager.register_processor("/test", MockWebhookProcessor, filter2)
+
+        assert len(processor_manager._processors["/test"]) == 2
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_successful_event_processing(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test successful processing of an event."""
+        processed_events: list[MockWebhookProcessor] = []
+
+        class SuccessProcessor(MockWebhookProcessor):
+            async def handle_event(self, payload: Dict[str, Any]) -> None:
+                self.processed = True
+                processed_events.append(self)
+
+        processor_manager.register_processor("/test", SuccessProcessor)
+
+        await processor_manager.start_processing_event_messages()
+        await processor_manager._event_queues["/test"].put(mock_event)
+
+        # Allow time for processing
+        await asyncio.sleep(0.1)
+
+        # Verify at least one processor ran and completed successfully
+        assert len(processed_events) > 0
+        for processor in processed_events:
+            self.assert_event_processed_successfully(processor)
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_graceful_shutdown(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test graceful shutdown with in-flight requests"""
+        processor_manager.register_processor("/test", MockWebhookProcessor)
+
+        await processor_manager.start_processing_event_messages()
+        await processor_manager._event_queues["/test"].put(mock_event)
+
+        # Start shutdown
+        await processor_manager.shutdown()
+
+        # Verify all tasks are cleaned up
+        assert len(processor_manager._webhook_processor_tasks) == 0
+        self.assert_event_processed_successfully(
+            processor_manager.running_processors[0]  # type: ignore
+        )
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_handler_filter_matching(
+        self, processor_manager: TestableWebhookProcessorManager
+    ) -> None:
+        """Test that processors are selected based on their filters."""
+        type1_event = WebhookEvent.from_dict(
+            {"payload": {"type": "type1"}, "headers": {}, "trace_id": "test-trace-1"}
+        )
+
+        type2_event = WebhookEvent.from_dict(
+            {"payload": {"type": "type2"}, "headers": {}, "trace_id": "test-trace-2"}
+        )
+
+        def filter1(e: WebhookEvent) -> bool:
+            return e.payload.get("type") == "type1"
+
+        def filter2(e: WebhookEvent) -> bool:
+            return e.payload.get("type") == "type2"
+
+        processor_manager.register_processor("/test", MockWebhookProcessor, filter1)
+        processor_manager.register_processor("/test", MockWebhookProcessor, filter2)
+
+        await processor_manager.start_processing_event_messages()
+
+        # Process both events
+        await processor_manager._event_queues["/test"].put(type1_event)
+        await processor_manager._event_queues["/test"].put(type2_event)
+
+        await asyncio.sleep(0.1)
+
+        # Verify both events were processed
+        self.assert_event_processed_successfully(
+            processor_manager.running_processors[0]  # type: ignore
+        )
+        self.assert_event_processed_successfully(
+            processor_manager.running_processors[1]  # type: ignore
+        )
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_handler_timeout(
+        self, router: APIRouter, signal_handler: SignalHandler, mock_event: WebhookEvent
+    ) -> None:
+        """Test processor timeout behavior."""
+
+        # Set a short timeout for testing
+        processor_manager = TestableWebhookProcessorManager(
+            router, signal_handler, max_event_processing_seconds=0.1
+        )
+
+        class TimeoutHandler(MockWebhookProcessor):
+            async def handle_event(self, payload: Dict[str, Any]) -> None:
+                await asyncio.sleep(2)  # Longer than max_handler_processing_seconds
+
+        processor_manager.register_processor("/test", TimeoutHandler)
+        await processor_manager.start_processing_event_messages()
+        await processor_manager._event_queues["/test"].put(mock_event)
+
+        # Wait long enough for the timeout to occur
+        await asyncio.sleep(0.2)
+
+        self.assert_event_processed_with_error(
+            processor_manager.running_processors[0]  # type: ignore
+        )
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_handler_cancellation(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test processor cancellation during shutdown."""
+        cancelled_events: list[WebhookEvent] = []
+
+        class CanceledHandler(MockWebhookProcessor):
+            async def handle_event(self, payload: Dict[str, Any]) -> None:
+                await asyncio.sleep(0.2)
+
+            async def cancel(self) -> None:
+                cancelled_events.append(self.event)
+                self.event.payload["canceled"] = True
+
+        processor_manager.register_processor("/test", CanceledHandler)
+        await processor_manager.start_processing_event_messages()
+        await processor_manager._event_queues["/test"].put(mock_event)
+
+        await asyncio.sleep(0.1)
+
+        # Wait for the event to be processed
+        await processor_manager._cancel_all_tasks()
+
+        # Verify at least one event was cancelled
+        assert len(cancelled_events) > 0
+        assert any(event.payload.get("canceled") for event in cancelled_events)
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_invalid_handler_registration(self) -> None:
+        """Test registration of invalid processor type."""
+        handler_manager = WebhookProcessorManager(APIRouter(), SignalHandler())
+
+        with pytest.raises(ValueError):
+            handler_manager.register_processor("/test", object)  # type: ignore
+
+    async def test_no_matching_handlers(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test behavior when no processors match the event."""
+        processor_manager.register_processor(
+            "/test", MockWebhookProcessor, lambda e: False
+        )
+
+        await processor_manager.start_processing_event_messages()
+        await processor_manager._event_queues["/test"].put(mock_event)
+
+        await asyncio.sleep(0.1)
+
+        assert processor_manager.no_matching_processors
+        assert len(processor_manager.running_processors) == 0
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_multiple_processors(
+        self, processor_manager: TestableWebhookProcessorManager
+    ) -> None:
+        # Test multiple processors for same path
+        processor_manager.register_processor("/test", MockWebhookProcessor)
+        processor_manager.register_processor("/test", MockWebhookProcessor)
+        assert len(processor_manager._processors["/test"]) == 2
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_all_matching_processors_execute(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test that all matching processors are executed even if some fail."""
+        processed_count = 0
+
+        class SuccessProcessor(MockWebhookProcessor):
+            async def handle_event(self, payload: Dict[str, Any]) -> None:
+                nonlocal processed_count
+                processed_count += 1
+                self.processed = True
+
+        class FailingProcessor(MockWebhookProcessor):
+            async def handle_event(self, payload: Dict[str, Any]) -> None:
+                raise Exception("Simulated failure")
+
+        # Register mix of successful and failing processors
+        processor_manager.register_processor("/test", SuccessProcessor)
+        processor_manager.register_processor("/test", FailingProcessor)
+        processor_manager.register_processor("/test", SuccessProcessor)
+
+        await processor_manager.start_processing_event_messages()
+        await processor_manager._event_queues["/test"].put(mock_event)
+
+        # Wait for processing to complete
+        await asyncio.sleep(0.1)
+
+        # Verify successful processors ran despite failing one
+        assert processed_count == 2
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_retry_mechanism(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test retry mechanism with temporary failures."""
+        processor = MockWebhookProcessor(mock_event)
+        processor.error_to_raise = RetryableError("Temporary failure")
+
+        # Simulate 2 failures before success
+        async def handle_event(payload: Dict[str, Any]) -> None:
+            if processor.retry_count < 2:
+                raise RetryableError("Temporary failure")
+            processor.processed = True
+
+        processor.handle_event = handle_event  # type: ignore
+
+        await processor_manager._process_webhook_request(processor)
+
+        assert processor.processed
+        assert processor.retry_count == 2
+
+    @pytest.mark.skip(reason="Temporarily ignoring this test")
+    async def test_max_retries_exceeded(
+        self,
+        processor_manager: TestableWebhookProcessorManager,
+        mock_event: WebhookEvent,
+    ) -> None:
+        """Test behavior when max retries are exceeded."""
+        processor = MockWebhookProcessor(mock_event)
+        processor.max_retries = 1
+        processor.error_to_raise = RetryableError("Temporary failure")
+
+        with pytest.raises(RetryableError):
+            await processor_manager._process_webhook_request(processor)
+
+        assert processor.retry_count == processor.max_retries

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

@@ -0,0 +1,65 @@
+import pytest
+from fastapi import Request
+from port_ocean.core.handlers.webhook.webhook_event import (
+    EventHeaders,
+    EventPayload,
+    WebhookEvent,
+)
+
+
+class TestWebhookEvent:
+    @pytest.fixture
+    def sample_payload(self) -> EventPayload:
+        return {"test": "data", "nested": {"value": 123}}
+
+    @pytest.fixture
+    def sample_headers(self) -> EventHeaders:
+        return {"content-type": "application/json", "x-test-header": "test-value"}
+
+    @pytest.fixture
+    def mock_request(
+        self, sample_payload: EventPayload, sample_headers: EventHeaders
+    ) -> Request:
+        scope = {
+            "type": "http",
+            "headers": [(k.encode(), v.encode()) for k, v in sample_headers.items()],
+        }
+        mock_request = Request(scope)
+        mock_request._json = sample_payload
+        return mock_request
+
+    @pytest.fixture
+    def webhook_event(
+        self, sample_payload: EventPayload, sample_headers: EventHeaders
+    ) -> WebhookEvent:
+        return WebhookEvent(
+            trace_id="test-trace-id",
+            payload=sample_payload,
+            headers=sample_headers,
+        )
+
+    async def test_create_from_request(self, mock_request: Request) -> None:
+        """Test creating WebhookEvent from a request."""
+        event = await WebhookEvent.from_request(mock_request)
+
+        assert event.trace_id is not None
+        assert len(event.trace_id) > 0
+        assert event.headers == dict(mock_request.headers)
+        assert event._original_request == mock_request
+
+    def test_create_from_dict(
+        self, sample_payload: EventPayload, sample_headers: EventHeaders
+    ) -> None:
+        """Test creating WebhookEvent from a dictionary."""
+        data = {
+            "trace_id": "test-trace-id",
+            "payload": sample_payload,
+            "headers": sample_headers,
+        }
+
+        event = WebhookEvent.from_dict(data)
+
+        assert event.trace_id == "test-trace-id"
+        assert event.payload == sample_payload
+        assert event.headers == sample_headers
+        assert event._original_request is None

port_ocean/utils/signal.py

@@ -1,3 +1,4 @@
+from asyncio import iscoroutinefunction
 from typing import Callable, Any
 
 from werkzeug.local import LocalProxy, LocalStack
@@ -13,13 +14,16 @@ class SignalHandler:
     def __init__(self) -> None:
         self._handlers: dict[str, Callable[[], Any]] = {}
 
-    def exit(self) -> None:
+    async def exit(self) -> None:
         """
         Handles the exit signal.
         """
         while self._handlers:
             _, handler = self._handlers.popitem()
-            handler()
+            if iscoroutinefunction(handler):
+                await handler()
+            else:
+                handler()
 
     def register(self, callback: Callable[[], Any]) -> str:
         _id = generate_uuid()

{port_ocean-0.18.5.dist-info → port_ocean-0.18.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.18.5
+Version: 0.18.7
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.18.5.dist-info → port_ocean-0.18.7.dist-info}/RECORD

@@ -64,7 +64,7 @@ port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 port_ocean/consumers/kafka_consumer.py,sha256=N8KocjBi9aR0BOPG8hgKovg-ns_ggpEjrSxqSqF_BSo,4710
 port_ocean/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/context/event.py,sha256=QK2ben4fJtxdorq_yRroATttP0DRc4wLtlUJ1as5D58,6208
-port_ocean/context/ocean.py,sha256=0kgIi0zAsGarF52Qehu4bOxnAFEb0yayzG7xZioMHJc,4993
+port_ocean/context/ocean.py,sha256=-T8Z_xcUNMeobr33TTABiOQjxC4KCVvVrP0IytRfen8,6425
 port_ocean/context/resource.py,sha256=yDj63URzQelj8zJPh4BAzTtPhpKr9Gw9DRn7I_0mJ1s,1692
 port_ocean/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/defaults/__init__.py,sha256=8qCZg8n06WAdMu9s_FiRtDYLGPGHbOuS60vapeUoAks,142
@@ -84,7 +84,7 @@ port_ocean/core/handlers/base.py,sha256=cTarblazu8yh8xz2FpB-dzDKuXxtoi143XJgPbV_
 port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r-0nzW9k78haOZNf6PX7mJOUr34A4c8,173
 port_ocean/core/handlers/entities_state_applier/base.py,sha256=5wHL0icfFAYRPqk8iV_wN49GdJ3aRUtO8tumSxBi4Wo,2268
 port_ocean/core/handlers/entities_state_applier/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=FSJ77o-lilv5tF5WgpPNjA5lAw13CseFilL-kMHIF3A,5564
+port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=6YketOyFDYrqK9tGM7FWZLO0bTXiYz0lQB-u3dyJvWw,6271
 port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py,sha256=1zncwCbE-Gej0xaWKlzZgoXxOBe9bgs_YxlZ8QW3NdI,1751
 port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=lyv6xKzhYfd6TioUgR3AVRSJqj7JpAaj1LxxU2xAqeo,1720
 port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybem9MthOs7p1Wawac87uSXz9U8,156
@@ -93,16 +93,23 @@ port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=C6zJbS3m
 port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iEgEeXtn2pRMrT4Dze5r1Ixbk,134
 port_ocean/core/handlers/port_app_config/api.py,sha256=r_Th66NEw38IpRdnXZcRvI8ACfvxW_A6V62WLwjWXlQ,1044
 port_ocean/core/handlers/port_app_config/base.py,sha256=4Nxt2g8voEIHJ4Y1Km5NJcaG2iSbCklw5P8-Kus7Y9k,3007
-port_ocean/core/handlers/port_app_config/models.py,sha256=YvYtf_44KD_rN4xK-3xHtdpRZ1M8Qo-m9K4LDtH7FYU,2344
+port_ocean/core/handlers/port_app_config/models.py,sha256=5Tt2BWHOJ4nnkh4xVrwyVG4KO5Tp4e64Cu_eFF-9jBg,2449
+port_ocean/core/handlers/queue/__init__.py,sha256=1fICM0ZLATmmj6f7cdq_eV2kmw0_jy7y2INuLQIpzIE,121
+port_ocean/core/handlers/queue/abstract_queue.py,sha256=q_gpaWFFZHxM3XovEbgsDn8jEOLM45iAZWVC81Paxto,620
+port_ocean/core/handlers/queue/local_queue.py,sha256=EzqsGIX43xbVAcePwTcCg5QDrXATQpy-VzWxxN_OyAM,574
 port_ocean/core/handlers/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
 port_ocean/core/handlers/resync_state_updater/updater.py,sha256=Yg9ET6ZV5B9GW7u6zZA6GlB_71kmvxvYX2FWgQNzMvo,3182
+port_ocean/core/handlers/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=oZvYgE3rqirx7yN0PAL-9Nls1EHLwOHQaNtFzla3Heo,3500
+port_ocean/core/handlers/webhook/processor_manager.py,sha256=B1NjvuWD5MXaW0PWxxOAkbkNfgC9oeuQreusna0EUBA,9166
+port_ocean/core/handlers/webhook/webhook_event.py,sha256=9Lk4JzHfgWNruts3pYe-t6OgaG1xP4EkD6lFr_78yUk,2210
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/integrations/base.py,sha256=eS0WDOfCTim1UOQQrNuP14I6hvT_fr8dof_cr1ls01s,3107
 port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4_RgZnwSRmTCreKcBVM,220
 port_ocean/core/integrations/mixins/events.py,sha256=0jKRsBw6lU8Mqs7MaQK4n-t_H6Z4NEkXZ5VWzqTrKEc,2396
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
-port_ocean/core/integrations/mixins/sync.py,sha256=B9fEs8faaYLLikH9GBjE_E61vo0bQDjIGQsQ1SRXOlA,3931
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=XLxH9_OOudLW4Q5lrUWWpcXIM3KdEDnYwEEP661Rfao,24465
+port_ocean/core/integrations/mixins/sync.py,sha256=GHiFbnw0XrBfl7aCTH_w67f_N7EZbcUgssc-0fPujNU,4047
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=7kk2p5lLKq9oivqqintZumuaIHSbcSmoUfWrE346l7g,24821
 port_ocean/core/integrations/mixins/utils.py,sha256=oN4Okz6xlaefpid1_Pud8HPSw9BwwjRohyNsknq-Myg,2309
 port_ocean/core/models.py,sha256=FvTp-BlpbvLbMbngE0wsiimsCfmIhUR1PvsE__Z--1I,2206
 port_ocean/core/ocean_types.py,sha256=j_-or1VxDy22whLLxwxgzIsE4wAhFLH19Xff9l4oJA8,1124
@@ -117,6 +124,7 @@ port_ocean/exceptions/context.py,sha256=mA8HII6Rl4QxKUz98ppy1zX3kaziaen21h1ZWuU3
 port_ocean/exceptions/core.py,sha256=Zmb1m6NnkSPWpAiQA5tgejm3zpDMt1WQEN47OJNo54A,856
 port_ocean/exceptions/port_defaults.py,sha256=2a7Koy541KxMan33mU-gbauUxsumG3NT4itVxSpQqfw,666
 port_ocean/exceptions/utils.py,sha256=gjOqpi-HpY1l4WlMFsGA9yzhxDhajhoGGdDDyGbLnqI,197
+port_ocean/exceptions/webhook_processor.py,sha256=yQYazg53Y-ohb7HfViwq1opH_ZUuUdhHSRxcUNveFpI,114
 port_ocean/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/helpers/async_client.py,sha256=SRlP6o7_FCSY3UHnRlZdezppePVxxOzZ0z861vE3K40,1783
 port_ocean/helpers/retry.py,sha256=fmvaUFLIW6PICgYH4RI5rrKBXDxCAhR1Gtl0dsb2kMs,15625
@@ -125,7 +133,7 @@ port_ocean/log/handlers.py,sha256=ncVjgqrZRh6BhyRrA6DQG86Wsbxph1yWYuEC0cWfe-Q,36
 port_ocean/log/logger_setup.py,sha256=CoEDowe5OwNOL_5clU6Z4faktfh0VWaOTS0VLmyhHjw,2404
 port_ocean/log/sensetive.py,sha256=lVKiZH6b7TkrZAMmhEJRhcl67HNM94e56x12DwFgCQk,2920
 port_ocean/middlewares.py,sha256=9wYCdyzRZGK1vjEJ28FY_DkfwDNENmXp504UKPf5NaQ,2727
-port_ocean/ocean.py,sha256=XxO-aRExs1hcy6aJY_nceu-QXRWB2ZLpkIPPuBkp-bQ,5247
+port_ocean/ocean.py,sha256=MmLGxx0EC3Q6FEpbnZc9_5A7DculsvN2nAz3aZkj2kI,5536
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=COoRSmLG4hbsjIW5DzhV0NYVegI9xHd1POv6sg4U1No,2217
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
@@ -134,10 +142,15 @@ port_ocean/tests/clients/port/mixins/test_entities.py,sha256=A9myrnkLhKSQrnOLv1Z
 port_ocean/tests/clients/port/mixins/test_organization_mixin.py,sha256=-8iHM33Oe8PuyEfj3O_6Yob8POp4fSmB0hnIT0Gv-8Y,868
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
 port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcGsYZ2SCe_PYX5vLYM,5560
+port_ocean/tests/core/handlers/entities_state_applier/test_applier.py,sha256=R9bqyJocUWTh0NW0s-5ttD_SYYeM5EbYILgVmgWa7qA,2776
 port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=FnEnaDjuoAbKvKyv6xJ46n3j0ZcaT70Sg2zc7oy7HAA,13596
-port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=SSf1ZRZVcIta9zfx2-SpYFc_-MoHPDJSa1MkbIx3icI,31172
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=gxQ4e9hQuMS8-o5UbiUSt1I1uaK0DCO3yCFDVigpZvo,31740
 port_ocean/tests/core/handlers/port_app_config/test_api.py,sha256=eJZ6SuFBLz71y4ca3DNqKag6d6HUjNJS0aqQPwiLMTI,1999
 port_ocean/tests/core/handlers/port_app_config/test_base.py,sha256=s3D98JP3YV9V6T5PCDPE2852gkqGiDmo03UyexESX_I,6872
+port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
+port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=pMETxEW98FCpPs28VGKTtueRwA5ka4Z3--4CJpfNi2U,3911
+port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=k7ZjegY4qSfkf5uRqdSpc_v8RhObE_20wd1AwrO08Q4,14976
+port_ocean/tests/core/handlers/webhook/test_webhook_event.py,sha256=yfsXuJzwEe9WYzyhWwT2IOEwwD9dHtKp_ufREM5v_DI,2090
 port_ocean/tests/core/test_utils.py,sha256=Z3kdhb5V7Svhcyy3EansdTpgHL36TL6erNtU-OPwAcI,2647
 port_ocean/tests/core/utils/test_entity_topological_sorter.py,sha256=zuq5WSPy_88PemG3mOUIHTxWMR_js1R7tOzUYlgBd68,3447
 port_ocean/tests/core/utils/test_resolve_entities_diff.py,sha256=4kTey1c0dWKbLXjJ-9m2GXrHyAWZeLQ2asdtYRRUdRs,16573
@@ -159,11 +172,11 @@ port_ocean/utils/cache.py,sha256=RgfN4SjjHrEkbqUChyboeD1mrXomolUUjsJtvbkmr3U,335
 port_ocean/utils/misc.py,sha256=0q2cJ5psqxn_5u_56pT7vOVQ3shDM02iC1lzyWQ_zl0,2098
 port_ocean/utils/queue_utils.py,sha256=KWWl8YVnG-glcfIHhM6nefY-2sou_C6DVP1VynQwzB4,2762
 port_ocean/utils/repeat.py,sha256=0EFWM9d8lLXAhZmAyczY20LAnijw6UbIECf5lpGbOas,3231
-port_ocean/utils/signal.py,sha256=K-6kKFQTltcmKDhtyZAcn0IMa3sUpOHGOAUdWKgx0_E,1369
+port_ocean/utils/signal.py,sha256=mMVq-1Ab5YpNiqN4PkiyTGlV_G0wkUDMMjTZp5z3pb0,1514
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.18.5.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.18.5.dist-info/METADATA,sha256=qIcD5yXlV1899BUdBrFNoPzqda6yrqyrQFG27dZoOoc,6669
-port_ocean-0.18.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.18.5.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.18.5.dist-info/RECORD,,
+port_ocean-0.18.7.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.18.7.dist-info/METADATA,sha256=ZWM3fXr54v89kiXWYwF3y6PHl28sjSUuf6BRV2PVAyI,6669
+port_ocean-0.18.7.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.18.7.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.18.7.dist-info/RECORD,,