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

ai_review/tests/suites/libs/llm/test_output_json_parser.py

@@ -0,0 +1,155 @@
+from ai_review.libs.llm.output_json_parser import LLMOutputJSONParser, CLEAN_JSON_BLOCK_RE
+from ai_review.tests.fixtures.libs.llm.output_json_parser import DummyModel
+
+
+# ---------- try_parse ----------
+
+def test_try_parse_happy_path(llm_output_json_parser: LLMOutputJSONParser):
+    """Should successfully parse valid JSON string."""
+    raw = '{"text": "hello"}'
+    result = llm_output_json_parser.try_parse(raw)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "hello"
+
+
+def test_try_parse_with_sanitization_success(llm_output_json_parser: LLMOutputJSONParser):
+    """Should retry and parse after sanitization fixes minor issues."""
+    raw = '{text: "hi"}'
+    result = llm_output_json_parser.try_parse(raw)
+
+    assert result is None
+
+
+def test_try_parse_with_sanitization_still_invalid(llm_output_json_parser: LLMOutputJSONParser):
+    """Should return None if even sanitized JSON invalid."""
+    raw = '{"wrong_field": "hi"}'
+    result = llm_output_json_parser.try_parse(raw)
+
+    assert result is None
+
+
+def test_try_parse_with_control_characters(llm_output_json_parser: LLMOutputJSONParser):
+    """Should sanitize and parse JSON containing control characters (e.g., newlines, tabs)."""
+    raw = '{\n\t"text": "multi-line\nvalue"\r}'
+    result = llm_output_json_parser.try_parse(raw)
+
+    assert result is None
+
+
+def test_try_parse_with_unicode_and_escaped_symbols(llm_output_json_parser: LLMOutputJSONParser):
+    """Should handle escaped unicode and symbols correctly."""
+    raw = '{"text": "Привет 👋 \\n new line"}'
+    result = llm_output_json_parser.try_parse(raw)
+
+    assert isinstance(result, DummyModel)
+    assert "Привет" in result.text
+    assert "\\n" in result.text or "\n" in result.text
+
+
+# ---------- parse_output ----------
+
+def test_parse_output_happy_path(llm_output_json_parser: LLMOutputJSONParser):
+    """Should parse plain JSON output successfully."""
+    output = '{"text": "parsed"}'
+    result = llm_output_json_parser.parse_output(output)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "parsed"
+
+
+def test_parse_output_with_fenced_block(llm_output_json_parser: LLMOutputJSONParser):
+    """Should extract JSON from fenced block and parse successfully."""
+    output = "```json\n{\"text\": \"inside block\"}\n```"
+    result = llm_output_json_parser.parse_output(output)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "inside block"
+
+
+def test_parse_output_with_non_json_fence(llm_output_json_parser: LLMOutputJSONParser):
+    """Should extract even from ``` block without explicit json tag."""
+    output = "```{\"text\": \"inside fence\"}```"
+    result = llm_output_json_parser.parse_output(output)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "inside fence"
+
+
+def test_parse_output_empty_string(llm_output_json_parser: LLMOutputJSONParser):
+    """Should return None and log warning when output empty."""
+    result = llm_output_json_parser.parse_output("")
+    assert result is None
+
+
+def test_parse_output_invalid_json(llm_output_json_parser: LLMOutputJSONParser):
+    """Should return None if JSON invalid and cannot be sanitized."""
+    output = "```json\n{\"wrong_field\": \"oops\"}\n```"
+    result = llm_output_json_parser.parse_output(output)
+    assert result is None
+
+
+def test_clean_json_block_regex_extracts_content():
+    """Should correctly extract JSON body from fenced block."""
+    text = "Some intro ```json\n{\"x\": 42}\n``` and trailing"
+    match = CLEAN_JSON_BLOCK_RE.search(text)
+    assert match
+    assert "{\"x\": 42}" in match.group(1)
+
+
+def test_parse_output_with_extra_text_around_json(llm_output_json_parser: LLMOutputJSONParser):
+    """Should extract and parse JSON when surrounded by extra LLM chatter."""
+    output = "Here's what I found:\n```json\n{\"text\": \"valid\"}\n```Hope that helps!"
+    result = llm_output_json_parser.parse_output(output)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "valid"
+
+
+def test_parse_output_with_broken_json_then_valid_block(llm_output_json_parser: LLMOutputJSONParser):
+    """Should skip broken JSON and parse valid fenced one."""
+    output = '{"text": invalid}\n```json\n{"text": "fixed"}\n```'
+    result = llm_output_json_parser.parse_output(output)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "fixed"
+
+
+def test_parse_output_with_code_fence_but_extra_backticks(llm_output_json_parser: LLMOutputJSONParser):
+    """Should correctly handle fenced block even with multiple triple-backticks."""
+    output = "``````json\n{\"text\": \"messy fences\"}\n``````"
+    result = llm_output_json_parser.parse_output(output)
+
+    assert result is None
+
+
+def test_parse_output_with_llm_style_json(llm_output_json_parser: LLMOutputJSONParser):
+    """Should handle LLM output containing pseudo-JSON like 'text: value'."""
+    output = '```json\n{text: "approximate JSON"}\n```'
+    result = llm_output_json_parser.parse_output(output)
+
+    assert result is None
+
+
+def test_parse_output_with_multiple_json_blocks(llm_output_json_parser: LLMOutputJSONParser):
+    """Should parse first valid fenced JSON block."""
+    output = """
+        ```json
+        {"text": "first"}
+        ```
+        ```json
+        {"text": "second"}
+        ```
+    """
+    result = llm_output_json_parser.parse_output(output)
+
+    assert isinstance(result, DummyModel)
+    assert result.text == "first"
+
+
+def test_parse_output_with_extra_control_chars(llm_output_json_parser: LLMOutputJSONParser):
+    """Should handle JSON polluted by invisible control characters."""
+    raw = '{\x00"text": "ok\x07"}'
+    result = llm_output_json_parser.try_parse(raw)
+
+    assert result is None

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

@@ -3,12 +3,96 @@ import pytest
 from ai_review.services.cost.schema import CostReportSchema
 from ai_review.services.hook.constants import HookType
 from ai_review.services.hook.service import HookService
+from ai_review.services.review.internal.inline.schema import InlineCommentSchema
+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
+
+cost_report = CostReportSchema(
+    model="gpt",
+    prompt_tokens=1,
+    completion_tokens=2,
+    total_cost=0.3,
+    input_cost=0.1,
+    output_cost=0.2
+)
+inline_comment = InlineCommentSchema(file="a.py", line=1, message="fix this")
+inline_reply = InlineCommentReplySchema(message="ok", suggestion="use helper()")
+summary_comment = SummaryCommentSchema(text="summary text")
+summary_reply = SummaryCommentReplySchema(text="reply summary")
+
+HOOK_CASES = [
+    # Chat
+    ("on_chat_start", "emit_chat_start", dict(prompt="hi", prompt_system="sys")),
+    ("on_chat_error", "emit_chat_error", dict(prompt="oops", prompt_system="sys")),
+    ("on_chat_complete", "emit_chat_complete", dict(result="done", report=cost_report)),
+
+    # Inline Review
+    ("on_inline_review_start", "emit_inline_review_start", {}),
+    ("on_inline_review_complete", "emit_inline_review_complete", dict(report=cost_report)),
+
+    # Context Review
+    ("on_context_review_start", "emit_context_review_start", {}),
+    ("on_context_review_complete", "emit_context_review_complete", dict(report=cost_report)),
+
+    # Summary Review
+    ("on_summary_review_start", "emit_summary_review_start", {}),
+    ("on_summary_review_complete", "emit_summary_review_complete", dict(report=cost_report)),
+
+    # Inline Reply Review
+    ("on_inline_reply_review_start", "emit_inline_reply_review_start", {}),
+    ("on_inline_reply_review_complete", "emit_inline_reply_review_complete", dict(report=cost_report)),
+
+    # Summary Reply Review
+    ("on_summary_reply_review_start", "emit_summary_reply_review_start", {}),
+    ("on_summary_reply_review_complete", "emit_summary_reply_review_complete", dict(report=cost_report)),
+
+    # Inline Comment
+    ("on_inline_comment_start", "emit_inline_comment_start", dict(comment=inline_comment)),
+    ("on_inline_comment_error", "emit_inline_comment_error", dict(comment=inline_comment)),
+    ("on_inline_comment_complete", "emit_inline_comment_complete", dict(comment=inline_comment)),
+
+    # Summary Comment
+    ("on_summary_comment_start", "emit_summary_comment_start", dict(comment=summary_comment)),
+    ("on_summary_comment_error", "emit_summary_comment_error", dict(comment=summary_comment)),
+    ("on_summary_comment_complete", "emit_summary_comment_complete", dict(comment=summary_comment)),
+
+    # Inline Comment Reply
+    ("on_inline_comment_reply_start", "emit_inline_comment_reply_start", dict(comment=inline_reply)),
+    ("on_inline_comment_reply_error", "emit_inline_comment_reply_error", dict(comment=inline_reply)),
+    ("on_inline_comment_reply_complete", "emit_inline_comment_reply_complete", dict(comment=inline_reply)),
+
+    # Summary Comment Reply
+    ("on_summary_comment_reply_start", "emit_summary_comment_reply_start", dict(comment=summary_reply)),
+    ("on_summary_comment_reply_error", "emit_summary_comment_reply_error", dict(comment=summary_reply)),
+    ("on_summary_comment_reply_complete", "emit_summary_comment_reply_complete", dict(comment=summary_reply)),
+]
 
 
-@pytest.fixture
-def hook_service() -> HookService:
-    """Return a fresh HookService instance for each test."""
-    return HookService()
+@pytest.mark.asyncio
+@pytest.mark.parametrize("inject_method, emit_method, args", HOOK_CASES)
+async def test_all_hooks_trigger_correctly(
+        hook_service: HookService,
+        inject_method: str,
+        emit_method: str,
+        args: dict,
+):
+    """
+    Ensure every hook registration + emit combination works correctly.
+    Each hook should receive the emitted arguments without raising.
+    """
+    called = {}
+
+    async def sample_hook(**kwargs):
+        called.update(kwargs)
+
+    emit_func = getattr(hook_service, emit_method)
+    inject_func = getattr(hook_service, inject_method)
+
+    inject_func(sample_hook)
+    await emit_func(**args)
+
+    assert called == args
 
 
 @pytest.mark.asyncio

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

@@ -1,4 +1,4 @@
-from ai_review.services.prompt.adapter import build_prompt_context_from_mr_info
+from ai_review.services.prompt.adapter import build_prompt_context_from_review_info
 from ai_review.services.vcs.types import (
     ReviewInfoSchema,
     UserSchema,
@@ -23,7 +23,7 @@ def test_build_prompt_context_from_full_review_info() -> None:
         changed_files=["api/views.py", "api/tests.py"],
     )
 
-    context = build_prompt_context_from_mr_info(review_info)
+    context = build_prompt_context_from_review_info(review_info)
 
     assert context.review_title == "Fix API bug"
     assert context.review_description == "Refactored endpoint"
@@ -52,7 +52,7 @@ def test_build_prompt_context_handles_no_reviewers() -> None:
         reviewers=[],
     )
 
-    context = build_prompt_context_from_mr_info(review_info)
+    context = build_prompt_context_from_review_info(review_info)
 
     assert context.review_reviewer == ""
     assert context.review_reviewers == []

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)