port-ocean 0.18.6__py3-none-any.whl → 0.18.8__py3-none-any.whl

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/port_app_config/test_base.py

@@ -10,7 +10,7 @@ from port_ocean.context.event import EventType, event_context
 from port_ocean.exceptions.api import EmptyPortAppConfigError
 
 
-class TestPortAppConfig(BasePortAppConfig):
+class MockPortAppConfig(BasePortAppConfig):
     mock_get_port_app_config: Any
 
     async def _get_port_app_config(self) -> Dict[str, Any]:
@@ -25,15 +25,15 @@ def mock_context() -> PortOceanContext:
 
 
 @pytest.fixture
-def port_app_config_handler(mock_context: PortOceanContext) -> TestPortAppConfig:
-    handler = TestPortAppConfig(mock_context)
+def port_app_config_handler(mock_context: PortOceanContext) -> MockPortAppConfig:
+    handler = MockPortAppConfig(mock_context)
     handler.mock_get_port_app_config = MagicMock()
     return handler
 
 
 @pytest.mark.asyncio
 async def test_get_port_app_config_success(
-    port_app_config_handler: TestPortAppConfig,
+    port_app_config_handler: MockPortAppConfig,
 ) -> None:
     # Arrange
     valid_config = {
@@ -83,7 +83,7 @@ async def test_get_port_app_config_success(
 
 @pytest.mark.asyncio
 async def test_get_port_app_config_uses_cache(
-    port_app_config_handler: TestPortAppConfig,
+    port_app_config_handler: MockPortAppConfig,
 ) -> None:
     # Arrange
     valid_config = {
@@ -122,7 +122,7 @@ async def test_get_port_app_config_uses_cache(
 
 @pytest.mark.asyncio
 async def test_get_port_app_config_bypass_cache(
-    port_app_config_handler: TestPortAppConfig,
+    port_app_config_handler: MockPortAppConfig,
 ) -> None:
     # Arrange
     valid_config = {
@@ -163,7 +163,7 @@ async def test_get_port_app_config_bypass_cache(
 
 @pytest.mark.asyncio
 async def test_get_port_app_config_validation_error(
-    port_app_config_handler: TestPortAppConfig, monkeypatch: pytest.MonkeyPatch
+    port_app_config_handler: MockPortAppConfig, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     # Arrange
     invalid_config = {"invalid_field": "invalid_value"}
@@ -184,7 +184,7 @@ async def test_get_port_app_config_validation_error(
 
 @pytest.mark.asyncio
 async def test_get_port_app_config_fetch_error(
-    port_app_config_handler: TestPortAppConfig,
+    port_app_config_handler: MockPortAppConfig,
 ) -> None:
     # Arrange
     port_app_config_handler.mock_get_port_app_config.side_effect = (

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,115 @@
+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)
+
+
+@pytest.mark.skip("Skipping until fixed")
+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