port-ocean 0.18.3__tar.gz → 0.18.5__tar.gz

{port_ocean-0.18.3 → port_ocean-0.18.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.18.3
+Version: 0.18.5
 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.3 → port_ocean-0.18.5}/port_ocean/clients/port/mixins/entities.py

@@ -22,7 +22,9 @@ class EntityClientMixin:
         # Semaphore is used to limit the number of concurrent requests to port, to avoid overloading it.
         # The number of concurrent requests is set to 90% of the max connections limit, to leave some room for other
         # requests that are not related to entities.
-        self.semaphore = asyncio.Semaphore(round(0.9 * PORT_HTTP_MAX_CONNECTIONS_LIMIT))
+        self.semaphore = asyncio.Semaphore(
+            round(0.5 * PORT_HTTP_MAX_CONNECTIONS_LIMIT)
+        )  # 50% of the max connections limit in order to avoid overloading port
 
     async def upsert_entity(
         self,

{port_ocean-0.18.3 → port_ocean-0.18.5}/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-0.18.3 → port_ocean-0.18.5}/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-0.18.3 → port_ocean-0.18.5}/port_ocean/core/integrations/mixins/sync_raw.py

@@ -220,33 +220,27 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         )
         modified_objects = []
 
-        if ocean.app.is_saas():
-            try:
-                changed_entities = await self._map_entities_compared_with_port(
-                    objects_diff[0].entity_selector_diff.passed,
-                    resource,
-                    user_agent_type
+        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
                 )
-
-                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:
+            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
-        )
+                )
+
         return CalculationResult(
             objects_diff[0].entity_selector_diff._replace(passed=modified_objects),
             errors=objects_diff[0].errors,

{port_ocean-0.18.3 → port_ocean-0.18.5}/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-0.18.3 → port_ocean-0.18.5}/port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -433,93 +433,76 @@ async def test_sync_raw_mixin_dependency(
 @pytest.mark.asyncio
 async def test_register_raw(
     mock_sync_raw_mixin_with_jq_processor: SyncRawMixin,
-    mock_ocean: Ocean,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
+    mock_resource_config: ResourceConfig,
 ) -> None:
-    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"},
-        },
-    ]
-
-    # Set is_saas to False
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: False)
-
-    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=[
-                    ResourceConfig(
-                        kind=kind,
-                        selector=Selector(query="true"),
-                        port=PortResourceConfig(
-                            entity=MappingsConfig(
-                                mappings=EntityMapping(
-                                    identifier=".id | tostring",
-                                    title=".name",
-                                    blueprint='"service"',
-                                    properties={"url": ".web_url"},
-                                    relations={},
-                                )
-                            )
-                        ),
-                    )
-                ],
-            ),
-        ):
-            # 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
+    # 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": {},
+            },
+        ]
 
-            # Patch the upsert method with the side effect
+        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.entities_state_applier,
-                "upsert",
-                side_effect=upsert_side_effect,
+                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],
+                ),
             ):
-                # Call the register_raw method
-                registered_entities = (
-                    await mock_sync_raw_mixin_with_jq_processor.register_raw(
-                        kind, raw_entity, user_agent_type
-                    )
+                # 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
                 )
 
-                # 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"]
+                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
+                        )
+                    )
+
+                    # 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
 async def test_unregister_raw(
     mock_sync_raw_mixin_with_jq_processor: SyncRawMixin,
-    mock_ocean: Ocean,
     mock_context: PortOceanContext,
     monkeypatch: pytest.MonkeyPatch,
+    mock_resource_config: ResourceConfig,
 ) -> None:
     kind = "service"
     user_agent_type = UserAgentType.exporter
@@ -547,23 +530,7 @@ async def test_unregister_raw(
                 enable_merge_entity=True,
                 delete_dependent_entities=True,
                 create_missing_related_entities=False,
-                resources=[
-                    ResourceConfig(
-                        kind=kind,
-                        selector=Selector(query="true"),
-                        port=PortResourceConfig(
-                            entity=MappingsConfig(
-                                mappings=EntityMapping(
-                                    identifier=".id | tostring",
-                                    title=".name",
-                                    blueprint='"service"',
-                                    properties={"url": ".web_url"},
-                                    relations={},
-                                )
-                            )
-                        ),
-                    )
-                ],
+                resources=[mock_resource_config],
             ),
         ):
             # Ensure the event.port_app_config is set correctly
@@ -718,142 +685,92 @@ class CalculationResult:
 
 
 @pytest.mark.asyncio
-async def test_register_resource_raw_saas_no_changes_upsert_not_called_entitiy_is_returned(
-    mock_sync_raw_mixin: SyncRawMixin,
-    mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: True)
-
-    # Mock dependencies
-    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()
-
-
-@pytest.mark.asyncio
-async def test_register_resource_raw_saas_with_changes_upsert_called_and_entities_are_mapped(
+async def test_register_resource_raw_no_changes_upsert_not_called_entitiy_is_returned(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: True)
-
-    # Mock dependencies
-    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,
-        )
+    # 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,
+            )
 
-        # 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_not_called()
+            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
 
 
 @pytest.mark.asyncio
-async def test_register_resource_raw_non_saas_upsert_called_and_no_entitites_diff_calculation(
+async def test_register_resource_raw_with_changes_upsert_called_and_entities_are_mapped(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: False)
-
-    # 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.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,
-        )
+    # 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,
+            )
 
-        # 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()
+            # 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_saas_with_errors(
-    mock_sync_raw_mixin: SyncRawMixin,
-    mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
+async def test_register_resource_raw_with_errors(
+    mock_sync_raw_mixin: SyncRawMixin, mock_port_app_config: PortAppConfig
 ) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: True)
-
-    # Mock dependencies
-    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,
-        )
+    # 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,
+            )
 
-        # 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) == 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()

port_ocean-0.18.5/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()