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

port_ocean/context/event.py

@@ -19,6 +19,7 @@ from pydispatch import dispatcher  # type: ignore
 from werkzeug.local import LocalStack, LocalProxy
 
 from port_ocean.context.resource import resource
+from port_ocean.exceptions.api import EmptyPortAppConfigError
 from port_ocean.exceptions.context import (
     EventContextNotFoundError,
     ResourceContextNotFoundError,
@@ -176,8 +177,14 @@ async def event_context(
         logger.info("Event started")
         try:
             yield event
-        except:
+        except EmptyPortAppConfigError as e:
+            logger.error(
+                f"Skipping resync due to empty mapping: {str(e)}", exc_info=True
+            )
+            raise
+        except Exception as e:
             success = False
+            logger.error(f"Event failed with error: {str(e)}", exc_info=True)
             raise
         else:
             success = True

port_ocean/core/handlers/port_app_config/api.py

@@ -3,6 +3,7 @@ from typing import Any
 from loguru import logger
 
 from port_ocean.core.handlers.port_app_config.base import BasePortAppConfig
+from port_ocean.exceptions.api import EmptyPortAppConfigError
 
 
 class APIPortAppConfig(BasePortAppConfig):
@@ -20,7 +21,9 @@ class APIPortAppConfig(BasePortAppConfig):
         if not config:
             logger.error(
                 "The integration port app config is empty. "
+                f"Integration: {integration}, "
+                f"Config: {config}. "
                 "Please make sure to configure your port app config using Port's API."
             )
-
+            raise EmptyPortAppConfigError()
         return config

port_ocean/core/integrations/mixins/sync_raw.py

@@ -220,26 +220,32 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         )
         modified_objects = []
 
-        try:
-            changed_entities = await self._map_entities_compared_with_port(
-                objects_diff[0].entity_selector_diff.passed,
-                resource,
-                user_agent_type
-            )
-            if changed_entities:
-                logger.info("Upserting changed entities", changed_entities=len(changed_entities),
-                    total_entities=len(objects_diff[0].entity_selector_diff.passed))
-                await self.entities_state_applier.upsert(
-                    changed_entities, user_agent_type
-                )
-            else:
-                logger.info("Entities in batch didn't changed since last sync, skipping", total_entities=len(objects_diff[0].entity_selector_diff.passed))
-            modified_objects = [ocean.port_client._reduce_entity(entity) for entity in objects_diff[0].entity_selector_diff.passed]
-        except Exception as e:
-            logger.warning(f"Failed to resolve batch entities with Port, falling back to upserting all entities: {str(e)}")
-            modified_objects = await self.entities_state_applier.upsert(
-                objects_diff[0].entity_selector_diff.passed, user_agent_type
+        if event.event_type == EventType.RESYNC:
+            try:
+                changed_entities = await self._map_entities_compared_with_port(
+                    objects_diff[0].entity_selector_diff.passed,
+                    resource,
+                    user_agent_type
                 )
+                if changed_entities:
+                    logger.info("Upserting changed entities", changed_entities=len(changed_entities),
+                        total_entities=len(objects_diff[0].entity_selector_diff.passed))
+                    await self.entities_state_applier.upsert(
+                        changed_entities, user_agent_type
+                    )
+                else:
+                    logger.info("Entities in batch didn't changed since last sync, skipping", total_entities=len(objects_diff[0].entity_selector_diff.passed))
+                modified_objects = [ocean.port_client._reduce_entity(entity) for entity in objects_diff[0].entity_selector_diff.passed]
+            except Exception as e:
+                logger.warning(f"Failed to resolve batch entities with Port, falling back to upserting all entities: {str(e)}")
+                modified_objects = await self.entities_state_applier.upsert(
+                    objects_diff[0].entity_selector_diff.passed, user_agent_type
+                    )
+        else:
+           modified_objects = await self.entities_state_applier.upsert(
+                    objects_diff[0].entity_selector_diff.passed, user_agent_type
+                    )
+
 
         return CalculationResult(
             objects_diff[0].entity_selector_diff._replace(passed=modified_objects),

port_ocean/exceptions/api.py

@@ -13,3 +13,10 @@ class BaseAPIException(BaseOceanException, abc.ABC):
 class InternalServerException(BaseAPIException):
     def response(self) -> Response:
         return PlainTextResponse(content="Internal server error", status_code=500)
+
+
+class EmptyPortAppConfigError(Exception):
+    """Exception raised when the Port app configuration is empty."""
+
+    def __init__(self, message: str = "Port app config is empty") -> None:
+        super().__init__(message)

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

@@ -0,0 +1,67 @@
+import pytest
+from unittest.mock import AsyncMock
+
+from port_ocean.core.handlers.port_app_config.api import APIPortAppConfig
+from port_ocean.exceptions.api import EmptyPortAppConfigError
+
+
+@pytest.fixture
+def mock_context() -> AsyncMock:
+    context = AsyncMock()
+    context.port_client.get_current_integration = AsyncMock()
+    return context
+
+
+@pytest.fixture
+def api_config(mock_context: AsyncMock) -> APIPortAppConfig:
+    return APIPortAppConfig(mock_context)
+
+
+async def test_get_port_app_config_valid_config_returns_config(
+    api_config: APIPortAppConfig, mock_context: AsyncMock
+) -> None:
+    # Arrange
+    expected_config = {"key": "value"}
+    mock_context.port_client.get_current_integration.return_value = {
+        "config": expected_config
+    }
+
+    # Act
+    result = await api_config._get_port_app_config()
+
+    # Assert
+    assert result == expected_config
+    mock_context.port_client.get_current_integration.assert_called_once()
+
+
+async def test_get_port_app_config_empty_config_raises_value_error(
+    api_config: APIPortAppConfig, mock_context: AsyncMock
+) -> None:
+    # Arrange
+    mock_context.port_client.get_current_integration.return_value = {"config": {}}
+
+    # Act & Assert
+    with pytest.raises(EmptyPortAppConfigError, match="Port app config is empty"):
+        await api_config._get_port_app_config()
+
+
+async def test_get_port_app_config_missing_config_key_raises_key_error(
+    api_config: APIPortAppConfig, mock_context: AsyncMock
+) -> None:
+    # Arrange
+    mock_context.port_client.get_current_integration.return_value = {}
+
+    # Act & Assert
+    with pytest.raises(KeyError):
+        await api_config._get_port_app_config()
+
+
+async def test_get_port_app_config_empty_integration_raises_key_error(
+    api_config: APIPortAppConfig, mock_context: AsyncMock
+) -> None:
+    # Arrange
+    mock_context.port_client.get_current_integration.return_value = {}
+
+    # Act & Assert
+    with pytest.raises(KeyError):
+        await api_config._get_port_app_config()

port_ocean/tests/core/handlers/port_app_config/test_base.py

@@ -0,0 +1,197 @@
+import pytest
+from unittest.mock import MagicMock
+from pydantic import ValidationError
+from typing import Any, Dict
+
+from port_ocean.context.ocean import PortOceanContext
+from port_ocean.core.handlers.port_app_config.base import BasePortAppConfig
+from port_ocean.core.handlers.port_app_config.models import PortAppConfig
+from port_ocean.context.event import EventType, event_context
+from port_ocean.exceptions.api import EmptyPortAppConfigError
+
+
+class TestPortAppConfig(BasePortAppConfig):
+    mock_get_port_app_config: Any
+
+    async def _get_port_app_config(self) -> Dict[str, Any]:
+        return self.mock_get_port_app_config()
+
+
+@pytest.fixture
+def mock_context() -> PortOceanContext:
+    context = MagicMock(spec=PortOceanContext)
+    context.config.port.port_app_config_cache_ttl = 300  # 5 minutes
+    return context
+
+
+@pytest.fixture
+def port_app_config_handler(mock_context: PortOceanContext) -> TestPortAppConfig:
+    handler = TestPortAppConfig(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,
+) -> None:
+    # Arrange
+    valid_config = {
+        "resources": [
+            {
+                "kind": "repository",
+                "selector": {"query": "true"},
+                "port": {
+                    "entity": {
+                        "mappings": {
+                            "identifier": ".name",
+                            "title": ".name",
+                            "blueprint": '"service"',
+                            "properties": {
+                                "description": ".description",
+                                "url": ".html_url",
+                                "defaultBranch": ".default_branch",
+                            },
+                        }
+                    }
+                },
+            }
+        ]
+    }
+    port_app_config_handler.mock_get_port_app_config.return_value = valid_config
+
+    # Act
+    async with event_context(EventType.RESYNC, trigger_type="machine"):
+        result = await port_app_config_handler.get_port_app_config()
+
+    # Assert
+    assert isinstance(result, PortAppConfig)
+    assert result.resources[0].port.entity.mappings.title == ".name"
+    assert result.resources[0].port.entity.mappings.identifier == ".name"
+    assert result.resources[0].port.entity.mappings.blueprint == '"service"'
+    assert (
+        result.resources[0].port.entity.mappings.properties["description"]
+        == ".description"
+    )
+    assert result.resources[0].port.entity.mappings.properties["url"] == ".html_url"
+    assert (
+        result.resources[0].port.entity.mappings.properties["defaultBranch"]
+        == ".default_branch"
+    )
+    port_app_config_handler.mock_get_port_app_config.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_get_port_app_config_uses_cache(
+    port_app_config_handler: TestPortAppConfig,
+) -> None:
+    # Arrange
+    valid_config = {
+        "resources": [
+            {
+                "kind": "repository",
+                "selector": {"query": "true"},
+                "port": {
+                    "entity": {
+                        "mappings": {
+                            "identifier": ".name",
+                            "title": ".name",
+                            "blueprint": '"service"',
+                            "properties": {
+                                "description": ".description",
+                                "url": ".html_url",
+                                "defaultBranch": ".default_branch",
+                            },
+                        }
+                    }
+                },
+            }
+        ]
+    }
+    port_app_config_handler.mock_get_port_app_config.return_value = valid_config
+
+    # Act
+    async with event_context(EventType.RESYNC, trigger_type="machine"):
+        result1 = await port_app_config_handler.get_port_app_config()
+        result2 = await port_app_config_handler.get_port_app_config()
+
+        # Assert
+        assert result1 == result2
+        port_app_config_handler.mock_get_port_app_config.assert_called_once()  # Called only once due to caching
+
+
+@pytest.mark.asyncio
+async def test_get_port_app_config_bypass_cache(
+    port_app_config_handler: TestPortAppConfig,
+) -> None:
+    # Arrange
+    valid_config = {
+        "resources": [
+            {
+                "kind": "repository",
+                "selector": {"query": "true"},
+                "port": {
+                    "entity": {
+                        "mappings": {
+                            "identifier": ".name",
+                            "title": ".name",
+                            "blueprint": '"service"',
+                            "properties": {
+                                "description": ".description",
+                                "url": ".html_url",
+                                "defaultBranch": ".default_branch",
+                            },
+                        }
+                    }
+                },
+            }
+        ]
+    }
+    port_app_config_handler.mock_get_port_app_config.return_value = valid_config
+
+    # Act
+    async with event_context(EventType.RESYNC, trigger_type="machine"):
+        result1 = await port_app_config_handler.get_port_app_config()
+        result2 = await port_app_config_handler.get_port_app_config(use_cache=False)
+
+        # Assert
+        assert result1 == result2
+        assert (
+            port_app_config_handler.mock_get_port_app_config.call_count == 2
+        )  # Called twice due to cache bypass
+
+
+@pytest.mark.asyncio
+async def test_get_port_app_config_validation_error(
+    port_app_config_handler: TestPortAppConfig, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # Arrange
+    invalid_config = {"invalid_field": "invalid_value"}
+    port_app_config_handler.mock_get_port_app_config.return_value = invalid_config
+
+    def mock_parse_obj(*args: Any, **kwargs: Any) -> None:
+        raise ValidationError(errors=[], model=PortAppConfig)
+
+    monkeypatch.setattr(
+        port_app_config_handler.CONFIG_CLASS, "parse_obj", mock_parse_obj
+    )
+
+    # Act & Assert
+    with pytest.raises(ValidationError):
+        async with event_context(EventType.RESYNC, trigger_type="machine"):
+            await port_app_config_handler.get_port_app_config()
+
+
+@pytest.mark.asyncio
+async def test_get_port_app_config_fetch_error(
+    port_app_config_handler: TestPortAppConfig,
+) -> None:
+    # Arrange
+    port_app_config_handler.mock_get_port_app_config.side_effect = (
+        EmptyPortAppConfigError("Port app config is empty")
+    )
+
+    # Act & Assert
+    async with event_context(EventType.RESYNC, trigger_type="machine"):
+        with pytest.raises(EmptyPortAppConfigError, match="Port app config is empty"):
+            await port_app_config_handler.get_port_app_config()

{port_ocean-0.18.4.dist-info → port_ocean-0.18.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.18.4
+Version: 0.18.6
 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.4.dist-info → port_ocean-0.18.6.dist-info}/RECORD

@@ -63,7 +63,7 @@ port_ocean/config/settings.py,sha256=q5KgDIr8snIxejoKyWSyf21R_AYEEXiEd3-ry9qf3ss
 port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=tf254jMqBW1GBmYDhfXMCkOqHA7C_chaYp1OY3Dfnsg,5869
+port_ocean/context/event.py,sha256=QK2ben4fJtxdorq_yRroATttP0DRc4wLtlUJ1as5D58,6208
 port_ocean/context/ocean.py,sha256=0kgIi0zAsGarF52Qehu4bOxnAFEb0yayzG7xZioMHJc,4993
 port_ocean/context/resource.py,sha256=yDj63URzQelj8zJPh4BAzTtPhpKr9Gw9DRn7I_0mJ1s,1692
 port_ocean/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -91,7 +91,7 @@ port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybe
 port_ocean/core/handlers/entity_processor/base.py,sha256=udR0w5TstTOS5xOfTjAZIEdldn4xr6Oyb3DylatYX3Q,1869
 port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=C6zJbS3miKyDeXiEV-0t5vJvkEznOeXRZFFOnwJcNdA,11714
 port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iEgEeXtn2pRMrT4Dze5r1Ixbk,134
-port_ocean/core/handlers/port_app_config/api.py,sha256=6VbKPwFzsWG0IYsVD81hxSmfqtHUFqrfUuj1DBX5g4w,853
+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/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
@@ -102,7 +102,7 @@ port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4
 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_raw.py,sha256=xDGz4pOfpd6G_pMQveEHQCDdOTk-Uun_aP0G_0IxsDA,24784
 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
@@ -110,7 +110,7 @@ port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN
 port_ocean/core/utils/utils.py,sha256=HmumOeH27N0NX1_OP3t4oGKt074ht9XyXhvfZ5I05s4,6474
 port_ocean/debug_cli.py,sha256=gHrv-Ey3cImKOcGZpjoHlo4pa_zfmyOl6TUM4o9VtcA,96
 port_ocean/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/exceptions/api.py,sha256=TLmTMqn4uHGaHgZK8PMIJ0TVJlPB4iP7xl9rx7GtCyY,426
+port_ocean/exceptions/api.py,sha256=1JcA-H12lhSgolMEA6dM4JMbDrh9sYDcE7oydPSTuK8,649
 port_ocean/exceptions/base.py,sha256=uY4DX7fIITDFfemCJDWpaZi3bD51lcANc5swpoNvMJA,46
 port_ocean/exceptions/clients.py,sha256=LKLLs-Zy3caNG85rwxfOw2rMr8qqVV6SHUq4fRCZ99U,180
 port_ocean/exceptions/context.py,sha256=mA8HII6Rl4QxKUz98ppy1zX3kaziaen21h1ZWuU3ADc,372
@@ -135,7 +135,9 @@ port_ocean/tests/clients/port/mixins/test_organization_mixin.py,sha256=-8iHM33Oe
 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/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/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
@@ -160,8 +162,8 @@ port_ocean/utils/repeat.py,sha256=0EFWM9d8lLXAhZmAyczY20LAnijw6UbIECf5lpGbOas,32
 port_ocean/utils/signal.py,sha256=K-6kKFQTltcmKDhtyZAcn0IMa3sUpOHGOAUdWKgx0_E,1369
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.18.4.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.18.4.dist-info/METADATA,sha256=qe_3HL2F4NgoCId8n4gmLPqVUGKaOTU11XC05vMPO8I,6669
-port_ocean-0.18.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.18.4.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.18.4.dist-info/RECORD,,
+port_ocean-0.18.6.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.18.6.dist-info/METADATA,sha256=71enLFwwGK7wlTo-ETXIVzGAtGQ5VHEFfs0y75kAtP0,6669
+port_ocean-0.18.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.18.6.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.18.6.dist-info/RECORD,,