xai-review 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

ai_review/services/vcs/factory.py

@@ -2,10 +2,10 @@ from ai_review.config import settings
 from ai_review.libs.constants.vcs_provider import VCSProvider
 from ai_review.services.vcs.github.client import GitHubVCSClient
 from ai_review.services.vcs.gitlab.client import GitLabVCSClient
-from ai_review.services.vcs.types import VCSClient
+from ai_review.services.vcs.types import VCSClientProtocol
 
 
-def get_vcs_client() -> VCSClient:
+def get_vcs_client() -> VCSClientProtocol:
     match settings.vcs.provider:
         case VCSProvider.GITLAB:
             return GitLabVCSClient()

ai_review/services/vcs/github/client.py

@@ -3,7 +3,7 @@ from ai_review.clients.github.pr.schema.comments import GitHubCreateReviewCommen
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
 from ai_review.services.vcs.types import (
-    VCSClient,
+    VCSClientProtocol,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
@@ -13,7 +13,7 @@ from ai_review.services.vcs.types import (
 logger = get_logger("GITHUB_VCS_CLIENT")
 
 
-class GitHubVCSClient(VCSClient):
+class GitHubVCSClient(VCSClientProtocol):
     def __init__(self):
         self.http_client = get_github_http_client()
         self.owner = settings.vcs.pipeline.owner
@@ -135,6 +135,7 @@ class GitHubVCSClient(VCSClient):
             logger.exception(
                 f"Failed to create general comment in PR {self.owner}/{self.repo}#{self.pull_number}: {error}"
             )
+            raise
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
@@ -167,3 +168,4 @@ class GitHubVCSClient(VCSClient):
                 f"Failed to create inline comment in {self.owner}/{self.repo}#{self.pull_number} "
                 f"at {file}:{line}: {error}"
             )
+            raise

ai_review/services/vcs/gitlab/client.py

@@ -6,7 +6,7 @@ from ai_review.clients.gitlab.mr.schema.discussions import (
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
 from ai_review.services.vcs.types import (
-    VCSClient,
+    VCSClientProtocol,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
@@ -16,7 +16,7 @@ from ai_review.services.vcs.types import (
 logger = get_logger("GITLAB_VCS_CLIENT")
 
 
-class GitLabVCSClient(VCSClient):
+class GitLabVCSClient(VCSClientProtocol):
     def __init__(self):
         self.http_client = get_gitlab_http_client()
         self.project_id = settings.vcs.pipeline.project_id
@@ -132,6 +132,7 @@ class GitLabVCSClient(VCSClient):
             logger.exception(
                 f"Failed to create general comment in merge_request_id={self.merge_request_id}: {error}"
             )
+            raise
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
@@ -168,3 +169,4 @@ class GitLabVCSClient(VCSClient):
                 f"Failed to create inline comment in merge_request_id={self.merge_request_id} "
                 f"at {file}:{line}: {error}"
             )
+            raise

ai_review/services/vcs/types.py

@@ -42,7 +42,7 @@ class ReviewThreadSchema(BaseModel):
     comments: list[ReviewCommentSchema]
 
 
-class VCSClient(Protocol):
+class VCSClientProtocol(Protocol):
     """
     Unified interface for version control system integrations (GitHub, GitLab, Bitbucket, etc.).
     Designed for code review automation: fetching review info, comments, and posting feedback.

ai_review/tests/fixtures/clients/claude.py

@@ -0,0 +1,22 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.config import settings
+from ai_review.libs.config.claude import ClaudeMetaConfig, ClaudeHTTPClientConfig
+from ai_review.libs.config.llm import ClaudeLLMConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+
+
+@pytest.fixture
+def claude_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = ClaudeLLMConfig(
+        meta=ClaudeMetaConfig(),
+        provider=LLMProvider.CLAUDE,
+        http_client=ClaudeHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.anthropic.com"),
+            api_token=SecretStr("fake-token"),
+            api_version="2023-06-01",
+        )
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)

ai_review/tests/fixtures/clients/gemini.py

@@ -0,0 +1,21 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.config import settings
+from ai_review.libs.config.gemini import GeminiMetaConfig, GeminiHTTPClientConfig
+from ai_review.libs.config.llm import GeminiLLMConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+
+
+@pytest.fixture
+def gemini_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = GeminiLLMConfig(
+        meta=GeminiMetaConfig(),
+        provider=LLMProvider.GEMINI,
+        http_client=GeminiHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://generativelanguage.googleapis.com"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)

ai_review/tests/fixtures/clients/github.py

@@ -0,0 +1,181 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubPRCommentSchema,
+    GitHubGetPRCommentsResponseSchema,
+    GitHubCreateIssueCommentResponseSchema,
+    GitHubCreateReviewCommentRequestSchema,
+    GitHubCreateReviewCommentResponseSchema,
+)
+from ai_review.clients.github.pr.schema.files import GitHubGetPRFilesResponseSchema, GitHubPRFileSchema
+from ai_review.clients.github.pr.schema.pull_request import (
+    GitHubUserSchema,
+    GitHubLabelSchema,
+    GitHubBranchSchema,
+    GitHubGetPRResponseSchema,
+)
+from ai_review.clients.github.pr.schema.reviews import GitHubGetPRReviewsResponseSchema, GitHubPRReviewSchema
+from ai_review.clients.github.pr.types import GitHubPullRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.github import GitHubPipelineConfig, GitHubHTTPClientConfig
+from ai_review.libs.config.vcs import GitHubVCSConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.github.client import GitHubVCSClient
+
+
+class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRResponseSchema:
+        self.calls.append(("get_pull_request", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRResponseSchema(
+            id=1,
+            number=1,
+            title="Fake Pull Request",
+            body="This is a fake PR for testing",
+            user=GitHubUserSchema(id=101, login="tester"),
+            labels=[
+                GitHubLabelSchema(id=1, name="bugfix"),
+                GitHubLabelSchema(id=2, name="backend"),
+            ],
+            assignees=[
+                GitHubUserSchema(id=102, login="dev1"),
+                GitHubUserSchema(id=103, login="dev2"),
+            ],
+            requested_reviewers=[
+                GitHubUserSchema(id=104, login="reviewer"),
+            ],
+            base=GitHubBranchSchema(ref="main", sha="abc123"),
+            head=GitHubBranchSchema(ref="feature/test", sha="def456"),
+        )
+
+    async def get_files(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRFilesResponseSchema:
+        self.calls.append(("get_files", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRFilesResponseSchema(
+            root=[
+                GitHubPRFileSchema(
+                    sha="abc",
+                    status="modified",
+                    filename="app/main.py",
+                    patch="@@ -1,2 +1,2 @@\n- old\n+ new",
+                ),
+                GitHubPRFileSchema(
+                    sha="def",
+                    status="added",
+                    filename="utils/helper.py",
+                    patch="+ print('Hello')",
+                ),
+            ]
+        )
+
+    async def get_issue_comments(self, owner: str, repo: str, issue_number: str) -> GitHubGetPRCommentsResponseSchema:
+        self.calls.append(("get_issue_comments", {"owner": owner, "repo": repo, "issue_number": issue_number}))
+
+        return GitHubGetPRCommentsResponseSchema(
+            root=[
+                GitHubPRCommentSchema(id=1, body="General comment"),
+                GitHubPRCommentSchema(id=2, body="Another general comment"),
+            ]
+        )
+
+    async def get_review_comments(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRCommentsResponseSchema:
+        self.calls.append(("get_review_comments", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRCommentsResponseSchema(
+            root=[
+                GitHubPRCommentSchema(id=3, body="Inline comment", path="file.py", line=5),
+                GitHubPRCommentSchema(id=4, body="Another inline comment", path="utils.py", line=10),
+            ]
+        )
+
+    async def get_reviews(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRReviewsResponseSchema:
+        self.calls.append(("get_reviews", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRReviewsResponseSchema(
+            root=[
+                GitHubPRReviewSchema(id=1, body="Looks good", state="APPROVED"),
+                GitHubPRReviewSchema(id=2, body="Needs changes", state="CHANGES_REQUESTED"),
+            ]
+        )
+
+    async def create_review_comment(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GitHubCreateReviewCommentRequestSchema,
+    ) -> GitHubCreateReviewCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_review_comment",
+                {"owner": owner, "repo": repo, "pull_number": pull_number, **request.model_dump()}
+            )
+        )
+        return GitHubCreateReviewCommentResponseSchema(id=10, body=request.body)
+
+    async def create_issue_comment(
+            self,
+            owner: str,
+            repo: str,
+            issue_number: str,
+            body: str,
+    ) -> GitHubCreateIssueCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_issue_comment",
+                {"owner": owner, "repo": repo, "issue_number": issue_number, "body": body}
+            )
+        )
+        return GitHubCreateIssueCommentResponseSchema(id=11, body=body)
+
+
+class FakeGitHubHTTPClient:
+    def __init__(self, pull_requests_client: GitHubPullRequestsHTTPClientProtocol):
+        self.pr = pull_requests_client
+
+
+@pytest.fixture
+def fake_github_pull_requests_http_client() -> FakeGitHubPullRequestsHTTPClient:
+    return FakeGitHubPullRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_github_http_client(
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient
+) -> FakeGitHubHTTPClient:
+    return FakeGitHubHTTPClient(pull_requests_client=fake_github_pull_requests_http_client)
+
+
+@pytest.fixture
+def github_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_github_http_client: FakeGitHubHTTPClient
+) -> GitHubVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.github.client.get_github_http_client",
+        lambda: fake_github_http_client,
+    )
+
+    return GitHubVCSClient()
+
+
+@pytest.fixture
+def github_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = GitHubVCSConfig(
+        provider=VCSProvider.GITHUB,
+        pipeline=GitHubPipelineConfig(
+            repo="repo",
+            owner="owner",
+            pull_number="pull_number"
+        ),
+        http_client=GitHubHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://github.com"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/fixtures/clients/gitlab.py

@@ -0,0 +1,150 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.gitlab.mr.schema.changes import (
+    GitLabUserSchema,
+    GitLabMRChangeSchema,
+    GitLabDiffRefsSchema,
+    GitLabGetMRChangesResponseSchema,
+)
+from ai_review.clients.gitlab.mr.schema.discussions import (
+    GitLabDiscussionSchema,
+    GitLabGetMRDiscussionsResponseSchema,
+    GitLabCreateMRDiscussionRequestSchema,
+    GitLabCreateMRDiscussionResponseSchema,
+)
+from ai_review.clients.gitlab.mr.schema.notes import (
+    GitLabNoteSchema,
+    GitLabGetMRNotesResponseSchema,
+    GitLabCreateMRNoteResponseSchema,
+)
+from ai_review.clients.gitlab.mr.types import GitLabMergeRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
+from ai_review.libs.config.vcs import GitLabVCSConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.gitlab.client import GitLabVCSClient
+
+
+class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_changes(self, project_id: str, merge_request_id: str) -> GitLabGetMRChangesResponseSchema:
+        self.calls.append(("get_changes", {"project_id": project_id, "merge_request_id": merge_request_id}))
+        return GitLabGetMRChangesResponseSchema(
+            id=1,
+            iid=1,
+            title="Fake Merge Request",
+            author=GitLabUserSchema(id=42, name="Tester", username="tester"),
+            labels=["bugfix", "backend"],
+            description="This is a fake MR for testing",
+            project_id=1,
+            diff_refs=GitLabDiffRefsSchema(
+                base_sha="abc123",
+                head_sha="def456",
+                start_sha="ghi789",
+            ),
+            source_branch="feature/test",
+            target_branch="main",
+            changes=[
+                GitLabMRChangeSchema(
+                    diff="@@ -1,2 +1,2 @@\n- old\n+ new",
+                    old_path="main.py",
+                    new_path="main.py",
+                )
+            ],
+        )
+
+    async def get_notes(self, project_id: str, merge_request_id: str) -> GitLabGetMRNotesResponseSchema:
+        self.calls.append(("get_notes", {"project_id": project_id, "merge_request_id": merge_request_id}))
+        return GitLabGetMRNotesResponseSchema(
+            root=[
+                GitLabNoteSchema(id=1, body="General comment"),
+                GitLabNoteSchema(id=2, body="Another note"),
+            ]
+        )
+
+    async def get_discussions(self, project_id: str, merge_request_id: str) -> GitLabGetMRDiscussionsResponseSchema:
+        self.calls.append(("get_discussions", {"project_id": project_id, "merge_request_id": merge_request_id}))
+        return GitLabGetMRDiscussionsResponseSchema(
+            root=[
+                GitLabDiscussionSchema(
+                    id="discussion-1",
+                    notes=[
+                        GitLabNoteSchema(id=10, body="Inline comment A"),
+                        GitLabNoteSchema(id=11, body="Inline comment B"),
+                    ],
+                )
+            ]
+        )
+
+    async def create_note(self, body: str, project_id: str, merge_request_id: str) -> GitLabCreateMRNoteResponseSchema:
+        self.calls.append(
+            (
+                "create_note",
+                {"body": body, "project_id": project_id, "merge_request_id": merge_request_id}
+            )
+        )
+        return GitLabCreateMRNoteResponseSchema(id=99, body=body)
+
+    async def create_discussion(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            request: GitLabCreateMRDiscussionRequestSchema,
+    ) -> GitLabCreateMRDiscussionResponseSchema:
+        self.calls.append(
+            (
+                "create_discussion",
+                {"project_id": project_id, "merge_request_id": merge_request_id, "body": request.body}
+            )
+        )
+        return GitLabCreateMRDiscussionResponseSchema(id="discussion-new", body=request.body)
+
+
+class FakeGitLabHTTPClient:
+    def __init__(self, merge_requests_client: FakeGitLabMergeRequestsHTTPClient):
+        self.mr = merge_requests_client
+
+
+@pytest.fixture
+def fake_gitlab_merge_requests_http_client() -> FakeGitLabMergeRequestsHTTPClient:
+    return FakeGitLabMergeRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_gitlab_http_client(
+        fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient
+) -> FakeGitLabHTTPClient:
+    return FakeGitLabHTTPClient(merge_requests_client=fake_gitlab_merge_requests_http_client)
+
+
+@pytest.fixture
+def gitlab_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_gitlab_http_client: FakeGitLabHTTPClient
+) -> GitLabVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.gitlab.client.get_gitlab_http_client",
+        lambda: fake_gitlab_http_client,
+    )
+
+    return GitLabVCSClient()
+
+
+@pytest.fixture
+def gitlab_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = GitLabVCSConfig(
+        provider=VCSProvider.GITLAB,
+        pipeline=GitLabPipelineConfig(
+            project_id="project-id",
+            merge_request_id="merge-request-id"
+        ),
+        http_client=GitLabHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://gitlab.com"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/fixtures/clients/openai.py

@@ -0,0 +1,21 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.config import settings
+from ai_review.libs.config.llm import OpenAILLMConfig
+from ai_review.libs.config.openai import OpenAIMetaConfig, OpenAIHTTPClientConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+
+
+@pytest.fixture
+def openai_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = OpenAILLMConfig(
+        meta=OpenAIMetaConfig(),
+        provider=LLMProvider.OPENAI,
+        http_client=OpenAIHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.openai.com/v1"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)

ai_review/tests/fixtures/services/artifacts.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+import pytest
+
+from ai_review.services.artifacts.types import ArtifactsServiceProtocol
+
+
+class FakeArtifactsService(ArtifactsServiceProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+        self.saved_artifacts: list[tuple[Path, str, str]] = []
+        self.saved_llm_interactions: list[dict[str, str | None]] = []
+
+    async def save_llm_interaction(
+            self,
+            prompt: str,
+            prompt_system: str,
+            response: str | None = None
+    ) -> str:
+        self.calls.append((
+            "save_llm_interaction",
+            {"prompt": prompt, "prompt_system": prompt_system, "response": response},
+        ))
+
+        artifact_id = f"fake-{len(self.saved_llm_interactions) + 1}"
+        self.saved_llm_interactions.append({
+            "id": artifact_id,
+            "prompt": prompt,
+            "prompt_system": prompt_system,
+            "response": response,
+        })
+        return artifact_id
+
+    async def save_artifact(
+            self,
+            file: Path,
+            content: str,
+            kind: str = "artifact"
+    ) -> Path:
+        self.calls.append((
+            "save_artifact",
+            {"file": str(file), "content": content, "kind": kind},
+        ))
+
+        self.saved_artifacts.append((file, content, kind))
+        return file
+
+
+@pytest.fixture
+def fake_artifacts_service() -> FakeArtifactsService:
+    return FakeArtifactsService()

ai_review/tests/fixtures/services/cost.py

@@ -0,0 +1,48 @@
+import pytest
+
+from ai_review.services.cost.schema import CostReportSchema
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.llm.types import ChatResultSchema
+
+
+class FakeCostService(CostServiceProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+        self.reports: list[CostReportSchema] = []
+        self.calculated_results: list[ChatResultSchema] = []
+
+    def calculate(self, result: ChatResultSchema) -> CostReportSchema:
+        self.calls.append(("calculate", {"result": result}))
+        self.calculated_results.append(result)
+
+        report = CostReportSchema(
+            model="fake-model",
+            prompt_tokens=result.prompt_tokens or 10,
+            completion_tokens=result.completion_tokens or 5,
+            input_cost=0.001,
+            output_cost=0.002,
+            total_cost=0.003,
+        )
+        self.reports.append(report)
+        return report
+
+    def aggregate(self) -> CostReportSchema | None:
+        self.calls.append(("aggregate", {}))
+
+        if not self.reports:
+            return None
+
+        total_cost = sum(r.total_cost for r in self.reports)
+        return CostReportSchema(
+            model="fake-model",
+            total_cost=total_cost,
+            input_cost=0.001 * len(self.reports),
+            output_cost=0.002 * len(self.reports),
+            prompt_tokens=sum(r.prompt_tokens for r in self.reports),
+            completion_tokens=sum(r.completion_tokens for r in self.reports),
+        )
+
+
+@pytest.fixture
+def fake_cost_service() -> "FakeCostService":
+    return FakeCostService()

ai_review/tests/fixtures/services/diff.py

@@ -0,0 +1,46 @@
+import pytest
+
+from ai_review.libs.diff.models import Diff
+from ai_review.services.diff.schema import DiffFileSchema
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+
+
+class FakeDiffService(DiffServiceProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    def parse(self, raw_diff: str) -> Diff:
+        self.calls.append(("parse", {"raw_diff": raw_diff}))
+        return Diff(files=[], raw=raw_diff)
+
+    def render_file(
+            self,
+            file: str,
+            raw_diff: str,
+            base_sha: str | None = None,
+            head_sha: str | None = None,
+    ) -> DiffFileSchema:
+        self.calls.append((
+            "render_file",
+            {"file": file, "raw_diff": raw_diff, "base_sha": base_sha, "head_sha": head_sha},
+        ))
+        return DiffFileSchema(file=file, diff=f"FAKE_DIFF_CONTENT for {file}")
+
+    def render_files(
+            self,
+            git: GitServiceProtocol,
+            files: list[str],
+            base_sha: str,
+            head_sha: str,
+    ) -> list[DiffFileSchema]:
+        self.calls.append((
+            "render_files",
+            {"git": git, "files": files, "base_sha": base_sha, "head_sha": head_sha},
+        ))
+        return [DiffFileSchema(file=file, diff=f"FAKE_DIFF for {file}") for file in files]
+
+
+@pytest.fixture
+def fake_diff_service() -> FakeDiffService:
+    return FakeDiffService()

ai_review/tests/fixtures/{git.py → services/git.py}

@@ -1,4 +1,3 @@
-# ai_review/tests/conftest.py
 from typing import Any
 
 import pytest
@@ -7,25 +6,32 @@ from ai_review.services.git.types import GitServiceProtocol
 
 
 class FakeGitService(GitServiceProtocol):
-    """Simple fake for GitService used in tests."""
-
     def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
         self.responses = responses or {}
 
     def get_diff(self, base_sha: str, head_sha: str, unified: int = 3) -> str:
+        self.calls.append(("get_diff", {"base_sha": base_sha, "head_sha": head_sha, "unified": unified}))
         return self.responses.get("get_diff", "")
 
     def get_diff_for_file(self, base_sha: str, head_sha: str, file: str, unified: int = 3) -> str:
+        self.calls.append(
+            (
+                "get_diff_for_file",
+                {"base_sha": base_sha, "head_sha": head_sha, "file": file, "unified": unified}
+            )
+        )
         return self.responses.get("get_diff_for_file", "")
 
     def get_changed_files(self, base_sha: str, head_sha: str) -> list[str]:
+        self.calls.append(("get_changed_files", {"base_sha": base_sha, "head_sha": head_sha}))
         return self.responses.get("get_changed_files", [])
 
     def get_file_at_commit(self, file_path: str, sha: str) -> str | None:
+        self.calls.append(("get_file_at_commit", {"file_path": file_path, "sha": sha}))
         return self.responses.get("get_file_at_commit", None)
 
 
 @pytest.fixture
-def fake_git() -> FakeGitService:
-    """Default fake GitService with empty responses."""
+def fake_git_service() -> FakeGitService:
     return FakeGitService()