fix(tests): Fix tests

Author: timothedelion

packages/gg_api_core/src/gg_api_core/tools/remediate_secret_incidents.py

@@ -68,16 +68,20 @@ class RemediateSecretIncidentsResult(BaseModel):
     env_example_content: str | None = Field(default=None, description="Suggested .env.example content")
     env_example_instructions: list[str] | None = Field(default=None, description="Instructions for .env.example")
     git_commands: dict[str, Any] | None = Field(default=None, description="Git commands to fix history")
-    applied_filters: dict[str, Any] = Field(default_factory=dict, description="Filters applied when querying occurrences")
+    applied_filters: dict[str, Any] = Field(default_factory=dict,
+                                            description="Filters applied when querying occurrences")
     suggestion: str = Field(default="", description="Suggestions for interpreting results")
+    sub_tools_results: dict[str, Any] = Field(default_factory=dict, description="Results from sub tools")
 
 
 class RemediateSecretIncidentsError(BaseModel):
     """Error result from remediating secret incidents."""
     error: str = Field(description="Error message")
+    sub_tools_results: dict[str, Any] = Field(default_factory=dict, description="Results from sub tools")
 
 
-async def remediate_secret_incidents(params: RemediateSecretIncidentsParams) -> RemediateSecretIncidentsResult | RemediateSecretIncidentsError:
+async def remediate_secret_incidents(
+        params: RemediateSecretIncidentsParams) -> RemediateSecretIncidentsResult | RemediateSecretIncidentsError:
     """
     Find and remediate secret incidents in the current repository using EXACT match locations.
 
@@ -124,12 +128,31 @@ async def remediate_secret_incidents(params: RemediateSecretIncidentsParams) ->
 
     try:
         # Get detailed occurrences with exact match locations
-        # Extract filter parameters from list_repo_occurrences_params
-        occurrences_result = await list_repo_occurrences(params.list_repo_occurrences_params)
+        # Build ListRepoOccurrencesParams by combining repository info with filters
+        from .list_repo_occurrences import ListRepoOccurrencesParams
+
+        occurrences_params = ListRepoOccurrencesParams(
+            repository_name=params.repository_name,
+            source_id=params.source_id,
+            from_date=params.list_repo_occurrences_params.from_date,
+            to_date=params.list_repo_occurrences_params.to_date,
+            presence=params.list_repo_occurrences_params.presence,
+            tags=params.list_repo_occurrences_params.tags,
+            exclude_tags=params.list_repo_occurrences_params.exclude_tags,
+            status=params.list_repo_occurrences_params.status,
+            severity=params.list_repo_occurrences_params.severity,
+            validity=params.list_repo_occurrences_params.validity,
+            ordering=None,
+            per_page=20,
+            cursor=None,
+            get_all=params.get_all,
+        )
+        occurrences_result = await list_repo_occurrences(occurrences_params)
 
         # Check if list_repo_occurrences returned an error
-        if getattr(occurrences_result, "error"):
-            return RemediateSecretIncidentsError(error=occurrences_result.error)
+        if hasattr(occurrences_result, "error") and occurrences_result.error:
+            return RemediateSecretIncidentsError(error=occurrences_result.error,
+                                                 sub_tools_results={"list_repo_occurrences": occurrences_result})
         occurrences = occurrences_result.occurrences
 
         # Filter by assignee if mine=True
@@ -157,6 +180,7 @@ async def remediate_secret_incidents(params: RemediateSecretIncidentsParams) ->
                 remediation_steps=[],
                 applied_filters=occurrences_result.applied_filters or {},
                 suggestion=occurrences_result.suggestion or "",
+                sub_tools_results={"list_repo_occurrences": occurrences_result}
             )
 
         # Process occurrences for remediation with exact location data
@@ -168,22 +192,34 @@ async def remediate_secret_incidents(params: RemediateSecretIncidentsParams) ->
             create_env_example=params.create_env_example,
         )
         logger.debug(
-            f"Remediation processing complete, returning result with {len(result.get('remediation_steps', []))} steps"
+            f"Remediation processing complete, returning result with {len(result.remediation_steps)} steps"
         )
-        # Convert dict result to Pydantic model
-        return RemediateSecretIncidentsResult(**result)
+
+        # Add sub_tools_results and applied_filters/suggestion from occurrences_result
+        result_dict = result.model_dump()
+        result_dict["sub_tools_results"] = {
+            "list_repo_occurrences": {
+                "total_occurrences": result.summary.get("total_occurrences",
+                                                        len(occurrences)) if result.summary else len(occurrences),
+                "affected_files": result.summary.get("affected_files", 0) if result.summary else 0,
+            }
+        }
+        result_dict["applied_filters"] = occurrences_result.applied_filters or {}
+        result_dict["suggestion"] = occurrences_result.suggestion or ""
+
+        return RemediateSecretIncidentsResult(**result_dict)
 
     except Exception as e:
         logger.error(f"Error remediating incidents: {str(e)}")
         return RemediateSecretIncidentsError(error=f"Failed to remediate incidents: {str(e)}")
 
 
 async def _process_occurrences_for_remediation(
-    occurrences: list[dict[str, Any]],
-    repository_name: str,
-    include_git_commands: bool = True,
-    create_env_example: bool = True,
-) -> dict[str, Any]:
+        occurrences: list[dict[str, Any]],
+        repository_name: str,
+        include_git_commands: bool = True,
+        create_env_example: bool = True,
+) -> RemediateSecretIncidentsResult:
     """
     Process occurrences for remediation using exact match locations.
 
@@ -319,4 +355,4 @@ async def _process_occurrences_for_remediation(
     if git_commands:
         result["git_commands"] = git_commands
 
-    return result
+    return RemediateSecretIncidentsResult(**result)

tests/tools/test_list_repo_incidents.py

@@ -18,7 +18,7 @@ async def test_list_repo_incidents_with_repository_name(
         """
         # Mock the client response
         mock_response = {
-            "data": [
+            "incidents": [
                 {
                     "id": "incident_1",
                     "detector": {"name": "AWS Access Key"},
@@ -56,7 +56,8 @@ async def test_list_repo_incidents_with_repository_name(
         assert call_kwargs["mine"] is True
 
         # Verify response
-        assert result == mock_response
+        assert result.total_count == mock_response["total_count"]
+        assert len(result.incidents) == len(mock_response["incidents"])
 
     @pytest.mark.asyncio
     async def test_list_repo_incidents_with_source_id(self, mock_gitguardian_client):
@@ -106,9 +107,9 @@ async def test_list_repo_incidents_with_source_id(self, mock_gitguardian_client)
         assert call_args[1]["with_sources"] == "false"
 
         # Verify response
-        assert "source_id" in result
-        assert result["source_id"] == "source_123"
-        assert len(result["incidents"]) == 1
+        assert hasattr(result, "source_id")
+        assert result.source_id == "source_123"
+        assert len(result.incidents) == 1
 
     @pytest.mark.asyncio
     async def test_list_repo_incidents_with_filters(self, mock_gitguardian_client):
@@ -182,8 +183,8 @@ async def test_list_repo_incidents_get_all(self, mock_gitguardian_client):
         mock_gitguardian_client.paginate_all.assert_called_once()
 
         # Verify response
-        assert result["total_count"] == 3
-        assert len(result["incidents"]) == 3
+        assert result.total_count == 3
+        assert len(result.incidents) == 3
 
     @pytest.mark.asyncio
     async def test_list_repo_incidents_no_repository_or_source(
@@ -212,8 +213,8 @@ async def test_list_repo_incidents_no_repository_or_source(
         )
 
         # Verify error response
-        assert "error" in result
-        assert "Either repository_name or source_id must be provided" in result["error"]
+        assert hasattr(result, "error")
+        assert "Either repository_name or source_id must be provided" in result.error
 
     @pytest.mark.asyncio
     async def test_list_repo_incidents_client_error(self, mock_gitguardian_client):
@@ -246,8 +247,8 @@ async def test_list_repo_incidents_client_error(self, mock_gitguardian_client):
         )
 
         # Verify error response
-        assert "error" in result
-        assert "Failed to list repository incidents" in result["error"]
+        assert hasattr(result, "error")
+        assert "Failed to list repository incidents" in result.error
 
     @pytest.mark.asyncio
     async def test_list_repo_incidents_with_cursor(self, mock_gitguardian_client):
@@ -322,9 +323,9 @@ async def test_list_repo_incidents_source_id_list_response(
         )
 
         # Verify response format
-        assert result["source_id"] == "source_123"
-        assert result["total_count"] == 2
-        assert len(result["incidents"]) == 2
+        assert result.source_id == "source_123"
+        assert result.total_count == 2
+        assert len(result.incidents) == 2
 
     @pytest.mark.asyncio
     async def test_list_repo_incidents_get_all_dict_response(
@@ -348,6 +349,6 @@ async def test_list_repo_incidents_get_all_dict_response(
         )
 
         # Verify response
-        assert result["source_id"] == "source_123"
-        assert result["total_count"] == 2
-        assert len(result["incidents"]) == 2
+        assert result.source_id == "source_123"
+        assert result.total_count == 2
+        assert len(result.incidents) == 2

tests/tools/test_list_repo_occurrences.py

@@ -1,6 +1,7 @@
 from unittest.mock import AsyncMock
 
 import pytest
+from pydantic import ValidationError
 from gg_api_core.tools.list_repo_occurrences import list_repo_occurrences, ListRepoOccurrencesParams
 
 
@@ -184,11 +185,11 @@ async def test_list_repo_occurrences_no_repository_or_source(
     ):
         """
         GIVEN: Neither repository_name nor source_id provided
-        WHEN: Attempting to list occurrences
-        THEN: An error is returned
+        WHEN: Attempting to create params
+        THEN: A ValidationError is raised
         """
-        # Call the function without repository_name or source_id
-        result = await list_repo_occurrences(
+        # Try to create params without repository_name or source_id
+        with pytest.raises(ValidationError) as exc_info:
             ListRepoOccurrencesParams(
                 repository_name=None,
                 source_id=None,
@@ -201,11 +202,11 @@ async def test_list_repo_occurrences_no_repository_or_source(
                 cursor=None,
                 get_all=False,
             )
-        )
 
-        # Verify error response
-        assert hasattr(result, "error")
-        assert "Either repository_name or source_id must be provided" in result.error
+        # Verify error message
+        errors = exc_info.value.errors()
+        assert len(errors) == 1
+        assert "Either 'source_id' or 'repository_name' must be provided" in str(errors[0])
 
     @pytest.mark.asyncio
     async def test_list_repo_occurrences_client_error(self, mock_gitguardian_client):