xai-review 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

ai_review/tests/fixtures/clients/github.py

@@ -0,0 +1,181 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubPRCommentSchema,
+    GitHubGetPRCommentsResponseSchema,
+    GitHubCreateIssueCommentResponseSchema,
+    GitHubCreateReviewCommentRequestSchema,
+    GitHubCreateReviewCommentResponseSchema,
+)
+from ai_review.clients.github.pr.schema.files import GitHubGetPRFilesResponseSchema, GitHubPRFileSchema
+from ai_review.clients.github.pr.schema.pull_request import (
+    GitHubUserSchema,
+    GitHubLabelSchema,
+    GitHubBranchSchema,
+    GitHubGetPRResponseSchema,
+)
+from ai_review.clients.github.pr.schema.reviews import GitHubGetPRReviewsResponseSchema, GitHubPRReviewSchema
+from ai_review.clients.github.pr.types import GitHubPullRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.github import GitHubPipelineConfig, GitHubHTTPClientConfig
+from ai_review.libs.config.vcs import GitHubVCSConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.github.client import GitHubVCSClient
+
+
+class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRResponseSchema:
+        self.calls.append(("get_pull_request", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRResponseSchema(
+            id=1,
+            number=1,
+            title="Fake Pull Request",
+            body="This is a fake PR for testing",
+            user=GitHubUserSchema(id=101, login="tester"),
+            labels=[
+                GitHubLabelSchema(id=1, name="bugfix"),
+                GitHubLabelSchema(id=2, name="backend"),
+            ],
+            assignees=[
+                GitHubUserSchema(id=102, login="dev1"),
+                GitHubUserSchema(id=103, login="dev2"),
+            ],
+            requested_reviewers=[
+                GitHubUserSchema(id=104, login="reviewer"),
+            ],
+            base=GitHubBranchSchema(ref="main", sha="abc123"),
+            head=GitHubBranchSchema(ref="feature/test", sha="def456"),
+        )
+
+    async def get_files(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRFilesResponseSchema:
+        self.calls.append(("get_files", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRFilesResponseSchema(
+            root=[
+                GitHubPRFileSchema(
+                    sha="abc",
+                    status="modified",
+                    filename="app/main.py",
+                    patch="@@ -1,2 +1,2 @@\n- old\n+ new",
+                ),
+                GitHubPRFileSchema(
+                    sha="def",
+                    status="added",
+                    filename="utils/helper.py",
+                    patch="+ print('Hello')",
+                ),
+            ]
+        )
+
+    async def get_issue_comments(self, owner: str, repo: str, issue_number: str) -> GitHubGetPRCommentsResponseSchema:
+        self.calls.append(("get_issue_comments", {"owner": owner, "repo": repo, "issue_number": issue_number}))
+
+        return GitHubGetPRCommentsResponseSchema(
+            root=[
+                GitHubPRCommentSchema(id=1, body="General comment"),
+                GitHubPRCommentSchema(id=2, body="Another general comment"),
+            ]
+        )
+
+    async def get_review_comments(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRCommentsResponseSchema:
+        self.calls.append(("get_review_comments", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRCommentsResponseSchema(
+            root=[
+                GitHubPRCommentSchema(id=3, body="Inline comment", path="file.py", line=5),
+                GitHubPRCommentSchema(id=4, body="Another inline comment", path="utils.py", line=10),
+            ]
+        )
+
+    async def get_reviews(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRReviewsResponseSchema:
+        self.calls.append(("get_reviews", {"owner": owner, "repo": repo, "pull_number": pull_number}))
+
+        return GitHubGetPRReviewsResponseSchema(
+            root=[
+                GitHubPRReviewSchema(id=1, body="Looks good", state="APPROVED"),
+                GitHubPRReviewSchema(id=2, body="Needs changes", state="CHANGES_REQUESTED"),
+            ]
+        )
+
+    async def create_review_comment(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GitHubCreateReviewCommentRequestSchema,
+    ) -> GitHubCreateReviewCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_review_comment",
+                {"owner": owner, "repo": repo, "pull_number": pull_number, **request.model_dump()}
+            )
+        )
+        return GitHubCreateReviewCommentResponseSchema(id=10, body=request.body)
+
+    async def create_issue_comment(
+            self,
+            owner: str,
+            repo: str,
+            issue_number: str,
+            body: str,
+    ) -> GitHubCreateIssueCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_issue_comment",
+                {"owner": owner, "repo": repo, "issue_number": issue_number, "body": body}
+            )
+        )
+        return GitHubCreateIssueCommentResponseSchema(id=11, body=body)
+
+
+class FakeGitHubHTTPClient:
+    def __init__(self, pull_requests_client: GitHubPullRequestsHTTPClientProtocol):
+        self.pr = pull_requests_client
+
+
+@pytest.fixture
+def fake_github_pull_requests_http_client() -> FakeGitHubPullRequestsHTTPClient:
+    return FakeGitHubPullRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_github_http_client(
+        fake_github_pull_requests_http_client: FakeGitHubPullRequestsHTTPClient
+) -> FakeGitHubHTTPClient:
+    return FakeGitHubHTTPClient(pull_requests_client=fake_github_pull_requests_http_client)
+
+
+@pytest.fixture
+def github_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_github_http_client: FakeGitHubHTTPClient
+) -> GitHubVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.github.client.get_github_http_client",
+        lambda: fake_github_http_client,
+    )
+
+    return GitHubVCSClient()
+
+
+@pytest.fixture
+def github_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = GitHubVCSConfig(
+        provider=VCSProvider.GITHUB,
+        pipeline=GitHubPipelineConfig(
+            repo="repo",
+            owner="owner",
+            pull_number="pull_number"
+        ),
+        http_client=GitHubHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://github.com"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/fixtures/clients/gitlab.py

@@ -0,0 +1,150 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.gitlab.mr.schema.changes import (
+    GitLabUserSchema,
+    GitLabMRChangeSchema,
+    GitLabDiffRefsSchema,
+    GitLabGetMRChangesResponseSchema,
+)
+from ai_review.clients.gitlab.mr.schema.discussions import (
+    GitLabDiscussionSchema,
+    GitLabGetMRDiscussionsResponseSchema,
+    GitLabCreateMRDiscussionRequestSchema,
+    GitLabCreateMRDiscussionResponseSchema,
+)
+from ai_review.clients.gitlab.mr.schema.notes import (
+    GitLabNoteSchema,
+    GitLabGetMRNotesResponseSchema,
+    GitLabCreateMRNoteResponseSchema,
+)
+from ai_review.clients.gitlab.mr.types import GitLabMergeRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
+from ai_review.libs.config.vcs import GitLabVCSConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.gitlab.client import GitLabVCSClient
+
+
+class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_changes(self, project_id: str, merge_request_id: str) -> GitLabGetMRChangesResponseSchema:
+        self.calls.append(("get_changes", {"project_id": project_id, "merge_request_id": merge_request_id}))
+        return GitLabGetMRChangesResponseSchema(
+            id=1,
+            iid=1,
+            title="Fake Merge Request",
+            author=GitLabUserSchema(id=42, name="Tester", username="tester"),
+            labels=["bugfix", "backend"],
+            description="This is a fake MR for testing",
+            project_id=1,
+            diff_refs=GitLabDiffRefsSchema(
+                base_sha="abc123",
+                head_sha="def456",
+                start_sha="ghi789",
+            ),
+            source_branch="feature/test",
+            target_branch="main",
+            changes=[
+                GitLabMRChangeSchema(
+                    diff="@@ -1,2 +1,2 @@\n- old\n+ new",
+                    old_path="main.py",
+                    new_path="main.py",
+                )
+            ],
+        )
+
+    async def get_notes(self, project_id: str, merge_request_id: str) -> GitLabGetMRNotesResponseSchema:
+        self.calls.append(("get_notes", {"project_id": project_id, "merge_request_id": merge_request_id}))
+        return GitLabGetMRNotesResponseSchema(
+            root=[
+                GitLabNoteSchema(id=1, body="General comment"),
+                GitLabNoteSchema(id=2, body="Another note"),
+            ]
+        )
+
+    async def get_discussions(self, project_id: str, merge_request_id: str) -> GitLabGetMRDiscussionsResponseSchema:
+        self.calls.append(("get_discussions", {"project_id": project_id, "merge_request_id": merge_request_id}))
+        return GitLabGetMRDiscussionsResponseSchema(
+            root=[
+                GitLabDiscussionSchema(
+                    id="discussion-1",
+                    notes=[
+                        GitLabNoteSchema(id=10, body="Inline comment A"),
+                        GitLabNoteSchema(id=11, body="Inline comment B"),
+                    ],
+                )
+            ]
+        )
+
+    async def create_note(self, body: str, project_id: str, merge_request_id: str) -> GitLabCreateMRNoteResponseSchema:
+        self.calls.append(
+            (
+                "create_note",
+                {"body": body, "project_id": project_id, "merge_request_id": merge_request_id}
+            )
+        )
+        return GitLabCreateMRNoteResponseSchema(id=99, body=body)
+
+    async def create_discussion(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            request: GitLabCreateMRDiscussionRequestSchema,
+    ) -> GitLabCreateMRDiscussionResponseSchema:
+        self.calls.append(
+            (
+                "create_discussion",
+                {"project_id": project_id, "merge_request_id": merge_request_id, "body": request.body}
+            )
+        )
+        return GitLabCreateMRDiscussionResponseSchema(id="discussion-new", body=request.body)
+
+
+class FakeGitLabHTTPClient:
+    def __init__(self, merge_requests_client: FakeGitLabMergeRequestsHTTPClient):
+        self.mr = merge_requests_client
+
+
+@pytest.fixture
+def fake_gitlab_merge_requests_http_client() -> FakeGitLabMergeRequestsHTTPClient:
+    return FakeGitLabMergeRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_gitlab_http_client(
+        fake_gitlab_merge_requests_http_client: FakeGitLabMergeRequestsHTTPClient
+) -> FakeGitLabHTTPClient:
+    return FakeGitLabHTTPClient(merge_requests_client=fake_gitlab_merge_requests_http_client)
+
+
+@pytest.fixture
+def gitlab_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_gitlab_http_client: FakeGitLabHTTPClient
+) -> GitLabVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.gitlab.client.get_gitlab_http_client",
+        lambda: fake_gitlab_http_client,
+    )
+
+    return GitLabVCSClient()
+
+
+@pytest.fixture
+def gitlab_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = GitLabVCSConfig(
+        provider=VCSProvider.GITLAB,
+        pipeline=GitLabPipelineConfig(
+            project_id="project-id",
+            merge_request_id="merge-request-id"
+        ),
+        http_client=GitLabHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://gitlab.com"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/fixtures/clients/openai.py

@@ -0,0 +1,21 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.config import settings
+from ai_review.libs.config.llm import OpenAILLMConfig
+from ai_review.libs.config.openai import OpenAIMetaConfig, OpenAIHTTPClientConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+
+
+@pytest.fixture
+def openai_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = OpenAILLMConfig(
+        meta=OpenAIMetaConfig(),
+        provider=LLMProvider.OPENAI,
+        http_client=OpenAIHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.openai.com/v1"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)

ai_review/tests/suites/clients/claude/test_client.py

@@ -1,29 +1,10 @@
 import pytest
 from httpx import AsyncClient
-from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.claude.client import get_claude_http_client, ClaudeHTTPClient
-from ai_review.config import settings
-from ai_review.libs.config.claude import ClaudeMetaConfig
-from ai_review.libs.config.llm import ClaudeLLMConfig, ClaudeHTTPClientConfig
-from ai_review.libs.constants.llm_provider import LLMProvider
-
-
-@pytest.fixture(autouse=True)
-def claude_http_client_config(monkeypatch):
-    fake_config = ClaudeLLMConfig(
-        meta=ClaudeMetaConfig(),
-        provider=LLMProvider.CLAUDE,
-        http_client=ClaudeHTTPClientConfig(
-            timeout=10,
-            api_url=HttpUrl("https://api.anthropic.com"),
-            api_token=SecretStr("fake-token"),
-            api_version="2023-06-01",
-        )
-    )
-    monkeypatch.setattr(settings, "llm", fake_config)
 
 
+@pytest.mark.usefixtures('claude_http_client_config')
 def test_get_claude_http_client_builds_ok():
     claude_http_client = get_claude_http_client()
 

ai_review/tests/suites/clients/gemini/test_client.py

@@ -1,28 +1,10 @@
 import pytest
 from httpx import AsyncClient
-from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.gemini.client import get_gemini_http_client, GeminiHTTPClient
-from ai_review.config import settings
-from ai_review.libs.config.gemini import GeminiMetaConfig, GeminiHTTPClientConfig
-from ai_review.libs.config.llm import GeminiLLMConfig
-from ai_review.libs.constants.llm_provider import LLMProvider
-
-
-@pytest.fixture(autouse=True)
-def gemini_http_client_config(monkeypatch):
-    fake_config = GeminiLLMConfig(
-        meta=GeminiMetaConfig(),
-        provider=LLMProvider.GEMINI,
-        http_client=GeminiHTTPClientConfig(
-            timeout=10,
-            api_url=HttpUrl("https://generativelanguage.googleapis.com"),
-            api_token=SecretStr("fake-token"),
-        )
-    )
-    monkeypatch.setattr(settings, "llm", fake_config)
 
 
+@pytest.mark.usefixtures('gemini_http_client_config')
 def test_get_gemini_http_client_builds_ok():
     gemini_http_client = get_gemini_http_client()
 

ai_review/tests/suites/clients/github/test_client.py

@@ -1,33 +1,11 @@
 import pytest
 from httpx import AsyncClient
-from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.github.client import get_github_http_client, GitHubHTTPClient
 from ai_review.clients.github.pr.client import GitHubPullRequestsHTTPClient
-from ai_review.config import settings
-from ai_review.libs.config.github import GitHubPipelineConfig, GitHubHTTPClientConfig
-from ai_review.libs.config.vcs import GitHubVCSConfig
-from ai_review.libs.constants.vcs_provider import VCSProvider
-
-
-@pytest.fixture(autouse=True)
-def github_http_client_config(monkeypatch: pytest.MonkeyPatch):
-    fake_config = GitHubVCSConfig(
-        provider=VCSProvider.GITHUB,
-        pipeline=GitHubPipelineConfig(
-            repo="repo",
-            owner="owner",
-            pull_number="pull_number"
-        ),
-        http_client=GitHubHTTPClientConfig(
-            timeout=10,
-            api_url=HttpUrl("https://github.com"),
-            api_token=SecretStr("fake-token"),
-        )
-    )
-    monkeypatch.setattr(settings, "vcs", fake_config)
 
 
+@pytest.mark.usefixtures("github_http_client_config")
 def test_get_github_http_client_builds_ok():
     github_http_client = get_github_http_client()
 

ai_review/tests/suites/clients/gitlab/test_client.py

@@ -1,32 +1,11 @@
 import pytest
 from httpx import AsyncClient
-from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.gitlab.client import get_gitlab_http_client, GitLabHTTPClient
 from ai_review.clients.gitlab.mr.client import GitLabMergeRequestsHTTPClient
-from ai_review.config import settings
-from ai_review.libs.config.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
-from ai_review.libs.config.vcs import GitLabVCSConfig
-from ai_review.libs.constants.vcs_provider import VCSProvider
-
-
-@pytest.fixture(autouse=True)
-def gitlab_http_client_config(monkeypatch: pytest.MonkeyPatch):
-    fake_config = GitLabVCSConfig(
-        provider=VCSProvider.GITLAB,
-        pipeline=GitLabPipelineConfig(
-            project_id="project-id",
-            merge_request_id="merge-request-id"
-        ),
-        http_client=GitLabHTTPClientConfig(
-            timeout=10,
-            api_url=HttpUrl("https://gitlab.com"),
-            api_token=SecretStr("fake-token"),
-        )
-    )
-    monkeypatch.setattr(settings, "vcs", fake_config)
 
 
+@pytest.mark.usefixtures("gitlab_http_client_config")
 def test_get_gitlab_http_client_builds_ok():
     gitlab_http_client = get_gitlab_http_client()
 

ai_review/tests/suites/clients/openai/test_client.py

@@ -1,28 +1,10 @@
 import pytest
 from httpx import AsyncClient
-from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.openai.client import get_openai_http_client, OpenAIHTTPClient
-from ai_review.config import settings
-from ai_review.libs.config.llm import OpenAILLMConfig
-from ai_review.libs.config.openai import OpenAIMetaConfig, OpenAIHTTPClientConfig
-from ai_review.libs.constants.llm_provider import LLMProvider
-
-
-@pytest.fixture(autouse=True)
-def openai_http_client_config(monkeypatch):
-    fake_config = OpenAILLMConfig(
-        meta=OpenAIMetaConfig(),
-        provider=LLMProvider.OPENAI,
-        http_client=OpenAIHTTPClientConfig(
-            timeout=10,
-            api_url=HttpUrl("https://api.openai.com/v1"),
-            api_token=SecretStr("fake-token"),
-        )
-    )
-    monkeypatch.setattr(settings, "llm", fake_config)
 
 
+@pytest.mark.usefixtures('openai_http_client_config')
 def test_get_openai_http_client_builds_ok():
     openai_http_client = get_openai_http_client()
 

ai_review/tests/suites/libs/asynchronous/test_gather.py

@@ -0,0 +1,46 @@
+import asyncio
+
+import pytest
+
+from ai_review.config import settings
+from ai_review.libs.asynchronous.gather import bounded_gather
+
+
+@pytest.mark.asyncio
+async def test_bounded_gather_limits_concurrency(monkeypatch: pytest.MonkeyPatch):
+    concurrency_limit = 3
+    monkeypatch.setattr(settings.core, "concurrency", concurrency_limit)
+
+    active = 0
+    max_active = 0
+
+    async def task(number: int):
+        nonlocal active, max_active
+        active += 1
+        max_active = max(max_active, active)
+        await asyncio.sleep(0.05)
+        active -= 1
+        return number * 2
+
+    results = await bounded_gather(task(index) for index in range(10))
+
+    assert max_active <= concurrency_limit
+    assert results == tuple(index * 2 for index in range(10))
+
+
+@pytest.mark.asyncio
+async def test_bounded_gather_returns_exceptions(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr(settings.core, "concurrency", 2)
+
+    async def ok_task():
+        await asyncio.sleep(0.01)
+        return "ok"
+
+    async def fail_task():
+        raise ValueError("boom")
+
+    results = await bounded_gather([ok_task(), fail_task(), ok_task()])
+
+    assert len(results) == 3
+    assert any(isinstance(result, Exception) for result in results)
+    assert any(r == "ok" for r in results)

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

@@ -4,7 +4,7 @@ from ai_review import config
 from ai_review.libs.config.review import ReviewMode
 from ai_review.libs.diff.models import Diff, DiffFile, FileMode
 from ai_review.services.diff.service import DiffService
-from ai_review.tests.fixtures.git import FakeGitService
+from ai_review.tests.fixtures.services.git import FakeGitService
 
 
 @pytest.fixture

ai_review/tests/suites/services/diff/test_tools.py

@@ -5,7 +5,7 @@ import pytest
 
 from ai_review.libs.diff.models import Diff, DiffFile, DiffHunk, DiffRange, DiffLineType, FileMode
 from ai_review.services.diff import tools
-from ai_review.tests.fixtures.git import FakeGitService
+from ai_review.tests.fixtures.services.git import FakeGitService
 
 
 # ---------- normalize_file_path ----------

ai_review/tests/suites/services/llm/test_factory.py

@@ -0,0 +1,30 @@
+import pytest
+
+from ai_review.services.llm.claude.client import ClaudeLLMClient
+from ai_review.services.llm.factory import get_llm_client
+from ai_review.services.llm.gemini.client import GeminiLLMClient
+from ai_review.services.llm.openai.client import OpenAILLMClient
+
+
+@pytest.mark.usefixtures("openai_http_client_config")
+def test_get_llm_client_returns_openai(monkeypatch: pytest.MonkeyPatch):
+    client = get_llm_client()
+    assert isinstance(client, OpenAILLMClient)
+
+
+@pytest.mark.usefixtures("gemini_http_client_config")
+def test_get_llm_client_returns_gemini(monkeypatch: pytest.MonkeyPatch):
+    client = get_llm_client()
+    assert isinstance(client, GeminiLLMClient)
+
+
+@pytest.mark.usefixtures("claude_http_client_config")
+def test_get_llm_client_returns_claude(monkeypatch: pytest.MonkeyPatch):
+    client = get_llm_client()
+    assert isinstance(client, ClaudeLLMClient)
+
+
+def test_get_llm_client_unsupported_provider(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setattr("ai_review.services.llm.factory.settings.llm.provider", "DEEPSEEK")
+    with pytest.raises(ValueError):
+        get_llm_client()