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

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

@@ -0,0 +1,82 @@
+import pytest
+
+from ai_review.services.llm.types import ChatResultSchema
+from ai_review.services.review.gateway.llm import ReviewLLMGateway
+from ai_review.tests.fixtures.services.artifacts import FakeArtifactsService
+from ai_review.tests.fixtures.services.cost import FakeCostService
+from ai_review.tests.fixtures.services.llm import FakeLLMClient
+
+
+@pytest.fixture
+def review_llm_gateway(
+        fake_llm_client: FakeLLMClient,
+        fake_cost_service: FakeCostService,
+        fake_artifacts_service: FakeArtifactsService,
+) -> ReviewLLMGateway:
+    """Fixture providing ReviewLLMGateway with fake dependencies."""
+    return ReviewLLMGateway(
+        llm=fake_llm_client,
+        cost=fake_cost_service,
+        artifacts=fake_artifacts_service,
+    )
+
+
+@pytest.mark.asyncio
+async def test_ask_happy_path(
+        review_llm_gateway: ReviewLLMGateway,
+        fake_llm_client: FakeLLMClient,
+        fake_cost_service: FakeCostService,
+        fake_artifacts_service: FakeArtifactsService,
+):
+    """Should call LLM, calculate cost, save artifacts, and return text."""
+    fake_llm_client.responses["chat"] = ChatResultSchema(text="FAKE_RESPONSE")
+
+    result = await review_llm_gateway.ask("PROMPT", "SYSTEM_PROMPT")
+
+    assert result == "FAKE_RESPONSE"
+    assert any(call[0] == "chat" for call in fake_llm_client.calls)
+    assert any(call[0] == "calculate" for call in fake_cost_service.calls)
+    assert any(call[0] == "save_llm_interaction" for call in fake_artifacts_service.calls)
+
+
+@pytest.mark.asyncio
+async def test_ask_warns_on_empty_response(
+        capsys,
+        review_llm_gateway: ReviewLLMGateway,
+        fake_llm_client: FakeLLMClient,
+        fake_cost_service: FakeCostService,
+        fake_artifacts_service: FakeArtifactsService,
+):
+    """Should warn if LLM returns an empty response."""
+    fake_llm_client.responses["chat"] = ChatResultSchema(text="")
+
+    result = await review_llm_gateway.ask("PROMPT", "SYSTEM_PROMPT")
+    output = capsys.readouterr().out
+
+    assert result == ""
+    assert "LLM returned an empty response" in output
+
+    assert any(call[0] == "chat" for call in fake_llm_client.calls)
+    assert any(call[0] == "calculate" for call in fake_cost_service.calls)
+    assert any(call[0] == "save_llm_interaction" for call in fake_artifacts_service.calls)
+
+
+@pytest.mark.asyncio
+async def test_ask_handles_llm_error(
+        capsys,
+        fake_llm_client: FakeLLMClient,
+        review_llm_gateway: ReviewLLMGateway,
+):
+    """Should handle exceptions gracefully and log error."""
+
+    async def failing_chat(prompt: str, prompt_system: str):
+        raise RuntimeError("LLM connection failed")
+
+    fake_llm_client.chat = failing_chat
+
+    result = await review_llm_gateway.ask("PROMPT", "SYSTEM_PROMPT")
+    output = capsys.readouterr().out
+
+    assert result is None
+    assert "LLM request failed" in output
+    assert "RuntimeError" in output

ai_review/tests/suites/services/review/{inline → internal/inline}/test_schema.py

@@ -1,7 +1,7 @@
 import pytest
 
 from ai_review.config import settings
-from ai_review.services.review.inline.schema import (
+from ai_review.services.review.internal.inline.schema import (
     InlineCommentSchema,
     InlineCommentListSchema,
 )

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

@@ -0,0 +1,81 @@
+from ai_review.services.review.internal.inline.schema import InlineCommentListSchema
+from ai_review.services.review.internal.inline.service import InlineCommentService
+
+
+def test_empty_output_returns_empty_list(inline_comment_service: InlineCommentService):
+    result = inline_comment_service.parse_model_output("")
+    assert isinstance(result, InlineCommentListSchema)
+    assert result.root == []
+
+
+def test_valid_json_array_parsed(inline_comment_service: InlineCommentService):
+    json_output = '[{"file": "a.py", "line": 1, "message": "use f-string"}]'
+    result = inline_comment_service.parse_model_output(json_output)
+    assert len(result.root) == 1
+    assert result.root[0].file == "a.py"
+    assert result.root[0].line == 1
+    assert result.root[0].message == "use f-string"
+
+
+def test_json_inside_code_block_parsed(inline_comment_service: InlineCommentService):
+    output = """```json
+    [
+      {"file": "b.py", "line": 42, "message": "check for None"}
+    ]
+    ```"""
+    result = inline_comment_service.parse_model_output(output)
+    assert len(result.root) == 1
+    assert result.root[0].file == "b.py"
+    assert result.root[0].line == 42
+
+
+def test_non_json_but_array_inside_text(inline_comment_service: InlineCommentService):
+    output = "some explanation...\n[ {\"file\": \"c.py\", \"line\": 7, \"message\": \"fix this\"} ]\nend"
+    result = inline_comment_service.parse_model_output(output)
+    assert len(result.root) == 1
+    assert result.root[0].file == "c.py"
+    assert result.root[0].line == 7
+
+
+def test_invalid_json_array_logs_and_returns_empty(inline_comment_service: InlineCommentService):
+    output = '[{"file": "d.py", "line": "oops", "message": "bad"}]'
+    result = inline_comment_service.parse_model_output(output)
+    assert result.root == []
+
+
+def test_no_json_array_found_logs_and_returns_empty(inline_comment_service: InlineCommentService):
+    output = "this is not json at all"
+    result = inline_comment_service.parse_model_output(output)
+    assert result.root == []
+
+
+def test_json_with_raw_newline_sanitized(inline_comment_service: InlineCommentService):
+    output = '[{"file": "e.py", "line": 3, "message": "line1\nline2"}]'
+    result = inline_comment_service.parse_model_output(output)
+    assert len(result.root) == 1
+    assert result.root[0].file == "e.py"
+    assert result.root[0].line == 3
+    assert result.root[0].message == "line1\nline2"
+
+
+def test_json_with_tab_character_sanitized(inline_comment_service: InlineCommentService):
+    output = '[{"file": "f.py", "line": 4, "message": "a\tb"}]'
+    result = inline_comment_service.parse_model_output(output)
+    assert len(result.root) == 1
+    assert result.root[0].message == "a\tb"
+
+
+def test_json_with_null_byte_sanitized(inline_comment_service: InlineCommentService):
+    raw = "abc\0def"
+    output = f'[{{"file": "g.py", "line": 5, "message": "{raw}"}}]'
+    result = inline_comment_service.parse_model_output(output)
+    assert len(result.root) == 1
+    assert result.root[0].message == "abc\0def"
+
+
+def test_json_with_multiple_control_chars(inline_comment_service: InlineCommentService):
+    raw = "x\n\ry\t\0z"
+    output = f'[{{"file": "h.py", "line": 6, "message": "{raw}"}}]'
+    result = inline_comment_service.parse_model_output(output)
+    assert len(result.root) == 1
+    assert result.root[0].message == "x\n\ry\t\0z"

ai_review/tests/suites/services/review/internal/inline_reply/test_schema.py

@@ -0,0 +1,57 @@
+import pytest
+
+from ai_review.config import settings
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+
+
+def test_message_is_trimmed_by_validator():
+    """Message should be stripped of leading/trailing whitespace."""
+    schema = InlineCommentReplySchema(message="   fix this issue   ")
+    assert schema.message == "fix this issue"
+
+
+def test_body_without_suggestion():
+    """Body should contain only message when no suggestion is provided."""
+    schema = InlineCommentReplySchema(message="Use f-string")
+    assert schema.body == "Use f-string"
+    assert "```suggestion" not in schema.body
+
+
+def test_body_with_suggestion():
+    """Body should include formatted suggestion block when suggestion is present."""
+    schema = InlineCommentReplySchema(
+        message="Replace concatenation with f-string",
+        suggestion='print(f"Hello {name}")'
+    )
+    expected = (
+        "Replace concatenation with f-string\n\n"
+        "```suggestion\nprint(f\"Hello {name}\")\n```"
+    )
+    assert schema.body == expected
+
+
+def test_body_with_tag(monkeypatch: pytest.MonkeyPatch):
+    """body_with_tag should append the configured inline reply tag."""
+    monkeypatch.setattr(settings.review, "inline_reply_tag", "#ai-reply")
+    schema = InlineCommentReplySchema(message="Looks good")
+    result = schema.body_with_tag
+    assert result.endswith("\n\n#ai-reply")
+    assert "#ai-reply" not in schema.body
+
+
+def test_body_with_tag_and_suggestion(monkeypatch: pytest.MonkeyPatch):
+    """body_with_tag should include both suggestion and tag."""
+    monkeypatch.setattr(settings.review, "inline_reply_tag", "#ai-reply")
+    schema = InlineCommentReplySchema(
+        message="Simplify condition",
+        suggestion="if x:"
+    )
+    result = schema.body_with_tag
+    assert "```suggestion" in result
+    assert result.endswith("\n\n#ai-reply")
+
+
+def test_message_cannot_be_empty():
+    """Empty message should raise validation error (min_length=1)."""
+    with pytest.raises(ValueError):
+        InlineCommentReplySchema(message="")

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

@@ -0,0 +1,72 @@
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.inline_reply.service import InlineCommentReplyService
+
+
+def test_empty_output_returns_none(inline_comment_reply_service: InlineCommentReplyService):
+    """Empty LLM output should return None."""
+    result = inline_comment_reply_service.parse_model_output("")
+    assert result is None
+
+
+def test_valid_json_object_parsed(inline_comment_reply_service: InlineCommentReplyService):
+    """A valid JSON object should be parsed successfully."""
+    output = '{"message": "Looks good!"}'
+    result = inline_comment_reply_service.parse_model_output(output)
+
+    assert isinstance(result, InlineCommentReplySchema)
+    assert result.message == "Looks good!"
+    assert result.suggestion is None
+
+
+def test_valid_json_with_suggestion(inline_comment_reply_service: InlineCommentReplyService):
+    """Parser should correctly handle JSON with both message and suggestion."""
+    output = '{"message": "Consider refactoring", "suggestion": "use helper()"}'
+    result = inline_comment_reply_service.parse_model_output(output)
+
+    assert isinstance(result, InlineCommentReplySchema)
+    assert result.message == "Consider refactoring"
+    assert result.suggestion == "use helper()"
+    assert "```suggestion" in result.body
+    assert result.message in result.body
+
+
+def test_json_inside_code_block_parsed(inline_comment_reply_service: InlineCommentReplyService):
+    """JSON inside a ```json code block should be extracted successfully."""
+    output = """```json
+    {"message": "Please add docstring"}
+    ```"""
+    result = inline_comment_reply_service.parse_model_output(output)
+
+    assert isinstance(result, InlineCommentReplySchema)
+    assert result.message == "Please add docstring"
+    assert result.suggestion is None
+
+
+def test_invalid_json_returns_none(inline_comment_reply_service: InlineCommentReplyService):
+    """Invalid JSON (wrong field type) should return None."""
+    output = '{"message": 12345}'
+    result = inline_comment_reply_service.parse_model_output(output)
+    assert result is None
+
+
+def test_non_json_text_returns_none(inline_comment_reply_service: InlineCommentReplyService):
+    """Non-JSON text should return None."""
+    output = "some random text output"
+    result = inline_comment_reply_service.parse_model_output(output)
+    assert result is None
+
+
+def test_json_with_empty_message_returns_none(inline_comment_reply_service: InlineCommentReplyService):
+    """JSON with an empty message field should return None (violates min_length)."""
+    output = '{"message": ""}'
+    result = inline_comment_reply_service.parse_model_output(output)
+    assert result is None
+
+
+def test_message_is_trimmed(inline_comment_reply_service: InlineCommentReplyService):
+    """Message should be trimmed — leading and trailing spaces removed."""
+    output = '{"message": "   spaced out   "}'
+    result = inline_comment_reply_service.parse_model_output(output)
+
+    assert isinstance(result, InlineCommentReplySchema)
+    assert result.message == "spaced out"

ai_review/tests/suites/services/review/{policy → internal/policy}/test_service.py

@@ -1,7 +1,7 @@
 import pytest
 
 from ai_review.config import settings
-from ai_review.services.review.policy.service import ReviewPolicyService
+from ai_review.services.review.internal.policy.service import ReviewPolicyService
 
 
 @pytest.fixture(autouse=True)

ai_review/tests/suites/services/review/{summary → internal/summary}/test_schema.py

@@ -1,5 +1,5 @@
 from ai_review.config import settings
-from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
 
 
 def test_normalize_text_strips_whitespace():

ai_review/tests/suites/services/review/{summary → internal/summary}/test_service.py

@@ -1,7 +1,7 @@
 import pytest
 
-from ai_review.services.review.summary.schema import SummaryCommentSchema
-from ai_review.services.review.summary.service import SummaryCommentService
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary.service import SummaryCommentService
 
 
 @pytest.mark.parametrize(

ai_review/tests/suites/services/review/internal/summary_reply/test_schema.py

@@ -0,0 +1,19 @@
+from ai_review.config import settings
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+
+
+def test_body_with_tag_appends_reply_tag(monkeypatch):
+    """body_with_tag should append the configured summary reply tag."""
+    monkeypatch.setattr(settings.review, "summary_reply_tag", "#ai-summary-reply")
+    comment = SummaryCommentReplySchema(text="This is a summary reply")
+
+    result = comment.body_with_tag
+    assert result.startswith("This is a summary reply")
+    assert result.endswith("\n\n#ai-summary-reply")
+    assert "\n\n#ai-summary-reply" in result
+
+
+def test_inherits_text_normalization_from_parent():
+    """SummaryCommentReplySchema should inherit normalization behavior."""
+    comment = SummaryCommentReplySchema(text="   spaced summary reply   ")
+    assert comment.text == "spaced summary reply"

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

@@ -0,0 +1,21 @@
+import pytest
+
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+from ai_review.services.review.internal.summary_reply.service import SummaryCommentReplyService
+
+
+@pytest.mark.parametrize(
+    "raw, expected",
+    [
+        ("Some reply", "Some reply"),
+        ("   padded reply   ", "padded reply"),
+        ("", ""),
+        (None, ""),
+    ],
+)
+def test_parse_model_output_normalizes_and_wraps(raw: str | None, expected: str):
+    """parse_model_output should normalize input and wrap it into schema."""
+    result = SummaryCommentReplyService.parse_model_output(raw)
+
+    assert isinstance(result, SummaryCommentReplySchema)
+    assert result.text == expected

ai_review/tests/suites/services/review/runner/test_context.py

@@ -0,0 +1,89 @@
+import pytest
+
+from ai_review.services.review.runner.context import ContextReviewRunner
+from ai_review.tests.fixtures.services.cost import FakeCostService
+from ai_review.tests.fixtures.services.diff import FakeDiffService
+from ai_review.tests.fixtures.services.prompt import FakePromptService
+from ai_review.tests.fixtures.services.review.gateway.comment import FakeReviewCommentGateway
+from ai_review.tests.fixtures.services.review.gateway.llm import FakeReviewLLMGateway
+from ai_review.tests.fixtures.services.review.internal.inline import FakeInlineCommentService
+from ai_review.tests.fixtures.services.review.internal.policy import FakeReviewPolicyService
+from ai_review.tests.fixtures.services.vcs import FakeVCSClient
+
+
+@pytest.mark.asyncio
+async def test_run_happy_path(
+        context_review_runner: ContextReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_diff_service: FakeDiffService,
+        fake_cost_service: FakeCostService,
+        fake_prompt_service: FakePromptService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_policy_service: FakeReviewPolicyService,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should render all changed files, call LLM and post inline comments."""
+    await context_review_runner.run()
+
+    vcs_calls = [call[0] for call in fake_vcs_client.calls]
+    assert "get_review_info" in vcs_calls
+
+    assert any(call[0] == "render_files" for call in fake_diff_service.calls)
+    assert any(call[0] == "apply_for_files" for call in fake_review_policy_service.calls)
+    assert any(call[0] == "build_context_request" for call in fake_prompt_service.calls)
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert any(call[0] == "process_inline_comments" for call in fake_review_comment_gateway.calls)
+
+    assert any(call[0] == "aggregate" for call in fake_cost_service.calls)
+
+
+@pytest.mark.asyncio
+async def test_run_skips_when_existing_comments(
+        context_review_runner: ContextReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip context review if inline comments already exist."""
+    fake_review_comment_gateway.responses["has_existing_inline_comments"] = True
+
+    await context_review_runner.run()
+
+    vcs_calls = [call[0] for call in fake_vcs_client.calls]
+    assert vcs_calls == []
+    assert not any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_run_skips_when_no_changed_files(
+        context_review_runner: ContextReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_review_policy_service: FakeReviewPolicyService,
+):
+    """Should skip when no changed files after policy filtering."""
+    fake_review_policy_service.responses["apply_for_files"] = []
+
+    await context_review_runner.run()
+
+    vcs_calls = [call[0] for call in fake_vcs_client.calls]
+    assert "get_review_info" in vcs_calls
+    assert any(call[0] == "apply_for_files" for call in fake_review_policy_service.calls)
+
+
+@pytest.mark.asyncio
+async def test_run_skips_when_no_comments_after_llm(
+        context_review_runner: ContextReviewRunner,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_policy_service: FakeReviewPolicyService,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+        fake_inline_comment_service: FakeInlineCommentService,
+
+):
+    """Should not post comments if LLM output is empty."""
+    fake_inline_comment_service.comments = []
+
+    await context_review_runner.run()
+
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert any(call[0] == "apply_for_context_comments" for call in fake_review_policy_service.calls)
+    assert not any(call[0] == "process_inline_comments" for call in fake_review_comment_gateway.calls)

ai_review/tests/suites/services/review/runner/test_inline.py

@@ -0,0 +1,100 @@
+import pytest
+
+from ai_review.services.review.runner.inline import InlineReviewRunner
+from ai_review.services.vcs.types import ReviewInfoSchema
+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.prompt import FakePromptService
+from ai_review.tests.fixtures.services.review.gateway.comment import FakeReviewCommentGateway
+from ai_review.tests.fixtures.services.review.gateway.llm import FakeReviewLLMGateway
+from ai_review.tests.fixtures.services.review.internal.inline import FakeInlineCommentService
+from ai_review.tests.fixtures.services.review.internal.policy import FakeReviewPolicyService
+from ai_review.tests.fixtures.services.vcs import FakeVCSClient
+
+
+@pytest.mark.asyncio
+async def test_run_happy_path(
+        inline_review_runner: InlineReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_git_service: FakeGitService,
+        fake_diff_service: FakeDiffService,
+        fake_cost_service: FakeCostService,
+        fake_prompt_service: FakePromptService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_policy_service: FakeReviewPolicyService,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should process all changed files, call LLM and post inline comments."""
+    fake_git_service.responses["get_diff_for_file"] = "FAKE_DIFF"
+
+    await inline_review_runner.run()
+
+    vcs_calls = [call[0] for call in fake_vcs_client.calls]
+    assert "get_review_info" in vcs_calls
+
+    git_calls = [call[0] for call in fake_git_service.calls]
+    assert any(call == "get_diff_for_file" for call in git_calls)
+
+    assert any(call[0] == "render_file" for call in fake_diff_service.calls)
+    assert any(call[0] == "apply_for_files" for call in fake_review_policy_service.calls)
+    assert any(call[0] == "build_inline_request" for call in fake_prompt_service.calls)
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert any(call[0] == "process_inline_comments" for call in fake_review_comment_gateway.calls)
+
+    assert any(call[0] == "aggregate" for call in fake_cost_service.calls)
+
+
+@pytest.mark.asyncio
+async def test_run_skips_when_existing_comments(
+        inline_review_runner: InlineReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip review if there are already existing inline comments."""
+    fake_review_comment_gateway.responses["has_existing_inline_comments"] = True
+
+    await inline_review_runner.run()
+
+    vcs_calls = [call[0] for call in fake_vcs_client.calls]
+    assert vcs_calls == []
+    assert not any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_file_skips_when_no_diff(
+        inline_review_runner: InlineReviewRunner,
+        fake_git_service: FakeGitService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip processing file if no diff found."""
+    fake_git_service.responses["get_diff_for_file"] = ""
+
+    review_info = ReviewInfoSchema(base_sha="A", head_sha="B")
+    await inline_review_runner.process_file("file.py", review_info)
+
+    assert not any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert not any(call[0] == "process_inline_comments" for call in fake_review_comment_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_file_skips_when_no_comments_after_llm(
+        inline_review_runner: InlineReviewRunner,
+        fake_git_service: FakeGitService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_policy_service: FakeReviewPolicyService,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+        fake_inline_comment_service: FakeInlineCommentService,
+):
+    """Should not post comments if model output produces no inline comments."""
+    fake_git_service.responses["get_diff_for_file"] = "SOME_DIFF"
+    fake_inline_comment_service.comments = []
+
+    review_info = ReviewInfoSchema(base_sha="A", head_sha="B")
+    await inline_review_runner.process_file("file.py", review_info)
+
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert any(call[0] == "apply_for_inline_comments" for call in fake_review_policy_service.calls)
+    assert not any(call[0] == "process_inline_comments" for call in fake_review_comment_gateway.calls)