port-ocean 0.10.10__tar.gz → 0.10.12__tar.gz

{port_ocean-0.10.10 → port_ocean-0.10.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.10.10
+Version: 0.10.12
 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.10.10 → port_ocean-0.10.12}/port_ocean/core/integrations/mixins/sync_raw.py

@@ -456,7 +456,8 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
                         creation_results.append(await task)
             except asyncio.CancelledError as e:
-                logger.warning("Resync aborted successfully")
+                logger.warning("Resync aborted successfully, skipping delete phase. This leads to an incomplete state")
+                raise
             else:
                 if not did_fetched_current_state:
                     logger.warning(
@@ -489,3 +490,4 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         {"before": entities_at_port, "after": flat_created_entities},
                         user_agent_type,
                     )
+                    logger.info("Resync finished successfully")

{port_ocean-0.10.10 → port_ocean-0.10.12}/port_ocean/ocean.py

@@ -82,6 +82,10 @@ class Ocean:
             try:
                 await self.integration.sync_raw_all()
                 await self.resync_state_updater.update_after_resync()
+            except asyncio.CancelledError:
+                logger.warning(
+                    "resync was cancelled by the scheduled resync, skipping state update"
+                )
             except Exception as e:
                 await self.resync_state_updater.update_after_resync(
                     IntegrationStateStatus.Failed

port_ocean-0.10.12/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-0.10.12/port_ocean/tests/helpers/fixtures.py

@@ -0,0 +1,110 @@
+from os import environ, path
+from typing import Any, AsyncGenerator, Callable, List, Tuple, Union
+
+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
+from port_ocean.ocean import Ocean
+from port_ocean.tests.helpers.ocean_app import (
+    get_integation_resource_configs,
+    get_integration_ocean_app,
+)
+
+
+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,
+    )
+
+    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])
+
+
+@pytest_asyncio.fixture
+def get_mocked_ocean_app(request: Any) -> Callable[[], Ocean]:
+    test_dir = path.join(path.dirname(request.module.__file__), "..")
+
+    def get_ocean_app() -> Ocean:
+        return get_integration_ocean_app(test_dir)
+
+    return get_ocean_app
+
+
+@pytest_asyncio.fixture
+def get_mock_ocean_resource_configs(request: Any) -> Callable[[], List[ResourceConfig]]:
+    module_dir = path.join(path.dirname(request.module.__file__), "..")
+
+    def get_ocean_resource_configs() -> List[ResourceConfig]:
+        return get_integation_resource_configs(module_dir)
+
+    return get_ocean_resource_configs

port_ocean-0.10.10/port_ocean/tests/helpers/__init__.py → port_ocean-0.10.12/port_ocean/tests/helpers/ocean_app.py

@@ -1,7 +1,7 @@
 import sys
 from inspect import getmembers
 from pathlib import Path
-from typing import Dict, List, Set, Tuple, Union
+from typing import List, Tuple
 
 from yaml import safe_load
 
@@ -46,35 +46,9 @@ def get_integation_resource_configs(integration_path: str) -> List[ResourceConfi
     return [ResourceConfig(**item) for item in resource_configs["resources"]]
 
 
-def get_integation_resource_config_by_name(
-    integration_path: str, kind: str
-) -> Union[ResourceConfig, None]:
-    resource_configs = get_integation_resource_configs(integration_path)
+async def get_raw_result_on_integration_sync_resource_config(
+    app: Ocean, resource_config: ResourceConfig
+) -> Tuple[RESYNC_RESULT, List[Exception]]:
+    resource_result = await app.integration._get_resource_raw_results(resource_config)
 
-    relevant_configs = [x for x in resource_configs if x.kind == kind]
-
-    return relevant_configs[0] if len(relevant_configs) else None
-
-
-async def get_raw_result_on_integration_sync_kinds(
-    integration_path: str, override_kinds: Union[Set[str], None] = None
-) -> Dict[str, List[Tuple[RESYNC_RESULT, List[Exception]]]]:
-    app = get_integration_ocean_app(integration_path)
-
-    resource_configs = get_integation_resource_configs(integration_path)
-
-    if override_kinds:
-        resource_configs = [x for x in resource_configs if x.kind in override_kinds]
-
-    results: Dict[str, List[Tuple[RESYNC_RESULT, List[Exception]]]] = {}
-
-    for resource_config in resource_configs:
-        resource_result = await app.integration._get_resource_raw_results(
-            resource_config
-        )
-
-        results[resource_config.kind] = results.get(resource_config.kind, []) + [
-            resource_result
-        ]
-
-    return results
+    return resource_result

port_ocean-0.10.12/port_ocean/tests/test_smoke.py

@@ -0,0 +1,71 @@
+from os import environ
+from typing import Tuple
+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
+
+
+@pytest.mark.skipif(
+    environ.get("SMOKE_TEST_SUFFIX", None) is None,
+    reason="You need to run the fake integration once",
+)
+async def test_valid_fake_integration(
+    port_client_for_fake_integration: Tuple[SmokeTestDetails, PortClient],
+) -> None:
+    _, port_client = port_client_for_fake_integration
+    current_integration = await port_client.get_current_integration()
+    assert current_integration is not None
+    assert current_integration.get("resyncState") is not None
+    assert current_integration.get("resyncState", {}).get("status") == "completed"
+
+
+@pytest.mark.skipif(
+    environ.get("SMOKE_TEST_SUFFIX", None) is None,
+    reason="You need to run the fake integration once",
+)
+async def test_valid_fake_departments(
+    port_client_for_fake_integration: Tuple[SmokeTestDetails, PortClient],
+) -> None:
+    details, port_client = port_client_for_fake_integration
+    entities = await port_client.search_entities(user_agent_type=UserAgentType.exporter)
+    assert len(entities)
+    departments = [
+        x for x in entities if f"{x.blueprint}" == details.blueprint_department
+    ]
+    assert len(departments) == 5
+
+
+@pytest.mark.skipif(
+    environ.get("SMOKE_TEST_SUFFIX", None) is None,
+    reason="You need to run the fake integration once",
+)
+async def test_valid_fake_persons(
+    port_client_for_fake_integration: Tuple[SmokeTestDetails, PortClient],
+) -> None:
+    details, port_client = port_client_for_fake_integration
+    headers = await port_client.auth.headers()
+    fake_person_entities_result = await port_client.client.get(
+        f"{port_client.auth.api_url}/blueprints/{details.blueprint_person}/entities",
+        headers=headers,
+    )
+
+    fake_person_entities = fake_person_entities_result.json()["entities"]
+    assert len(fake_person_entities)
+
+    fake_departments_result = await port_client.client.get(
+        f"{port_client.auth.api_url}/blueprints/{details.blueprint_department}/entities",
+        headers=headers,
+    )
+
+    departments = [x["identifier"] for x in fake_departments_result.json()["entities"]]
+
+    for department in departments:
+        assert len(
+            [
+                x
+                for x in fake_person_entities
+                if x["relations"]["department"] == department
+            ]
+        )

{port_ocean-0.10.10 → port_ocean-0.10.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.10.10"
+version = "0.10.12"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"