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

ai_review/tests/suites/services/vcs/bitbucket/{test_service.py → test_client.py}

@@ -1,7 +1,7 @@
 import pytest
 
 from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
-from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema
+from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema, ReviewThreadSchema, ThreadKind
 from ai_review.tests.fixtures.clients.bitbucket import FakeBitbucketPullRequestsHTTPClient
 
 
@@ -115,3 +115,90 @@ async def test_create_inline_comment_posts_comment(
     assert call_args["content"]["raw"] == message
     assert call_args["inline"]["path"] == file
     assert call_args["inline"]["to"] == line
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_create_inline_reply_posts_comment(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should post a reply to an existing inline thread."""
+    thread_id = 42
+    message = "I agree with this inline comment."
+
+    await bitbucket_vcs_client.create_inline_reply(thread_id, message)
+
+    calls = [args for name, args in fake_bitbucket_pull_requests_http_client.calls if name == "create_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["parent"]["id"] == thread_id
+    assert call_args["content"]["raw"] == message
+    assert call_args["workspace"] == "workspace"
+    assert call_args["repo_slug"] == "repo"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_create_summary_reply_posts_comment_with_parent(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should post a reply to a general thread (same API with parent id)."""
+    thread_id = 7
+    message = "Thanks for the clarification."
+
+    await bitbucket_vcs_client.create_summary_reply(thread_id, message)
+
+    calls = [args for name, args in fake_bitbucket_pull_requests_http_client.calls if name == "create_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["parent"]["id"] == thread_id
+    assert call_args["content"]["raw"] == message
+    assert call_args["workspace"] == "workspace"
+    assert call_args["repo_slug"] == "repo"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_inline_threads_groups_by_thread_id(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should group inline comments into threads."""
+    threads = await bitbucket_vcs_client.get_inline_threads()
+
+    assert all(isinstance(thread, ReviewThreadSchema) for thread in threads)
+    assert len(threads) == 1
+
+    thread = threads[0]
+    assert thread.kind == ThreadKind.INLINE
+    assert thread.file == "file.py"
+    assert thread.line == 5
+    assert len(thread.comments) == 1
+    assert isinstance(thread.comments[0], ReviewCommentSchema)
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert "get_comments" in called_methods
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_general_threads_groups_by_thread_id(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should group general (non-inline) comments into SUMMARY threads."""
+    threads = await bitbucket_vcs_client.get_general_threads()
+
+    assert all(isinstance(t, ReviewThreadSchema) for t in threads)
+    assert len(threads) == 1
+    thread = threads[0]
+    assert thread.kind == ThreadKind.SUMMARY
+    assert len(thread.comments) == 1
+    assert isinstance(thread.comments[0], ReviewCommentSchema)
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert "get_comments" in called_methods

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

@@ -0,0 +1,162 @@
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubPRCommentSchema,
+    GitHubIssueCommentSchema,
+)
+from ai_review.clients.github.pr.schema.user import GitHubUserSchema
+from ai_review.services.vcs.github.adapter import (
+    get_review_comment_from_github_pr_comment,
+    get_review_comment_from_github_issue_comment,
+)
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def test_maps_all_fields_correctly_for_pr_comment():
+    """Should map GitHub PR comment with all fields correctly."""
+    comment = GitHubPRCommentSchema(
+        id=101,
+        body="Looks fine to me",
+        path="src/utils.py",
+        line=42,
+        user=GitHubUserSchema(id=7, login="alice"),
+        in_reply_to_id=None,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 101
+    assert result.body == "Looks fine to me"
+    assert result.file == "src/utils.py"
+    assert result.line == 42
+    assert result.parent_id is None
+    assert result.thread_id == 101
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id == 7
+    assert result.author.name == "alice"
+    assert result.author.username == "alice"
+
+
+def test_maps_reply_comment_with_parent_id():
+    """Should assign parent_id and use it as thread_id for replies."""
+    comment = GitHubPRCommentSchema(
+        id=202,
+        body="Agreed with above",
+        path="src/main.py",
+        line=10,
+        user=GitHubUserSchema(id=8, login="bob"),
+        in_reply_to_id=101,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert result.parent_id == 101
+    assert result.thread_id == 101
+    assert result.id == 202
+
+
+def test_maps_comment_without_user():
+    """Should handle missing user gracefully."""
+    comment = GitHubPRCommentSchema(
+        id=303,
+        body="Anonymous feedback",
+        path="src/app.py",
+        line=20,
+        user=None,
+        in_reply_to_id=None,
+    )
+
+    result = get_review_comment_from_github_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_comment_with_empty_body():
+    """Should default body to empty string if it's empty or None."""
+    comment = GitHubPRCommentSchema(
+        id=404,
+        body="",
+        path=None,
+        line=None,
+        user=GitHubUserSchema(id=1, login="bot"),
+        in_reply_to_id=None,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.body == ""
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == 404
+
+
+def test_maps_issue_comment_all_fields():
+    """Should map GitHub issue-level comment correctly."""
+    comment = GitHubIssueCommentSchema(
+        id=555,
+        body="Top-level discussion",
+        user=GitHubUserSchema(id=9, login="charlie"),
+    )
+
+    result = get_review_comment_from_github_issue_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 555
+    assert result.body == "Top-level discussion"
+    assert result.thread_id == 555
+    assert isinstance(result.author, UserSchema)
+
+
+def test_maps_issue_comment_with_empty_body():
+    """Should default empty body to empty string."""
+    comment = GitHubIssueCommentSchema(id=666, body="", user=None)
+
+    result = get_review_comment_from_github_issue_comment(comment)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 666
+    assert result.body == ""
+    assert result.thread_id == 666
+
+
+def test_issue_comment_without_user_is_handled():
+    """Should create empty UserSchema when GitHub issue comment has no user."""
+    comment = GitHubIssueCommentSchema(
+        id=777,
+        body="General feedback",
+        user=None,
+    )
+
+    result = get_review_comment_from_github_issue_comment(comment)
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id is None
+    assert result.author.name == ""
+    assert result.author.username == ""
+    assert result.body == "General feedback"
+    assert result.thread_id == 777
+
+
+def test_pr_comment_with_parent_and_missing_file_line():
+    """Should handle replies without path/line gracefully."""
+    comment = GitHubPRCommentSchema(
+        id=999,
+        body="Follow-up question",
+        path=None,
+        line=None,
+        user=GitHubUserSchema(id=10, login="eve"),
+        in_reply_to_id=101,
+    )
+
+    result = get_review_comment_from_github_pr_comment(comment)
+
+    assert result.parent_id == 101
+    assert result.thread_id == 101
+    assert result.file is None
+    assert result.line is None
+    assert result.body == "Follow-up question"
+    assert result.author.username == "eve"

ai_review/tests/suites/services/vcs/github/{test_service.py → test_client.py}

@@ -1,7 +1,13 @@
 import pytest
 
 from ai_review.services.vcs.github.client import GitHubVCSClient
-from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema
+from ai_review.services.vcs.types import (
+    ThreadKind,
+    UserSchema,
+    ReviewInfoSchema,
+    ReviewThreadSchema,
+    ReviewCommentSchema,
+)
 from ai_review.tests.fixtures.clients.github import FakeGitHubPullRequestsHTTPClient
 
 
@@ -111,4 +117,98 @@ async def test_create_inline_comment_posts_comment(
     assert call_args["path"] == "file.py"
     assert call_args["line"] == 10
     assert call_args["body"] == "Looks good"
-    assert call_args["commit_id"] == "def456"  # from fake PR head
+    assert call_args["commit_id"] == "def456"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_create_inline_reply_posts_comment(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should post a reply to an existing inline comment."""
+    thread_id = 3
+    message = "I agree with this suggestion."
+
+    await github_vcs_client.create_inline_reply(thread_id, message)
+
+    calls = [args for name, args in fake_github_pull_requests_http_client.calls if name == "create_review_reply"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["in_reply_to"] == thread_id
+    assert call_args["body"] == message
+    assert call_args["repo"] == "repo"
+    assert call_args["owner"] == "owner"
+    assert call_args["pull_number"] == "pull_number"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_create_summary_reply_reuses_general_comment_method(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should call create_issue_comment internally (since GitHub summary comments are flat)."""
+    thread_id = 11
+    message = "Thanks for clarifying."
+
+    await github_vcs_client.create_summary_reply(thread_id, message)
+
+    calls = [args for name, args in fake_github_pull_requests_http_client.calls if name == "create_issue_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["body"] == message
+    assert call_args["repo"] == "repo"
+    assert call_args["owner"] == "owner"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_get_inline_threads_returns_grouped_threads(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should group inline review comments into threads by file and line."""
+    threads = await github_vcs_client.get_inline_threads()
+
+    assert all(isinstance(t, ReviewThreadSchema) for t in threads)
+    assert len(threads) == 2  # 2 comments with unique IDs
+
+    first = threads[0]
+    assert first.kind == ThreadKind.INLINE
+    assert isinstance(first.comments[0], ReviewCommentSchema)
+    assert first.file == "file.py"
+    assert first.line == 5
+
+    called_methods = [name for name, _ in fake_github_pull_requests_http_client.calls]
+    assert "get_review_comments" in called_methods
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("github_http_client_config")
+async def test_get_general_threads_wraps_comments_in_threads(
+        github_vcs_client: GitHubVCSClient,
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient,
+):
+    """Should wrap each general comment as a separate SUMMARY thread."""
+    threads = await github_vcs_client.get_general_threads()
+
+    assert all(isinstance(thread, ReviewThreadSchema) for thread in threads)
+    assert all(thread.kind == ThreadKind.SUMMARY for thread in threads)
+    assert len(threads) == 2
+
+    authors = {t.comments[0].author.username for t in threads}
+    assert authors == {"alice", "bob"}
+
+    for thread in threads:
+        comment = thread.comments[0]
+        assert isinstance(comment, ReviewCommentSchema)
+        assert isinstance(comment.author, UserSchema)
+        assert comment.author.id is not None
+        assert comment.author.username != ""
+        assert comment.thread_id == comment.id
+
+    called_methods = [name for name, _ in fake_github_pull_requests_http_client.calls]
+    assert "get_issue_comments" in called_methods

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

@@ -0,0 +1,134 @@
+from ai_review.clients.gitlab.mr.schema.discussions import GitLabDiscussionSchema
+from ai_review.clients.gitlab.mr.schema.notes import GitLabNoteSchema
+from ai_review.clients.gitlab.mr.schema.position import GitLabPositionSchema
+from ai_review.clients.gitlab.mr.schema.user import GitLabUserSchema
+from ai_review.services.vcs.gitlab.adapter import get_review_comment_from_gitlab_note
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def test_maps_all_fields_correctly():
+    """Should map GitLab note and discussion into ReviewCommentSchema."""
+    note = GitLabNoteSchema(
+        id=123,
+        body="Looks good!",
+        author=GitLabUserSchema(id=10, name="Alice", username="alice"),
+    )
+    discussion = GitLabDiscussionSchema(
+        id="42",
+        notes=[note],
+        position=GitLabPositionSchema(
+            base_sha="AAA000",
+            head_sha="BBB111",
+            start_sha="CCC222",
+            new_path="src/app.py",
+            new_line=15,
+        )
+    )
+
+    result = get_review_comment_from_gitlab_note(note, discussion)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 123
+    assert result.body == "Looks good!"
+    assert result.file == "src/app.py"
+    assert result.line == 15
+    assert result.thread_id == "42"
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id == 10
+    assert result.author.name == "Alice"
+    assert result.author.username == "alice"
+
+
+def test_maps_with_missing_author():
+    """Should handle note without author gracefully (default empty UserSchema)."""
+    note = GitLabNoteSchema(id=1, body="Anonymous comment", author=None)
+    discussion = GitLabDiscussionSchema(
+        id="7",
+        notes=[note],
+        position=GitLabPositionSchema(
+            base_sha="AAA000",
+            head_sha="BBB111",
+            start_sha="CCC222",
+            new_path="main.py",
+            new_line=3,
+        ),
+    )
+
+    result = get_review_comment_from_gitlab_note(note, discussion)
+
+    assert isinstance(result.author, UserSchema)
+    assert result.author.id is None
+    assert result.author.name == ""
+    assert result.author.username == ""
+
+
+def test_maps_with_missing_position():
+    """Should handle discussion without position gracefully (file/line become None)."""
+    note = GitLabNoteSchema(
+        id=55,
+        body="General comment",
+        author=GitLabUserSchema(id=9, name="Bob", username="bob"),
+    )
+    discussion = GitLabDiscussionSchema(
+        id="999",
+        notes=[note],
+        position=None,
+    )
+
+    result = get_review_comment_from_gitlab_note(note, discussion)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == "999"
+
+
+def test_maps_with_empty_body_and_defaults():
+    """Should default body to empty string when note.body is empty string."""
+    note = GitLabNoteSchema(id=12, body="", author=None)
+    discussion = GitLabDiscussionSchema(
+        id="100",
+        notes=[note],
+        position=None,
+    )
+
+    result = get_review_comment_from_gitlab_note(note, discussion)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.body == ""
+    assert result.file is None
+    assert result.line is None
+    assert result.thread_id == "100"
+    assert isinstance(result.author, UserSchema)
+
+
+def test_maps_with_note_position_fallback():
+    """Should use note.position when discussion.position is missing."""
+    note = GitLabNoteSchema(
+        id=77,
+        body="Inline note with its own position",
+        author=GitLabUserSchema(id=2, name="Carol", username="carol"),
+        position=GitLabPositionSchema(
+            base_sha="aaa",
+            head_sha="bbb",
+            start_sha="ccc",
+            new_path="module/utils.py",
+            new_line=42,
+        ),
+    )
+    discussion = GitLabDiscussionSchema(
+        id="200",
+        notes=[note],
+        position=None,
+    )
+
+    result = get_review_comment_from_gitlab_note(note, discussion)
+
+    assert isinstance(result, ReviewCommentSchema)
+    assert result.id == 77
+    assert result.file == "module/utils.py"
+    assert result.line == 42
+    assert result.thread_id == "200"
+    assert result.body == "Inline note with its own position"
+    assert result.author.name == "Carol"

ai_review/tests/suites/services/vcs/gitlab/{test_service.py → test_client.py}

@@ -1,7 +1,7 @@
 import pytest
 
 from ai_review.services.vcs.gitlab.client import GitLabVCSClient
-from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema
+from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema, ReviewThreadSchema, ThreadKind
 from ai_review.tests.fixtures.clients.gitlab import FakeGitLabMergeRequestsHTTPClient
 
 
@@ -52,6 +52,15 @@ async def test_get_general_comments_returns_expected_list(
     assert "General comment" in bodies
     assert "Another note" in bodies
 
+    authors = {comment.author.username for comment in comments}
+    assert authors == {"charlie", "diana"}
+
+    for comment in comments:
+        assert comment.thread_id == comment.id
+        assert comment.author.id is not None
+        assert comment.author.name != ""
+        assert comment.author.username != ""
+
     called_methods = [name for name, _ in fake_gitlab_merge_requests_http_client.calls]
     assert called_methods == ["get_notes"]
 
@@ -62,14 +71,20 @@ async def test_get_inline_comments_returns_expected_list(
         gitlab_vcs_client: GitLabVCSClient,
         fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient,
 ):
-    """Should return inline comments from MR discussions."""
+    """Should return inline comments from MR discussions (including ones without position)."""
     comments = await gitlab_vcs_client.get_inline_comments()
 
     assert all(isinstance(c, ReviewCommentSchema) for c in comments)
-    assert len(comments) == 2
+    assert len(comments) == 3
 
     first = comments[0]
     assert first.body == "Inline comment A"
+    assert first.file == "src/app.py"
+    assert first.line == 12
+
+    last = comments[-1]
+    assert last.file is None
+    assert last.line is None
 
     called_methods = [name for name, _ in fake_gitlab_merge_requests_http_client.calls]
     assert called_methods == ["get_discussions"]
@@ -121,3 +136,98 @@ async def test_create_inline_comment_posts_comment(
     assert call_args["body"] == "Looks good!"
     assert call_args["project_id"] == "project-id"
     assert call_args["merge_request_id"] == "merge-request-id"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("gitlab_http_client_config")
+async def test_create_inline_reply_posts_comment(
+        gitlab_vcs_client: GitLabVCSClient,
+        fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient,
+):
+    """Should reply to an existing inline discussion."""
+    thread_id = "discussion-1"
+    message = "I agree with this point."
+
+    await gitlab_vcs_client.create_inline_reply(thread_id, message)
+
+    call = next(
+        args for name, args in fake_gitlab_merge_requests_http_client.calls
+        if name == "create_discussion_reply"
+    )
+
+    assert call["discussion_id"] == thread_id
+    assert call["body"] == message
+    assert call["project_id"] == "project-id"
+    assert call["merge_request_id"] == "merge-request-id"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("gitlab_http_client_config")
+async def test_create_summary_reply_uses_general_comment_method(
+        gitlab_vcs_client: GitLabVCSClient,
+        fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient,
+):
+    """Should reuse create_general_comment when replying to summary thread."""
+    thread_id = "summary-1"
+    message = "Thanks for clarifying."
+
+    await gitlab_vcs_client.create_summary_reply(thread_id, message)
+
+    call = next(
+        args for name, args in fake_gitlab_merge_requests_http_client.calls
+        if name == "create_note"
+    )
+
+    assert call["body"] == message
+    assert call["project_id"] == "project-id"
+    assert call["merge_request_id"] == "merge-request-id"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("gitlab_http_client_config")
+async def test_get_inline_threads_returns_valid_schema(
+        gitlab_vcs_client: GitLabVCSClient,
+        fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient,
+):
+    """Should transform GitLab discussions into inline threads, including those without position."""
+    threads = await gitlab_vcs_client.get_inline_threads()
+
+    assert all(isinstance(thread, ReviewThreadSchema) for thread in threads)
+    assert len(threads) == 2
+
+    first_thread = threads[0]
+    assert first_thread.id == "discussion-1"
+    assert first_thread.kind == ThreadKind.INLINE
+    assert first_thread.file == "src/app.py"
+    assert first_thread.line == 12
+    assert len(first_thread.comments) == 2
+    assert isinstance(first_thread.comments[0], ReviewCommentSchema)
+
+    second_thread = threads[1]
+    assert second_thread.id == "discussion-2"
+    assert second_thread.file is None
+    assert second_thread.line is None
+    assert len(second_thread.comments) == 1
+
+    called = [name for name, _ in fake_gitlab_merge_requests_http_client.calls]
+    assert "get_discussions" in called
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("gitlab_http_client_config")
+async def test_get_general_threads_wraps_comments_in_threads(
+        gitlab_vcs_client: GitLabVCSClient,
+        fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient,
+):
+    """Should wrap each general MR note into its own SUMMARY thread."""
+    threads = await gitlab_vcs_client.get_general_threads()
+
+    assert len(threads) == 2
+    for thread in threads:
+        assert isinstance(thread, ReviewThreadSchema)
+        assert thread.kind == ThreadKind.SUMMARY
+        assert len(thread.comments) == 1
+        assert isinstance(thread.comments[0], ReviewCommentSchema)
+
+    called = [name for name, _ in fake_gitlab_merge_requests_http_client.calls]
+    assert "get_notes" in called