[Core] Added metrics to the unit tests (#1688)

# Description

What - added metrics to the tests

Why - want to test the metrics as well

How - removed the mocks

## Type of change

Please leave one option from the following and delete the rest:

- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] New Integration (non-breaking change which adds a new integration)
- [ ] Breaking change (fix or feature that would cause existing
functionality to not work as expected)
- [ ] Non-breaking change (fix of existing functionality that will not
change current behavior)
- [ ] Documentation (added/updated documentation)

<h4> All tests should be run against the port production
environment(using a testing org). </h4>

### Core testing checklist

- [ ] Integration able to create all default resources from scratch
- [ ] Resync finishes successfully
- [ ] Resync able to create entities
- [ ] Resync able to update entities
- [ ] Resync able to detect and delete entities
- [ ] Scheduled resync able to abort existing resync and start a new one
- [ ] Tested with at least 2 integrations from scratch
- [ ] Tested with Kafka and Polling event listeners
- [ ] Tested deletion of entities that don't pass the selector


### Integration testing checklist

- [ ] Integration able to create all default resources from scratch
- [ ] Resync able to create entities
- [ ] Resync able to update entities
- [ ] Resync able to detect and delete entities
- [ ] Resync finishes successfully
- [ ] If new resource kind is added or updated in the integration, add
example raw data, mapping and expected result to the `examples` folder
in the integration directory.
- [ ] If resource kind is updated, run the integration with the example
data and check if the expected result is achieved
- [ ] If new resource kind is added or updated, validate that
live-events for that resource are working as expected
- [ ] Docs PR link [here](#)

### Preflight checklist

- [ ] Handled rate limiting
- [ ] Handled pagination
- [ ] Implemented the code in async
- [ ] Support Multi account

## Screenshots

Include screenshots from your environment showing how the resources of
the integration will look.

## API Documentation

Provide links to the API documentation used for this integration.

Author: yaelibarg

port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -1,5 +1,5 @@
 from graphlib import CycleError
-from typing import Any
+from typing import Any, AsyncGenerator
 
 from port_ocean.clients.port.client import PortClient
 from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
@@ -25,6 +25,8 @@
 from dataclasses import dataclass
 from typing import List, Optional
 from port_ocean.tests.core.conftest import create_entity, no_op_event_context
+from port_ocean.helpers.metric.metric import Metrics
+from port_ocean.config.settings import MetricsSettings, IntegrationSettings
 
 
 @pytest.fixture
@@ -37,7 +39,47 @@ def mock_sync_raw_mixin(
     sync_raw_mixin._entity_processor = mock_entity_processor
     sync_raw_mixin._entities_state_applier = mock_entities_state_applier
     sync_raw_mixin._port_app_config_handler = mock_port_app_config_handler
-    sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([{}], []))  # type: ignore
+
+    # Create raw data that matches the entity structure
+    raw_data = [
+        {
+            "id": "entity_1",
+            "name": "Entity 1",
+            "service": "entity_3",
+            "web_url": "https://example.com/entity1",
+        },
+        {
+            "id": "entity_2",
+            "name": "Entity 2",
+            "service": "entity_4",
+            "web_url": "https://example.com/entity2",
+        },
+        {
+            "id": "entity_3",
+            "name": "Entity 3",
+            "service": "",
+            "web_url": "https://example.com/entity3",
+        },
+        {
+            "id": "entity_4",
+            "name": "Entity 4",
+            "service": "entity_3",
+            "web_url": "https://example.com/entity4",
+        },
+        {
+            "id": "entity_5",
+            "name": "Entity 5",
+            "service": "entity_1",
+            "web_url": "https://example.com/entity5",
+        },
+    ]
+
+    # Create an async generator that yields the raw data
+    async def raw_results_generator() -> AsyncGenerator[list[dict[str, Any]], None]:
+        yield raw_data
+
+    # Return a list containing the async generator and an empty error list
+    sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([raw_results_generator()], []))  # type: ignore
     sync_raw_mixin._entity_processor.parse_items = AsyncMock(return_value=MagicMock())  # type: ignore
 
     return sync_raw_mixin
@@ -62,9 +104,15 @@ def mock_ocean(mock_port_client: PortClient) -> Ocean:
         ocean_mock.config.port = MagicMock()
         ocean_mock.config.port.port_app_config_cache_ttl = 60
         ocean_mock.port_client = mock_port_client
-        ocean_mock.metrics = MagicMock()
-        ocean_mock.metrics.post_metrics = AsyncMock()
-        ocean_mock.metrics.flush = AsyncMock()
+
+        # Create real metrics instance
+        metrics_settings = MetricsSettings(enabled=True)
+        integration_settings = IntegrationSettings(type="test", identifier="test")
+        ocean_mock.metrics = Metrics(
+            metrics_settings=metrics_settings,
+            integration_configuration=integration_settings,
+            port_client=mock_port_client,
+        )
 
         return ocean_mock
 
@@ -81,13 +129,17 @@ async def test_sync_raw_mixin_self_dependency(
     entities = [create_entity(*entity_param) for entity_param in entities_params]
 
     calc_result_mock = MagicMock()
-    calc_result_mock.entity_selector_diff.passed = entities
-    calc_result_mock.errors = []
+    calc_result_mock.entity_selector_diff = EntitySelectorDiff(
+        passed=entities, failed=[]  # No failed entities in this test case
+    )
+    calc_result_mock.errors = []  # No errors in this test case
+    calc_result_mock.number_of_transformed_entities = len(
+        entities
+    )  # Add this to match real behavior
+    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
 
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
-    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
-    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
-    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
+
     mock_order_by_entities_dependencies = MagicMock(
         side_effect=EntityTopologicalSorter.order_by_entities_dependencies
     )
@@ -126,6 +178,50 @@ async def test_sync_raw_mixin_self_dependency(
                     for call in mock_order_by_entities_dependencies.call_args_list
                 ] == [entity for entity in entities if entity.identifier == "entity_1"]
 
+                # Add assertions for actual metrics
+                metrics = mock_ocean.metrics.generate_metrics()
+                assert len(metrics) == 2
+
+                # Verify object counts
+                for metric in metrics:
+                    if metric["kind"] == "project":
+                        assert (
+                            metric["metrics"]["phase"]["extract"]["object_count_type"][
+                                "raw_extracted"
+                            ]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["transformed"]["object_count"]
+                            == 2
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["filtered_out"]["object_count"]
+                            == 3
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 1
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "loaded"
+                            ]["object_count"]
+                            == 1
+                        )
+
+                        # Verify success
+                        assert metric["metrics"]["phase"]["resync"]["success"] == 1
+
+                        # Verify sync state
+                        assert metric["syncState"] == "completed"
+
 
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_circular_dependency(
@@ -138,13 +234,17 @@ async def test_sync_raw_mixin_circular_dependency(
     entities = [create_entity(*entity_param) for entity_param in entities_params]
 
     calc_result_mock = MagicMock()
-    calc_result_mock.entity_selector_diff.passed = entities
-    calc_result_mock.errors = []
+    calc_result_mock.entity_selector_diff = EntitySelectorDiff(
+        passed=entities, failed=[]  # No failed entities in this test case
+    )
+    calc_result_mock.errors = []  # No errors in this test case
+    calc_result_mock.number_of_transformed_entities = len(
+        entities
+    )  # Add this to match real behavior
+    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
 
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
-    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
-    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
-    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
+
     mock_order_by_entities_dependencies = MagicMock(
         side_effect=EntityTopologicalSorter.order_by_entities_dependencies
     )
@@ -206,11 +306,56 @@ def handle_failed_wrapper(*args: Any, **kwargs: Any) -> Any:
                     == 2
                 )
 
+                # Add assertions for actual metrics
+                metrics = mock_ocean.metrics.generate_metrics()
+                assert len(metrics) == 2
+
+                # Verify object counts
+                for metric in metrics:
+                    if metric["kind"] == "project":
+                        assert (
+                            metric["metrics"]["phase"]["extract"]["object_count_type"][
+                                "raw_extracted"
+                            ]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["transformed"]["object_count"]
+                            == 2
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["filtered_out"]["object_count"]
+                            == 3
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 2
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "loaded"
+                            ]["object_count"]
+                            == 0
+                        )
+
+                        # Verify success
+                        assert metric["metrics"]["phase"]["resync"]["success"] == 1
+
+                        # Verify sync state
+                        assert metric["syncState"] == "completed"
+
 
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_dependency(
     mock_sync_raw_mixin: SyncRawMixin, mock_ocean: Ocean
 ) -> None:
+    # Create entities with more realistic data
     entities_params = [
         ("entity_1", "service", {"service": "entity_3"}, True),
         ("entity_2", "service", {"service": "entity_4"}, True),
@@ -219,13 +364,19 @@ async def test_sync_raw_mixin_dependency(
         ("entity_5", "service", {"service": "entity_1"}, True),
     ]
     entities = [create_entity(*entity_param) for entity_param in entities_params]
-    mock_ocean.metrics.report_sync_metrics = AsyncMock(return_value=None)  # type: ignore
-    mock_ocean.metrics.report_kind_sync_metrics = AsyncMock(return_value=None)  # type: ignore
-    mock_ocean.metrics.send_metrics_to_webhook = AsyncMock(return_value=None)  # type: ignore
+
+    # Create a more realistic CalculationResult mock
     calc_result_mock = MagicMock()
-    calc_result_mock.entity_selector_diff.passed = entities
-    calc_result_mock.errors = []
+    calc_result_mock.entity_selector_diff = EntitySelectorDiff(
+        passed=entities, failed=[]  # No failed entities in this test case
+    )
+    calc_result_mock.errors = []  # No errors in this test case
+    calc_result_mock.number_of_transformed_entities = len(
+        entities
+    )  # Add this to match real behavior
+    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
 
+    # Mock the parse_items method to return our realistic mock
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
 
     mock_order_by_entities_dependencies = MagicMock(
@@ -295,6 +446,44 @@ def get_entities_wrapper(*args: Any, **kwargs: Any) -> Any:
                     "entity_3-entity_1-entity_4-entity_5-entity_2",
                 )
 
+                # Add assertions for actual metrics
+                metrics = mock_ocean.metrics.generate_metrics()
+                assert len(metrics) == 2
+
+                # Verify object counts
+                for metric in metrics:
+                    if metric["kind"] == "project":
+                        assert (
+                            metric["metrics"]["phase"]["extract"]["object_count_type"][
+                                "raw_extracted"
+                            ]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["transformed"]["object_count"]
+                            == 5
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["transform"][
+                                "object_count_type"
+                            ]["filtered_out"]["object_count"]
+                            == 0
+                        )
+                        assert (
+                            metric["metrics"]["phase"]["load"]["object_count_type"][
+                                "failed"
+                            ]["object_count"]
+                            == 5
+                        )
+
+                        # Verify success
+                        assert metric["metrics"]["phase"]["resync"]["success"] == 1
+
+                        # Verify sync state
+                        assert metric["syncState"] == "completed"
+
 
 @pytest.mark.asyncio
 async def test_register_raw(