port-ocean 0.22.0__tar.gz → 0.22.1__tar.gz

{port_ocean-0.22.0 → port_ocean-0.22.1}/PKG-INFO

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

@@ -133,7 +133,7 @@ class EntityClientMixin:
         request_options: RequestOptions,
         user_agent_type: UserAgentType | None = None,
         should_raise: bool = True,
-    ) -> list[Entity]:
+    ) -> list[tuple[bool, Entity]]:
         modified_entities_results = await asyncio.gather(
             *(
                 self.upsert_entity(
@@ -146,17 +146,17 @@ class EntityClientMixin:
             ),
             return_exceptions=True,
         )
-        entity_results = [
-            entity for entity in modified_entities_results if isinstance(entity, Entity)
-        ]
-        if not should_raise:
-            return entity_results
 
-        for entity_result in modified_entities_results:
-            if isinstance(entity_result, Exception):
-                raise entity_result
+        entities_results: list[tuple[bool, Entity]] = []
+        for original_entity, result in zip(entities, modified_entities_results):
+            if isinstance(result, Exception) and should_raise:
+                raise result
+            elif isinstance(result, Entity):
+                entities_results.append((True, result))
+            elif result is False:
+                entities_results.append((False, original_entity))
 
-        return entity_results
+        return entities_results
 
     async def delete_entity(
         self,

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/core/defaults/common.py

@@ -68,6 +68,7 @@ def deconstruct_blueprints_to_creation_steps(
         with_relations.append(blueprint.copy())
 
         blueprint.pop("teamInheritance", {})
+        blueprint.pop("ownership", {})
         blueprint.pop("relations", {})
         bare_blueprint.append(blueprint)
 

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/core/defaults/initialize.py

@@ -42,8 +42,8 @@ def deconstruct_blueprints_to_creation_steps(
         blueprint.pop("mirrorProperties", {})
         blueprint.pop("aggregationProperties", {})
         with_relations.append(blueprint.copy())
-
         blueprint.pop("teamInheritance", {})
+        blueprint.pop("ownership", {})
         blueprint.pop("relations", {})
         bare_blueprint.append(blueprint)
 

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/core/handlers/entities_state_applier/port/applier.py

@@ -121,26 +121,20 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
     ) -> list[Entity]:
         logger.info(f"Upserting {len(entities)} entities")
         modified_entities: list[Entity] = []
-        if event.port_app_config.create_missing_related_entities:
-            modified_entities = await self.context.port_client.batch_upsert_entities(
-                entities,
-                event.port_app_config.get_port_request_options(),
-                user_agent_type,
-                should_raise=False,
-            )
-        else:
-            for entity in entities:
-                upsertedEntity = await self.context.port_client.upsert_entity(
-                    entity,
-                    event.port_app_config.get_port_request_options(),
-                    user_agent_type,
-                    should_raise=False,
-                )
-                if upsertedEntity:
-                    modified_entities.append(upsertedEntity)
-                # condition to false to differentiate from `result_entity.is_using_search_identifier`
-                if upsertedEntity is False:
-                    event.entity_topological_sorter.register_entity(entity)
+        upserted_entities: list[tuple[bool, Entity]] = []
+
+        upserted_entities = await self.context.port_client.batch_upsert_entities(
+            entities,
+            event.port_app_config.get_port_request_options(),
+            user_agent_type,
+            should_raise=False,
+        )
+
+        for is_upserted, entity in upserted_entities:
+            if is_upserted:
+                modified_entities.append(entity)
+            else:
+                event.entity_topological_sorter.register_entity(entity)
         return modified_entities
 
     async def delete(

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/core/handlers/port_app_config/models.py

@@ -22,7 +22,7 @@ class EntityMapping(BaseModel):
     identifier: str | IngestSearchQuery
     title: str | None
     blueprint: str
-    team: str | None
+    team: str | IngestSearchQuery | None
     properties: dict[str, str] = Field(default_factory=dict)
     relations: dict[str, str | IngestSearchQuery] = Field(default_factory=dict)
 

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/core/models.py

@@ -40,7 +40,7 @@ class Entity(BaseModel):
     identifier: Any
     blueprint: Any
     title: Any
-    team: str | None | list[Any] = []
+    team: str | None | list[Any] | dict[str, Any] = []
     properties: dict[str, Any] = {}
     relations: dict[str, Any] = {}
 
@@ -50,7 +50,11 @@ class Entity(BaseModel):
 
     @property
     def is_using_search_relation(self) -> bool:
-        return any(isinstance(relation, dict) for relation in self.relations.values())
+        return any(
+            isinstance(relation, dict) for relation in self.relations.values()
+        ) or (
+            self.team is not None and any(isinstance(team, dict) for team in self.team)
+        )
 
 
 class BlueprintRelation(BaseModel):

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/core/utils/utils.py

@@ -110,7 +110,8 @@ def get_port_diff(before: Iterable[Entity], after: Iterable[Entity]) -> EntityPo
 
 
 def are_teams_different(
-    first_team: str | None | list[Any], second_team: str | None | list[Any]
+    first_team: str | None | list[Any] | dict[str, Any],
+    second_team: str | None | list[Any] | dict[str, Any],
 ) -> bool:
     if isinstance(first_team, list) and isinstance(second_team, list):
         return sorted(first_team) != sorted(second_team)
@@ -122,6 +123,7 @@ def are_entities_fields_equal(
 ) -> bool:
     """
     Compare two entity fields by serializing them to JSON and comparing their SHA-256 hashes.
+    Removes keys with None values before comparison if the corresponding key doesn't exist in the other dict.
 
     Args:
         first_entity_field: First entity field dictionary to compare
@@ -130,7 +132,13 @@ def are_entities_fields_equal(
     Returns:
         bool: True if the entity fields have identical content
     """
-    first_props = json.dumps(first_entity_field, sort_keys=True)
+    first_entity_field_copy = first_entity_field.copy()
+
+    for key in list(first_entity_field.keys()):
+        if first_entity_field[key] is None and key not in second_entity_field:
+            del first_entity_field_copy[key]
+
+    first_props = json.dumps(first_entity_field_copy, sort_keys=True)
     second_props = json.dumps(second_entity_field, sort_keys=True)
     first_hash = hashlib.sha256(first_props.encode()).hexdigest()
     second_hash = hashlib.sha256(second_props.encode()).hexdigest()

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/tests/clients/port/mixins/test_entities.py

@@ -41,8 +41,9 @@ async def test_batch_upsert_entities_read_timeout_should_raise_false(
         result_entities = await entity_client.batch_upsert_entities(
             entities=all_entities, request_options=MagicMock(), should_raise=False
         )
+        entities_only = [entity for _, entity in result_entities]
 
-        assert result_entities == expected_result_entities
+        assert entities_only == expected_result_entities
 
 
 async def test_batch_upsert_entities_read_timeout_should_raise_true(

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/tests/core/conftest.py

@@ -177,10 +177,11 @@ def create_entity(
     blueprint: str,
     relation: dict[str, str] | None = None,
     is_to_fail: bool = False,
+    team: str | list[str] | dict[str, Any] | None = None,
 ) -> Entity:
     if relation is None:
         relation = {}
-    entity = Entity(identifier=id, blueprint=blueprint)
+    entity = Entity(identifier=id, blueprint=blueprint, team=team)
     entity.relations = relation
     entity.properties = {"mock_is_to_fail": is_to_fail}
     return entity

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/tests/core/handlers/entities_state_applier/test_applier.py

@@ -130,6 +130,74 @@ async def test_applier_with_mock_context(
             assert result[0].identifier == "test_entity"
 
 
+@pytest.mark.asyncio
+async def test_applier_one_not_upserted(
+    mock_ocean: Ocean,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Create an applier using the mock_context fixture
+    applier = HttpEntitiesStateApplier(mock_context)
+
+    # Create test entities
+    entity = Entity(identifier="test_entity", blueprint="test_blueprint")
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        # Mock the register_entity method
+        event.entity_topological_sorter.register_entity = Mock()  # type: ignore
+        event.port_app_config = mock_port_app_config
+
+        # Test the upsert method with mocked client
+        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
+            mock_post.return_value = Mock(
+                status_code=404,
+                json=lambda: {"ok": False, "error": "not_found"},
+            )
+
+            result = await applier.upsert([entity], UserAgentType.exporter)
+
+            # Assert that the post method was called
+            mock_post.assert_called_once()
+            assert len(result) == 0
+            event.entity_topological_sorter.register_entity.assert_called_once_with(
+                entity
+            )
+
+
+@pytest.mark.asyncio
+async def test_applier_error_upserting(
+    mock_ocean: Ocean,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Create an applier using the mock_context fixture
+    applier = HttpEntitiesStateApplier(mock_context)
+
+    # Create test entities
+    entity = Entity(identifier="test_entity", blueprint="test_blueprint")
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        # Mock the register_entity method
+        event.entity_topological_sorter.register_entity = Mock()  # type: ignore
+        event.port_app_config = mock_port_app_config
+
+        # Test the upsert method with mocked client
+        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
+            mock_post.return_value = Mock(
+                status_code=404,
+                json=lambda: {"ok": False, "error": "not_found"},
+            )
+
+            result = await applier.upsert([entity], UserAgentType.exporter)
+
+            # Assert that the post method was called
+            mock_post.assert_called_once()
+            assert len(result) == 0
+            event.entity_topological_sorter.register_entity.assert_called_once_with(
+                entity
+            )
+
+
 @pytest.mark.asyncio
 async def test_using_create_entity_helper(
     mock_ocean: Ocean,

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -417,6 +417,30 @@ async def test_map_entities_compared_with_port_no_port_entities_all_entities_are
     assert "entity_2" in [e.identifier for e in changed_entities]
 
 
+@pytest.mark.asyncio
+async def test_map_entities_compared_with_port_returns_original_entities_when_using_team_search_query(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_resource_config: ResourceConfig,
+) -> None:
+
+    team_search_query = {
+        "combinator": "and",
+        "rules": [{"property": "$team", "operator": "=", "value": "my-team"}],
+    }
+
+    entities = [
+        create_entity("entity_1", "service", {}, False, team=team_search_query),
+        create_entity("entity_2", "service", {}, False, team=team_search_query),
+    ]
+
+    changed_entities = await mock_sync_raw_mixin._map_entities_compared_with_port(
+        entities, mock_resource_config, UserAgentType.exporter
+    )
+
+    assert len(changed_entities) == 2
+    assert changed_entities == entities
+
+
 @pytest.mark.asyncio
 async def test_map_entities_compared_with_port_with_existing_entities_only_changed_third_party_entities_are_mapped(
     mock_sync_raw_mixin: SyncRawMixin,

{port_ocean-0.22.0 → port_ocean-0.22.1}/port_ocean/tests/core/utils/test_resolve_entities_diff.py

@@ -246,6 +246,58 @@ def test_are_entities_fields_equal_different_nested_relations_should_be_false()
     )
 
 
+def test_are_entities_fields_equal_null_properties_should_be_true() -> None:
+    assert (
+        are_entities_fields_equal(
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+            {"members": ["user1", "user2"], "metadata": {"role": "admin"}},
+        )
+        is True
+    )
+
+
+def test_are_entities_fields_equal_null_properties_and_real_data_in_other_entity_should_be_false() -> (
+    None
+):
+    assert (
+        are_entities_fields_equal(
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+            {
+                "team": "team_id1",
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+        )
+        is False
+    )
+
+
+def test_are_entities_fields_equal_null_properties_in_both_should_be_true() -> None:
+    assert (
+        are_entities_fields_equal(
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+        )
+        is True
+    )
+
+
 def test_are_entities_different_identical_entities_should_be_false() -> None:
     entity1 = create_test_entity(
         "",

{port_ocean-0.22.0 → port_ocean-0.22.1}/pyproject.toml

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