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

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

@@ -0,0 +1,109 @@
+import pytest
+
+from ai_review.services.review.runner.inline_reply import InlineReplyReviewRunner
+from ai_review.services.vcs.types import ReviewInfoSchema, ReviewThreadSchema, ReviewCommentSchema, ThreadKind
+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_reply import FakeInlineCommentReplyService
+from ai_review.tests.fixtures.services.vcs import FakeVCSClient
+
+
+@pytest.mark.asyncio
+async def test_run_happy_path(
+        inline_reply_review_runner: InlineReplyReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_git_service: FakeGitService,
+        fake_cost_service: FakeCostService,
+        fake_diff_service: FakeDiffService,
+        fake_prompt_service: FakePromptService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should process all threads, call LLM, and post replies."""
+    fake_git_service.responses["get_diff_for_file"] = "FAKE_DIFF"
+
+    await inline_reply_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] == "get_inline_threads" for call in fake_review_comment_gateway.calls)
+    assert any(call[0] == "get_diff_for_file" for call in fake_git_service.calls)
+    assert any(call[0] == "render_file" for call in fake_diff_service.calls)
+    assert any(call[0] == "build_inline_reply_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_reply" 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_no_threads(
+        fake_vcs_client: FakeVCSClient,
+        inline_reply_review_runner: InlineReplyReviewRunner,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip when there are no AI inline threads."""
+    fake_review_comment_gateway.responses["get_inline_threads"] = []
+
+    await inline_reply_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] == "get_inline_threads" for call in fake_review_comment_gateway.calls)
+    assert not any(call[0] == "process_inline_reply" for call in fake_review_comment_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_thread_reply_skips_when_no_diff(
+        inline_reply_review_runner: InlineReplyReviewRunner,
+        fake_git_service: FakeGitService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip reply processing when no diff found for file."""
+    fake_git_service.responses["get_diff_for_file"] = ""
+
+    review_info = ReviewInfoSchema(base_sha="A", head_sha="B")
+    thread = ReviewThreadSchema(
+        id="1",
+        kind=ThreadKind.INLINE,
+        file="file.py",
+        line=1,
+        comments=[ReviewCommentSchema(id="c1", body="Some comment")]
+    )
+
+    await inline_reply_review_runner.process_thread_reply(thread, review_info)
+
+    assert not any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert not any(call[0] == "process_inline_reply" for call in fake_review_comment_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_thread_reply_skips_when_no_reply(
+        inline_reply_review_runner: InlineReplyReviewRunner,
+        fake_git_service: FakeGitService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+        fake_inline_comment_reply_service: FakeInlineCommentReplyService,
+):
+    """Should not post reply if model output produces no reply schema."""
+    fake_git_service.responses["get_diff_for_file"] = "SOME_DIFF"
+    fake_inline_comment_reply_service.reply = None
+
+    review_info = ReviewInfoSchema(base_sha="A", head_sha="B")
+    thread = ReviewThreadSchema(
+        id="42",
+        kind=ThreadKind.INLINE,
+        file="main.py",
+        line=12,
+        comments=[ReviewCommentSchema(id="cm1", body="Fix this!")]
+    )
+
+    await inline_reply_review_runner.process_thread_reply(thread, review_info)
+
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert not any(call[0] == "process_inline_reply" for call in fake_review_comment_gateway.calls)

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

@@ -0,0 +1,87 @@
+import pytest
+
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.runner.summary import SummaryReviewRunner
+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.policy import FakeReviewPolicyService
+from ai_review.tests.fixtures.services.review.internal.summary import FakeSummaryCommentService
+from ai_review.tests.fixtures.services.vcs import FakeVCSClient
+
+
+@pytest.mark.asyncio
+async def test_run_happy_path(
+        summary_review_runner: SummaryReviewRunner,
+        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 summary comment."""
+    await summary_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_summary_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_summary_comment" 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_summary_comments(
+        summary_review_runner: SummaryReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip summary review if summary comment already exists."""
+    fake_review_comment_gateway.responses["has_existing_summary_comments"] = True
+
+    await summary_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(
+        summary_review_runner: SummaryReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_review_policy_service: FakeReviewPolicyService,
+):
+    """Should skip when no changed files remain after policy filtering."""
+    fake_review_policy_service.responses["apply_for_files"] = []
+
+    await summary_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_empty_summary_from_llm(
+        summary_review_runner: SummaryReviewRunner,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+        fake_summary_comment_service: FakeSummaryCommentService,
+):
+    """Should skip posting comment if LLM output is empty."""
+    fake_summary_comment_service.responses["parse_model_output"] = SummaryCommentSchema(text="")
+
+    await summary_review_runner.run()
+
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert not any(call[0] == "process_summary_comment" for call in fake_review_comment_gateway.calls)

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

@@ -0,0 +1,97 @@
+import pytest
+
+from ai_review.services.review.runner.summary_reply import SummaryReplyReviewRunner
+from ai_review.services.vcs.types import ReviewInfoSchema, ReviewThreadSchema, ReviewCommentSchema, ThreadKind
+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.policy import FakeReviewPolicyService
+from ai_review.tests.fixtures.services.review.internal.summary_reply import FakeSummaryCommentReplyService
+from ai_review.tests.fixtures.services.vcs import FakeVCSClient
+
+
+@pytest.mark.asyncio
+async def test_run_happy_path(
+        summary_reply_review_runner: SummaryReplyReviewRunner,
+        fake_vcs_client: FakeVCSClient,
+        fake_diff_service: FakeDiffService,
+        fake_cost_service: FakeCostService,
+        fake_prompt_service: FakePromptService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should process all summary threads, call LLM, and post replies."""
+    await summary_reply_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] == "get_summary_threads" for call in fake_review_comment_gateway.calls)
+    assert any(call[0] == "render_files" for call in fake_diff_service.calls)
+    assert any(call[0] == "build_summary_reply_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_summary_reply" 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_no_threads(
+        summary_reply_review_runner: SummaryReplyReviewRunner,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+        fake_vcs_client: FakeVCSClient,
+):
+    """Should skip when there are no AI summary threads."""
+    fake_review_comment_gateway.responses["get_summary_threads"] = []
+
+    await summary_reply_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] == "get_summary_threads" for call in fake_review_comment_gateway.calls)
+    assert not any(call[0] == "process_summary_reply" for call in fake_review_comment_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_thread_reply_skips_when_no_allowed_files(
+        summary_reply_review_runner: SummaryReplyReviewRunner,
+        fake_review_policy_service: FakeReviewPolicyService,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should skip processing thread if policy filtered out all files."""
+    fake_review_policy_service.responses["apply_for_files"] = []
+
+    review_info = ReviewInfoSchema(base_sha="A", head_sha="B", changed_files=["a.py"])
+    thread = ReviewThreadSchema(
+        id="99",
+        kind=ThreadKind.SUMMARY,
+        comments=[ReviewCommentSchema(id="c1", body="Summary comment")],
+    )
+
+    await summary_reply_review_runner.process_thread_reply(thread, review_info)
+
+    assert not any(call[0] == "process_summary_reply" for call in fake_review_comment_gateway.calls)
+
+
+@pytest.mark.asyncio
+async def test_process_thread_reply_skips_when_no_reply(
+        summary_reply_review_runner: SummaryReplyReviewRunner,
+        fake_summary_comment_reply_service: FakeSummaryCommentReplyService,
+        fake_review_llm_gateway: FakeReviewLLMGateway,
+        fake_review_comment_gateway: FakeReviewCommentGateway,
+):
+    """Should not post reply if model output produced no reply schema."""
+    fake_summary_comment_reply_service.reply = None
+
+    review_info = ReviewInfoSchema(base_sha="A", head_sha="B", changed_files=["x.py"])
+    thread = ReviewThreadSchema(
+        id="42",
+        kind=ThreadKind.SUMMARY,
+        comments=[ReviewCommentSchema(id="cm1", body="AI summary comment")],
+    )
+
+    await summary_reply_review_runner.process_thread_reply(thread, review_info)
+
+    assert any(call[0] == "ask" for call in fake_review_llm_gateway.calls)
+    assert not any(call[0] == "process_summary_reply" for call in fake_review_comment_gateway.calls)

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

@@ -1,126 +1,93 @@
 import pytest
 
+from ai_review.services.llm.types import ChatResultSchema
 from ai_review.services.review.service import ReviewService
-from ai_review.tests.fixtures.services.artifacts import FakeArtifactsService
 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.llm import FakeLLMClient
-from ai_review.tests.fixtures.services.prompt import FakePromptService
-from ai_review.tests.fixtures.services.review.inline import FakeInlineCommentService
-from ai_review.tests.fixtures.services.review.summary import FakeSummaryCommentService
-from ai_review.tests.fixtures.services.vcs import FakeVCSClient
-
-
-@pytest.fixture
-def review_service(
-        monkeypatch: pytest.MonkeyPatch,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_git_service: FakeGitService,
-        fake_diff_service: FakeDiffService,
-        fake_cost_service: FakeCostService,
-        fake_prompt_service: FakePromptService,
-        fake_artifacts_service: FakeArtifactsService,
-        fake_inline_comment_service: FakeInlineCommentService,
-        fake_summary_comment_service: FakeSummaryCommentService,
-):
-    monkeypatch.setattr("ai_review.services.review.service.get_llm_client", lambda: fake_llm_client)
-    monkeypatch.setattr("ai_review.services.review.service.get_vcs_client", lambda: fake_vcs_client)
-    monkeypatch.setattr("ai_review.services.review.service.GitService", lambda: fake_git_service)
-    monkeypatch.setattr("ai_review.services.review.service.DiffService", lambda: fake_diff_service)
-    monkeypatch.setattr("ai_review.services.review.service.PromptService", lambda: fake_prompt_service)
-    monkeypatch.setattr("ai_review.services.review.service.InlineCommentService", lambda: fake_inline_comment_service)
-    monkeypatch.setattr("ai_review.services.review.service.SummaryCommentService", lambda: fake_summary_comment_service)
-    monkeypatch.setattr("ai_review.services.review.service.ArtifactsService", lambda: fake_artifacts_service)
-    monkeypatch.setattr("ai_review.services.review.service.CostService", lambda: fake_cost_service)
-    return ReviewService()
+from ai_review.tests.fixtures.services.review.runner.context import FakeContextReviewRunner
+from ai_review.tests.fixtures.services.review.runner.inline import FakeInlineReviewRunner
+from ai_review.tests.fixtures.services.review.runner.inline_reply import FakeInlineReplyReviewRunner
+from ai_review.tests.fixtures.services.review.runner.summary import FakeSummaryReviewRunner
+from ai_review.tests.fixtures.services.review.runner.summary_reply import FakeSummaryReplyReviewRunner
 
 
 @pytest.mark.asyncio
-async def test_run_inline_review_happy_path(
+async def test_run_inline_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_prompt_service: FakePromptService,
-        fake_git_service: FakeGitService,
-        fake_diff_service: FakeDiffService,
-        fake_cost_service: FakeCostService,
-        fake_artifacts_service: FakeArtifactsService,
+        fake_inline_review_runner: FakeInlineReviewRunner
 ):
-    """Should perform inline review for changed files and create inline comments via VCS."""
-    fake_git_service.responses["get_diff_for_file"] = "FAKE_DIFF"
-
+    """Should call run() on InlineReviewRunner."""
     await review_service.run_inline_review()
-
-    vcs_calls = [c[0] for c in fake_vcs_client.calls]
-    assert "get_review_info" in vcs_calls
-    assert "create_inline_comment" in vcs_calls
-
-    assert (
-               "get_diff_for_file",
-               {"base_sha": "A", "head_sha": "B", "file": "file.py", "unified": 3}
-           ) in fake_git_service.calls
-    assert any(call[0] == "render_file" for call in fake_diff_service.calls)
-
-    assert any(call[0] == "build_inline_request" for call in fake_prompt_service.calls)
-    assert any(call[0] == "chat" for call in fake_llm_client.calls)
-
-    assert len(fake_cost_service.reports) == 1
-    assert any(call[0] == "save_llm_interaction" for call in fake_artifacts_service.calls)
+    assert fake_inline_review_runner.calls == [("run", {})]
 
 
 @pytest.mark.asyncio
-async def test_run_inline_review_skips_when_no_diff(
+async def test_run_context_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_git_service: FakeGitService,
-        fake_llm_client: FakeLLMClient,
+        fake_context_review_runner: FakeContextReviewRunner
 ):
-    """Should skip inline review when no diffs exist."""
-    fake_git_service.responses["get_diff_for_file"] = ""
-
-    await review_service.run_inline_review()
-
-    assert not any(call[0] == "chat" for call in fake_llm_client.calls)
-    assert not any(call[0] == "create_inline_comment" for call in fake_vcs_client.calls)
+    """Should call run() on ContextReviewRunner."""
+    await review_service.run_context_review()
+    assert fake_context_review_runner.calls == [("run", {})]
 
 
 @pytest.mark.asyncio
-async def test_run_context_review_happy_path(
+async def test_run_summary_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_prompt_service: FakePromptService,
-        fake_diff_service: FakeDiffService,
+        fake_summary_review_runner: FakeSummaryReviewRunner
 ):
-    """Should perform context review and post inline comments based on rendered files."""
-    await review_service.run_context_review()
+    """Should call run() on SummaryReviewRunner."""
+    await review_service.run_summary_review()
+    assert fake_summary_review_runner.calls == [("run", {})]
 
-    vcs_calls = [c[0] for c in fake_vcs_client.calls]
-    assert "get_review_info" in vcs_calls
-    assert "create_inline_comment" in vcs_calls
 
-    assert any(call[0] == "render_files" for call in fake_diff_service.calls)
-    assert any(call[0] == "build_context_request" for call in fake_prompt_service.calls)
-    assert any(call[0] == "chat" for call in fake_llm_client.calls)
+@pytest.mark.asyncio
+async def test_run_inline_reply_review_invokes_runner(
+        review_service: ReviewService,
+        fake_inline_reply_review_runner: FakeInlineReplyReviewRunner
+):
+    """Should call run() on InlineReplyReviewRunner."""
+    await review_service.run_inline_reply_review()
+    assert fake_inline_reply_review_runner.calls == [("run", {})]
 
 
 @pytest.mark.asyncio
-async def test_run_summary_review_happy_path(
+async def test_run_summary_reply_review_invokes_runner(
         review_service: ReviewService,
-        fake_vcs_client: FakeVCSClient,
-        fake_llm_client: FakeLLMClient,
-        fake_prompt_service: FakePromptService,
-        fake_diff_service: FakeDiffService,
+        fake_summary_reply_review_runner: FakeSummaryReplyReviewRunner
 ):
-    """Should perform summary review and post a single summary comment."""
-    await review_service.run_summary_review()
+    """Should call run() on SummaryReplyReviewRunner."""
+    await review_service.run_summary_reply_review()
+    assert fake_summary_reply_review_runner.calls == [("run", {})]
 
-    vcs_calls = [c[0] for c in fake_vcs_client.calls]
-    assert "get_review_info" in vcs_calls
-    assert "create_general_comment" in vcs_calls
 
-    assert any(call[0] == "render_files" for call in fake_diff_service.calls)
-    assert any(call[0] == "build_summary_request" for call in fake_prompt_service.calls)
-    assert any(call[0] == "chat" for call in fake_llm_client.calls)
+def test_report_total_cost_with_data(
+        capsys,
+        review_service: ReviewService,
+        fake_cost_service: FakeCostService
+):
+    """Should log total cost when cost report exists."""
+    fake_cost_service.reports.append(
+        fake_cost_service.calculate(
+            result=ChatResultSchema(
+                text="result",
+                total_tokens=100,
+                prompt_tokens=50,
+                completion_tokens=10,
+            )
+        )
+    )
+
+    review_service.report_total_cost()
+    output = capsys.readouterr().out
+
+    assert "TOTAL REVIEW COST" in output
+    assert "fake-model" in output
+    assert "0.006" in output
+
+
+def test_report_total_cost_no_data(capsys, review_service: ReviewService):
+    """Should log message when no cost data is available."""
+    review_service.report_total_cost()
+    output = capsys.readouterr().out
+
+    assert "No cost data collected" in output

ai_review/tests/suites/services/vcs/bitbucket/test_adapter.py

@@ -0,0 +1,109 @@
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketPRCommentSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCommentInlineSchema,
+    BitbucketCommentParentSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.user import BitbucketUserSchema
+from ai_review.services.vcs.bitbucket.adapter import get_review_comment_from_bitbucket_pr_comment
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def test_maps_all_fields_correctly():
+    """Should map Bitbucket PR comment with all fields correctly."""
+    comment = BitbucketPRCommentSchema(
+        id=101,
+        user=BitbucketUserSchema(uuid="u-123", display_name="Alice", nickname="alice"),
+        parent=None,
+        inline=BitbucketCommentInlineSchema(path="src/utils.py", to_line=10),
+        content=BitbucketCommentContentSchema(raw="Looks good"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 101
+    assert result.body == "Looks good"
+    assert result.file == "src/utils.py"
+    assert result.line == 10
+    assert result.parent_id is None
+    assert result.thread_id == 101
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id == "u-123"
+    assert result.author.name == "Alice"
+    assert result.author.username == "alice"
+
+
+def test_maps_with_parent_comment():
+    """Should set parent_id and use it as thread_id."""
+    comment = BitbucketPRCommentSchema(
+        id=202,
+        user=BitbucketUserSchema(uuid="u-456", display_name="Bob", nickname="bob"),
+        parent=BitbucketCommentParentSchema(id=101),
+        inline=BitbucketCommentInlineSchema(path="src/main.py", to_line=20),
+        content=BitbucketCommentContentSchema(raw="I agree"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert result.parent_id == 101
+    assert result.thread_id == 101
+    assert result.id == 202
+    assert result.file == "src/main.py"
+    assert result.line == 20
+
+
+def test_maps_without_user():
+    """Should handle missing user gracefully."""
+    comment = BitbucketPRCommentSchema(
+        id=303,
+        user=None,
+        parent=None,
+        inline=BitbucketCommentInlineSchema(path="src/app.py", to_line=5),
+        content=BitbucketCommentContentSchema(raw="Anonymous feedback"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id is None
+    assert result.author.name == ""
+    assert result.author.username == ""
+
+
+def test_maps_without_inline():
+    """Should handle missing inline gracefully (file and line None)."""
+    comment = BitbucketPRCommentSchema(
+        id=404,
+        user=BitbucketUserSchema(uuid="u-789", display_name="Charlie", nickname="charlie"),
+        parent=None,
+        inline=None,
+        content=BitbucketCommentContentSchema(raw="General comment"),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == 404
+
+
+def test_maps_with_empty_body_and_defaults():
+    """Should default body to empty string if content.raw is empty or None."""
+    comment = BitbucketPRCommentSchema(
+        id=505,
+        user=None,
+        parent=None,
+        inline=None,
+        content=BitbucketCommentContentSchema(raw="", html=None, markup=None),
+    )
+
+    result = get_review_comment_from_bitbucket_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.body == ""
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == 505
+    assert isinstance(result.author, UserSchema)