port-ocean 0.28.5__py3-none-any.whl → 0.29.0__py3-none-any.whl

port_ocean/tests/core/handlers/webhook/test_processor_manager.py

@@ -348,6 +348,7 @@ async def test_extractMatchingProcessors_processorMatch(
         assert len(processors) == 1
         config, processor = processors[0]
         assert isinstance(processor, MockProcessor)
+        assert config is not None
         assert config.kind == "repository"
         assert processor.event != webhook_event
         assert processor.event.payload == webhook_event.payload
@@ -414,6 +415,7 @@ async def test_extractMatchingProcessors_onlyOneMatches(
     assert len(processors) == 1
     config, processor = processors[0]
     assert isinstance(processor, MockProcessor)
+    assert config is not None
     assert config.kind == "repository"
     assert processor.event != webhook_event
     assert processor.event.payload == webhook_event.payload
@@ -885,7 +887,7 @@ async def test_integrationTest_postRequestSent_noMatchingHandlers_entityNotUpser
 
     async def patched_extract_matching_processors(
         self: LiveEventsProcessorManager, event: WebhookEvent, path: str
-    ) -> list[tuple[ResourceConfig, AbstractWebhookProcessor]]:
+    ) -> list[tuple[ResourceConfig | None, AbstractWebhookProcessor]]:
         try:
             return await original_process_data(self, event, path)
         except Exception as e:

port_ocean/tests/core/utils/test_get_port_diff.py

@@ -0,0 +1,164 @@
+from typing import Any
+
+from port_ocean.core.models import Entity
+from port_ocean.core.utils.utils import get_port_diff
+
+
+def create_test_entity(
+    identifier: str,
+    blueprint: str,
+    properties: dict[str, Any],
+    relations: dict[str, Any],
+    title: Any,
+    team: str | None | list[Any] = [],
+) -> Entity:
+    return Entity(
+        identifier=identifier,
+        blueprint=blueprint,
+        properties=properties,
+        relations=relations,
+        title=title,
+        team=team,
+    )
+
+
+entity1 = create_test_entity(
+    "id1",
+    "bp1",
+    {"totalIssues": 123, "url": "https://test.atlassian.net/browse/test-29081"},
+    {"reporter": "id1", "project": "project_id"},
+    "",
+    "",
+)
+entity1_modified_properties = create_test_entity(
+    "id1",
+    "bp1",
+    {"totalIssues": 5, "url": "https://test.atlassian.net/browse/test-29081"},
+    {"reporter": "id1", "project": "project_id"},
+    "",
+    "",
+)
+entity2 = create_test_entity(
+    "id2",
+    "bp2",
+    {"totalIssues": 234, "url": "https://test.atlassian.net/browse/test-23451"},
+    {"reporter": "id2", "project": "project_id2"},
+    "",
+    "",
+)
+entity3 = create_test_entity(
+    "id3",
+    "bp3",
+    {"totalIssues": 20, "url": "https://test.atlassian.net/browse/test-542"},
+    {"reporter": "id3", "project": "project_id3"},
+    "",
+    "",
+)
+
+
+def test_get_port_diff_with_dictionary_identifier() -> None:
+    """
+    Test that get_port_diff handles dictionary identifiers by converting them to strings.
+    An entity with a dictionary identifier in 'before' and not in 'after' should be marked as deleted.
+    """
+    entity_with_dict_id = create_test_entity(
+        identifier={"rules": "some_id", "combinator": "some combinator"},  # type: ignore
+        blueprint="bp1",
+        properties={},
+        relations={},
+        title="test",
+    )
+    before = [entity_with_dict_id]
+    after: list[Entity] = []
+
+    diff = get_port_diff(before, after)
+
+    assert not diff.created
+    assert not diff.modified
+    assert len(diff.deleted) == 1
+    assert entity_with_dict_id in diff.deleted
+
+
+def test_get_port_diff_no_changes() -> None:
+    """
+    Test get_port_diff with no changes between before and after.
+    Entities present in both should be in the 'modified' list.
+    """
+    before = [entity1, entity2]
+    after = [entity1, entity2]
+
+    diff = get_port_diff(before, after)
+
+    assert not diff.created
+    assert not diff.deleted
+    assert len(diff.modified) == 2
+    assert entity1 in diff.modified
+    assert entity2 in diff.modified
+
+
+def test_get_port_diff_created_entities() -> None:
+    """
+    Test get_port_diff with only new entities.
+    """
+    before: list[Entity] = []
+    after = [entity1, entity2]
+
+    diff = get_port_diff(before, after)
+
+    assert not diff.modified
+    assert not diff.deleted
+    assert len(diff.created) == 2
+    assert entity1 in diff.created
+    assert entity2 in diff.created
+
+
+def test_get_port_diff_deleted_entities() -> None:
+    """
+    Test get_port_diff with only deleted entities.
+    """
+    before = [entity1, entity2]
+    after: list[Entity] = []
+
+    diff = get_port_diff(before, after)
+
+    assert not diff.created
+    assert not diff.modified
+    assert len(diff.deleted) == 2
+    assert entity1 in diff.deleted
+    assert entity2 in diff.deleted
+
+
+def test_get_port_diff_modified_entities() -> None:
+    """
+    Test get_port_diff with modified entities.
+    Entities with same identifier and blueprint are considered modified.
+    """
+    before = [entity1, entity2]
+    after = [entity1_modified_properties, entity2]
+
+    diff = get_port_diff(before, after)
+
+    assert not diff.created
+    assert not diff.deleted
+    assert len(diff.modified) == 2
+    assert entity1_modified_properties in diff.modified
+    assert entity2 in diff.modified
+
+
+def test_get_port_diff_mixed_changes() -> None:
+    """
+    Test get_port_diff with a mix of created, modified, and deleted entities.
+    """
+    before = [entity1, entity2]
+    after = [entity1_modified_properties, entity3]
+
+    diff = get_port_diff(before, after)
+
+    assert len(diff.created) == 1
+    assert entity3 in diff.created
+
+    assert len(diff.modified) == 1
+    assert entity1_modified_properties in diff.modified
+
+    assert len(diff.deleted) == 1
+    assert entity2 in diff.deleted

port_ocean/tests/helpers/test_retry.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 from http import HTTPStatus
 import httpx
 
@@ -307,3 +307,243 @@ class TestRetryConfigIntegration:
             "Retry-After",
         ]
         assert HTTPStatus.FORBIDDEN in transport._retry_config.retry_status_codes
+
+
+class TestResponseSizeLogging:
+    """Tests for response size logging functionality."""
+
+    def setup_method(self) -> None:
+        """Reset global callback state before each test."""
+        retry_module._RETRY_CONFIG_CALLBACK = None
+        retry_module._ON_RETRY_CALLBACK = None
+
+    def test_should_log_response_size_with_logger(self) -> None:
+        """Test _should_log_response_size returns True when logger is present and not getport.io."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.example.com"
+
+        assert transport._should_log_response_size(mock_request) is True
+
+    def test_should_log_response_size_without_logger(self) -> None:
+        """Test _should_log_response_size returns False when no logger."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.example.com"
+
+        assert transport._should_log_response_size(mock_request) is False
+
+    def test_should_log_response_size_getport_io(self) -> None:
+        """Test _should_log_response_size returns False for getport.io domains."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.getport.io"
+
+        assert transport._should_log_response_size(mock_request) is False
+
+    def test_get_content_length_from_headers(self) -> None:
+        """Test _get_content_length extracts content length from headers."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "1024"}
+
+        assert transport._get_content_length(mock_response) == 1024
+
+    def test_get_content_length_case_insensitive(self) -> None:
+        """Test _get_content_length works with case insensitive headers."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {"content-length": "2048"}
+
+        assert transport._get_content_length(mock_response) == 2048
+
+    def test_get_content_length_no_header(self) -> None:
+        """Test _get_content_length returns None when no content-length header."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {}
+
+        assert transport._get_content_length(mock_response) is None
+
+    def test_get_content_length_invalid_value(self) -> None:
+        """Test _get_content_length handles invalid header values."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "invalid"}
+
+        # Should raise ValueError when converting to int
+        with pytest.raises(ValueError):
+            transport._get_content_length(mock_response)
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_with_content_length(self, mock_cast: Mock) -> None:
+        """Test _log_response_size logs when Content-Length header is present."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        mock_cast.return_value = mock_logger
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.method = "GET"
+        mock_url = Mock()
+        mock_url.host = "api.example.com"
+        mock_url.configure_mock(__str__=lambda self: "https://api.example.com/data")
+        mock_request.url = mock_url
+
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "1024"}
+
+        transport._log_response_size(mock_request, mock_response)
+
+        mock_logger.info.assert_called_once_with(
+            "Response for GET https://api.example.com/data - Size: 1024 bytes"
+        )
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_without_content_length(self, mock_cast: Mock) -> None:
+        """Test _log_response_size does nothing when no Content-Length header."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        mock_cast.return_value = mock_logger
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.method = "POST"
+        mock_url = Mock()
+        mock_url.host = "api.example.com"
+        mock_url.configure_mock(__str__=lambda self: "https://api.example.com/create")
+        mock_request.url = mock_url
+
+        mock_response = Mock()
+        mock_response.headers = {}
+
+        transport._log_response_size(mock_request, mock_response)
+
+        mock_response.read.assert_not_called()
+        mock_logger.info.assert_not_called()
+
+    # Read error path removed since _log_response_size no longer reads body
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_skips_when_should_not_log(self, mock_cast: Mock) -> None:
+        """Test _log_response_size skips logging when _should_log_response_size returns False."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        mock_cast.return_value = mock_logger
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.getport.io"  # This should skip logging
+
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "1024"}
+
+        transport._log_response_size(mock_request, mock_response)
+
+        mock_logger.info.assert_not_called()
+
+
+class TestResponseSizeLoggingIntegration:
+    """Integration tests to verify response consumption works after size logging."""
+
+    def setup_method(self) -> None:
+        """Reset global callback state before each test."""
+        retry_module._RETRY_CONFIG_CALLBACK = None
+        retry_module._ON_RETRY_CALLBACK = None
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_preserves_json_consumption(
+        self, mock_cast: Mock
+    ) -> None:
+        """When no Content-Length, no logging/reading occurs; response usable."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        mock_cast.return_value = mock_logger
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.method = "GET"
+        mock_request.url.host = "api.example.com"
+
+        mock_response = Mock()
+        mock_response.headers = {}
+        mock_response.json.return_value = {"message": "test", "data": [1, 2, 3]}
+
+        transport._log_response_size(mock_request, mock_response)
+
+        mock_logger.info.assert_not_called()
+        result = mock_response.json()
+        assert result == {"message": "test", "data": [1, 2, 3]}
+        mock_response.read.assert_not_called()
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_with_content_length_preserves_json(
+        self, mock_cast: Mock
+    ) -> None:
+        """Test that _log_response_size with Content-Length header preserves JSON consumption."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        mock_cast.return_value = mock_logger
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.method = "POST"
+        mock_request.url.host = "api.example.com"
+
+        # Create a mock response with Content-Length header
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "1024"}
+        mock_response.json.return_value = {"status": "success", "id": 123}
+
+        # Call the logging function
+        transport._log_response_size(mock_request, mock_response)
+
+        # Verify logging occurred
+        mock_logger.info.assert_called_once()
+
+        # Verify that response.json() can still be called
+        result = mock_response.json()
+        assert result == {"status": "success", "id": 123}
+
+        # Verify that read was NOT called since we had Content-Length
+        mock_response.read.assert_not_called()
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_preserves_text_consumption(
+        self, mock_cast: Mock
+    ) -> None:
+        """When no Content-Length, no logging/reading; response.text still accessible."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        mock_cast.return_value = mock_logger
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.method = "GET"
+        mock_request.url.host = "api.example.com"
+
+        mock_response = Mock()
+        mock_response.headers = {}
+        mock_response.text = "Hello, World! This is a test response."
+
+        transport._log_response_size(mock_request, mock_response)
+
+        mock_logger.info.assert_not_called()
+        assert mock_response.text == "Hello, World! This is a test response."
+        mock_response.read.assert_not_called()

port_ocean/tests/utils/test_cache.py

@@ -272,3 +272,243 @@ async def test_cache_failures_dont_affect_execution(
     # Verify that both read and write errors were raised
     assert isinstance(mock_cache_provider.get.side_effect, FailedToReadCacheError)
     assert isinstance(mock_cache_provider.set.side_effect, FailedToWriteCacheError)
+
+
+@pytest.mark.asyncio
+async def test_cache_iterator_result_on_instance_method(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    class Sample:
+        def __init__(self) -> None:
+            self.calls = 0
+
+        @cache.cache_iterator_result()
+        async def inst_method(self, x: int) -> AsyncGenerator[List[int], None]:
+            self.calls += 1
+            for i in range(x):
+                await asyncio.sleep(0.01)
+                yield [i]
+
+    s = Sample()
+
+    # First call should MISS and increment calls
+    result1 = await collect_iterator_results(s.inst_method(3))
+    assert result1 == [0, 1, 2]
+    assert s.calls == 1
+
+    # Second call with same args should HIT cache
+    result2 = await collect_iterator_results(s.inst_method(3))
+    assert result2 == [0, 1, 2]
+    assert s.calls == 1  # no extra call
+
+    # Different args should MISS again
+    result3 = await collect_iterator_results(s.inst_method(4))
+    assert result3 == [0, 1, 2, 3]
+    assert s.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_cache_iterator_result_on_class_method(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    class Sample:
+        calls = 0
+
+        @classmethod
+        @cache.cache_iterator_result()
+        async def cls_method(cls, x: int) -> AsyncGenerator[List[int], None]:
+            cls.calls += 1
+            for i in range(x):
+                await asyncio.sleep(0.01)
+                yield [i]
+
+    # First call should MISS
+    result1 = await collect_iterator_results(Sample.cls_method(3))
+    assert result1 == [0, 1, 2]
+    assert Sample.calls == 1
+
+    # Second call with same args should HIT cache
+    result2 = await collect_iterator_results(Sample.cls_method(3))
+    assert result2 == [0, 1, 2]
+    assert Sample.calls == 1
+
+    # Different args should MISS
+    result3 = await collect_iterator_results(Sample.cls_method(2))
+    assert result3 == [0, 1]
+    assert Sample.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_cache_iterator_result_on_static_method(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    class Sample:
+        calls = 0
+
+        @staticmethod
+        @cache.cache_iterator_result()
+        async def static_method(x: int) -> AsyncGenerator[List[int], None]:
+            Sample.calls += 1
+            for i in range(x):
+                await asyncio.sleep(0.01)
+                yield [i]
+
+    # First call should MISS
+    result1 = await collect_iterator_results(Sample.static_method(3))
+    assert result1 == [0, 1, 2]
+    assert Sample.calls == 1
+
+    # Second call with same args should HIT
+    result2 = await collect_iterator_results(Sample.static_method(3))
+    assert result2 == [0, 1, 2]
+    assert Sample.calls == 1
+
+    # Different args should MISS
+    result3 = await collect_iterator_results(Sample.static_method(4))
+    assert result3 == [0, 1, 2, 3]
+    assert Sample.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_regular_iterator_with_self_param_not_filtered(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    """Test that regular iterator functions with 'self' parameter are not filtered (by design)."""
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    async def regular_function_with_self(
+        self: int, y: int
+    ) -> AsyncGenerator[List[int], None]:
+        for i in range(self + y):
+            await asyncio.sleep(0.01)
+            yield [i]
+
+    # Test that 'self' parameter IS filtered (by design, for consistency)
+    key1 = cache.hash_func(regular_function_with_self, 5, y=3)
+    key2 = cache.hash_func(regular_function_with_self, 4, y=3)
+
+    # Keys should not be the same because 'self' is not filtered (by design)
+    assert key1 != key2
+
+
+@pytest.mark.asyncio
+async def test_cache_coroutine_result_on_instance_method(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    class Sample:
+        def __init__(self) -> None:
+            self.calls = 0
+
+        @cache.cache_coroutine_result()
+        async def inst_method(self, x: int) -> int:
+            self.calls += 1
+            await asyncio.sleep(0.01)
+            return x * 2
+
+    s = Sample()
+
+    # First call should MISS and increment calls
+    result1 = await s.inst_method(3)
+    assert result1 == 6
+    assert s.calls == 1
+
+    # Second call with same args should HIT cache
+    result2 = await s.inst_method(3)
+    assert result2 == 6
+    assert s.calls == 1  # still 1 call
+
+    # Different args should MISS again
+    result3 = await s.inst_method(4)
+    assert result3 == 8
+    assert s.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_cache_coroutine_result_on_class_method(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    class Sample:
+        calls = 0
+
+        @classmethod
+        @cache.cache_coroutine_result()
+        async def cls_method(cls, x: int) -> int:
+            cls.calls += 1
+            await asyncio.sleep(0.01)
+            return x + 5
+
+    # First call should MISS
+    result1 = await Sample.cls_method(3)
+    assert result1 == 8
+    assert Sample.calls == 1
+
+    # Second call with same args should HIT
+    result2 = await Sample.cls_method(3)
+    assert result2 == 8
+    assert Sample.calls == 1
+
+    # Different args should MISS
+    result3 = await Sample.cls_method(2)
+    assert result3 == 7
+    assert Sample.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_cache_coroutine_result_on_static_method(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    class Sample:
+        calls = 0
+
+        @staticmethod
+        @cache.cache_coroutine_result()
+        async def static_method(x: int) -> int:
+            Sample.calls += 1
+            await asyncio.sleep(0.01)
+            return x * x
+
+    # First call should MISS
+    result1 = await Sample.static_method(3)
+    assert result1 == 9
+    assert Sample.calls == 1
+
+    # Second call with same args should HIT
+    result2 = await Sample.static_method(3)
+    assert result2 == 9
+    assert Sample.calls == 1
+
+    # Different args should MISS
+    result3 = await Sample.static_method(4)
+    assert result3 == 16
+    assert Sample.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_regular_coroutine_with_self_param_not_filtered(
+    mock_ocean: Any, monkeypatch: Any
+) -> None:
+    """Test that regular coroutines with 'self' parameter are not filtered (by design)."""
+    monkeypatch.setattr(cache, "ocean", mock_ocean)
+
+    @cache.cache_coroutine_result()
+    async def regular_function_with_self(self: int, y: int) -> int:
+        await asyncio.sleep(0.01)
+        return self + y
+
+    key1 = cache.hash_func(regular_function_with_self, 5, y=3)
+    key2 = cache.hash_func(regular_function_with_self, 4, y=3)
+
+    # Keys should not be the same because 'self' is not filtered
+    assert key1 != key2