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

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

@@ -5,41 +5,13 @@ 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.service import PromptService
+from ai_review.services.vcs.types import ReviewThreadSchema, ThreadKind, ReviewCommentSchema
 
 
-@pytest.fixture(autouse=True)
-def patch_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"])
-
-
-@pytest.fixture
-def dummy_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"],
-    )
-
-
-def test_build_inline_request_includes_prompts_and_diff(dummy_context: PromptContextSchema) -> None:
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_inline_request_includes_prompts_and_diff(fake_prompt_context: PromptContextSchema) -> None:
     diff = DiffFileSchema(file="foo.py", diff="+ added line\n- removed line")
-    result = PromptService.build_inline_request(diff, dummy_context)
+    result = PromptService.build_inline_request(diff, fake_prompt_context)
 
     assert "GLOBAL_INLINE" in result
     assert "INLINE_PROMPT" in result
@@ -48,12 +20,13 @@ def test_build_inline_request_includes_prompts_and_diff(dummy_context: PromptCon
     assert "- removed line" in result
 
 
-def test_build_summary_request_includes_prompts_and_diffs(dummy_context: PromptContextSchema) -> None:
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_summary_request_includes_prompts_and_diffs(fake_prompt_context: PromptContextSchema) -> None:
     diffs = [
         DiffFileSchema(file="a.py", diff="+ foo"),
         DiffFileSchema(file="b.py", diff="- bar"),
     ]
-    result = PromptService.build_summary_request(diffs, dummy_context)
+    result = PromptService.build_summary_request(diffs, fake_prompt_context)
 
     assert "GLOBAL_SUMMARY" in result
     assert "SUMMARY_PROMPT" in result
@@ -63,9 +36,10 @@ def test_build_summary_request_includes_prompts_and_diffs(dummy_context: PromptC
     assert "- bar" in result
 
 
-def test_build_summary_request_empty_list(dummy_context: PromptContextSchema) -> None:
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_summary_request_empty_list(fake_prompt_context: PromptContextSchema) -> None:
     """Empty diffs list should still produce valid prompt with no diff content."""
-    result = PromptService.build_summary_request([], dummy_context)
+    result = PromptService.build_summary_request([], fake_prompt_context)
 
     assert "GLOBAL_SUMMARY" in result
     assert "SUMMARY_PROMPT" in result
@@ -73,12 +47,13 @@ def test_build_summary_request_empty_list(dummy_context: PromptContextSchema) ->
     assert result.strip().endswith("## Changes")
 
 
-def test_build_context_request_includes_prompts_and_diffs(dummy_context: PromptContextSchema) -> None:
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_context_request_includes_prompts_and_diffs(fake_prompt_context: PromptContextSchema) -> None:
     diffs = [
         DiffFileSchema(file="a.py", diff="+ foo"),
         DiffFileSchema(file="b.py", diff="- bar"),
     ]
-    result = PromptService.build_context_request(diffs, dummy_context)
+    result = PromptService.build_context_request(diffs, fake_prompt_context)
 
     assert "GLOBAL_CONTEXT" in result
     assert "CONTEXT_PROMPT" in result
@@ -88,84 +63,153 @@ def test_build_context_request_includes_prompts_and_diffs(dummy_context: PromptC
     assert "- bar" in result
 
 
-def test_build_system_inline_request_returns_joined_prompts(dummy_context: PromptContextSchema) -> None:
-    result = PromptService.build_system_inline_request(dummy_context)
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_system_inline_request_returns_joined_prompts(fake_prompt_context: PromptContextSchema) -> None:
+    result = PromptService.build_system_inline_request(fake_prompt_context)
     assert result == "SYS_INLINE_A\n\nSYS_INLINE_B".replace("SYS_INLINE_A", "SYS_INLINE_A")
 
 
-def test_build_system_context_request_returns_joined_prompts(dummy_context: PromptContextSchema) -> None:
-    result = PromptService.build_system_context_request(dummy_context)
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_system_context_request_returns_joined_prompts(fake_prompt_context: PromptContextSchema) -> None:
+    result = PromptService.build_system_context_request(fake_prompt_context)
     assert result == "SYS_CONTEXT_A\n\nSYS_CONTEXT_B"
 
 
-def test_build_system_summary_request_returns_joined_prompts(dummy_context: PromptContextSchema) -> None:
-    result = PromptService.build_system_summary_request(dummy_context)
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_system_summary_request_returns_joined_prompts(fake_prompt_context: PromptContextSchema) -> None:
+    result = PromptService.build_system_summary_request(fake_prompt_context)
     assert result == "SYS_SUMMARY_A\n\nSYS_SUMMARY_B"
 
 
+@pytest.mark.usefixtures("fake_prompts")
 def test_build_system_inline_request_empty(
         monkeypatch: pytest.MonkeyPatch,
-        dummy_context: PromptContextSchema
+        fake_prompt_context: PromptContextSchema
 ) -> None:
     monkeypatch.setattr(PromptConfig, "load_system_inline", lambda self: [])
-    result = PromptService.build_system_inline_request(dummy_context)
+    result = PromptService.build_system_inline_request(fake_prompt_context)
     assert result == ""
 
 
+@pytest.mark.usefixtures("fake_prompts")
 def test_build_system_context_request_empty(
         monkeypatch: pytest.MonkeyPatch,
-        dummy_context: PromptContextSchema
+        fake_prompt_context: PromptContextSchema
 ) -> None:
     monkeypatch.setattr(PromptConfig, "load_system_context", lambda self: [])
-    result = PromptService.build_system_context_request(dummy_context)
+    result = PromptService.build_system_context_request(fake_prompt_context)
     assert result == ""
 
 
+@pytest.mark.usefixtures("fake_prompts")
 def test_build_system_summary_request_empty(
         monkeypatch: pytest.MonkeyPatch,
-        dummy_context: PromptContextSchema
+        fake_prompt_context: PromptContextSchema
 ) -> None:
     monkeypatch.setattr(PromptConfig, "load_system_summary", lambda self: [])
-    result = PromptService.build_system_summary_request(dummy_context)
+    result = PromptService.build_system_summary_request(fake_prompt_context)
     assert result == ""
 
 
-def test_diff_placeholders_are_not_replaced(dummy_context: PromptContextSchema) -> None:
+@pytest.mark.usefixtures("fake_prompts")
+def test_diff_placeholders_are_not_replaced(fake_prompt_context: PromptContextSchema) -> None:
     diffs = [DiffFileSchema(file="x.py", diff='print("<<review_title>>")')]
-    result = PromptService.build_summary_request(diffs, dummy_context)
+    result = PromptService.build_summary_request(diffs, fake_prompt_context)
 
     assert "<<review_title>>" in result
     assert "Fix login bug" not in result
 
 
-def test_prepare_prompt_basic_substitution(dummy_context: PromptContextSchema) -> None:
+@pytest.mark.usefixtures("fake_prompts")
+def test_prepare_prompt_basic_substitution(fake_prompt_context: PromptContextSchema) -> None:
     prompts = ["Hello", "MR title: <<review_title>>"]
-    result = PromptService.prepare_prompt(prompts, dummy_context)
+    result = PromptService.prepare_prompt(prompts, fake_prompt_context)
 
     assert "Hello" in result
     assert "MR title: Fix login bug" in result
 
 
+@pytest.mark.usefixtures("fake_prompts")
 def test_prepare_prompt_applies_normalization(
         monkeypatch: pytest.MonkeyPatch,
-        dummy_context: PromptContextSchema
+        fake_prompt_context: PromptContextSchema
 ) -> None:
     monkeypatch.setattr(settings.prompt, "normalize_prompts", True)
     prompts = ["Line with space   ", "", "", "Next line"]
-    result = PromptService.prepare_prompt(prompts, dummy_context)
+    result = PromptService.prepare_prompt(prompts, fake_prompt_context)
 
     assert "Line with space" in result
     assert "Next line" in result
     assert "\n\n\n" not in result
 
 
+@pytest.mark.usefixtures("fake_prompts")
 def test_prepare_prompt_skips_normalization(
         monkeypatch: pytest.MonkeyPatch,
-        dummy_context: PromptContextSchema
+        fake_prompt_context: PromptContextSchema
 ) -> None:
     monkeypatch.setattr(settings.prompt, "normalize_prompts", False)
     prompts = ["Line with space   ", "", "", "Next line"]
-    result = PromptService.prepare_prompt(prompts, dummy_context)
+    result = PromptService.prepare_prompt(prompts, fake_prompt_context)
 
     assert "Line with space   " in result
     assert "\n\n\n" in result
+
+
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_inline_reply_request_includes_conversation_and_diff(fake_prompt_context: PromptContextSchema) -> None:
+    diff = DiffFileSchema(file="foo.py", diff="+ added\n- removed")
+    thread = ReviewThreadSchema(
+        id="t1",
+        kind=ThreadKind.INLINE,
+        file="foo.py",
+        line=10,
+        comments=[
+            ReviewCommentSchema(id=1, body="Initial comment"),
+            ReviewCommentSchema(id=2, body="Follow-up"),
+        ],
+    )
+
+    result = PromptService.build_inline_reply_request(diff, thread, fake_prompt_context)
+
+    assert "INLINE_REPLY_A" in result
+    assert "INLINE_REPLY_B" in result
+    assert "## Conversation" in result
+    assert "Initial comment" in result
+    assert "Follow-up" in result
+    assert "## Diff" in result
+    assert "# File: foo.py" in result
+    assert "+ added" in result
+
+
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_summary_reply_request_includes_conversation_and_changes(
+        fake_prompt_context: PromptContextSchema
+) -> None:
+    diffs = [DiffFileSchema(file="a.py", diff="+ foo")]
+    thread = ReviewThreadSchema(
+        id="t2",
+        kind=ThreadKind.SUMMARY,
+        comments=[ReviewCommentSchema(id=1, body="Overall feedback")],
+    )
+
+    result = PromptService.build_summary_reply_request(diffs, thread, fake_prompt_context)
+
+    assert "SUMMARY_REPLY_A" in result
+    assert "SUMMARY_REPLY_B" in result
+    assert "## Conversation" in result
+    assert "Overall feedback" in result
+    assert "## Changes" in result
+    assert "+ foo" in result
+
+
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_system_inline_reply_request_returns_joined_prompts(fake_prompt_context: PromptContextSchema) -> None:
+    result = PromptService.build_system_inline_reply_request(fake_prompt_context)
+    assert result == "SYS_INLINE_REPLY_A\n\nSYS_INLINE_REPLY_B"
+
+
+@pytest.mark.usefixtures("fake_prompts")
+def test_build_system_summary_reply_request_returns_joined_prompts(fake_prompt_context: PromptContextSchema) -> None:
+    result = PromptService.build_system_summary_reply_request(fake_prompt_context)
+    assert result == "SYS_SUMMARY_REPLY_A\n\nSYS_SUMMARY_REPLY_B"

ai_review/tests/suites/services/prompt/test_tools.py

@@ -1,7 +1,10 @@
 from ai_review.services.diff.schema import DiffFileSchema
-from ai_review.services.prompt.tools import format_file, normalize_prompt
+from ai_review.services.prompt.tools import format_file, normalize_prompt, format_files, format_thread
+from ai_review.services.vcs.types import ReviewThreadSchema, ReviewCommentSchema, UserSchema, ThreadKind
 
 
+# ---------- format_file ----------
+
 def test_format_file_basic():
     diff = DiffFileSchema(file="main.py", diff="+ print('hello')")
     result = format_file(diff)
@@ -36,6 +39,88 @@ def test_format_file_filename_with_path():
     assert result.endswith("+ class User:\n")
 
 
+def test_format_file_handles_whitespace_filename():
+    diff = DiffFileSchema(file="   spaced.py  ", diff="+ print('x')")
+    result = format_file(diff)
+    assert "# File:    spaced.py  " in result
+
+
+# ---------- format_files ----------
+
+def test_format_files_combines_multiple_diffs():
+    diffs = [
+        DiffFileSchema(file="a.py", diff="+ foo"),
+        DiffFileSchema(file="b.py", diff="- bar"),
+    ]
+    result = format_files(diffs)
+
+    assert "# File: a.py" in result
+    assert "# File: b.py" in result
+    assert "+ foo" in result
+    assert "- bar" in result
+    assert "\n\n# File: b.py" in result
+
+
+def test_format_files_empty_list():
+    result = format_files([])
+    assert result == ""
+
+
+# ---------- format_thread ----------
+
+def test_format_thread_with_multiple_comments():
+    thread = ReviewThreadSchema(
+        id="t1",
+        kind=ThreadKind.INLINE,
+        comments=[
+            ReviewCommentSchema(
+                id=1, body="Looks good", author=UserSchema(name="Alice")
+            ),
+            ReviewCommentSchema(
+                id=2, body="Maybe refactor?", author=UserSchema(username="bob")
+            ),
+        ],
+    )
+    result = format_thread(thread)
+
+    assert "- Alice: Looks good" in result
+    assert "- bob: Maybe refactor?" in result
+    assert "\n\n- bob" in result
+
+
+def test_format_thread_ignores_empty_bodies():
+    thread = ReviewThreadSchema(
+        id="t2",
+        kind=ThreadKind.SUMMARY,
+        comments=[
+            ReviewCommentSchema(id=1, body="", author=UserSchema(name="Alice")),
+            ReviewCommentSchema(id=2, body="", author=UserSchema(username="bob")),
+        ],
+    )
+    result = format_thread(thread)
+    assert result == "No comments in thread." or result == ""
+
+
+def test_format_thread_handles_empty_comments_list():
+    thread = ReviewThreadSchema(id="t3", kind=ThreadKind.SUMMARY, comments=[])
+    result = format_thread(thread)
+    assert result == "No comments in thread."
+
+
+def test_format_thread_fallback_to_user_when_no_name_or_username():
+    thread = ReviewThreadSchema(
+        id="t4",
+        kind=ThreadKind.INLINE,
+        comments=[
+            ReviewCommentSchema(id=1, body="Anon feedback", author=UserSchema())
+        ],
+    )
+    result = format_thread(thread)
+    assert "- User: Anon feedback" in result
+
+
+# ---------- normalize_prompt ----------
+
 def test_trailing_spaces_are_removed():
     text = "hello   \nworld\t\t"
     result = normalize_prompt(text)

ai_review/tests/suites/services/review/gateway/test_comment.py

@@ -0,0 +1,253 @@
+import pytest
+
+from ai_review.config import settings
+from ai_review.services.review.gateway.comment import ReviewCommentGateway
+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 ReviewThreadSchema, ReviewCommentSchema, ThreadKind
+from ai_review.tests.fixtures.services.vcs import FakeVCSClient
+
+
+# === INLINE THREADS ===
+
+@pytest.mark.asyncio
+async def test_get_inline_threads_filters_by_tag(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should return only threads containing AI inline tags."""
+    threads = [
+        ReviewThreadSchema(
+            id="1",
+            kind=ThreadKind.INLINE,
+            file="a.py",
+            comments=[ReviewCommentSchema(id="1", body=f"Hello {settings.review.inline_reply_tag}")]
+        ),
+        ReviewThreadSchema(
+            id="2",
+            kind=ThreadKind.INLINE,
+            file="b.py",
+            comments=[ReviewCommentSchema(id="2", body="No AI tag here")]
+        ),
+    ]
+    fake_vcs_client.responses["get_inline_threads"] = threads
+
+    result = await review_comment_gateway.get_inline_threads()
+
+    assert len(result) == 1
+    assert result[0].id == "1"
+    assert any(call[0] == "get_inline_threads" for call in fake_vcs_client.calls)
+
+
+@pytest.mark.asyncio
+async def test_get_summary_threads_filters_by_tag(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should return only threads containing AI summary tags."""
+    threads = [
+        ReviewThreadSchema(
+            id="10",
+            kind=ThreadKind.SUMMARY,
+            comments=[ReviewCommentSchema(id="1", body=f"AI {settings.review.summary_reply_tag}")]
+        ),
+        ReviewThreadSchema(
+            id="11",
+            kind=ThreadKind.SUMMARY,
+            comments=[ReviewCommentSchema(id="2", body="No tags here")]
+        ),
+    ]
+    fake_vcs_client.responses["get_general_threads"] = threads
+
+    result = await review_comment_gateway.get_summary_threads()
+
+    assert len(result) == 1
+    assert result[0].id == "10"
+    assert any(call[0] == "get_general_threads" for call in fake_vcs_client.calls)
+
+
+# === EXISTING COMMENTS ===
+
+@pytest.mark.asyncio
+async def test_has_existing_inline_comments_true(
+        capsys,
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should detect existing inline comments and log skip message."""
+    fake_vcs_client.responses["get_inline_comments"] = [
+        ReviewCommentSchema(id="1", body=f"{settings.review.inline_tag} existing comment")
+    ]
+
+    result = await review_comment_gateway.has_existing_inline_comments()
+    output = capsys.readouterr().out
+
+    assert result is True
+    assert "AI inline comments already exist" in output
+
+
+@pytest.mark.asyncio
+async def test_has_existing_summary_comments_false(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should return False when no summary AI comments exist."""
+    fake_vcs_client.responses["get_general_comments"] = [
+        ReviewCommentSchema(id="1", body="Regular comment")
+    ]
+    result = await review_comment_gateway.has_existing_summary_comments()
+    assert result is False
+
+
+# === INLINE REPLY ===
+
+@pytest.mark.asyncio
+async def test_process_inline_reply_happy_path(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should create inline reply and emit hook events."""
+    reply = InlineCommentReplySchema(message="AI reply text")
+
+    await review_comment_gateway.process_inline_reply("t1", reply)
+
+    assert any(call[0] == "create_inline_reply" for call in fake_vcs_client.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_inline_reply_error(
+        capsys,
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should log and emit error if VCS fails to create reply."""
+
+    async def failing_create_inline_reply(thread_id: str, body: str):
+        raise RuntimeError("API error")
+
+    fake_vcs_client.create_inline_reply = failing_create_inline_reply
+
+    reply = InlineCommentReplySchema(message="AI reply text")
+    await review_comment_gateway.process_inline_reply("t1", reply)
+    output = capsys.readouterr().out
+
+    assert "Failed to create inline reply" in output
+
+
+# === SUMMARY REPLY ===
+
+@pytest.mark.asyncio
+async def test_process_summary_reply_success(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should create summary reply comment."""
+    reply = SummaryCommentReplySchema(text="AI summary reply")
+    await review_comment_gateway.process_summary_reply("t42", reply)
+    assert any(call[0] == "create_summary_reply" for call in fake_vcs_client.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_summary_reply_error(
+        capsys,
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should log and emit error on exception in summary reply."""
+
+    async def failing_create_summary_reply(thread_id: str, body: str):
+        raise RuntimeError("Network fail")
+
+    fake_vcs_client.create_summary_reply = failing_create_summary_reply
+
+    reply = SummaryCommentReplySchema(text="AI summary reply")
+    await review_comment_gateway.process_summary_reply("t42", reply)
+    output = capsys.readouterr().out
+
+    assert "Failed to create summary reply" in output
+
+
+# === INLINE COMMENT ===
+
+@pytest.mark.asyncio
+async def test_process_inline_comment_happy_path(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should create inline comment via VCS."""
+    comment = InlineCommentSchema(file="f.py", line=1, message="AI inline comment")
+    await review_comment_gateway.process_inline_comment(comment)
+    assert any(call[0] == "create_inline_comment" for call in fake_vcs_client.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_inline_comment_error_fallback(
+        capsys,
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should fall back to summary comment when inline comment fails."""
+
+    async def failing_create_inline_comment(file: str, line: int, message: str):
+        raise RuntimeError("Failed to post inline")
+
+    fake_vcs_client.create_inline_comment = failing_create_inline_comment
+
+    comment = InlineCommentSchema(file="x.py", line=5, message="AI inline")
+    await review_comment_gateway.process_inline_comment(comment)
+    output = capsys.readouterr().out
+
+    assert "Falling back to general comment" in output
+    assert any(call[0] == "create_general_comment" for call in fake_vcs_client.calls)
+
+
+# === SUMMARY COMMENT ===
+
+@pytest.mark.asyncio
+async def test_process_summary_comment_happy_path(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should create general summary comment successfully."""
+    comment = SummaryCommentSchema(text="AI summary")
+    await review_comment_gateway.process_summary_comment(comment)
+    assert any(call[0] == "create_general_comment" for call in fake_vcs_client.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_summary_comment_error(
+        capsys,
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should log error if summary comment creation fails."""
+
+    async def failing_create_general_comment(body: str):
+        raise RuntimeError("Backend down")
+
+    fake_vcs_client.create_general_comment = failing_create_general_comment
+
+    comment = SummaryCommentSchema(text="Broken")
+    await review_comment_gateway.process_summary_comment(comment)
+    output = capsys.readouterr().out
+
+    assert "Failed to process summary comment" in output
+
+
+@pytest.mark.asyncio
+async def test_process_inline_comments_calls_each(
+        fake_vcs_client: FakeVCSClient,
+        review_comment_gateway: ReviewCommentGateway,
+):
+    """Should process all inline comments concurrently."""
+    comments = InlineCommentListSchema(root=[
+        InlineCommentSchema(file="a.py", line=1, message="c1"),
+        InlineCommentSchema(file="b.py", line=2, message="c2"),
+    ])
+
+    await review_comment_gateway.process_inline_comments(comments)
+
+    created = [call for call in fake_vcs_client.calls if call[0] == "create_inline_comment"]
+    assert len(created) == 2