xai-review 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

ai_review/services/review/service.py

@@ -1,16 +1,15 @@
-from typing import Literal
-
-from ai_review.config import settings
 from ai_review.libs.asynchronous.gather import bounded_gather
 from ai_review.libs.logger import get_logger
 from ai_review.services.artifacts.service import ArtifactsService
 from ai_review.services.cost.service import CostService
 from ai_review.services.diff.service import DiffService
 from ai_review.services.git.service import GitService
+from ai_review.services.hook import hook
 from ai_review.services.llm.factory import get_llm_client
 from ai_review.services.prompt.adapter import build_prompt_context_from_mr_info
 from ai_review.services.prompt.service import PromptService
-from ai_review.services.review.inline.schema import InlineCommentListSchema
+from ai_review.services.review.gateway.comment import ReviewCommentGateway
+from ai_review.services.review.gateway.llm import ReviewLLMGateway
 from ai_review.services.review.inline.service import InlineCommentService
 from ai_review.services.review.policy.service import ReviewPolicyService
 from ai_review.services.review.summary.service import SummaryCommentService
@@ -33,68 +32,12 @@ class ReviewService:
         self.summary = SummaryCommentService()
         self.artifacts = ArtifactsService()
 
-    async def ask_llm(self, prompt: str, prompt_system: str) -> str:
-        try:
-            result = await self.llm.chat(prompt, prompt_system)
-            if not result.text:
-                logger.warning(
-                    f"LLM returned an empty response (prompt length={len(prompt)} chars)"
-                )
-
-            report = self.cost.calculate(result)
-            if report:
-                logger.info(report.pretty())
-
-            await self.artifacts.save_llm_interaction(prompt, prompt_system, result.text)
-
-            return result.text
-        except Exception as error:
-            logger.exception(f"LLM request failed: {error}")
-            raise
-
-    async def has_existing_inline_comments(self) -> bool:
-        comments = await self.vcs.get_inline_comments()
-        has_comments = any(
-            settings.review.inline_tag in comment.body
-            for comment in comments
-        )
-        if has_comments:
-            logger.info("Skipping inline review: AI inline comments already exist")
-
-        return has_comments
-
-    async def has_existing_summary_comments(self) -> bool:
-        comments = await self.vcs.get_general_comments()
-        has_comments = any(
-            settings.review.summary_tag in comment.body for comment in comments
+        self.llm_gateway = ReviewLLMGateway(
+            llm=self.llm,
+            cost=self.cost,
+            artifacts=self.artifacts
         )
-        if has_comments:
-            logger.info("Skipping summary review: AI summary comment already exists")
-
-        return has_comments
-
-    async def process_inline_comments(
-            self,
-            flow: Literal["inline", "context"],
-            comments: InlineCommentListSchema
-    ) -> None:
-        results = await bounded_gather([
-            self.vcs.create_inline_comment(
-                file=comment.file,
-                line=comment.line,
-                message=comment.body_with_tag
-            )
-            for comment in comments.root
-        ])
-
-        fallbacks = [
-            self.vcs.create_general_comment(comment.fallback_body_with_tag)
-            for comment, result in zip(comments.root, results)
-            if isinstance(result, Exception)
-        ]
-        if fallbacks:
-            logger.warning(f"Falling back to {len(fallbacks)} general comments ({flow} review)")
-            await bounded_gather(fallbacks)
+        self.comment_gateway = ReviewCommentGateway(vcs=self.vcs)
 
     async def process_file_inline(self, file: str, review_info: ReviewInfoSchema) -> None:
         raw_diff = self.git.get_diff_for_file(review_info.base_sha, review_info.head_sha, file)
@@ -111,7 +54,7 @@ class ReviewService:
         prompt_context = build_prompt_context_from_mr_info(review_info)
         prompt = self.prompt.build_inline_request(rendered_file, prompt_context)
         prompt_system = self.prompt.build_system_inline_request(prompt_context)
-        prompt_result = await self.ask_llm(prompt, prompt_system)
+        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
 
         comments = self.inline.parse_model_output(prompt_result).dedupe()
         comments.root = self.policy.apply_for_inline_comments(comments.root)
@@ -120,10 +63,11 @@ class ReviewService:
             return
 
         logger.info(f"Posting {len(comments.root)} inline comments to {file}")
-        await self.process_inline_comments(flow="inline", comments=comments)
+        await self.comment_gateway.process_inline_comments(comments)
 
     async def run_inline_review(self) -> None:
-        if await self.has_existing_inline_comments():
+        await hook.emit_inline_review_start()
+        if await self.comment_gateway.has_existing_inline_comments():
             return
 
         review_info = await self.vcs.get_review_info()
@@ -134,9 +78,11 @@ class ReviewService:
             self.process_file_inline(changed_file, review_info)
             for changed_file in changed_files
         ])
+        await hook.emit_inline_review_complete(self.cost.aggregate())
 
     async def run_context_review(self) -> None:
-        if await self.has_existing_inline_comments():
+        await hook.emit_context_review_start()
+        if await self.comment_gateway.has_existing_inline_comments():
             return
 
         review_info = await self.vcs.get_review_info()
@@ -156,7 +102,7 @@ class ReviewService:
         prompt_context = build_prompt_context_from_mr_info(review_info)
         prompt = self.prompt.build_context_request(rendered_files, prompt_context)
         prompt_system = self.prompt.build_system_context_request(prompt_context)
-        prompt_result = await self.ask_llm(prompt, prompt_system)
+        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
 
         comments = self.inline.parse_model_output(prompt_result).dedupe()
         comments.root = self.policy.apply_for_context_comments(comments.root)
@@ -165,10 +111,12 @@ class ReviewService:
             return
 
         logger.info(f"Posting {len(comments.root)} inline comments (context review)")
-        await self.process_inline_comments(flow="context", comments=comments)
+        await self.comment_gateway.process_inline_comments(comments)
+        await hook.emit_context_review_complete(self.cost.aggregate())
 
     async def run_summary_review(self) -> None:
-        if await self.has_existing_summary_comments():
+        await hook.emit_summary_review_start()
+        if await self.comment_gateway.has_existing_summary_comments():
             return
 
         review_info = await self.vcs.get_review_info()
@@ -188,7 +136,7 @@ class ReviewService:
         prompt_context = build_prompt_context_from_mr_info(review_info)
         prompt = self.prompt.build_summary_request(rendered_files, prompt_context)
         prompt_system = self.prompt.build_system_summary_request(prompt_context)
-        prompt_result = await self.ask_llm(prompt, prompt_system)
+        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
 
         summary = self.summary.parse_model_output(prompt_result)
         if not summary.text.strip():
@@ -196,7 +144,8 @@ class ReviewService:
             return
 
         logger.info(f"Posting summary review comment ({len(summary.text)} chars)")
-        await self.vcs.create_general_comment(summary.body_with_tag)
+        await self.comment_gateway.process_summary_comment(summary)
+        await hook.emit_summary_review_complete(self.cost.aggregate())
 
     def report_total_cost(self):
         total_report = self.cost.aggregate()

ai_review/services/review/summary/service.py

@@ -1,10 +1,11 @@
 from ai_review.libs.logger import get_logger
 from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.summary.types import SummaryCommentServiceProtocol
 
 logger = get_logger("SUMMARY_COMMENT_SERVICE")
 
 
-class SummaryCommentService:
+class SummaryCommentService(SummaryCommentServiceProtocol):
     @classmethod
     def parse_model_output(cls, output: str) -> SummaryCommentSchema:
         text = (output or "").strip()

ai_review/services/review/summary/types.py

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+from ai_review.services.review.summary.schema import SummaryCommentSchema
+
+
+class SummaryCommentServiceProtocol(Protocol):
+    def parse_model_output(self, output: str) -> SummaryCommentSchema:
+        ...

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/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/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/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

@@ -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()

ai_review/tests/fixtures/llm.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+import pytest
+
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
+
+
+class FakeLLMClient(LLMClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        self.calls.append(("chat", {"prompt": prompt, "prompt_system": prompt_system}))
+
+        return ChatResultSchema(
+            text=self.responses.get("text", "FAKE_RESPONSE"),
+            total_tokens=self.responses.get("total_tokens", 42),
+            prompt_tokens=self.responses.get("prompt_tokens", 21),
+            completion_tokens=self.responses.get("completion_tokens", 21),
+        )
+
+
+@pytest.fixture
+def fake_llm_client() -> FakeLLMClient:
+    return FakeLLMClient()

ai_review/tests/fixtures/prompt.py

@@ -0,0 +1,43 @@
+import pytest
+
+from ai_review.services.diff.schema import DiffFileSchema
+from ai_review.services.prompt.schema import PromptContextSchema
+from ai_review.services.prompt.types import PromptServiceProtocol
+
+
+class FakePromptService(PromptServiceProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    def prepare_prompt(self, prompts: list[str], context: PromptContextSchema) -> str:
+        self.calls.append(("prepare_prompt", {"prompts": prompts, "context": context}))
+        return "FAKE_PROMPT"
+
+    def build_inline_request(self, diff: DiffFileSchema, context: PromptContextSchema) -> str:
+        self.calls.append(("build_inline_request", {"diff": diff, "context": context}))
+        return f"INLINE_PROMPT_FOR_{diff.file}"
+
+    def build_summary_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        self.calls.append(("build_summary_request", {"diffs": diffs, "context": context}))
+        return "SUMMARY_PROMPT"
+
+    def build_context_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        self.calls.append(("build_context_request", {"diffs": diffs, "context": context}))
+        return "CONTEXT_PROMPT"
+
+    def build_system_inline_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_inline_request", {"context": context}))
+        return "SYSTEM_INLINE_PROMPT"
+
+    def build_system_context_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_context_request", {"context": context}))
+        return "SYSTEM_CONTEXT_PROMPT"
+
+    def build_system_summary_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_summary_request", {"context": context}))
+        return "SYSTEM_SUMMARY_PROMPT"
+
+
+@pytest.fixture
+def fake_prompt_service() -> FakePromptService:
+    return FakePromptService()

ai_review/tests/fixtures/review/inline.py

@@ -0,0 +1,25 @@
+import pytest
+
+from ai_review.services.review.inline.schema import InlineCommentListSchema, InlineCommentSchema
+from ai_review.services.review.inline.types import InlineCommentServiceProtocol
+
+
+class FakeInlineCommentService(InlineCommentServiceProtocol):
+    def __init__(self, comments: list[InlineCommentSchema] | None = None):
+        self.calls: list[tuple[str, dict]] = []
+        self.comments = comments or [
+            InlineCommentSchema(file="main.py", line=1, message="Test comment"),
+        ]
+
+    def parse_model_output(self, output: str) -> InlineCommentListSchema:
+        self.calls.append(("parse_model_output", {"output": output}))
+        return InlineCommentListSchema(root=self.comments)
+
+    def try_parse_model_output(self, raw: str) -> InlineCommentListSchema | None:
+        self.calls.append(("try_parse_model_output", {"raw": raw}))
+        return InlineCommentListSchema(root=self.comments)
+
+
+@pytest.fixture
+def fake_inline_comment_service() -> FakeInlineCommentService:
+    return FakeInlineCommentService()

ai_review/tests/fixtures/review/summary.py

@@ -0,0 +1,19 @@
+import pytest
+
+from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.summary.types import SummaryCommentServiceProtocol
+
+
+class FakeSummaryCommentService(SummaryCommentServiceProtocol):
+    def __init__(self, text: str = "This is a summary comment"):
+        self.text = text
+        self.calls: list[tuple[str, dict]] = []
+
+    def parse_model_output(self, output: str) -> SummaryCommentSchema:
+        self.calls.append(("parse_model_output", {"output": output}))
+        return SummaryCommentSchema(text=self.text)
+
+
+@pytest.fixture
+def fake_summary_comment_service() -> FakeSummaryCommentService:
+    return FakeSummaryCommentService()

ai_review/tests/fixtures/vcs.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+import pytest
+
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
+)
+
+
+class FakeVCSClient(VCSClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, tuple, dict]] = []
+        self.responses = responses or {}
+
+    async def get_review_info(self) -> ReviewInfoSchema:
+        self.calls.append(("get_review_info", (), {}))
+        return self.responses.get(
+            "get_review_info",
+            ReviewInfoSchema(changed_files=["file.py"], base_sha="A", head_sha="B")
+        )
+
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        self.calls.append(("get_general_comments", (), {}))
+        return self.responses.get("get_general_comments", [])
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        self.calls.append(("get_inline_comments", (), {}))
+        return self.responses.get("get_inline_comments", [])
+
+    async def create_general_comment(self, message: str) -> None:
+        self.calls.append(("create_general_comment", (message,), {}))
+        if error := self.responses.get("create_general_comment_error"):
+            raise error
+
+        return self.responses.get("create_general_comment_result", None)
+
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
+        self.calls.append(("create_inline_comment", (file, line, message), {}))
+        if error := self.responses.get("create_inline_comment_error"):
+            raise error
+
+        return self.responses.get("create_inline_comment_result", None)
+
+
+@pytest.fixture
+def fake_vcs_client() -> FakeVCSClient:
+    return FakeVCSClient()

ai_review/tests/suites/services/diff/test_service.py

@@ -69,16 +69,16 @@ def test_render_file_returns_unsupported(monkeypatch: pytest.MonkeyPatch, fake_d
 
 
 def test_render_files_invokes_render_file(
-        fake_git: FakeGitService,
         fake_diff: Diff,
         monkeypatch: pytest.MonkeyPatch,
+        fake_git_service: FakeGitService,
 ) -> None:
     monkeypatch.setattr("ai_review.services.diff.service.DiffParser.parse", lambda _: fake_diff)
     monkeypatch.setattr(config.settings.review, "mode", ReviewMode.FULL_FILE_DIFF)
 
-    fake_git.responses["get_diff_for_file"] = "fake-diff"
+    fake_git_service.responses["get_diff_for_file"] = "fake-diff"
 
-    out = DiffService.render_files(git=fake_git, base_sha="A", head_sha="B", files=["b/x"])
+    out = DiffService.render_files(git=fake_git_service, base_sha="A", head_sha="B", files=["b/x"])
     assert out
     assert out[0].file == "b/x"
     assert out[0].diff.startswith("# No matching lines for mode")