port-ocean 0.5.5__py3-none-any.whl → 0.17.8__py3-none-any.whl

port_ocean/run.py

@@ -1,3 +1,4 @@
+import asyncio
 from inspect import getmembers
 from typing import Dict, Any, Type
 
@@ -8,9 +9,11 @@ from port_ocean.bootstrap import create_default_app
 from port_ocean.config.dynamic import default_config_factory
 from port_ocean.config.settings import ApplicationSettings, LogLevelType
 from port_ocean.core.defaults.initialize import initialize_defaults
+from port_ocean.core.utils.utils import validate_integration_runtime
 from port_ocean.log.logger_setup import setup_logger
 from port_ocean.ocean import Ocean
 from port_ocean.utils.misc import get_spec_file, load_module
+from port_ocean.utils.signal import init_signal_handler
 
 
 def _get_default_config_factory() -> None | Type[BaseModel]:
@@ -31,6 +34,7 @@ def run(
 ) -> None:
     application_settings = ApplicationSettings(log_level=log_level, port=port)
 
+    init_signal_handler()
     setup_logger(
         application_settings.log_level,
         enable_http_handler=application_settings.enable_http_logging,
@@ -45,13 +49,14 @@ def run(
         "app", default_app
     )
 
+    # Validate that the current integration's runtime matches the execution parameters
+    asyncio.get_event_loop().run_until_complete(
+        validate_integration_runtime(app.port_client, app.config.runtime)
+    )
+
     # Override config with arguments
     if initialize_port_resources is not None:
         app.config.initialize_port_resources = initialize_port_resources
-
-    if app.config.initialize_port_resources:
-        initialize_defaults(
-            app.integration.AppConfigHandlerClass.CONFIG_CLASS, app.config
-        )
+    initialize_defaults(app.integration.AppConfigHandlerClass.CONFIG_CLASS, app.config)
 
     uvicorn.run(app, host="0.0.0.0", port=application_settings.port)

port_ocean/tests/clients/port/mixins/test_entities.py

@@ -0,0 +1,53 @@
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+
+from port_ocean.clients.port.mixins.entities import EntityClientMixin
+from port_ocean.core.models import Entity
+from httpx import ReadTimeout
+
+
+errored_entity_identifier: str = "a"
+expected_result_entities = [
+    Entity(identifier="b", blueprint="b"),
+    Entity(identifier="c", blueprint="c"),
+]
+all_entities = [
+    Entity(identifier=errored_entity_identifier, blueprint="a")
+] + expected_result_entities
+
+
+async def mock_upsert_entity(entity: Entity, *args: Any, **kwargs: Any) -> Entity:
+    if entity.identifier == errored_entity_identifier:
+        raise ReadTimeout("")
+    else:
+        return entity
+
+
+@pytest.fixture
+async def entity_client(monkeypatch: Any) -> EntityClientMixin:
+    # Arrange
+    entity_client = EntityClientMixin(auth=MagicMock(), client=MagicMock())
+    monkeypatch.setattr(entity_client, "upsert_entity", mock_upsert_entity)
+
+    return entity_client
+
+
+async def test_batch_upsert_entities_read_timeout_should_raise_false(
+    entity_client: EntityClientMixin,
+) -> None:
+    result_entities = await entity_client.batch_upsert_entities(
+        entities=all_entities, request_options=MagicMock(), should_raise=False
+    )
+
+    assert result_entities == expected_result_entities
+
+
+async def test_batch_upsert_entities_read_timeout_should_raise_true(
+    entity_client: EntityClientMixin,
+) -> None:
+    with pytest.raises(ReadTimeout):
+        await entity_client.batch_upsert_entities(
+            entities=all_entities, request_options=MagicMock(), should_raise=True
+        )

port_ocean/tests/conftest.py

@@ -0,0 +1,4 @@
+# ruff: noqa
+from port_ocean.tests.helpers.fixtures import (
+    port_client_for_fake_integration,
+)

port_ocean/tests/core/defaults/test_common.py

@@ -0,0 +1,166 @@
+import pytest
+import json
+from unittest.mock import patch
+from pathlib import Path
+from port_ocean.core.handlers.port_app_config.models import PortAppConfig
+from port_ocean.core.defaults.common import (
+    get_port_integration_defaults,
+    Defaults,
+)
+
+
+@pytest.fixture
+def setup_mock_directories(tmp_path: Path) -> tuple[Path, Path, Path]:
+    # Create .port/resources with sample files
+    default_dir = tmp_path / ".port/resources"
+    default_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create mock JSON and YAML files with expected content
+    (default_dir / "blueprints.json").write_text(
+        json.dumps(
+            [
+                {
+                    "identifier": "mock-identifier",
+                    "title": "mock-title",
+                    "icon": "mock-icon",
+                    "schema": {
+                        "type": "object",
+                        "properties": {"key": {"type": "string"}},
+                    },
+                }
+            ]
+        )
+    )
+    (default_dir / "port-app-config.json").write_text(
+        json.dumps(
+            {
+                "resources": [
+                    {
+                        "kind": "mock-kind",
+                        "selector": {"query": "true"},
+                        "port": {
+                            "entity": {
+                                "mappings": {
+                                    "identifier": ".id",
+                                    "title": ".title",
+                                    "blueprint": '"mock-identifier"',
+                                }
+                            }
+                        },
+                    }
+                ]
+            }
+        )
+    )
+
+    # Create .port/custom_resources with different sample files
+    custom_resources_dir = tmp_path / ".port/custom_resources"
+    custom_resources_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create mock JSON and YAML files with expected content
+    (custom_resources_dir / "blueprints.json").write_text(
+        json.dumps(
+            [
+                {
+                    "identifier": "mock-custom-identifier",
+                    "title": "mock-custom-title",
+                    "icon": "mock-custom-icon",
+                    "schema": {
+                        "type": "object",
+                        "properties": {"key": {"type": "string"}},
+                    },
+                }
+            ]
+        )
+    )
+    (custom_resources_dir / "port-app-config.json").write_text(
+        json.dumps(
+            {
+                "resources": [
+                    {
+                        "kind": "mock-custom-kind",
+                        "selector": {"query": "true"},
+                        "port": {
+                            "entity": {
+                                "mappings": {
+                                    "identifier": ".id",
+                                    "title": ".title",
+                                    "blueprint": '"mock-custom-identifier"',
+                                }
+                            }
+                        },
+                    }
+                ]
+            }
+        )
+    )
+
+    # Define the non-existing directory path
+    non_existing_dir = tmp_path / ".port/do_not_exist"
+
+    return default_dir, custom_resources_dir, non_existing_dir
+
+
+def test_custom_defaults_dir_used_if_valid(
+    setup_mock_directories: tuple[Path, Path, Path]
+) -> None:
+    # Arrange
+    _, custom_resources_dir, _ = setup_mock_directories
+
+    with (
+        patch("port_ocean.core.defaults.common.is_valid_dir") as mock_is_valid_dir,
+        patch(
+            "pathlib.Path.iterdir",
+            return_value=custom_resources_dir.iterdir(),
+        ),
+    ):
+        mock_is_valid_dir.side_effect = lambda path: path == custom_resources_dir
+
+        # Act
+        defaults = get_port_integration_defaults(
+            port_app_config_class=PortAppConfig,
+            custom_defaults_dir=".port/custom_resources",
+            base_path=custom_resources_dir.parent.parent,
+        )
+
+        # Assert
+        assert isinstance(defaults, Defaults)
+        assert defaults.blueprints[0].get("identifier") == "mock-custom-identifier"
+        assert defaults.port_app_config is not None
+        assert defaults.port_app_config.resources[0].kind == "mock-custom-kind"
+
+
+def test_fallback_to_default_dir_if_custom_dir_invalid(
+    setup_mock_directories: tuple[Path, Path, Path]
+) -> None:
+    resources_dir, _, non_existing_dir = setup_mock_directories
+
+    # Arrange
+    with (
+        patch("port_ocean.core.defaults.common.is_valid_dir") as mock_is_valid_dir,
+        patch("pathlib.Path.iterdir", return_value=resources_dir.iterdir()),
+    ):
+
+        mock_is_valid_dir.side_effect = lambda path: path == resources_dir
+
+        # Act
+        custom_defaults_dir = str(non_existing_dir.relative_to(resources_dir.parent))
+        defaults = get_port_integration_defaults(
+            port_app_config_class=PortAppConfig,
+            custom_defaults_dir=custom_defaults_dir,
+            base_path=resources_dir.parent.parent,
+        )
+
+        # Assert
+        assert isinstance(defaults, Defaults)
+        assert defaults.blueprints[0].get("identifier") == "mock-identifier"
+        assert defaults.port_app_config is not None
+        assert defaults.port_app_config.resources[0].kind == "mock-kind"
+
+
+def test_default_resources_path_does_not_exist() -> None:
+    # Act
+    defaults = get_port_integration_defaults(port_app_config_class=PortAppConfig)
+
+    # Assert
+    assert defaults is None

port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py

@@ -0,0 +1,350 @@
+from typing import Any
+from unittest.mock import AsyncMock, Mock
+from loguru import logger
+import pytest
+from io import StringIO
+
+from port_ocean.context.ocean import PortOceanContext
+from port_ocean.core.handlers.entity_processor.jq_entity_processor import (
+    JQEntityProcessor,
+)
+from port_ocean.core.ocean_types import CalculationResult
+from port_ocean.exceptions.core import EntityProcessorException
+
+
+@pytest.mark.asyncio
+class TestJQEntityProcessor:
+
+    @pytest.fixture
+    def mocked_processor(self, monkeypatch: Any) -> JQEntityProcessor:
+        mock_context = AsyncMock()
+        monkeypatch.setattr(PortOceanContext, "app", mock_context)
+        return JQEntityProcessor(mock_context)
+
+    async def test_compile(self, mocked_processor: JQEntityProcessor) -> None:
+        pattern = ".foo"
+        compiled = mocked_processor._compile(pattern)
+        assert compiled is not None
+
+    async def test_search(self, mocked_processor: JQEntityProcessor) -> None:
+        data = {"foo": "bar"}
+        pattern = ".foo"
+        result = await mocked_processor._search(data, pattern)
+        assert result == "bar"
+
+    async def test_search_as_bool(self, mocked_processor: JQEntityProcessor) -> None:
+        data = {"foo": True}
+        pattern = ".foo"
+        result = await mocked_processor._search_as_bool(data, pattern)
+        assert result is True
+
+    async def test_search_as_object(self, mocked_processor: JQEntityProcessor) -> None:
+        data = {"foo": {"bar": "baz"}}
+        obj = {"foo": ".foo.bar"}
+        result = await mocked_processor._search_as_object(data, obj)
+        assert result == {"foo": "baz"}
+
+    async def test_get_mapped_entity(self, mocked_processor: JQEntityProcessor) -> None:
+        data = {"foo": "bar"}
+        raw_entity_mappings = {"foo": ".foo"}
+        selector_query = '.foo == "bar"'
+        result = await mocked_processor._get_mapped_entity(
+            data, raw_entity_mappings, selector_query
+        )
+        assert result.entity == {"foo": "bar"}
+        assert result.did_entity_pass_selector is True
+
+    async def test_calculate_entity(self, mocked_processor: JQEntityProcessor) -> None:
+        data = {"foo": "bar"}
+        raw_entity_mappings = {"foo": ".foo"}
+        selector_query = '.foo == "bar"'
+        result, errors = await mocked_processor._calculate_entity(
+            data, raw_entity_mappings, None, selector_query
+        )
+        assert len(result) == 1
+        assert result[0].entity == {"foo": "bar"}
+        assert result[0].did_entity_pass_selector is True
+        assert not errors
+
+    async def test_parse_items(self, mocked_processor: JQEntityProcessor) -> None:
+        mapping = Mock()
+        mapping.port.entity.mappings.dict.return_value = {
+            "identifier": ".foo",
+            "blueprint": ".foo",
+            "properties": {"foo": ".foo"},
+        }
+        mapping.port.items_to_parse = None
+        mapping.selector.query = '.foo == "bar"'
+        raw_results = [{"foo": "bar"}]
+        result = await mocked_processor._parse_items(mapping, raw_results)
+        assert isinstance(result, CalculationResult)
+        assert len(result.entity_selector_diff.passed) == 1
+        assert result.entity_selector_diff.passed[0].properties.get("foo") == "bar"
+        assert not result.errors
+
+    async def test_in_operator(self, mocked_processor: JQEntityProcessor) -> None:
+        data = {
+            "key": "GetPort_SelfService",
+            "name": "GetPort SelfService",
+            "desc": "Test",
+            "qualifier": "VW",
+            "visibility": "public",
+            "selectionMode": "NONE",
+            "subViews": [
+                {
+                    "key": "GetPort_SelfService_Second",
+                    "name": "GetPort SelfService Second",
+                    "qualifier": "SVW",
+                    "selectionMode": "NONE",
+                    "subViews": [
+                        {
+                            "key": "GetPort_SelfService_Third",
+                            "name": "GetPort SelfService Third",
+                            "qualifier": "SVW",
+                            "selectionMode": "NONE",
+                            "subViews": [],
+                            "referencedBy": [],
+                        },
+                        {
+                            "key": "Port_Test",
+                            "name": "Port Test",
+                            "qualifier": "SVW",
+                            "selectionMode": "NONE",
+                            "subViews": [],
+                            "referencedBy": [],
+                        },
+                    ],
+                    "referencedBy": [],
+                },
+                {
+                    "key": "Python",
+                    "name": "Python",
+                    "qualifier": "SVW",
+                    "selectionMode": "NONE",
+                    "subViews": [
+                        {
+                            "key": "Time",
+                            "name": "Time",
+                            "qualifier": "SVW",
+                            "selectionMode": "NONE",
+                            "subViews": [
+                                {
+                                    "key": "port_*****",
+                                    "name": "port-*****",
+                                    "qualifier": "SVW",
+                                    "selectionMode": "NONE",
+                                    "subViews": [
+                                        {
+                                            "key": "port_*****:REferenced",
+                                            "name": "REferenced",
+                                            "qualifier": "VW",
+                                            "visibility": "public",
+                                            "originalKey": "REferenced",
+                                        }
+                                    ],
+                                    "referencedBy": [],
+                                }
+                            ],
+                            "referencedBy": [],
+                        }
+                    ],
+                    "referencedBy": [],
+                },
+                {
+                    "key": "GetPort_SelfService:Authentication_Application",
+                    "name": "Authentication Application",
+                    "desc": "For auth services",
+                    "qualifier": "APP",
+                    "visibility": "private",
+                    "selectedBranches": ["main"],
+                    "originalKey": "Authentication_Application",
+                },
+            ],
+            "referencedBy": [],
+        }
+        pattern = '.subViews | map(select((.qualifier | IN("VW", "SVW"))) | .key)'
+        result = await mocked_processor._search(data, pattern)
+        assert result == ["GetPort_SelfService_Second", "Python"]
+
+    async def test_failure_of_jq_expression(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        data = {"foo": "bar"}
+        pattern = ".foo."
+        result = await mocked_processor._search(data, pattern)
+        assert result is None
+
+    async def test_search_as_object_failure(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        data = {"foo": {"bar": "baz"}}
+        obj = {"foo": ".foo.bar."}
+        result = await mocked_processor._search_as_object(data, obj)
+        assert result == {"foo": None}
+
+    async def test_double_quotes_in_jq_expression(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        data = {"foo": "bar"}
+        pattern = '"shalom"'
+        result = await mocked_processor._search(data, pattern)
+        assert result == "shalom"
+
+    async def test_search_as_bool_failure(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        data = {"foo": "bar"}
+        pattern = ".foo"
+        with pytest.raises(
+            EntityProcessorException,
+            match="Expected boolean value, got value:bar of type: <class 'str'> instead",
+        ):
+            await mocked_processor._search_as_bool(data, pattern)
+
+    @pytest.mark.parametrize(
+        "pattern, expected",
+        [
+            ('.parameters[] | select(.name == "not_exists") | .value', None),
+            (
+                '.parameters[] | select(.name == "parameter_name") | .value',
+                "parameter_value",
+            ),
+            (
+                '.parameters[] | select(.name == "another_parameter") | .value',
+                "another_value",
+            ),
+        ],
+    )
+    async def test_search_fails_on_stop_iteration(
+        self, mocked_processor: JQEntityProcessor, pattern: str, expected: Any
+    ) -> None:
+        data = {
+            "parameters": [
+                {"name": "parameter_name", "value": "parameter_value"},
+                {"name": "another_parameter", "value": "another_value"},
+                {"name": "another_parameter", "value": "another_value2"},
+            ]
+        }
+        result = await mocked_processor._search(data, pattern)
+        assert result == expected
+
+    async def test_return_a_list_of_values(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        data = {"parameters": ["parameter_value", "another_value", "another_value2"]}
+        pattern = ".parameters"
+        result = await mocked_processor._search(data, pattern)
+        assert result == ["parameter_value", "another_value", "another_value2"]
+
+    @pytest.mark.timeout(3)
+    async def test_search_performance_10000(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        """
+        This test is to check the performance of the search method when called 10000 times.
+        """
+        data = {"foo": "bar"}
+        pattern = ".foo"
+        for _ in range(10000):
+            result = await mocked_processor._search(data, pattern)
+            assert result == "bar"
+
+    @pytest.mark.timeout(15)
+    async def test_parse_items_performance_10000(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        """
+        This test is to check the performance of the parse_items method when called 10000 times.
+        """
+        mapping = Mock()
+        mapping.port.entity.mappings.dict.return_value = {
+            "identifier": ".foo",
+            "blueprint": ".foo",
+            "properties": {"foo": ".foo"},
+        }
+        mapping.port.items_to_parse = None
+        mapping.selector.query = '.foo == "bar"'
+        raw_results = [{"foo": "bar"}]
+        for _ in range(10000):
+            result = await mocked_processor._parse_items(mapping, raw_results)
+            assert isinstance(result, CalculationResult)
+            assert len(result.entity_selector_diff.passed) == 1
+            assert result.entity_selector_diff.passed[0].properties.get("foo") == "bar"
+            assert not result.errors
+
+    async def test_parse_items_wrong_mapping(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        mapping = Mock()
+        mapping.port.entity.mappings.dict.return_value = {
+            "title": ".foo",
+            "identifier": ".ark",
+            "blueprint": ".baz",
+            "properties": {
+                "description": ".bazbar",
+                "url": ".foobar",
+                "defaultBranch": ".bar.baz",
+            },
+        }
+        mapping.port.items_to_parse = None
+        mapping.selector.query = "true"
+        raw_results = [
+            {
+                "foo": "bar",
+                "baz": "bazbar",
+                "bar": {"foobar": "barfoo", "baz": "barbaz"},
+            },
+            {"foo": "bar", "baz": "bazbar", "bar": {"foobar": "foobar"}},
+        ]
+        result = await mocked_processor._parse_items(mapping, raw_results)
+        assert len(result.misonfigured_entity_keys) > 0
+        assert len(result.misonfigured_entity_keys) == 4
+        assert result.misonfigured_entity_keys == {
+            "identifier": ".ark",
+            "description": ".bazbar",
+            "url": ".foobar",
+            "defaultBranch": ".bar.baz",
+        }
+
+    async def test_parse_items_empty_required(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        stream = StringIO()
+        sink_id = logger.add(stream, level="DEBUG")
+
+        mapping = Mock()
+        mapping.port.entity.mappings.dict.return_value = {
+            "identifier": ".foo",
+            "blueprint": ".bar",
+        }
+        mapping.port.items_to_parse = None
+        mapping.selector.query = "true"
+        raw_results: list[dict[Any, Any]] = [
+            {"foo": "", "bar": "bluePrintMapped"},
+            {"foo": "identifierMapped", "bar": ""},
+        ]
+        result = await mocked_processor._parse_items(mapping, raw_results)
+        assert "identifier" not in result.misonfigured_entity_keys
+        assert "blueprint" not in result.misonfigured_entity_keys
+
+        raw_results = [
+            {"foo": "identifierMapped", "bar": None},
+            {"foo": None, "bar": ""},
+        ]
+        result = await mocked_processor._parse_items(mapping, raw_results)
+        assert result.misonfigured_entity_keys == {
+            "identifier": ".foo",
+            "blueprint": ".bar",
+        }
+
+        logger.remove(sink_id)
+        logs_captured = stream.getvalue()
+
+        assert (
+            "2 transformations of batch failed due to empty, null or missing values"
+            in logs_captured
+        )
+        assert (
+            "{'blueprint': '.bar', 'identifier': '.foo'} (null, missing, or misconfigured)"
+            in logs_captured
+        )