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

port_ocean/tests/core/utils/test_entity_topological_sorter.py

@@ -0,0 +1,99 @@
+from port_ocean.core.models import Entity
+from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
+from unittest.mock import MagicMock
+from port_ocean.exceptions.core import (
+    OceanAbortException,
+)
+
+
+def create_entity(
+    identifier: str, buleprint: str, dependencies: dict[str, str] = {}
+) -> Entity:
+    entity = MagicMock()
+    entity.identifier = identifier
+    entity.blueprint = buleprint
+    entity.relations = dependencies or {}
+    return entity
+
+
+def test_handle_failed_with_dependencies() -> None:
+    # processed_order:list[str] = []
+    entity_a = create_entity(
+        "entity_a",
+        "buleprint_a",
+    )  # No dependencies
+    entity_b = create_entity(
+        "entity_b", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Depends on entity_a
+    entity_c = create_entity(
+        "entity_c", "buleprint_b", {"dep_name_2": "entity_b"}
+    )  # Depends on entity_b
+
+    entity_topological_sort = EntityTopologicalSorter()
+    # Register fails with unsorted order
+    entity_topological_sort.register_entity(entity_c)
+    entity_topological_sort.register_entity(entity_a)
+    entity_topological_sort.register_entity(entity_b)
+
+    processed_order = [
+        f"{entity.identifier}-{entity.blueprint}"
+        for entity in list(entity_topological_sort.get_entities())
+    ]
+    assert processed_order == [
+        "entity_a-buleprint_a",
+        "entity_b-buleprint_a",
+        "entity_c-buleprint_b",
+    ], f"Processed order: {processed_order}"
+
+
+def test_handle_failed_with_self_dependencies() -> None:
+    entity_a = create_entity(
+        "entity_a", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Self dependency
+    entity_b = create_entity(
+        "entity_b", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Depends on entity_a
+    entity_c = create_entity(
+        "entity_c", "buleprint_b", {"dep_name_2": "entity_b"}
+    )  # Depends on entity_b
+
+    entity_topological_sort = EntityTopologicalSorter()
+
+    # Register fails with unsorted order
+    entity_topological_sort.register_entity(entity_c)
+    entity_topological_sort.register_entity(entity_a)
+    entity_topological_sort.register_entity(entity_b)
+
+    processed_order = [
+        f"{entity.identifier}-{entity.blueprint}"
+        for entity in list(entity_topological_sort.get_entities())
+    ]
+
+    assert processed_order == [
+        "entity_a-buleprint_a",
+        "entity_b-buleprint_a",
+        "entity_c-buleprint_b",
+    ], f"Processed order: {processed_order}"
+
+
+def test_handle_failed_with_circular_dependencies() -> None:
+    # processed_order:list[str] = []
+    entity_a = create_entity(
+        "entity_a", "buleprint_a", {"dep_name_1": "entity_b"}
+    )  # Self dependency
+    entity_b = create_entity(
+        "entity_b", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Depends on entity_a
+
+    entity_topological_sort = EntityTopologicalSorter()
+    try:
+        entity_topological_sort.register_entity(entity_a)
+        entity_topological_sort.register_entity(entity_b)
+        entity_topological_sort.get_entities()
+
+    except OceanAbortException as e:
+        assert isinstance(e, OceanAbortException)
+        assert (
+            e.args[0]
+            == "Cannot order entities due to cyclic dependencies. \nIf you do want to have cyclic dependencies, please make sure to set the keys 'createMissingRelatedEntities' and 'deleteDependentEntities' in the integration config in Port."
+        )

port_ocean/tests/helpers/fake_port_api.py

@@ -0,0 +1,191 @@
+import uvicorn
+import os
+from typing import Dict, Any
+from fastapi import FastAPI, Request
+
+SMOKE_TEST_SUFFIX = os.environ.get("SMOKE_TEST_SUFFIX", "smoke")
+
+app = FastAPI()
+
+FAKE_DEPARTMENT_BLUEPRINT = {
+    "identifier": f"fake-department-{SMOKE_TEST_SUFFIX}",
+    "title": "Fake Department",
+    "icon": "Blueprint",
+    "schema": {"properties": {"name": {"type": "string"}, "id": {"type": "string"}}},
+    "relations": {},
+}
+FAKE_PERSON_BLUEPRINT = {
+    "identifier": f"fake-person-{SMOKE_TEST_SUFFIX}",
+    "title": "Fake Person",
+    "icon": "Blueprint",
+    "schema": {
+        "properties": {
+            "status": {
+                "type": "string",
+                "enum": ["WORKING", "NOPE"],
+                "enumColors": {"WORKING": "green", "NOPE": "red"},
+                "title": "Status",
+            },
+            "email": {"type": "string", "format": "email", "title": "Email"},
+            "age": {"type": "number", "title": "Age"},
+            "bio": {"type": "string", "title": "Bio"},
+        }
+    },
+    "relations": {
+        "department": {
+            "title": "Department",
+            "description": "Fake Department",
+            "target": f"fake-department-{SMOKE_TEST_SUFFIX}",
+            "required": False,
+            "many": False,
+        }
+    },
+}
+
+
+@app.router.get("/v1/blueprints/{blueprint_id}")
+@app.router.patch("/v1/blueprints/{blueprint_id}")
+async def get_blueprint(blueprint_id: str) -> Dict[str, Any]:
+    return {
+        "blueprint": (
+            FAKE_PERSON_BLUEPRINT
+            if blueprint_id.startswith("fake-person")
+            else FAKE_DEPARTMENT_BLUEPRINT
+        )
+    }
+
+
+@app.router.post("/v1/entities/search")
+async def search_entities() -> Dict[str, Any]:
+    return {"ok": True, "entities": []}
+
+
+@app.router.get("/v1/integration/{integration_id}")
+@app.router.patch("/v1/integration/{integration_id}")
+@app.router.patch("/v1/integration/{integration_id}/resync-state")
+async def get_integration(integration_id: str) -> Dict[str, Any]:
+    return {
+        "integration": {
+            "identifer": integration_id,
+            "resyncState": {
+                "status": "completed",
+                "lastResyncEnd": "2024-11-20T12:01:54.225362+00:00",
+                "lastResyncStart": "2024-11-20T12:01:45.483844+00:00",
+                "nextResync": None,
+                "intervalInMinuets": None,
+                "updatedAt": "2024-11-20T12:01:54.355Z",
+            },
+            "config": {
+                "deleteDependentEntities": True,
+                "createMissingRelatedEntities": True,
+                "enableMergeEntity": True,
+                "resources": [
+                    {
+                        "kind": "fake-department",
+                        "selector": {"query": "true"},
+                        "port": {
+                            "entity": {
+                                "mappings": {
+                                    "identifier": ".id",
+                                    "title": ".name",
+                                    "blueprint": f'"fake-department-{SMOKE_TEST_SUFFIX}"',
+                                    "properties": {"name": ".name", "id": ".id"},
+                                }
+                            }
+                        },
+                    },
+                    {
+                        "kind": "fake-person",
+                        "selector": {"query": "true"},
+                        "port": {
+                            "entity": {
+                                "mappings": {
+                                    "identifier": ".id",
+                                    "title": ".name",
+                                    "blueprint": f'"fake-person-{SMOKE_TEST_SUFFIX}"',
+                                    "properties": {
+                                        "name": ".name",
+                                        "email": ".email",
+                                        "status": ".status",
+                                        "age": ".age",
+                                        "department": ".department.name",
+                                    },
+                                    "relations": {"department": ".department.id"},
+                                }
+                            }
+                        },
+                    },
+                ],
+            },
+            "installationType": "OnPrem",
+            "_orgId": "org_ZOMGMYUNIQUEID",
+            "_id": "integration_0dOOhnlJQDjMPnfe",
+            "identifier": f"smoke-test-integration-{SMOKE_TEST_SUFFIX}",
+            "integrationType": "smoke-test",
+            "createdBy": "APSQAYsYoIwPXqjn6XpwCAgnPakkNO67",
+            "updatedBy": "APSQAYsYoIwPXqjn6XpwCAgnPakkNO67",
+            "createdAt": "2024-11-20T12:01:42.651Z",
+            "updatedAt": "2024-11-20T12:01:54.355Z",
+            "clientId": "",
+            "logAttributes": {
+                "ingestId": "DOHSAIDHOMER",
+                "ingestUrl": "http://localhost:5555/logs/integration/DOHSAIDHOMER",
+            },
+        },
+    }
+
+
+@app.router.post("/v1/blueprints/{blueprint_id}/entities")
+async def upsert_entities(blueprint_id: str, request: Request) -> Dict[str, Any]:
+    json = await request.json()
+
+    return {
+        "ok": True,
+        "entity": json,
+    }
+
+
+@app.router.post("/v1/auth/access_token")
+async def auth_token() -> Dict[str, Any]:
+    return {
+        "accessToken": "ZOMG",
+        "expiresIn": 1232131231,
+        "tokenType": "adadad",
+    }
+
+
+@app.router.delete("/v1/blueprints/{blueprint_id}/all-entities")
+async def delete_blueprint(blueprint_id: str, request: Request) -> Dict[str, Any]:
+    return {"migrationId": "ZOMG"}
+
+
+@app.router.get("/v1/migrations/{migration_id}")
+async def migration(migration_id: str, request: Request) -> Dict[str, Any]:
+    return {
+        "migration": {
+            "id": migration_id,
+            "status": "COMPLETE",
+            "actor": "Dwayne Scissors Johnson",
+            "sourceBlueprint": "leBlue",
+            "mapping": {},
+        }
+    }
+
+
+CATCH_ALL = "/{full_path:path}"
+
+
+@app.router.get(CATCH_ALL)
+@app.router.post(CATCH_ALL)
+@app.router.patch(CATCH_ALL)
+@app.router.delete(CATCH_ALL)
+async def catch_all(full_path: str, request: Request) -> str:
+    return f"Hello there from fake Port API - {full_path}, thanks for accessing me with {request.method}"
+
+
+def start() -> None:
+    uvicorn.run(app, host="0.0.0.0", port=5555)
+
+
+if __name__ == "__main__":
+    start()

port_ocean/tests/helpers/fixtures.py

@@ -0,0 +1,46 @@
+from os import path
+from typing import Any, Callable, Dict, List, Tuple, Union
+
+import pytest
+import pytest_asyncio
+
+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,
+)
+from port_ocean.tests.helpers.smoke_test import (
+    SmokeTestDetails,
+    get_port_client_for_fake_integration,
+    get_smoke_test_details,
+)
+
+
+@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()
+
+    return smoke_test_details, port_client
+
+
+@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(config_overrides: Union[Dict[str, Any], None] = None) -> Ocean:
+        return get_integration_ocean_app(test_dir, config_overrides)
+
+    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/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/ocean_app.py

@@ -0,0 +1,66 @@
+import sys
+from inspect import getmembers
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
+
+from yaml import safe_load
+
+from port_ocean.bootstrap import create_default_app
+from port_ocean.config.dynamic import default_config_factory
+from port_ocean.core.handlers.port_app_config.models import ResourceConfig
+from port_ocean.core.ocean_types import RESYNC_RESULT
+from port_ocean.ocean import Ocean
+from port_ocean.utils.misc import get_spec_file, load_module
+
+
+def get_integration_ocean_app(
+    integration_path: str, config_overrides: Union[Dict[str, Any], None] = None
+) -> Ocean:
+    spec_file = get_spec_file(Path(integration_path))
+    config_factory = None
+    if spec_file is not None:
+        config_factory = default_config_factory(spec_file.get("configurations", []))
+
+    default_app = create_default_app(
+        integration_path,
+        config_factory,
+        {
+            **(config_overrides or {}),
+            **{
+                "port": {
+                    "client_id": "bla",
+                    "client_secret": "bla",
+                },
+            },
+        },
+    )
+
+    main_path = f"{integration_path}/main.py"
+    sys.path.append(integration_path)
+    app_module = load_module(main_path)
+    app: Ocean = {name: item for name, item in getmembers(app_module)}.get(
+        "app", default_app
+    )
+
+    return app
+
+
+def get_integation_resource_configs(integration_path: str) -> List[ResourceConfig]:
+    config_file_path = f"{integration_path}/.port/resources/port-app-config."
+    if not Path(f"{config_file_path}yml").exists():
+        config_file_path = f"{config_file_path}yaml"
+    else:
+        config_file_path = f"{config_file_path}yml"
+
+    with open(config_file_path) as port_app_config_file:
+        resource_configs = safe_load(port_app_config_file)
+
+    return [ResourceConfig(**item) for item in resource_configs["resources"]]
+
+
+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)
+
+    return resource_result

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/log/test_handlers.py

@@ -0,0 +1,71 @@
+from port_ocean.log.handlers import _serialize_record
+from loguru import logger
+from logging import LogRecord
+from queue import Queue
+from logging.handlers import QueueHandler
+from typing import Callable, Any
+
+
+log_message = "This is a test log message."
+exception_grouop_message = "Test Exception group"
+exception_message = "Test Exception"
+expected_keys = ["message", "level", "timestamp", "extra"]
+
+
+def test_serialize_record_log_shape() -> None:
+    record = log_record(
+        lambda: logger.exception(
+            log_message,
+            exc_info=None,
+        )
+    )
+    serialized_record = _serialize_record(record)
+    assert all(key in serialized_record for key in expected_keys)
+    assert log_message in serialized_record.get("message", None)
+
+
+def test_serialize_record_exc_info_single_exception() -> None:
+    record = log_record(
+        lambda: logger.exception(
+            log_message,
+            exc_info=ExceptionGroup(
+                exception_grouop_message, [Exception(exception_message)]
+            ),
+        )
+    )
+    serialized_record = _serialize_record(record)
+    exc_info = assert_extra(serialized_record.get("extra", {}))
+    assert exception_grouop_message in exc_info
+    assert exception_message in exc_info
+
+
+def test_serialize_record_exc_info_group_exception() -> None:
+    record = log_record(
+        lambda: logger.exception(log_message, exc_info=Exception(exception_message))
+    )
+    serialized_record = _serialize_record(record)
+    exc_info = assert_extra(serialized_record.get("extra", {}))
+    assert exception_message in exc_info
+
+
+def assert_extra(extra: dict[str, Any]) -> str:
+    exc_info = extra.get("exc_info", None)
+    assert isinstance(exc_info, str)
+    return exc_info
+
+
+def log_record(cb: Callable[[], None]) -> LogRecord:
+    queue = Queue[LogRecord]()
+    queue_handler = QueueHandler(queue)
+    logger_id = logger.add(
+        queue_handler,
+        level="DEBUG",
+        format="{message}",
+        diagnose=False,
+        enqueue=True,
+    )
+    cb()
+    logger.complete()
+    logger.remove(logger_id)
+    record = queue.get()
+    return record

port_ocean/tests/test_smoke.py

@@ -0,0 +1,74 @@
+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.smoke_test import SmokeTestDetails
+
+
+pytestmark = pytest.mark.smoke
+
+
+@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
+            ]
+        )