xai-review 0.26.0__tar.gz → 0.27.0__tar.gz

{xai_review-0.26.0 → xai_review-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xai-review
-Version: 0.26.0
+Version: 0.27.0
 Summary: AI-powered code review tool
 Author-email: Nikita Filonov <nikita.filonov@example.com>
 Maintainer-email: Nikita Filonov <nikita.filonov@example.com>
@@ -209,7 +209,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: Nikita-Filonov/ai-review@v0.26.0
+      - uses: Nikita-Filonov/ai-review@v0.27.0
         with:
           review-command: ${{ inputs.review-command }}
         env:

{xai_review-0.26.0 → xai_review-0.27.0}/README.md

@@ -175,7 +175,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: Nikita-Filonov/ai-review@v0.26.0
+      - uses: Nikita-Filonov/ai-review@v0.27.0
         with:
           review-command: ${{ inputs.review-command }}
         env:

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/bitbucket/pr/client.py

@@ -1,19 +1,24 @@
 from httpx import Response, QueryParams
 
 from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketPRCommentSchema,
     BitbucketGetPRCommentsQuerySchema,
     BitbucketGetPRCommentsResponseSchema,
     BitbucketCreatePRCommentRequestSchema,
     BitbucketCreatePRCommentResponseSchema,
 )
 from ai_review.clients.bitbucket.pr.schema.files import (
+    BitbucketPRFileSchema,
     BitbucketGetPRFilesQuerySchema,
     BitbucketGetPRFilesResponseSchema,
 )
 from ai_review.clients.bitbucket.pr.schema.pull_request import BitbucketGetPRResponseSchema
 from ai_review.clients.bitbucket.pr.types import BitbucketPullRequestsHTTPClientProtocol
+from ai_review.clients.bitbucket.tools import bitbucket_has_next_page
+from ai_review.config import settings
 from ai_review.libs.http.client import HTTPClient
 from ai_review.libs.http.handlers import handle_http_error, HTTPClientError
+from ai_review.libs.http.paginate import paginate
 
 
 class BitbucketPullRequestsHTTPClientError(HTTPClientError):
@@ -35,7 +40,7 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
     ) -> Response:
         return await self.get(
             f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/diffstat",
-            query=QueryParams(**query.model_dump()),
+            query=QueryParams(**query.model_dump(by_alias=True)),
         )
 
     @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
@@ -48,7 +53,7 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
     ) -> Response:
         return await self.get(
             f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/comments",
-            query=QueryParams(**query.model_dump()),
+            query=QueryParams(**query.model_dump(by_alias=True)),
         )
 
     @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
@@ -79,9 +84,25 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
             repo_slug: str,
             pull_request_id: str
     ) -> BitbucketGetPRFilesResponseSchema:
-        query = BitbucketGetPRFilesQuerySchema(pagelen=100)
-        resp = await self.get_diffstat_api(workspace, repo_slug, pull_request_id, query)
-        return BitbucketGetPRFilesResponseSchema.model_validate_json(resp.text)
+        async def fetch_page(page: int) -> Response:
+            query = BitbucketGetPRFilesQuerySchema(page=page, page_len=settings.vcs.pagination.per_page)
+            return await self.get_diffstat_api(workspace, repo_slug, pull_request_id, query)
+
+        def extract_items(response: Response) -> list[BitbucketPRFileSchema]:
+            result = BitbucketGetPRFilesResponseSchema.model_validate_json(response.text)
+            return result.values
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=bitbucket_has_next_page
+        )
+        return BitbucketGetPRFilesResponseSchema(
+            size=len(items),
+            values=items,
+            page_len=settings.vcs.pagination.per_page
+        )
 
     async def get_comments(
             self,
@@ -89,9 +110,25 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
             repo_slug: str,
             pull_request_id: str
     ) -> BitbucketGetPRCommentsResponseSchema:
-        query = BitbucketGetPRCommentsQuerySchema(pagelen=100)
-        response = await self.get_comments_api(workspace, repo_slug, pull_request_id, query)
-        return BitbucketGetPRCommentsResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = BitbucketGetPRCommentsQuerySchema(page=page, page_len=settings.vcs.pagination.per_page)
+            return await self.get_comments_api(workspace, repo_slug, pull_request_id, query)
+
+        def extract_items(response: Response) -> list[BitbucketPRCommentSchema]:
+            result = BitbucketGetPRCommentsResponseSchema.model_validate_json(response.text)
+            return result.values
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=bitbucket_has_next_page
+        )
+        return BitbucketGetPRCommentsResponseSchema(
+            size=len(items),
+            values=items,
+            page_len=settings.vcs.pagination.per_page
+        )
 
     async def create_comment(
             self,

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/bitbucket/pr/schema/comments.py

@@ -22,15 +22,20 @@ class BitbucketPRCommentSchema(BaseModel):
 
 
 class BitbucketGetPRCommentsQuerySchema(BaseModel):
-    pagelen: int = 100
+    model_config = ConfigDict(populate_by_name=True)
+
+    page: int = 1
+    page_len: int = Field(alias="pagelen", default=100)
 
 
 class BitbucketGetPRCommentsResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     size: int
     page: int | None = None
     next: str | None = None
     values: list[BitbucketPRCommentSchema]
-    pagelen: int
+    page_len: int = Field(alias="pagelen")
 
 
 class BitbucketCreatePRCommentRequestSchema(BaseModel):

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/bitbucket/pr/schema/files.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, ConfigDict
 
 
 class BitbucketPRFilePathSchema(BaseModel):
@@ -14,12 +14,17 @@ class BitbucketPRFileSchema(BaseModel):
 
 
 class BitbucketGetPRFilesQuerySchema(BaseModel):
-    pagelen: int = 100
+    model_config = ConfigDict(populate_by_name=True)
+
+    page: int = 1
+    page_len: int = Field(alias="pagelen", default=100)
 
 
 class BitbucketGetPRFilesResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     size: int
     page: int | None = None
     next: str | None = None
     values: list[BitbucketPRFileSchema]
-    pagelen: int
+    page_len: int = Field(alias="pagelen")

xai_review-0.27.0/ai_review/clients/bitbucket/tools.py

@@ -0,0 +1,6 @@
+from httpx import Response
+
+
+def bitbucket_has_next_page(response: Response) -> bool:
+    data = response.json()
+    return bool(data.get("next"))

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/github/pr/client.py

@@ -1,6 +1,7 @@
 from httpx import Response, QueryParams
 
 from ai_review.clients.github.pr.schema.comments import (
+    GitHubPRCommentSchema,
     GitHubGetPRCommentsQuerySchema,
     GitHubGetPRCommentsResponseSchema,
     GitHubCreateIssueCommentRequestSchema,
@@ -9,17 +10,22 @@ from ai_review.clients.github.pr.schema.comments import (
     GitHubCreateReviewCommentResponseSchema
 )
 from ai_review.clients.github.pr.schema.files import (
+    GitHubPRFileSchema,
     GitHubGetPRFilesQuerySchema,
     GitHubGetPRFilesResponseSchema
 )
 from ai_review.clients.github.pr.schema.pull_request import GitHubGetPRResponseSchema
 from ai_review.clients.github.pr.schema.reviews import (
+    GitHubPRReviewSchema,
     GitHubGetPRReviewsQuerySchema,
     GitHubGetPRReviewsResponseSchema
 )
 from ai_review.clients.github.pr.types import GitHubPullRequestsHTTPClientProtocol
+from ai_review.clients.github.tools import github_has_next_page
+from ai_review.config import settings
 from ai_review.libs.http.client import HTTPClient
 from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+from ai_review.libs.http.paginate import paginate
 
 
 class GitHubPullRequestsHTTPClientError(HTTPClientError):
@@ -114,24 +120,72 @@ class GitHubPullRequestsHTTPClient(HTTPClient, GitHubPullRequestsHTTPClientProto
         return GitHubGetPRResponseSchema.model_validate_json(response.text)
 
     async def get_files(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRFilesResponseSchema:
-        query = GitHubGetPRFilesQuerySchema(per_page=100)
-        response = await self.get_files_api(owner, repo, pull_number, query)
-        return GitHubGetPRFilesResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = GitHubGetPRFilesQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_files_api(owner, repo, pull_number, query)
+
+        def extract_items(response: Response) -> list[GitHubPRFileSchema]:
+            result = GitHubGetPRFilesResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=github_has_next_page
+        )
+        return GitHubGetPRFilesResponseSchema(root=items)
 
     async def get_issue_comments(self, owner: str, repo: str, issue_number: str) -> GitHubGetPRCommentsResponseSchema:
-        query = GitHubGetPRCommentsQuerySchema(per_page=100)
-        response = await self.get_issue_comments_api(owner, repo, issue_number, query)
-        return GitHubGetPRCommentsResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = GitHubGetPRCommentsQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_issue_comments_api(owner, repo, issue_number, query)
+
+        def extract_items(response: Response) -> list[GitHubPRCommentSchema]:
+            result = GitHubGetPRCommentsResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=github_has_next_page
+        )
+        return GitHubGetPRCommentsResponseSchema(root=items)
 
     async def get_review_comments(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRCommentsResponseSchema:
-        query = GitHubGetPRCommentsQuerySchema(per_page=100)
-        response = await self.get_review_comments_api(owner, repo, pull_number, query)
-        return GitHubGetPRCommentsResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = GitHubGetPRCommentsQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_review_comments_api(owner, repo, pull_number, query)
+
+        def extract_items(response: Response) -> list[GitHubPRCommentSchema]:
+            result = GitHubGetPRCommentsResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=github_has_next_page
+        )
+        return GitHubGetPRCommentsResponseSchema(root=items)
 
     async def get_reviews(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRReviewsResponseSchema:
-        query = GitHubGetPRReviewsQuerySchema(per_page=100)
-        response = await self.get_reviews_api(owner, repo, pull_number, query)
-        return GitHubGetPRReviewsResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = GitHubGetPRReviewsQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_reviews_api(owner, repo, pull_number, query)
+
+        def extract_items(response: Response) -> list[GitHubPRReviewSchema]:
+            result = GitHubGetPRReviewsResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=github_has_next_page
+        )
+        return GitHubGetPRReviewsResponseSchema(root=items)
 
     async def create_review_comment(
             self,

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/github/pr/schema/comments.py

@@ -9,7 +9,8 @@ class GitHubPRCommentSchema(BaseModel):
 
 
 class GitHubGetPRCommentsQuerySchema(BaseModel):
-    per_page: int
+    page: int = 1
+    per_page: int = 100
 
 
 class GitHubGetPRCommentsResponseSchema(RootModel[list[GitHubPRCommentSchema]]):

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/github/pr/schema/files.py

@@ -9,7 +9,8 @@ class GitHubPRFileSchema(BaseModel):
 
 
 class GitHubGetPRFilesQuerySchema(BaseModel):
-    per_page: int
+    page: int = 1
+    per_page: int = 100
 
 
 class GitHubGetPRFilesResponseSchema(RootModel[list[GitHubPRFileSchema]]):

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/github/pr/schema/reviews.py

@@ -10,7 +10,8 @@ class GitHubPRReviewSchema(BaseModel):
 
 
 class GitHubGetPRReviewsQuerySchema(BaseModel):
-    per_page: int
+    page: int = 1
+    per_page: int = 100
 
 
 class GitHubGetPRReviewsResponseSchema(RootModel[list[GitHubPRReviewSchema]]):

xai_review-0.27.0/ai_review/clients/github/tools.py

@@ -0,0 +1,6 @@
+from httpx import Response
+
+
+def github_has_next_page(response: Response) -> bool:
+    link_header = response.headers.get("Link")
+    return (link_header is not None) and ('rel="next"' in link_header)

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/gitlab/mr/client.py

@@ -2,20 +2,25 @@ from httpx import Response, QueryParams
 
 from ai_review.clients.gitlab.mr.schema.changes import GitLabGetMRChangesResponseSchema
 from ai_review.clients.gitlab.mr.schema.discussions import (
+    GitLabDiscussionSchema,
     GitLabGetMRDiscussionsQuerySchema,
     GitLabGetMRDiscussionsResponseSchema,
     GitLabCreateMRDiscussionRequestSchema,
     GitLabCreateMRDiscussionResponseSchema
 )
 from ai_review.clients.gitlab.mr.schema.notes import (
+    GitLabNoteSchema,
     GitLabGetMRNotesQuerySchema,
     GitLabGetMRNotesResponseSchema,
     GitLabCreateMRNoteRequestSchema,
     GitLabCreateMRNoteResponseSchema,
 )
 from ai_review.clients.gitlab.mr.types import GitLabMergeRequestsHTTPClientProtocol
+from ai_review.clients.gitlab.tools import gitlab_has_next_page
+from ai_review.config import settings
 from ai_review.libs.http.client import HTTPClient
 from ai_review.libs.http.handlers import handle_http_error, HTTPClientError
+from ai_review.libs.http.paginate import paginate
 
 
 class GitLabMergeRequestsHTTPClientError(HTTPClientError):
@@ -86,18 +91,42 @@ class GitLabMergeRequestsHTTPClient(HTTPClient, GitLabMergeRequestsHTTPClientPro
             project_id: str,
             merge_request_id: str
     ) -> GitLabGetMRNotesResponseSchema:
-        query = GitLabGetMRNotesQuerySchema(per_page=100)
-        response = await self.get_notes_api(project_id, merge_request_id, query)
-        return GitLabGetMRNotesResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = GitLabGetMRNotesQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_notes_api(project_id, merge_request_id, query)
+
+        def extract_items(response: Response) -> list[GitLabNoteSchema]:
+            result = GitLabGetMRNotesResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=gitlab_has_next_page
+        )
+        return GitLabGetMRNotesResponseSchema(root=items)
 
     async def get_discussions(
             self,
             project_id: str,
             merge_request_id: str
     ) -> GitLabGetMRDiscussionsResponseSchema:
-        query = GitLabGetMRDiscussionsQuerySchema(per_page=100)
-        response = await self.get_discussions_api(project_id, merge_request_id, query)
-        return GitLabGetMRDiscussionsResponseSchema.model_validate_json(response.text)
+        async def fetch_page(page: int) -> Response:
+            query = GitLabGetMRDiscussionsQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_discussions_api(project_id, merge_request_id, query)
+
+        def extract_items(response: Response) -> list[GitLabDiscussionSchema]:
+            result = GitLabGetMRDiscussionsResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=gitlab_has_next_page
+        )
+        return GitLabGetMRDiscussionsResponseSchema(root=items)
 
     async def create_note(
             self,

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/gitlab/mr/schema/discussions.py

@@ -18,7 +18,8 @@ class GitLabDiscussionPositionSchema(BaseModel):
 
 
 class GitLabGetMRDiscussionsQuerySchema(BaseModel):
-    per_page: int
+    page: int = 1
+    per_page: int = 100
 
 
 class GitLabGetMRDiscussionsResponseSchema(RootModel[list[GitLabDiscussionSchema]]):

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/clients/gitlab/mr/schema/notes.py

@@ -7,7 +7,8 @@ class GitLabNoteSchema(BaseModel):
 
 
 class GitLabGetMRNotesQuerySchema(BaseModel):
-    per_page: int
+    page: int = 1
+    per_page: int = 100
 
 
 class GitLabGetMRNotesResponseSchema(RootModel[list[GitLabNoteSchema]]):

xai_review-0.27.0/ai_review/clients/gitlab/tools.py

@@ -0,0 +1,5 @@
+from httpx import Response
+
+
+def gitlab_has_next_page(response: Response) -> bool:
+    return bool(response.headers.get("X-Next-Page"))

{xai_review-0.26.0 → xai_review-0.27.0}/ai_review/libs/config/vcs/base.py

@@ -5,11 +5,13 @@ from pydantic import BaseModel, Field
 from ai_review.libs.config.vcs.bitbucket import BitbucketPipelineConfig, BitbucketHTTPClientConfig
 from ai_review.libs.config.vcs.github import GitHubPipelineConfig, GitHubHTTPClientConfig
 from ai_review.libs.config.vcs.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
+from ai_review.libs.config.vcs.pagination import VCSPaginationConfig
 from ai_review.libs.constants.vcs_provider import VCSProvider
 
 
 class VCSConfigBase(BaseModel):
     provider: VCSProvider
+    pagination: VCSPaginationConfig = VCSPaginationConfig()
 
 
 class GitLabVCSConfig(VCSConfigBase):

xai_review-0.27.0/ai_review/libs/config/vcs/pagination.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+
+class VCSPaginationConfig(BaseModel):
+    per_page: int = Field(default=100, ge=1, le=100)
+    max_pages: int = Field(default=5, ge=1)

xai_review-0.27.0/ai_review/libs/http/paginate.py

@@ -0,0 +1,43 @@
+from typing import Awaitable, Callable, TypeVar
+
+from httpx import Response
+from pydantic import BaseModel
+
+from ai_review.libs.logger import get_logger
+
+T = TypeVar("T", bound=BaseModel)
+
+logger = get_logger("PAGINATE")
+
+
+async def paginate(
+        fetch_page: Callable[[int], Awaitable[Response]],
+        extract_items: Callable[[Response], list[T]],
+        has_next_page: Callable[[Response], bool],
+        max_pages: int | None = None,
+) -> list[T]:
+    page = 1
+    items: list[T] = []
+
+    while True:
+        response = await fetch_page(page)
+
+        try:
+            extracted = extract_items(response)
+        except Exception as error:
+            logger.error(f"Failed to extract items on {page=}")
+            raise RuntimeError(f"Failed to extract items on {page=}") from error
+
+        logger.debug(f"Page {page}: extracted {len(extracted)} items (total={len(items) + len(extracted)})")
+        items.extend(extracted)
+
+        if not has_next_page(response):
+            logger.debug(f"Pagination finished after {page} page(s), total items={len(items)}")
+            break
+
+        page += 1
+        if max_pages and (page > max_pages):
+            logger.error(f"Pagination exceeded {max_pages=}")
+            raise RuntimeError(f"Pagination exceeded {max_pages=}")
+
+    return items

xai_review-0.27.0/ai_review/tests/suites/clients/bitbucket/test_client.py

@@ -0,0 +1,14 @@
+import pytest
+from httpx import AsyncClient
+
+from ai_review.clients.bitbucket.client import get_bitbucket_http_client, BitbucketHTTPClient
+from ai_review.clients.bitbucket.pr.client import BitbucketPullRequestsHTTPClient
+
+
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+def test_get_bitbucket_http_client_builds_ok():
+    bitbucket_http_client = get_bitbucket_http_client()
+
+    assert isinstance(bitbucket_http_client, BitbucketHTTPClient)
+    assert isinstance(bitbucket_http_client.pr, BitbucketPullRequestsHTTPClient)
+    assert isinstance(bitbucket_http_client.pr.client, AsyncClient)

xai_review-0.27.0/ai_review/tests/suites/clients/bitbucket/test_tools.py

@@ -0,0 +1,31 @@
+from httpx import Response, Request
+
+from ai_review.clients.bitbucket.tools import bitbucket_has_next_page
+
+
+def make_response(data: dict) -> Response:
+    return Response(
+        json=data,
+        request=Request("GET", "http://bitbucket.test"),
+        status_code=200,
+    )
+
+
+def test_bitbucket_has_next_page_true():
+    resp = make_response({"next": "https://api.bitbucket.org/2.0/repositories/test/repo?page=2"})
+    assert bitbucket_has_next_page(resp) is True
+
+
+def test_bitbucket_has_next_page_false_none():
+    resp = make_response({"next": None})
+    assert bitbucket_has_next_page(resp) is False
+
+
+def test_bitbucket_has_next_page_false_missing():
+    resp = make_response({})
+    assert bitbucket_has_next_page(resp) is False
+
+
+def test_bitbucket_has_next_page_false_empty_string():
+    resp = make_response({"next": ""})
+    assert bitbucket_has_next_page(resp) is False

xai_review-0.27.0/ai_review/tests/suites/clients/github/test_tools.py

@@ -0,0 +1,31 @@
+from httpx import Response, Request
+
+from ai_review.clients.github.tools import github_has_next_page
+
+
+def make_response(headers: dict) -> Response:
+    return Response(
+        request=Request("GET", "http://test"),
+        headers=headers,
+        status_code=200,
+    )
+
+
+def test_github_has_next_page_true():
+    response = make_response({
+        "Link": '<https://api.github.com/resource?page=2>; rel="next", '
+                '<https://api.github.com/resource?page=5>; rel="last"'
+    })
+    assert github_has_next_page(response) is True
+
+
+def test_github_has_next_page_false_no_next():
+    response = make_response({
+        "Link": '<https://api.github.com/resource?page=5>; rel="last"'
+    })
+    assert github_has_next_page(response) is False
+
+
+def test_github_has_next_page_false_no_header():
+    resp = make_response({})
+    assert github_has_next_page(resp) is False

xai_review-0.27.0/ai_review/tests/suites/clients/gitlab/test_tools.py

@@ -0,0 +1,26 @@
+from httpx import Response, Request
+
+from ai_review.clients.gitlab.tools import gitlab_has_next_page
+
+
+def make_response(headers: dict) -> Response:
+    return Response(
+        request=Request("GET", "http://gitlab.test"),
+        headers=headers,
+        status_code=200,
+    )
+
+
+def test_gitlab_has_next_page_true():
+    resp = make_response({"X-Next-Page": "2"})
+    assert gitlab_has_next_page(resp) is True
+
+
+def test_gitlab_has_next_page_false_empty():
+    resp = make_response({"X-Next-Page": ""})
+    assert gitlab_has_next_page(resp) is False
+
+
+def test_gitlab_has_next_page_false_missing():
+    resp = make_response({})
+    assert gitlab_has_next_page(resp) is False