xai-review 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

ai_review/tests/fixtures/clients/gitlab.py

@@ -12,6 +12,7 @@ from ai_review.clients.gitlab.mr.schema.discussions import (
     GitLabGetMRDiscussionsResponseSchema,
     GitLabCreateMRDiscussionRequestSchema,
     GitLabCreateMRDiscussionResponseSchema,
+    GitLabCreateMRDiscussionReplyResponseSchema, GitLabDiscussionPositionSchema,
 )
 from ai_review.clients.gitlab.mr.schema.notes import (
     GitLabNoteSchema,
@@ -60,8 +61,16 @@ class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
         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"),
+                GitLabNoteSchema(
+                    id=1,
+                    body="General comment",
+                    author=GitLabUserSchema(id=301, name="Charlie", username="charlie"),
+                ),
+                GitLabNoteSchema(
+                    id=2,
+                    body="Another note",
+                    author=GitLabUserSchema(id=302, name="Diana", username="diana"),
+                ),
             ]
         )
 
@@ -75,6 +84,13 @@ class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
                         GitLabNoteSchema(id=10, body="Inline comment A"),
                         GitLabNoteSchema(id=11, body="Inline comment B"),
                     ],
+                    position=GitLabDiscussionPositionSchema(
+                        base_sha="abc123",
+                        head_sha="def456",
+                        start_sha="ghi789",
+                        new_path="src/app.py",
+                        new_line=12,
+                    ),
                 )
             ]
         )
@@ -100,7 +116,30 @@ class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
                 {"project_id": project_id, "merge_request_id": merge_request_id, "body": request.body}
             )
         )
-        return GitLabCreateMRDiscussionResponseSchema(id="discussion-new", body=request.body)
+        return GitLabCreateMRDiscussionResponseSchema(
+            id="discussion-new",
+            notes=[GitLabNoteSchema(id=1, body=request.body)]
+        )
+
+    async def create_discussion_reply(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            discussion_id: str,
+            body: str,
+    ) -> GitLabCreateMRDiscussionReplyResponseSchema:
+        self.calls.append(
+            (
+                "create_discussion_reply",
+                {
+                    "project_id": project_id,
+                    "merge_request_id": merge_request_id,
+                    "discussion_id": discussion_id,
+                    "body": body,
+                },
+            )
+        )
+        return GitLabCreateMRDiscussionReplyResponseSchema(id=100, body=body)
 
 
 class FakeGitLabHTTPClient:

ai_review/tests/fixtures/libs/llm/output_json_parser.py

@@ -0,0 +1,13 @@
+import pytest
+from pydantic import BaseModel
+
+from ai_review.libs.llm.output_json_parser import LLMOutputJSONParser
+
+
+class DummyModel(BaseModel):
+    text: str
+
+
+@pytest.fixture
+def llm_output_json_parser() -> LLMOutputJSONParser:
+    return LLMOutputJSONParser(DummyModel)

ai_review/tests/fixtures/services/hook.py

@@ -0,0 +1,8 @@
+import pytest
+
+from ai_review.services.hook import HookService
+
+
+@pytest.fixture
+def hook_service() -> HookService:
+    return HookService()

ai_review/tests/fixtures/services/llm.py

@@ -13,11 +13,14 @@ class FakeLLMClient(LLMClientProtocol):
     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),
+        return self.responses.get(
+            "chat",
+            ChatResultSchema(
+                text="FAKE_RESPONSE",
+                total_tokens=42,
+                prompt_tokens=21,
+                completion_tokens=21,
+            )
         )
 
 

ai_review/tests/fixtures/services/prompt.py

@@ -1,8 +1,10 @@
 import pytest
 
+from ai_review.libs.config.prompt import PromptConfig
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.prompt.schema import PromptContextSchema
 from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.vcs.types import ReviewThreadSchema
 
 
 class FakePromptService(PromptServiceProtocol):
@@ -25,6 +27,24 @@ class FakePromptService(PromptServiceProtocol):
         self.calls.append(("build_context_request", {"diffs": diffs, "context": context}))
         return "CONTEXT_PROMPT"
 
+    def build_inline_reply_request(
+            self,
+            diff: DiffFileSchema,
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        self.calls.append(("build_inline_reply_request", {"diff": diff, "thread": thread, "context": context}))
+        return f"INLINE_REPLY_PROMPT_FOR_{diff.file}"
+
+    def build_summary_reply_request(
+            self,
+            diffs: list[DiffFileSchema],
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        self.calls.append(("build_summary_reply_request", {"diffs": diffs, "thread": thread, "context": context}))
+        return "SUMMARY_REPLY_PROMPT"
+
     def build_system_inline_request(self, context: PromptContextSchema) -> str:
         self.calls.append(("build_system_inline_request", {"context": context}))
         return "SYSTEM_INLINE_PROMPT"
@@ -37,7 +57,57 @@ class FakePromptService(PromptServiceProtocol):
         self.calls.append(("build_system_summary_request", {"context": context}))
         return "SYSTEM_SUMMARY_PROMPT"
 
+    def build_system_inline_reply_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_inline_reply_request", {"context": context}))
+        return "SYSTEM_INLINE_REPLY_PROMPT"
+
+    def build_system_summary_reply_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_summary_reply_request", {"context": context}))
+        return "SYSTEM_SUMMARY_REPLY_PROMPT"
+
 
 @pytest.fixture
 def fake_prompt_service() -> FakePromptService:
     return FakePromptService()
+
+
+@pytest.fixture
+def fake_prompts(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Patch methods of settings.prompt to return dummy values."""
+    monkeypatch.setattr(PromptConfig, "load_inline", lambda self: ["GLOBAL_INLINE", "INLINE_PROMPT"])
+    monkeypatch.setattr(PromptConfig, "load_context", lambda self: ["GLOBAL_CONTEXT", "CONTEXT_PROMPT"])
+    monkeypatch.setattr(PromptConfig, "load_summary", lambda self: ["GLOBAL_SUMMARY", "SUMMARY_PROMPT"])
+    monkeypatch.setattr(PromptConfig, "load_system_inline", lambda self: ["SYS_INLINE_A", "SYS_INLINE_B"])
+    monkeypatch.setattr(PromptConfig, "load_system_context", lambda self: ["SYS_CONTEXT_A", "SYS_CONTEXT_B"])
+    monkeypatch.setattr(PromptConfig, "load_system_summary", lambda self: ["SYS_SUMMARY_A", "SYS_SUMMARY_B"])
+    monkeypatch.setattr(PromptConfig, "load_inline_reply", lambda self: ["INLINE_REPLY_A", "INLINE_REPLY_B"])
+    monkeypatch.setattr(PromptConfig, "load_summary_reply", lambda self: ["SUMMARY_REPLY_A", "SUMMARY_REPLY_B"])
+    monkeypatch.setattr(
+        PromptConfig,
+        "load_system_inline_reply",
+        lambda self: ["SYS_INLINE_REPLY_A", "SYS_INLINE_REPLY_B"]
+    )
+    monkeypatch.setattr(
+        PromptConfig,
+        "load_system_summary_reply",
+        lambda self: ["SYS_SUMMARY_REPLY_A", "SYS_SUMMARY_REPLY_B"]
+    )
+
+
+@pytest.fixture
+def fake_prompt_context() -> PromptContextSchema:
+    """Builds a context object that reflects the new unified review schema."""
+    return PromptContextSchema(
+        review_title="Fix login bug",
+        review_description="Some description",
+        review_author_name="Nikita",
+        review_author_username="nikita.filonov",
+        review_reviewers=["Alice", "Bob"],
+        review_reviewers_usernames=["alice", "bob"],
+        review_assignees=["Charlie"],
+        review_assignees_usernames=["charlie"],
+        source_branch="feature/login-fix",
+        target_branch="main",
+        labels=["bug", "critical"],
+        changed_files=["foo.py", "bar.py"],
+    )

ai_review/tests/fixtures/services/review/base.py

@@ -0,0 +1,41 @@
+import pytest
+
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.review.service import ReviewService
+
+
+@pytest.fixture
+def review_service(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_cost_service: CostServiceProtocol,
+        fake_inline_review_runner: ReviewRunnerProtocol,
+        fake_context_review_runner: ReviewRunnerProtocol,
+        fake_summary_review_runner: ReviewRunnerProtocol,
+        fake_inline_reply_review_runner: ReviewRunnerProtocol,
+        fake_summary_reply_review_runner: ReviewRunnerProtocol,
+):
+    monkeypatch.setattr("ai_review.services.review.service.CostService", lambda: fake_cost_service)
+
+    monkeypatch.setattr(
+        "ai_review.services.review.service.InlineReviewRunner",
+        lambda **_: fake_inline_review_runner
+    )
+    monkeypatch.setattr(
+        "ai_review.services.review.service.ContextReviewRunner",
+        lambda **_: fake_context_review_runner
+    )
+    monkeypatch.setattr(
+        "ai_review.services.review.service.SummaryReviewRunner",
+        lambda **_: fake_summary_review_runner
+    )
+    monkeypatch.setattr(
+        "ai_review.services.review.service.InlineReplyReviewRunner",
+        lambda **_: fake_inline_reply_review_runner
+    )
+    monkeypatch.setattr(
+        "ai_review.services.review.service.SummaryReplyReviewRunner",
+        lambda **_: fake_summary_reply_review_runner
+    )
+
+    return ReviewService()

ai_review/tests/fixtures/services/review/gateway/comment.py

@@ -0,0 +1,98 @@
+from typing import Any
+
+import pytest
+
+from ai_review.services.review.gateway.comment import ReviewCommentGateway
+from ai_review.services.review.gateway.types import ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.inline.schema import InlineCommentSchema, InlineCommentListSchema
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+from ai_review.services.vcs.types import (
+    UserSchema,
+    ThreadKind,
+    ReviewThreadSchema,
+    ReviewCommentSchema,
+    VCSClientProtocol
+)
+
+
+class FakeReviewCommentGateway(ReviewCommentGatewayProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None):
+        self.calls: list[tuple[str, dict]] = []
+
+        fake_user = UserSchema(id="u1", username="tester", name="Tester")
+
+        fake_inline_thread = ReviewThreadSchema(
+            id="t1",
+            kind=ThreadKind.INLINE,
+            file="file.py",
+            line=5,
+            comments=[
+                ReviewCommentSchema(
+                    id="c1",
+                    body="AI inline comment <!--AI-->",
+                    file="file.py",
+                    line=5,
+                    author=fake_user
+                ),
+                ReviewCommentSchema(id="c2", body="Developer reply", file="file.py", line=5, author=fake_user),
+            ],
+        )
+
+        fake_summary_thread = ReviewThreadSchema(
+            id="t2",
+            kind=ThreadKind.SUMMARY,
+            comments=[
+                ReviewCommentSchema(id="c3", body="AI summary comment <!--AI-->", author=fake_user),
+                ReviewCommentSchema(id="c4", body="Developer reply", author=fake_user),
+            ],
+        )
+
+        self.responses = responses or {
+            "get_inline_threads": [fake_inline_thread],
+            "get_summary_threads": [fake_summary_thread],
+            "has_existing_inline_comments": False,
+            "has_existing_summary_comments": False,
+        }
+
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        self.calls.append(("get_inline_threads", {}))
+        return self.responses.get("get_inline_threads", [])
+
+    async def get_summary_threads(self) -> list[ReviewThreadSchema]:
+        self.calls.append(("get_summary_threads", {}))
+        return self.responses.get("get_summary_threads", [])
+
+    async def has_existing_inline_comments(self) -> bool:
+        self.calls.append(("has_existing_inline_comments", {}))
+        return self.responses.get("has_existing_inline_comments", False)
+
+    async def has_existing_summary_comments(self) -> bool:
+        self.calls.append(("has_existing_summary_comments", {}))
+        return self.responses.get("has_existing_summary_comments", False)
+
+    async def process_inline_reply(self, thread_id: str, reply: InlineCommentReplySchema) -> None:
+        self.calls.append(("process_inline_reply", {"thread_id": thread_id, "reply": reply}))
+
+    async def process_summary_reply(self, thread_id: str, reply: SummaryCommentReplySchema) -> None:
+        self.calls.append(("process_summary_reply", {"thread_id": thread_id, "reply": reply}))
+
+    async def process_inline_comment(self, comment: InlineCommentSchema) -> None:
+        self.calls.append(("process_inline_comment", {"comment": comment}))
+
+    async def process_summary_comment(self, comment: SummaryCommentSchema) -> None:
+        self.calls.append(("process_summary_comment", {"comment": comment}))
+
+    async def process_inline_comments(self, comments: InlineCommentListSchema) -> None:
+        self.calls.append(("process_inline_comments", {"comments": comments}))
+
+
+@pytest.fixture
+def fake_review_comment_gateway() -> FakeReviewCommentGateway:
+    return FakeReviewCommentGateway()
+
+
+@pytest.fixture
+def review_comment_gateway(fake_vcs_client: VCSClientProtocol) -> ReviewCommentGateway:
+    return ReviewCommentGateway(vcs=fake_vcs_client)

ai_review/tests/fixtures/services/review/gateway/llm.py

@@ -0,0 +1,17 @@
+import pytest
+
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol
+
+
+class FakeReviewLLMGateway(ReviewLLMGatewayProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def ask(self, prompt: str, prompt_system: str) -> str:
+        self.calls.append(("ask", {"prompt": prompt, "prompt_system": prompt_system}))
+        return "FAKE_LLM_RESPONSE"
+
+
+@pytest.fixture
+def fake_review_llm_gateway() -> FakeReviewLLMGateway:
+    return FakeReviewLLMGateway()

ai_review/tests/fixtures/services/review/{inline.py → internal/inline.py}

@@ -1,7 +1,8 @@
 import pytest
 
-from ai_review.services.review.inline.schema import InlineCommentListSchema, InlineCommentSchema
-from ai_review.services.review.inline.types import InlineCommentServiceProtocol
+from ai_review.services.review.internal.inline.schema import InlineCommentListSchema, InlineCommentSchema
+from ai_review.services.review.internal.inline.service import InlineCommentService
+from ai_review.services.review.internal.inline.types import InlineCommentServiceProtocol
 
 
 class FakeInlineCommentService(InlineCommentServiceProtocol):
@@ -15,11 +16,12 @@ class FakeInlineCommentService(InlineCommentServiceProtocol):
         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()
+
+
+@pytest.fixture
+def inline_comment_service() -> InlineCommentService:
+    return InlineCommentService()

ai_review/tests/fixtures/services/review/internal/inline_reply.py

@@ -0,0 +1,25 @@
+import pytest
+
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.inline_reply.service import InlineCommentReplyService
+from ai_review.services.review.internal.inline_reply.types import InlineCommentReplyServiceProtocol
+
+
+class FakeInlineCommentReplyService(InlineCommentReplyServiceProtocol):
+    def __init__(self, reply: InlineCommentReplySchema | None = None):
+        self.calls: list[tuple[str, dict]] = []
+        self.reply = reply or InlineCommentReplySchema(message="Looks good!", suggestion="use const instead of var")
+
+    def parse_model_output(self, output: str) -> InlineCommentReplySchema | None:
+        self.calls.append(("parse_model_output", {"output": output}))
+        return self.reply
+
+
+@pytest.fixture
+def fake_inline_comment_reply_service() -> FakeInlineCommentReplyService:
+    return FakeInlineCommentReplyService()
+
+
+@pytest.fixture
+def inline_comment_reply_service() -> InlineCommentReplyService:
+    return InlineCommentReplyService()

ai_review/tests/fixtures/services/review/internal/policy.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+import pytest
+
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+
+
+class FakeReviewPolicyService(ReviewPolicyServiceProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None):
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    def apply_for_files(self, files: list[str]) -> list[str]:
+        self.calls.append(("apply_for_files", {"files": files}))
+        return self.responses.get("apply_for_files", files)
+
+    def apply_for_inline_comments(self, comments: list) -> list:
+        self.calls.append(("apply_for_inline_comments", {"comments": comments}))
+        return self.responses.get("apply_for_inline_comments", comments)
+
+    def apply_for_context_comments(self, comments: list) -> list:
+        self.calls.append(("apply_for_context_comments", {"comments": comments}))
+        return self.responses.get("apply_for_context_comments", comments)
+
+
+@pytest.fixture
+def fake_review_policy_service() -> FakeReviewPolicyService:
+    return FakeReviewPolicyService()

ai_review/tests/fixtures/services/review/internal/summary.py

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

ai_review/tests/fixtures/services/review/internal/summary_reply.py

@@ -0,0 +1,19 @@
+import pytest
+
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+from ai_review.services.review.internal.summary_reply.types import SummaryCommentReplyServiceProtocol
+
+
+class FakeSummaryCommentReplyService(SummaryCommentReplyServiceProtocol):
+    def __init__(self, reply: SummaryCommentReplySchema | None = None):
+        self.calls: list[tuple[str, dict]] = []
+        self.reply = reply or SummaryCommentReplySchema(text="Overall, the code looks clean and efficient.")
+
+    def parse_model_output(self, output: str) -> SummaryCommentReplySchema:
+        self.calls.append(("parse_model_output", {"output": output}))
+        return self.reply
+
+
+@pytest.fixture
+def fake_summary_comment_reply_service() -> FakeSummaryCommentReplyService:
+    return FakeSummaryCommentReplyService()

ai_review/tests/fixtures/services/review/runner/context.py

@@ -0,0 +1,50 @@
+import pytest
+
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol, ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.inline.types import InlineCommentServiceProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.runner.context import ContextReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeContextReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_context_review_runner() -> FakeContextReviewRunner:
+    return FakeContextReviewRunner()
+
+
+@pytest.fixture
+def context_review_runner(
+        fake_vcs_client: VCSClientProtocol,
+        fake_git_service: GitServiceProtocol,
+        fake_diff_service: DiffServiceProtocol,
+        fake_cost_service: CostServiceProtocol,
+        fake_prompt_service: PromptServiceProtocol,
+        fake_review_llm_gateway: ReviewLLMGatewayProtocol,
+        fake_review_policy_service: ReviewPolicyServiceProtocol,
+        fake_review_comment_gateway: ReviewCommentGatewayProtocol,
+        fake_inline_comment_service: InlineCommentServiceProtocol,
+) -> ContextReviewRunner:
+    return ContextReviewRunner(
+        vcs=fake_vcs_client,
+        git=fake_git_service,
+        diff=fake_diff_service,
+        cost=fake_cost_service,
+        prompt=fake_prompt_service,
+        review_policy=fake_review_policy_service,
+        inline_comment=fake_inline_comment_service,
+        review_llm_gateway=fake_review_llm_gateway,
+        review_comment_gateway=fake_review_comment_gateway,
+    )

ai_review/tests/fixtures/services/review/runner/inline.py

@@ -0,0 +1,50 @@
+import pytest
+
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol, ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.inline.types import InlineCommentServiceProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.runner.inline import InlineReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeInlineReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_inline_review_runner() -> FakeInlineReviewRunner:
+    return FakeInlineReviewRunner()
+
+
+@pytest.fixture
+def inline_review_runner(
+        fake_vcs_client: VCSClientProtocol,
+        fake_git_service: GitServiceProtocol,
+        fake_diff_service: DiffServiceProtocol,
+        fake_cost_service: CostServiceProtocol,
+        fake_prompt_service: PromptServiceProtocol,
+        fake_review_llm_gateway: ReviewLLMGatewayProtocol,
+        fake_review_policy_service: ReviewPolicyServiceProtocol,
+        fake_review_comment_gateway: ReviewCommentGatewayProtocol,
+        fake_inline_comment_service: InlineCommentServiceProtocol,
+) -> InlineReviewRunner:
+    return InlineReviewRunner(
+        vcs=fake_vcs_client,
+        git=fake_git_service,
+        diff=fake_diff_service,
+        cost=fake_cost_service,
+        prompt=fake_prompt_service,
+        review_policy=fake_review_policy_service,
+        inline_comment=fake_inline_comment_service,
+        review_llm_gateway=fake_review_llm_gateway,
+        review_comment_gateway=fake_review_comment_gateway,
+    )

ai_review/tests/fixtures/services/review/runner/inline_reply.py

@@ -0,0 +1,50 @@
+import pytest
+
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol, ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.inline_reply.types import InlineCommentReplyServiceProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.runner.inline_reply import InlineReplyReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeInlineReplyReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_inline_reply_review_runner() -> FakeInlineReplyReviewRunner:
+    return FakeInlineReplyReviewRunner()
+
+
+@pytest.fixture
+def inline_reply_review_runner(
+        fake_vcs_client: VCSClientProtocol,
+        fake_git_service: GitServiceProtocol,
+        fake_diff_service: DiffServiceProtocol,
+        fake_cost_service: CostServiceProtocol,
+        fake_prompt_service: PromptServiceProtocol,
+        fake_review_llm_gateway: ReviewLLMGatewayProtocol,
+        fake_review_policy_service: ReviewPolicyServiceProtocol,
+        fake_review_comment_gateway: ReviewCommentGatewayProtocol,
+        fake_inline_comment_reply_service: InlineCommentReplyServiceProtocol,
+) -> InlineReplyReviewRunner:
+    return InlineReplyReviewRunner(
+        vcs=fake_vcs_client,
+        git=fake_git_service,
+        diff=fake_diff_service,
+        cost=fake_cost_service,
+        prompt=fake_prompt_service,
+        review_policy=fake_review_policy_service,
+        review_llm_gateway=fake_review_llm_gateway,
+        inline_comment_reply=fake_inline_comment_reply_service,
+        review_comment_gateway=fake_review_comment_gateway,
+    )