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

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

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