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

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,
+    )

ai_review/tests/fixtures/services/review/runner/summary.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 ReviewCommentGatewayProtocol, ReviewLLMGatewayProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.internal.summary.types import SummaryCommentServiceProtocol
+from ai_review.services.review.runner.summary import SummaryReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeSummaryReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_summary_review_runner() -> FakeSummaryReviewRunner:
+    return FakeSummaryReviewRunner()
+
+
+@pytest.fixture
+def summary_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_summary_comment_service: SummaryCommentServiceProtocol,
+) -> SummaryReviewRunner:
+    return SummaryReviewRunner(
+        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,
+        summary_comment=fake_summary_comment_service,
+        review_llm_gateway=fake_review_llm_gateway,
+        review_comment_gateway=fake_review_comment_gateway,
+    )

ai_review/tests/fixtures/services/review/runner/summary_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.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.internal.summary_reply.types import SummaryCommentReplyServiceProtocol
+from ai_review.services.review.runner.summary_reply import SummaryReplyReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeSummaryReplyReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_summary_reply_review_runner() -> FakeSummaryReplyReviewRunner:
+    return FakeSummaryReplyReviewRunner()
+
+
+@pytest.fixture
+def summary_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_summary_comment_reply_service: SummaryCommentReplyServiceProtocol,
+) -> SummaryReplyReviewRunner:
+    return SummaryReplyReviewRunner(
+        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,
+        summary_comment_reply=fake_summary_comment_reply_service,
+        review_comment_gateway=fake_review_comment_gateway,
+    )

ai_review/tests/fixtures/services/vcs.py

@@ -5,6 +5,7 @@ import pytest
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
     ReviewInfoSchema,
+    ReviewThreadSchema,
     ReviewCommentSchema,
 )
 
@@ -43,6 +44,28 @@ class FakeVCSClient(VCSClientProtocol):
 
         return self.responses.get("create_inline_comment_result", None)
 
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        self.calls.append(("create_inline_reply", (thread_id, message), {}))
+        if error := self.responses.get("create_inline_reply_error"):
+            raise error
+
+        return self.responses.get("create_inline_reply_result", None)
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        self.calls.append(("create_summary_reply", (thread_id, message), {}))
+        if error := self.responses.get("create_summary_reply_error"):
+            raise error
+
+        return self.responses.get("create_summary_reply_result", None)
+
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        self.calls.append(("get_inline_threads", (), {}))
+        return self.responses.get("get_inline_threads", [])
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        self.calls.append(("get_general_threads", (), {}))
+        return self.responses.get("get_general_threads", [])
+
 
 @pytest.fixture
 def fake_vcs_client() -> FakeVCSClient:

ai_review/tests/suites/cli/test_main.py

@@ -0,0 +1,54 @@
+import pytest
+from typer.testing import CliRunner
+
+from ai_review.cli.main import app
+from ai_review.services.review.service import ReviewService
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def dummy_review_service(monkeypatch: pytest.MonkeyPatch, review_service: ReviewService):
+    monkeypatch.setattr("ai_review.cli.commands.run_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_inline_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_context_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_summary_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_inline_reply_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_summary_reply_review.ReviewService", lambda: review_service)
+
+
+@pytest.mark.parametrize(
+    "args, expected_output",
+    [
+        (["run"], "Starting full AI review..."),
+        (["run-inline"], "Starting inline AI review..."),
+        (["run-context"], "Starting context AI review..."),
+        (["run-summary"], "Starting summary AI review..."),
+        (["run-inline-reply"], "Starting inline reply AI review..."),
+        (["run-summary-reply"], "Starting summary reply AI review..."),
+    ],
+)
+def test_cli_commands_invoke_review_service_successfully(args: list[str], expected_output: str):
+    """
+    Ensure CLI commands correctly call the ReviewService with fake dependencies.
+    """
+    result = runner.invoke(app, args)
+
+    assert result.exit_code == 0
+    assert expected_output in result.output
+    assert "AI review completed successfully!" in result.output
+
+
+def test_show_config_outputs_json(monkeypatch: pytest.MonkeyPatch):
+    """
+    Validate that the 'show-config' command prints settings as JSON.
+    """
+    monkeypatch.setattr(
+        "ai_review.cli.main.settings.model_dump_json",
+        lambda **_: '{"debug": true}'
+    )
+
+    result = runner.invoke(app, ["show-config"])
+    assert result.exit_code == 0
+    assert "Loaded AI Review configuration" in result.output
+    assert '{"debug": true}' in result.output