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

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

ai_review/tests/suites/libs/config/test_prompt.py

@@ -2,56 +2,136 @@ from pathlib import Path
 
 import pytest
 
-from ai_review.libs.config.prompt import PromptConfig
+from ai_review.libs.config.prompt import PromptConfig, resolve_prompt_files, resolve_system_prompt_files
 
 
-def test_inline_prompt_files_or_default_uses_defaults(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    dummy_file = tmp_path / "dummy.md"
-    dummy_file.write_text("DUMMY")
-    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
-
-    config = PromptConfig()
-    result = config.inline_prompt_files_or_default
+# ---------- resolve_prompt_files ----------
 
+def test_resolve_prompt_files_returns_given_list(tmp_path: Path):
+    dummy_file = tmp_path / "file.md"
+    result = resolve_prompt_files([dummy_file], "default_inline.md")
     assert result == [dummy_file]
-    assert config.load_inline() == ["DUMMY"]
 
 
-def test_system_inline_prompts_none_returns_global(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    dummy_file = tmp_path / "global.md"
-    dummy_file.write_text("GLOBAL")
+def test_resolve_prompt_files_loads_default_when_none(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    dummy_file = tmp_path / "inline_default.md"
+    dummy_file.write_text("INLINE_DEFAULT")
     monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
 
-    config = PromptConfig(system_inline_prompt_files=None)
-    result = config.system_inline_prompt_files_or_default
+    result = resolve_prompt_files(None, "default_inline.md")
+    assert result == [dummy_file]
 
+
+# ---------- resolve_system_prompt_files ----------
+
+def test_resolve_system_prompt_files_none_returns_global(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys.md"
+    dummy_file.write_text("SYS")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    result = resolve_system_prompt_files(None, include=True, default_file="default_system_inline.md")
     assert result == [dummy_file]
-    assert config.load_system_inline() == ["GLOBAL"]
 
 
-def test_system_inline_prompts_include_true(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+def test_resolve_system_prompt_files_include_true(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
     global_file = tmp_path / "global.md"
     global_file.write_text("GLOBAL")
     custom_file = tmp_path / "custom.md"
-    custom_file.write_text("CUSTOM")
     monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: global_file)
 
-    config = PromptConfig(system_inline_prompt_files=[custom_file], include_inline_system_prompts=True)
-    result = config.system_inline_prompt_files_or_default
-
-    assert global_file in result and custom_file in result
-    assert config.load_system_inline() == ["GLOBAL", "CUSTOM"]
+    result = resolve_system_prompt_files([custom_file], include=True, default_file="default_system_inline.md")
+    assert result == [global_file, custom_file]
 
 
-def test_system_inline_prompts_include_false(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+def test_resolve_system_prompt_files_include_false(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
     global_file = tmp_path / "global.md"
     global_file.write_text("GLOBAL")
     custom_file = tmp_path / "custom.md"
-    custom_file.write_text("CUSTOM")
     monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: global_file)
 
-    config = PromptConfig(system_inline_prompt_files=[custom_file], include_inline_system_prompts=False)
-    result = config.system_inline_prompt_files_or_default
-
+    result = resolve_system_prompt_files([custom_file], include=False, default_file="default_system_inline.md")
     assert result == [custom_file]
-    assert config.load_system_inline() == ["CUSTOM"]
+
+
+# ---------- Prompts ---------
+
+def test_load_context_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "context.md"
+    dummy_file.write_text("CTX")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.context_prompt_files_or_default == [dummy_file]
+    assert config.load_context() == ["CTX"]
+
+
+def test_load_summary_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "summary.md"
+    dummy_file.write_text("SUM")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.summary_prompt_files_or_default == [dummy_file]
+    assert config.load_summary() == ["SUM"]
+
+
+def test_load_inline_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "inline_reply.md"
+    dummy_file.write_text("INL_R")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.inline_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_inline_reply() == ["INL_R"]
+
+
+def test_load_summary_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "summary_reply.md"
+    dummy_file.write_text("SUM_R")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.summary_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_summary_reply() == ["SUM_R"]
+
+
+# ---------- System Prompts ----------
+
+def test_load_system_context_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_context.md"
+    dummy_file.write_text("SYS_CTX")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_context_prompt_files_or_default == [dummy_file]
+    assert config.load_system_context() == ["SYS_CTX"]
+
+
+def test_load_system_summary_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_summary.md"
+    dummy_file.write_text("SYS_SUM")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_summary_prompt_files_or_default == [dummy_file]
+    assert config.load_system_summary() == ["SYS_SUM"]
+
+
+def test_load_system_inline_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_inline_reply.md"
+    dummy_file.write_text("SYS_IR")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_inline_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_system_inline_reply() == ["SYS_IR"]
+
+
+def test_load_system_summary_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_summary_reply.md"
+    dummy_file.write_text("SYS_SR")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_summary_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_system_summary_reply() == ["SYS_SR"]

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 == []