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

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

@@ -1,126 +1,93 @@
 import pytest
 
+from ai_review.services.llm.types import ChatResultSchema
 from ai_review.services.review.service import ReviewService
-from ai_review.tests.fixtures.services.artifacts import FakeArtifactsService
 from ai_review.tests.fixtures.services.cost import FakeCostService
-from ai_review.tests.fixtures.services.diff import FakeDiffService
-from ai_review.tests.fixtures.services.git import FakeGitService
-from ai_review.tests.fixtures.services.llm import FakeLLMClient
-from ai_review.tests.fixtures.services.prompt import FakePromptService
-from ai_review.tests.fixtures.services.review.inline import FakeInlineCommentService
-from ai_review.tests.fixtures.services.review.summary import FakeSummaryCommentService
-from ai_review.tests.fixtures.services.vcs import FakeVCSClient
-
-
-@pytest.fixture
-def review_service(
-        monkeypatch: pytest.MonkeyPatch,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_git_service: FakeGitService,
-        fake_diff_service: FakeDiffService,
-        fake_cost_service: FakeCostService,
-        fake_prompt_service: FakePromptService,
-        fake_artifacts_service: FakeArtifactsService,
-        fake_inline_comment_service: FakeInlineCommentService,
-        fake_summary_comment_service: FakeSummaryCommentService,
-):
-    monkeypatch.setattr("ai_review.services.review.service.get_llm_client", lambda: fake_llm_client)
-    monkeypatch.setattr("ai_review.services.review.service.get_vcs_client", lambda: fake_vcs_client)
-    monkeypatch.setattr("ai_review.services.review.service.GitService", lambda: fake_git_service)
-    monkeypatch.setattr("ai_review.services.review.service.DiffService", lambda: fake_diff_service)
-    monkeypatch.setattr("ai_review.services.review.service.PromptService", lambda: fake_prompt_service)
-    monkeypatch.setattr("ai_review.services.review.service.InlineCommentService", lambda: fake_inline_comment_service)
-    monkeypatch.setattr("ai_review.services.review.service.SummaryCommentService", lambda: fake_summary_comment_service)
-    monkeypatch.setattr("ai_review.services.review.service.ArtifactsService", lambda: fake_artifacts_service)
-    monkeypatch.setattr("ai_review.services.review.service.CostService", lambda: fake_cost_service)
-    return ReviewService()
+from ai_review.tests.fixtures.services.review.runner.context import FakeContextReviewRunner
+from ai_review.tests.fixtures.services.review.runner.inline import FakeInlineReviewRunner
+from ai_review.tests.fixtures.services.review.runner.inline_reply import FakeInlineReplyReviewRunner
+from ai_review.tests.fixtures.services.review.runner.summary import FakeSummaryReviewRunner
+from ai_review.tests.fixtures.services.review.runner.summary_reply import FakeSummaryReplyReviewRunner
 
 
 @pytest.mark.asyncio
-async def test_run_inline_review_happy_path(
+async def test_run_inline_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_prompt_service: FakePromptService,
-        fake_git_service: FakeGitService,
-        fake_diff_service: FakeDiffService,
-        fake_cost_service: FakeCostService,
-        fake_artifacts_service: FakeArtifactsService,
+        fake_inline_review_runner: FakeInlineReviewRunner
 ):
-    """Should perform inline review for changed files and create inline comments via VCS."""
-    fake_git_service.responses["get_diff_for_file"] = "FAKE_DIFF"
-
+    """Should call run() on InlineReviewRunner."""
     await review_service.run_inline_review()
-
-    vcs_calls = [c[0] for c in fake_vcs_client.calls]
-    assert "get_review_info" in vcs_calls
-    assert "create_inline_comment" in vcs_calls
-
-    assert (
-               "get_diff_for_file",
-               {"base_sha": "A", "head_sha": "B", "file": "file.py", "unified": 3}
-           ) in fake_git_service.calls
-    assert any(call[0] == "render_file" for call in fake_diff_service.calls)
-
-    assert any(call[0] == "build_inline_request" for call in fake_prompt_service.calls)
-    assert any(call[0] == "chat" for call in fake_llm_client.calls)
-
-    assert len(fake_cost_service.reports) == 1
-    assert any(call[0] == "save_llm_interaction" for call in fake_artifacts_service.calls)
+    assert fake_inline_review_runner.calls == [("run", {})]
 
 
 @pytest.mark.asyncio
-async def test_run_inline_review_skips_when_no_diff(
+async def test_run_context_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_git_service: FakeGitService,
-        fake_llm_client: FakeLLMClient,
+        fake_context_review_runner: FakeContextReviewRunner
 ):
-    """Should skip inline review when no diffs exist."""
-    fake_git_service.responses["get_diff_for_file"] = ""
-
-    await review_service.run_inline_review()
-
-    assert not any(call[0] == "chat" for call in fake_llm_client.calls)
-    assert not any(call[0] == "create_inline_comment" for call in fake_vcs_client.calls)
+    """Should call run() on ContextReviewRunner."""
+    await review_service.run_context_review()
+    assert fake_context_review_runner.calls == [("run", {})]
 
 
 @pytest.mark.asyncio
-async def test_run_context_review_happy_path(
+async def test_run_summary_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_prompt_service: FakePromptService,
-        fake_diff_service: FakeDiffService,
+        fake_summary_review_runner: FakeSummaryReviewRunner
 ):
-    """Should perform context review and post inline comments based on rendered files."""
-    await review_service.run_context_review()
+    """Should call run() on SummaryReviewRunner."""
+    await review_service.run_summary_review()
+    assert fake_summary_review_runner.calls == [("run", {})]
 
-    vcs_calls = [c[0] for c in fake_vcs_client.calls]
-    assert "get_review_info" in vcs_calls
-    assert "create_inline_comment" in vcs_calls
 
-    assert any(call[0] == "render_files" for call in fake_diff_service.calls)
-    assert any(call[0] == "build_context_request" for call in fake_prompt_service.calls)
-    assert any(call[0] == "chat" for call in fake_llm_client.calls)
+@pytest.mark.asyncio
+async def test_run_inline_reply_review_invokes_runner(
+        review_service: ReviewService,
+        fake_inline_reply_review_runner: FakeInlineReplyReviewRunner
+):
+    """Should call run() on InlineReplyReviewRunner."""
+    await review_service.run_inline_reply_review()
+    assert fake_inline_reply_review_runner.calls == [("run", {})]
 
 
 @pytest.mark.asyncio
-async def test_run_summary_review_happy_path(
+async def test_run_summary_reply_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_prompt_service: FakePromptService,
-        fake_diff_service: FakeDiffService,
+        fake_summary_reply_review_runner: FakeSummaryReplyReviewRunner
 ):
-    """Should perform summary review and post a single summary comment."""
-    await review_service.run_summary_review()
+    """Should call run() on SummaryReplyReviewRunner."""
+    await review_service.run_summary_reply_review()
+    assert fake_summary_reply_review_runner.calls == [("run", {})]
 
-    vcs_calls = [c[0] for c in fake_vcs_client.calls]
-    assert "get_review_info" in vcs_calls
-    assert "create_general_comment" in vcs_calls
 
-    assert any(call[0] == "render_files" for call in fake_diff_service.calls)
-    assert any(call[0] == "build_summary_request" for call in fake_prompt_service.calls)
-    assert any(call[0] == "chat" for call in fake_llm_client.calls)
+def test_report_total_cost_with_data(
+        capsys,
+        review_service: ReviewService,
+        fake_cost_service: FakeCostService
+):
+    """Should log total cost when cost report exists."""
+    fake_cost_service.reports.append(
+        fake_cost_service.calculate(
+            result=ChatResultSchema(
+                text="result",
+                total_tokens=100,
+                prompt_tokens=50,
+                completion_tokens=10,
+            )
+        )
+    )
+
+    review_service.report_total_cost()
+    output = capsys.readouterr().out
+
+    assert "TOTAL REVIEW COST" in output
+    assert "fake-model" in output
+    assert "0.006" in output
+
+
+def test_report_total_cost_no_data(capsys, review_service: ReviewService):
+    """Should log message when no cost data is available."""
+    review_service.report_total_cost()
+    output = capsys.readouterr().out
+
+    assert "No cost data collected" in output

ai_review/tests/suites/services/vcs/bitbucket/test_adapter.py

@@ -0,0 +1,109 @@
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketPRCommentSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCommentInlineSchema,
+    BitbucketCommentParentSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.user import BitbucketUserSchema
+from ai_review.services.vcs.bitbucket.adapter import get_review_comment_from_bitbucket_pr_comment
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def test_maps_all_fields_correctly():
+    """Should map Bitbucket PR comment with all fields correctly."""
+    comment = BitbucketPRCommentSchema(
+        id=101,
+        user=BitbucketUserSchema(uuid="u-123", display_name="Alice", nickname="alice"),
+        parent=None,
+        inline=BitbucketCommentInlineSchema(path="src/utils.py", to_line=10),
+        content=BitbucketCommentContentSchema(raw="Looks good"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 101
+    assert result.body == "Looks good"
+    assert result.file == "src/utils.py"
+    assert result.line == 10
+    assert result.parent_id is None
+    assert result.thread_id == 101
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id == "u-123"
+    assert result.author.name == "Alice"
+    assert result.author.username == "alice"
+
+
+def test_maps_with_parent_comment():
+    """Should set parent_id and use it as thread_id."""
+    comment = BitbucketPRCommentSchema(
+        id=202,
+        user=BitbucketUserSchema(uuid="u-456", display_name="Bob", nickname="bob"),
+        parent=BitbucketCommentParentSchema(id=101),
+        inline=BitbucketCommentInlineSchema(path="src/main.py", to_line=20),
+        content=BitbucketCommentContentSchema(raw="I agree"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert result.parent_id == 101
+    assert result.thread_id == 101
+    assert result.id == 202
+    assert result.file == "src/main.py"
+    assert result.line == 20
+
+
+def test_maps_without_user():
+    """Should handle missing user gracefully."""
+    comment = BitbucketPRCommentSchema(
+        id=303,
+        user=None,
+        parent=None,
+        inline=BitbucketCommentInlineSchema(path="src/app.py", to_line=5),
+        content=BitbucketCommentContentSchema(raw="Anonymous feedback"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id is None
+    assert result.author.name == ""
+    assert result.author.username == ""
+
+
+def test_maps_without_inline():
+    """Should handle missing inline gracefully (file and line None)."""
+    comment = BitbucketPRCommentSchema(
+        id=404,
+        user=BitbucketUserSchema(uuid="u-789", display_name="Charlie", nickname="charlie"),
+        parent=None,
+        inline=None,
+        content=BitbucketCommentContentSchema(raw="General comment"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == 404
+
+
+def test_maps_with_empty_body_and_defaults():
+    """Should default body to empty string if content.raw is empty or None."""
+    comment = BitbucketPRCommentSchema(
+        id=505,
+        user=None,
+        parent=None,
+        inline=None,
+        content=BitbucketCommentContentSchema(raw="", html=None, markup=None),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.body == ""
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == 505
+    assert isinstance(result.author, UserSchema)

ai_review/tests/suites/services/vcs/bitbucket/{test_service.py → test_client.py}

@@ -1,7 +1,7 @@
 import pytest
 
 from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
-from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema
+from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema, ReviewThreadSchema, ThreadKind
 from ai_review.tests.fixtures.clients.bitbucket import FakeBitbucketPullRequestsHTTPClient
 
 
@@ -115,3 +115,90 @@ async def test_create_inline_comment_posts_comment(
     assert call_args["content"]["raw"] == message
     assert call_args["inline"]["path"] == file
     assert call_args["inline"]["to"] == line
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_create_inline_reply_posts_comment(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should post a reply to an existing inline thread."""
+    thread_id = 42
+    message = "I agree with this inline comment."
+
+    await bitbucket_vcs_client.create_inline_reply(thread_id, message)
+
+    calls = [args for name, args in fake_bitbucket_pull_requests_http_client.calls if name == "create_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["parent"]["id"] == thread_id
+    assert call_args["content"]["raw"] == message
+    assert call_args["workspace"] == "workspace"
+    assert call_args["repo_slug"] == "repo"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_create_summary_reply_posts_comment_with_parent(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should post a reply to a general thread (same API with parent id)."""
+    thread_id = 7
+    message = "Thanks for the clarification."
+
+    await bitbucket_vcs_client.create_summary_reply(thread_id, message)
+
+    calls = [args for name, args in fake_bitbucket_pull_requests_http_client.calls if name == "create_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["parent"]["id"] == thread_id
+    assert call_args["content"]["raw"] == message
+    assert call_args["workspace"] == "workspace"
+    assert call_args["repo_slug"] == "repo"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_inline_threads_groups_by_thread_id(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should group inline comments into threads."""
+    threads = await bitbucket_vcs_client.get_inline_threads()
+
+    assert all(isinstance(thread, ReviewThreadSchema) for thread in threads)
+    assert len(threads) == 1
+
+    thread = threads[0]
+    assert thread.kind == ThreadKind.INLINE
+    assert thread.file == "file.py"
+    assert thread.line == 5
+    assert len(thread.comments) == 1
+    assert isinstance(thread.comments[0], ReviewCommentSchema)
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert "get_comments" in called_methods
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_general_threads_groups_by_thread_id(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should group general (non-inline) comments into SUMMARY threads."""
+    threads = await bitbucket_vcs_client.get_general_threads()
+
+    assert all(isinstance(t, ReviewThreadSchema) for t in threads)
+    assert len(threads) == 1
+    thread = threads[0]
+    assert thread.kind == ThreadKind.SUMMARY
+    assert len(thread.comments) == 1
+    assert isinstance(thread.comments[0], ReviewCommentSchema)
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert "get_comments" in called_methods

ai_review/tests/suites/services/vcs/github/test_adapter.py

@@ -0,0 +1,162 @@
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubPRCommentSchema,
+    GitHubIssueCommentSchema,
+)
+from ai_review.clients.github.pr.schema.user import GitHubUserSchema
+from ai_review.services.vcs.github.adapter import (
+    get_review_comment_from_github_pr_comment,
+    get_review_comment_from_github_issue_comment,
+)
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def test_maps_all_fields_correctly_for_pr_comment():
+    """Should map GitHub PR comment with all fields correctly."""
+    comment = GitHubPRCommentSchema(
+        id=101,
+        body="Looks fine to me",
+        path="src/utils.py",
+        line=42,
+        user=GitHubUserSchema(id=7, login="alice"),
+        in_reply_to_id=None,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 101
+    assert result.body == "Looks fine to me"
+    assert result.file == "src/utils.py"
+    assert result.line == 42
+    assert result.parent_id is None
+    assert result.thread_id == 101
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id == 7
+    assert result.author.name == "alice"
+    assert result.author.username == "alice"
+
+
+def test_maps_reply_comment_with_parent_id():
+    """Should assign parent_id and use it as thread_id for replies."""
+    comment = GitHubPRCommentSchema(
+        id=202,
+        body="Agreed with above",
+        path="src/main.py",
+        line=10,
+        user=GitHubUserSchema(id=8, login="bob"),
+        in_reply_to_id=101,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert result.parent_id == 101
+    assert result.thread_id == 101
+    assert result.id == 202
+
+
+def test_maps_comment_without_user():
+    """Should handle missing user gracefully."""
+    comment = GitHubPRCommentSchema(
+        id=303,
+        body="Anonymous feedback",
+        path="src/app.py",
+        line=20,
+        user=None,
+        in_reply_to_id=None,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id is None
+    assert result.author.name == ""
+    assert result.author.username == ""
+
+
+def test_maps_comment_with_empty_body():
+    """Should default body to empty string if it's empty or None."""
+    comment = GitHubPRCommentSchema(
+        id=404,
+        body="",
+        path=None,
+        line=None,
+        user=GitHubUserSchema(id=1, login="bot"),
+        in_reply_to_id=None,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.body == ""
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == 404
+
+
+def test_maps_issue_comment_all_fields():
+    """Should map GitHub issue-level comment correctly."""
+    comment = GitHubIssueCommentSchema(
+        id=555,
+        body="Top-level discussion",
+        user=GitHubUserSchema(id=9, login="charlie"),
+    )
+
+    result = get_review_comment_from_github_issue_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 555
+    assert result.body == "Top-level discussion"
+    assert result.thread_id == 555
+    assert isinstance(result.author, UserSchema)
+
+
+def test_maps_issue_comment_with_empty_body():
+    """Should default empty body to empty string."""
+    comment = GitHubIssueCommentSchema(id=666, body="", user=None)
+
+    result = get_review_comment_from_github_issue_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 666
+    assert result.body == ""
+    assert result.thread_id == 666
+
+
+def test_issue_comment_without_user_is_handled():
+    """Should create empty UserSchema when GitHub issue comment has no user."""
+    comment = GitHubIssueCommentSchema(
+        id=777,
+        body="General feedback",
+        user=None,
+    )
+
+    result = get_review_comment_from_github_issue_comment(comment)
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id is None
+    assert result.author.name == ""
+    assert result.author.username == ""
+    assert result.body == "General feedback"
+    assert result.thread_id == 777
+
+
+def test_pr_comment_with_parent_and_missing_file_line():
+    """Should handle replies without path/line gracefully."""
+    comment = GitHubPRCommentSchema(
+        id=999,
+        body="Follow-up question",
+        path=None,
+        line=None,
+        user=GitHubUserSchema(id=10, login="eve"),
+        in_reply_to_id=101,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert result.parent_id == 101
+    assert result.thread_id == 101
+    assert result.file is None
+    assert result.line is None
+    assert result.body == "Follow-up question"
+    assert result.author.username == "eve"

ai_review/tests/suites/services/vcs/github/{test_service.py → test_client.py}

@@ -1,7 +1,13 @@
 import pytest
 
 from ai_review.services.vcs.github.client import GitHubVCSClient
-from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema
+from ai_review.services.vcs.types import (
+    ThreadKind,
+    UserSchema,
+    ReviewInfoSchema,
+    ReviewThreadSchema,
+    ReviewCommentSchema,
+)
 from ai_review.tests.fixtures.clients.github import FakeGitHubPullRequestsHTTPClient
 
 
@@ -111,4 +117,98 @@ async def test_create_inline_comment_posts_comment(
     assert call_args["path"] == "file.py"
     assert call_args["line"] == 10
     assert call_args["body"] == "Looks good"
-    assert call_args["commit_id"] == "def456"  # from fake PR head
+    assert call_args["commit_id"] == "def456"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_create_inline_reply_posts_comment(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should post a reply to an existing inline comment."""
+    thread_id = 3
+    message = "I agree with this suggestion."
+
+    await github_vcs_client.create_inline_reply(thread_id, message)
+
+    calls = [args for name, args in fake_github_pull_requests_http_client.calls if name == "create_review_reply"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["in_reply_to"] == thread_id
+    assert call_args["body"] == message
+    assert call_args["repo"] == "repo"
+    assert call_args["owner"] == "owner"
+    assert call_args["pull_number"] == "pull_number"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_create_summary_reply_reuses_general_comment_method(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should call create_issue_comment internally (since GitHub summary comments are flat)."""
+    thread_id = 11
+    message = "Thanks for clarifying."
+
+    await github_vcs_client.create_summary_reply(thread_id, message)
+
+    calls = [args for name, args in fake_github_pull_requests_http_client.calls if name == "create_issue_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["body"] == message
+    assert call_args["repo"] == "repo"
+    assert call_args["owner"] == "owner"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_get_inline_threads_returns_grouped_threads(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should group inline review comments into threads by file and line."""
+    threads = await github_vcs_client.get_inline_threads()
+
+    assert all(isinstance(t, ReviewThreadSchema) for t in threads)
+    assert len(threads) == 2  # 2 comments with unique IDs
+
+    first = threads[0]
+    assert first.kind == ThreadKind.INLINE
+    assert isinstance(first.comments[0], ReviewCommentSchema)
+    assert first.file == "file.py"
+    assert first.line == 5
+
+    called_methods = [name for name, _ in fake_github_pull_requests_http_client.calls]
+    assert "get_review_comments" in called_methods
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_get_general_threads_wraps_comments_in_threads(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should wrap each general comment as a separate SUMMARY thread."""
+    threads = await github_vcs_client.get_general_threads()
+
+    assert all(isinstance(thread, ReviewThreadSchema) for thread in threads)
+    assert all(thread.kind == ThreadKind.SUMMARY for thread in threads)
+    assert len(threads) == 2
+
+    authors = {t.comments[0].author.username for t in threads}
+    assert authors == {"alice", "bob"}
+
+    for thread in threads:
+        comment = thread.comments[0]
+        assert isinstance(comment, ReviewCommentSchema)
+        assert isinstance(comment.author, UserSchema)
+        assert comment.author.id is not None
+        assert comment.author.username != ""
+        assert comment.thread_id == comment.id
+
+    called_methods = [name for name, _ in fake_github_pull_requests_http_client.calls]
+    assert "get_issue_comments" in called_methods