port-ocean 0.10.12__py3-none-any.whl → 0.12.0__py3-none-any.whl

port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -1,11 +1,10 @@
 import asyncio
-import functools
 from asyncio import Task
 from dataclasses import dataclass, field
 from functools import lru_cache
 from typing import Any, Optional
 
-import pyjq as jq  # type: ignore
+import jq  # type: ignore
 from loguru import logger
 
 from port_ocean.context.ocean import ocean
@@ -52,8 +51,8 @@ class JQEntityProcessor(BaseEntityProcessor):
         try:
             loop = asyncio.get_event_loop()
             compiled_pattern = self._compile(pattern)
-            first_value_callable = functools.partial(compiled_pattern.first, data)
-            return await loop.run_in_executor(None, first_value_callable)
+            func = compiled_pattern.input_value(data)
+            return await loop.run_in_executor(None, func.first)
         except Exception as exc:
             logger.debug(
                 f"Failed to search for pattern {pattern} in data {data}, {exc}"
@@ -62,10 +61,18 @@ class JQEntityProcessor(BaseEntityProcessor):
 
     async def _search_as_bool(self, data: dict[str, Any], pattern: str) -> bool:
         loop = asyncio.get_event_loop()
+        start_time = loop.time()
         compiled_pattern = self._compile(pattern)
-        first_value_callable = functools.partial(compiled_pattern.first, data)
-        value = await loop.run_in_executor(None, first_value_callable)
-
+        func = compiled_pattern.input_value(data)
+        compile_time = loop.time() - start_time
+        value = await loop.run_in_executor(None, func.first)
+        execute_time = loop.time() - start_time - compile_time
+        logger.debug(
+            f"Search for pattern {execute_time:.2f} seconds, compile time {compile_time:.2f} seconds",
+            pattern=pattern,
+            compile_time=compile_time,
+            execute_time=execute_time,
+        )
         if isinstance(value, bool):
             return value
 

port_ocean/core/integrations/base.py

@@ -54,7 +54,7 @@ class BaseIntegration(SyncRawMixin, SyncMixin):
         """
         Initializes handlers, establishes integration at the specified port, and starts the event listener.
         """
-        logger.info("Starting integration")
+        logger.info("Starting integration", integration_type=self.context.config.integration.type)
         if self.started:
             raise IntegrationAlreadyStartedException("Integration already started")
 

port_ocean/log/sensetive.py

@@ -21,7 +21,7 @@ secret_patterns = {
     "GitHub": r"[g|G][i|I][t|T][h|H][u|U][b|B].*['|\"][0-9a-zA-Z]{35,40}['|\"]",
     "Google Cloud Platform API Key": r"AIza[0-9A-Za-z\\-_]{35}",
     "Google Cloud Platform OAuth": r"[0-9]+-[0-9A-Za-z_]{32}\\.apps\\.googleusercontent\\.com",
-    "Google (GCP) Service-account": r'"type": "service_account"',
+    "Google (GCP) Service-account": f'"type":{" "}"service_account"',
     "Google OAuth Access Token": r"ya29\\.[0-9A-Za-z\\-_]+",
     "Connection String": r"[a-zA-Z]+:\/\/[^/\s]+:[^/\s]+@[^/\s]+\/[^/\s]+",
 }

port_ocean/ocean.py

@@ -96,7 +96,8 @@ class Ocean:
         loop = asyncio.get_event_loop()
         if interval is not None:
             logger.info(
-                f"Setting up scheduled resync, the integration will automatically perform a full resync every {interval} minutes)"
+                f"Setting up scheduled resync, the integration will automatically perform a full resync every {interval} minutes)",
+                scheduled_interval=interval,
             )
             repeated_function = repeat_every(
                 seconds=interval * 60,

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

@@ -0,0 +1,236 @@
+from typing import Any
+from unittest.mock import AsyncMock, Mock
+import pytest
+
+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 <class 'str'> instead",
+        ):
+            await mocked_processor._search_as_bool(data, pattern)
+
+    @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

port_ocean/tests/helpers/fixtures.py

@@ -1,8 +1,8 @@
-from os import environ, path
-from typing import Any, AsyncGenerator, Callable, List, Tuple, Union
+from os import path
+from typing import Any, Callable, List, Tuple
 
+import pytest
 import pytest_asyncio
-from pydantic import BaseModel
 
 from port_ocean.clients.port.client import PortClient
 from port_ocean.core.handlers.port_app_config.models import ResourceConfig
@@ -11,83 +11,19 @@ from port_ocean.tests.helpers.ocean_app import (
     get_integation_resource_configs,
     get_integration_ocean_app,
 )
+from port_ocean.tests.helpers.smoke_test import (
+    SmokeTestDetails,
+    get_port_client_for_fake_integration,
+    get_smoke_test_details,
+)
 
 
-def get_port_client_for_integration(
-    client_id: str,
-    client_secret: str,
-    integration_identifier: str,
-    integration_type: str,
-    integration_version: str,
-    base_url: Union[str, None],
-) -> PortClient:
-    return PortClient(
-        base_url=base_url or "https://api.getport/io",
-        client_id=client_id,
-        client_secret=client_secret,
-        integration_identifier=integration_identifier,
-        integration_type=integration_type,
-        integration_version=integration_version,
-    )
-
-
-async def cleanup_integration(client: PortClient, blueprints: List[str]) -> None:
-    for blueprint in blueprints:
-        bp = await client.get_blueprint(blueprint)
-        if bp is not None:
-            migration_id = await client.delete_blueprint(
-                identifier=blueprint, delete_entities=True
-            )
-            if migration_id:
-                await client.wait_for_migration_to_complete(migration_id=migration_id)
-    headers = await client.auth.headers()
-    await client.client.delete(f"{client.auth.api_url}/integrations", headers=headers)
-
-
-class SmokeTestDetails(BaseModel):
-    integration_identifier: str
-    blueprint_department: str
-    blueprint_person: str
-
-
-@pytest_asyncio.fixture()
-async def port_client_for_fake_integration() -> (
-    AsyncGenerator[Tuple[SmokeTestDetails, PortClient], None]
-):
-    blueprint_department = "fake-department"
-    blueprint_person = "fake-person"
-    integration_identifier = "smoke-test-integration"
-    smoke_test_suffix = environ.get("SMOKE_TEST_SUFFIX")
-    client_id = environ.get("PORT_CLIENT_ID")
-    client_secret = environ.get("PORT_CLIENT_SECRET")
-
-    if not client_secret or not client_id:
-        assert False, "Missing port credentials"
-
-    base_url = environ.get("PORT_BASE_URL")
-    integration_version = "0.1.1-dev"
-    integration_type = "smoke-test"
-    if smoke_test_suffix is not None:
-        integration_identifier = f"{integration_identifier}-{smoke_test_suffix}"
-        blueprint_person = f"{blueprint_person}-{smoke_test_suffix}"
-        blueprint_department = f"{blueprint_department}-{smoke_test_suffix}"
-
-    client = get_port_client_for_integration(
-        client_id,
-        client_secret,
-        integration_identifier,
-        integration_type,
-        integration_version,
-        base_url,
-    )
+@pytest.fixture
+def port_client_for_fake_integration() -> Tuple[SmokeTestDetails, PortClient]:
+    smoke_test_details = get_smoke_test_details()
+    port_client = get_port_client_for_fake_integration()
 
-    smoke_test_details = SmokeTestDetails(
-        integration_identifier=integration_identifier,
-        blueprint_person=blueprint_person,
-        blueprint_department=blueprint_department,
-    )
-    yield smoke_test_details, client
-    await cleanup_integration(client, [blueprint_department, blueprint_person])
+    return smoke_test_details, port_client
 
 
 @pytest_asyncio.fixture

port_ocean/tests/helpers/integration.py

@@ -0,0 +1,31 @@
+from typing import List
+
+from loguru import logger
+
+from port_ocean.clients.port.client import PortClient
+
+
+async def cleanup_integration(client: PortClient, blueprints: List[str]) -> None:
+    for blueprint in blueprints:
+        try:
+            bp = await client.get_blueprint(blueprint)
+            if bp is not None:
+                migration_id = await client.delete_blueprint(
+                    identifier=blueprint, delete_entities=True
+                )
+                if migration_id:
+                    await client.wait_for_migration_to_complete(
+                        migration_id=migration_id
+                    )
+        except Exception as bp_e:
+            logger.info(f"Skipping missing blueprint ({blueprint}): {bp_e}")
+    headers = await client.auth.headers()
+    try:
+        await client.client.delete(
+            f"{client.auth.api_url}/integrations/{client.integration_identifier}",
+            headers=headers,
+        )
+    except Exception as int_e:
+        logger.info(
+            f"Failed to delete integration ({client.integration_identifier}): {int_e}"
+        )

port_ocean/tests/helpers/port_client.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+from port_ocean.clients.port.client import PortClient
+
+
+def get_port_client_for_integration(
+    client_id: str,
+    client_secret: str,
+    integration_identifier: str,
+    integration_type: str,
+    integration_version: str,
+    base_url: Union[str, None],
+) -> PortClient:
+    return PortClient(
+        base_url=base_url or "https://api.getport/io",
+        client_id=client_id,
+        client_secret=client_secret,
+        integration_identifier=integration_identifier,
+        integration_type=integration_type,
+        integration_version=integration_version,
+    )

port_ocean/tests/helpers/smoke_test.py

@@ -0,0 +1,82 @@
+from os import environ
+from port_ocean.clients.port.client import PortClient
+
+from loguru import logger
+from pydantic import BaseModel
+
+from port_ocean.tests.helpers.integration import cleanup_integration
+from port_ocean.tests.helpers.port_client import get_port_client_for_integration
+
+
+class SmokeTestDetails(BaseModel):
+    integration_identifier: str
+    blueprint_department: str
+    blueprint_person: str
+    integration_type: str
+    integration_version: str
+
+
+def get_smoke_test_details() -> SmokeTestDetails:
+    blueprint_department = "fake-department"
+    blueprint_person = "fake-person"
+    integration_identifier = "smoke-test-integration"
+    smoke_test_suffix = environ.get("SMOKE_TEST_SUFFIX")
+    if smoke_test_suffix is not None:
+        integration_identifier = f"{integration_identifier}-{smoke_test_suffix}"
+        blueprint_person = f"{blueprint_person}-{smoke_test_suffix}"
+        blueprint_department = f"{blueprint_department}-{smoke_test_suffix}"
+
+    return SmokeTestDetails(
+        integration_identifier=integration_identifier,
+        blueprint_person=blueprint_person,
+        blueprint_department=blueprint_department,
+        integration_version="0.1.4-dev",
+        integration_type="smoke-test",
+    )
+
+
+async def cleanup_smoke_test() -> None:
+    smoke_test_details = get_smoke_test_details()
+    client_id = environ.get("PORT_CLIENT_ID")
+    client_secret = environ.get("PORT_CLIENT_SECRET")
+
+    if not client_secret or not client_id:
+        assert False, "Missing port credentials"
+
+    base_url = environ.get("PORT_BASE_URL")
+    client = get_port_client_for_integration(
+        client_id,
+        client_secret,
+        smoke_test_details.integration_identifier,
+        smoke_test_details.integration_type,
+        smoke_test_details.integration_version,
+        base_url,
+    )
+
+    logger.info("Cleaning up fake integration")
+    await cleanup_integration(
+        client,
+        [smoke_test_details.blueprint_department, smoke_test_details.blueprint_person],
+    )
+    logger.info("Cleaning up fake integration complete")
+
+
+def get_port_client_for_fake_integration() -> PortClient:
+    smoke_test_details = get_smoke_test_details()
+    client_id = environ.get("PORT_CLIENT_ID")
+    client_secret = environ.get("PORT_CLIENT_SECRET")
+
+    if not client_secret or not client_id:
+        assert False, "Missing port credentials"
+
+    base_url = environ.get("PORT_BASE_URL")
+    client = get_port_client_for_integration(
+        client_id,
+        client_secret,
+        smoke_test_details.integration_identifier,
+        smoke_test_details.integration_type,
+        smoke_test_details.integration_version,
+        base_url,
+    )
+
+    return client

port_ocean/tests/test_smoke.py

@@ -4,7 +4,10 @@ import pytest
 
 from port_ocean.clients.port.client import PortClient
 from port_ocean.clients.port.types import UserAgentType
-from port_ocean.tests.helpers.fixtures import SmokeTestDetails
+from port_ocean.tests.helpers.smoke_test import SmokeTestDetails
+
+
+pytestmark = pytest.mark.smoke
 
 
 @pytest.mark.skipif(

{port_ocean-0.10.12.dist-info → port_ocean-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.10.12
+Version: 0.12.0
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port
@@ -28,11 +28,11 @@ Requires-Dist: cookiecutter (>=2.1.1,<3.0.0) ; extra == "cli"
 Requires-Dist: fastapi (>=0.100,<0.112)
 Requires-Dist: httpx (>=0.24.1,<0.28.0)
 Requires-Dist: jinja2-time (>=0.2.0,<0.3.0) ; extra == "cli"
+Requires-Dist: jq (>=1.8.0,<2.0.0)
 Requires-Dist: loguru (>=0.7.0,<0.8.0)
 Requires-Dist: pydantic[dotenv] (>=1.10.8,<2.0.0)
 Requires-Dist: pydispatcher (>=2.0.7,<3.0.0)
 Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
-Requires-Dist: pyjq (>=2.6.0,<3.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: rich (>=13.4.1,<14.0.0) ; extra == "cli"

{port_ocean-0.10.12.dist-info → port_ocean-0.12.0.dist-info}/RECORD

@@ -81,7 +81,7 @@ port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py,sha
 port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=82BvU8t5w9uhsxX8hbnwuRPuWhW3cMeuT_5sVIkip1I,1550
 port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybem9MthOs7p1Wawac87uSXz9U8,156
 port_ocean/core/handlers/entity_processor/base.py,sha256=udR0w5TstTOS5xOfTjAZIEdldn4xr6Oyb3DylatYX3Q,1869
-port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=_nQtlY0ZcCDf_Mpq4qcG7vVQ8LJS6DfkFMv-NHyFiJI,8421
+port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=HQ3lnOqNITHxSn0_9TXZFaQYfMZvvPaJwnsvlNKGDKQ,8703
 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/base.py,sha256=4Nxt2g8voEIHJ4Y1Km5NJcaG2iSbCklw5P8-Kus7Y9k,3007
@@ -89,7 +89,7 @@ port_ocean/core/handlers/port_app_config/models.py,sha256=YvYtf_44KD_rN4xK-3xHtd
 port_ocean/core/handlers/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
 port_ocean/core/handlers/resync_state_updater/updater.py,sha256=Yg9ET6ZV5B9GW7u6zZA6GlB_71kmvxvYX2FWgQNzMvo,3182
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/integrations/base.py,sha256=KHsRYFZ38ff3AkkqIQu45883ovgKOJn_fZfnTNy7HWY,2952
+port_ocean/core/integrations/base.py,sha256=JxqQApEf7phi_Q_b4U0mKNomxIPdDyKPq3AbApFmhjU,3007
 port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4_RgZnwSRmTCreKcBVM,220
 port_ocean/core/integrations/mixins/events.py,sha256=Ddfx2L4FpghV38waF8OfVeOV0bHBxNIgjU-q5ffillI,2341
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
@@ -113,20 +113,23 @@ port_ocean/helpers/retry.py,sha256=IQ0RfQ2T5o6uoZh2WW2nrFH5TT6K_k3y2Im0HDp5j9Y,1
 port_ocean/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/log/handlers.py,sha256=k9G_Mb4ga2-Jke9irpdlYqj6EYiwv0gEsh4TgyqqOmI,2853
 port_ocean/log/logger_setup.py,sha256=BaXt-mh9CVXhneh37H46d04lqOdIBixG1pFyGfotuZs,2328
-port_ocean/log/sensetive.py,sha256=wkyvkKMbyLTjZDSbvvLHL9bv4RvD0DPAyL3uWSttUOA,2916
+port_ocean/log/sensetive.py,sha256=lVKiZH6b7TkrZAMmhEJRhcl67HNM94e56x12DwFgCQk,2920
 port_ocean/middlewares.py,sha256=9wYCdyzRZGK1vjEJ28FY_DkfwDNENmXp504UKPf5NaQ,2727
-port_ocean/ocean.py,sha256=fHF3nCIb2bfD3gMizXV9mwF11DR3fXoK6am172jrIt4,5025
+port_ocean/ocean.py,sha256=Oe4H3kKtkj52uNO4Rd_47iY3MBdrTtshXZ_16q7A8bM,5071
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=rTxBlrQd4yyrtgErCFJCHCEHs7d1OXrRiJehUYmIbN0,2212
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
 port_ocean/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/tests/clients/port/mixins/test_entities.py,sha256=A9myrnkLhKSQrnOLv1Zz2wiOVSxW65Q9RIUIRbn_V7w,1586
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
+port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=fqhlLTFkP0SS12bqViYWgqayNGXWZhqpDSJObHVRnNg,9472
 port_ocean/tests/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/tests/helpers/fixtures.py,sha256=XGR8wjcAKBBYoIRKh_KzFg1PdqhlL9GqqR8z_q08nHA,3699
+port_ocean/tests/helpers/fixtures.py,sha256=blc4ZgPEkKOmmwT6GVxceS9r1ERUwSdOIBGxWFwvRyY,1398
+port_ocean/tests/helpers/integration.py,sha256=_RxS-RHpu11lrbhUXYPZp862HLWx8AoD7iZM6iXN8rs,1104
 port_ocean/tests/helpers/ocean_app.py,sha256=Dp1bwEDhWsx_G-KVxOfJX1eVIS4168ajLu39wAY275g,1693
-port_ocean/tests/test_sample.py,sha256=Ew5LA_G1k6DC5a2ygU2FoyjZQa0fRmPy73N0bio0d14,46
-port_ocean/tests/test_smoke.py,sha256=F-1MoEcdIT1smjWv3s1iaS7U5UxpKGf-AHc8mYHjOlw,2522
+port_ocean/tests/helpers/port_client.py,sha256=5d6GNr8vNNSOkrz1AdOhxBUKuusr_-UPDP7AVpHasQw,599
+port_ocean/tests/helpers/smoke_test.py,sha256=_9aJJFRfuGJEg2D2YQJVJRmpreS6gEPHHQq8Q01x4aQ,2697
+port_ocean/tests/test_smoke.py,sha256=uix2uIg_yOm8BHDgHw2hTFPy1fiIyxBGW3ENU_KoFlo,2557
 port_ocean/utils/__init__.py,sha256=KMGnCPXZJbNwtgxtyMycapkDz8tpSyw23MSYT3iVeHs,91
 port_ocean/utils/async_http.py,sha256=arnH458TExn2Dju_Sy6pHas_vF5RMWnOp-jBz5WAAcE,1226
 port_ocean/utils/async_iterators.py,sha256=iw3cUHxfQm3zUSPdw2FmSXDU8E1Ppnys4TGhswNuQ8s,1569
@@ -137,8 +140,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.10.12.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.10.12.dist-info/METADATA,sha256=tttQQiBv4cQkkOpY3210bf0r_HlbdbshcCVt5JFfELs,6617
-port_ocean-0.10.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-port_ocean-0.10.12.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.10.12.dist-info/RECORD,,
+port_ocean-0.12.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.12.0.dist-info/METADATA,sha256=PrJZo5rBOy6h2_slD1tjSHcTdHCc-PgyIsk9DNqk0pY,6614
+port_ocean-0.12.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+port_ocean-0.12.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.12.0.dist-info/RECORD,,

port_ocean/tests/test_sample.py

@@ -1,2 +0,0 @@
-def test_example() -> None:
-    assert 1 == 1