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

ai_review/tests/fixtures/services/review/runner/summary.py

@@ -0,0 +1,50 @@
+import pytest
+
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewCommentGatewayProtocol, ReviewLLMGatewayProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.internal.summary.types import SummaryCommentServiceProtocol
+from ai_review.services.review.runner.summary import SummaryReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeSummaryReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_summary_review_runner() -> FakeSummaryReviewRunner:
+    return FakeSummaryReviewRunner()
+
+
+@pytest.fixture
+def summary_review_runner(
+        fake_vcs_client: VCSClientProtocol,
+        fake_git_service: GitServiceProtocol,
+        fake_diff_service: DiffServiceProtocol,
+        fake_cost_service: CostServiceProtocol,
+        fake_prompt_service: PromptServiceProtocol,
+        fake_review_llm_gateway: ReviewLLMGatewayProtocol,
+        fake_review_policy_service: ReviewPolicyServiceProtocol,
+        fake_review_comment_gateway: ReviewCommentGatewayProtocol,
+        fake_summary_comment_service: SummaryCommentServiceProtocol,
+) -> SummaryReviewRunner:
+    return SummaryReviewRunner(
+        vcs=fake_vcs_client,
+        git=fake_git_service,
+        diff=fake_diff_service,
+        cost=fake_cost_service,
+        prompt=fake_prompt_service,
+        review_policy=fake_review_policy_service,
+        summary_comment=fake_summary_comment_service,
+        review_llm_gateway=fake_review_llm_gateway,
+        review_comment_gateway=fake_review_comment_gateway,
+    )

ai_review/tests/fixtures/services/review/runner/summary_reply.py

@@ -0,0 +1,50 @@
+import pytest
+
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol, ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.internal.summary_reply.types import SummaryCommentReplyServiceProtocol
+from ai_review.services.review.runner.summary_reply import SummaryReplyReviewRunner
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+
+class FakeSummaryReplyReviewRunner(ReviewRunnerProtocol):
+    def __init__(self):
+        self.calls = []
+
+    async def run(self) -> None:
+        self.calls.append(("run", {}))
+
+
+@pytest.fixture
+def fake_summary_reply_review_runner() -> FakeSummaryReplyReviewRunner:
+    return FakeSummaryReplyReviewRunner()
+
+
+@pytest.fixture
+def summary_reply_review_runner(
+        fake_vcs_client: VCSClientProtocol,
+        fake_git_service: GitServiceProtocol,
+        fake_diff_service: DiffServiceProtocol,
+        fake_cost_service: CostServiceProtocol,
+        fake_prompt_service: PromptServiceProtocol,
+        fake_review_llm_gateway: ReviewLLMGatewayProtocol,
+        fake_review_policy_service: ReviewPolicyServiceProtocol,
+        fake_review_comment_gateway: ReviewCommentGatewayProtocol,
+        fake_summary_comment_reply_service: SummaryCommentReplyServiceProtocol,
+) -> SummaryReplyReviewRunner:
+    return SummaryReplyReviewRunner(
+        vcs=fake_vcs_client,
+        git=fake_git_service,
+        diff=fake_diff_service,
+        cost=fake_cost_service,
+        prompt=fake_prompt_service,
+        review_policy=fake_review_policy_service,
+        review_llm_gateway=fake_review_llm_gateway,
+        summary_comment_reply=fake_summary_comment_reply_service,
+        review_comment_gateway=fake_review_comment_gateway,
+    )

ai_review/tests/fixtures/services/vcs.py

@@ -5,6 +5,7 @@ import pytest
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
     ReviewInfoSchema,
+    ReviewThreadSchema,
     ReviewCommentSchema,
 )
 
@@ -43,6 +44,28 @@ class FakeVCSClient(VCSClientProtocol):
 
         return self.responses.get("create_inline_comment_result", None)
 
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        self.calls.append(("create_inline_reply", (thread_id, message), {}))
+        if error := self.responses.get("create_inline_reply_error"):
+            raise error
+
+        return self.responses.get("create_inline_reply_result", None)
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        self.calls.append(("create_summary_reply", (thread_id, message), {}))
+        if error := self.responses.get("create_summary_reply_error"):
+            raise error
+
+        return self.responses.get("create_summary_reply_result", None)
+
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        self.calls.append(("get_inline_threads", (), {}))
+        return self.responses.get("get_inline_threads", [])
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        self.calls.append(("get_general_threads", (), {}))
+        return self.responses.get("get_general_threads", [])
+
 
 @pytest.fixture
 def fake_vcs_client() -> FakeVCSClient:

ai_review/tests/suites/cli/test_main.py

@@ -0,0 +1,54 @@
+import pytest
+from typer.testing import CliRunner
+
+from ai_review.cli.main import app
+from ai_review.services.review.service import ReviewService
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def dummy_review_service(monkeypatch: pytest.MonkeyPatch, review_service: ReviewService):
+    monkeypatch.setattr("ai_review.cli.commands.run_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_inline_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_context_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_summary_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_inline_reply_review.ReviewService", lambda: review_service)
+    monkeypatch.setattr("ai_review.cli.commands.run_summary_reply_review.ReviewService", lambda: review_service)
+
+
+@pytest.mark.parametrize(
+    "args, expected_output",
+    [
+        (["run"], "Starting full AI review..."),
+        (["run-inline"], "Starting inline AI review..."),
+        (["run-context"], "Starting context AI review..."),
+        (["run-summary"], "Starting summary AI review..."),
+        (["run-inline-reply"], "Starting inline reply AI review..."),
+        (["run-summary-reply"], "Starting summary reply AI review..."),
+    ],
+)
+def test_cli_commands_invoke_review_service_successfully(args: list[str], expected_output: str):
+    """
+    Ensure CLI commands correctly call the ReviewService with fake dependencies.
+    """
+    result = runner.invoke(app, args)
+
+    assert result.exit_code == 0
+    assert expected_output in result.output
+    assert "AI review completed successfully!" in result.output
+
+
+def test_show_config_outputs_json(monkeypatch: pytest.MonkeyPatch):
+    """
+    Validate that the 'show-config' command prints settings as JSON.
+    """
+    monkeypatch.setattr(
+        "ai_review.cli.main.settings.model_dump_json",
+        lambda **_: '{"debug": true}'
+    )
+
+    result = runner.invoke(app, ["show-config"])
+    assert result.exit_code == 0
+    assert "Loaded AI Review configuration" in result.output
+    assert '{"debug": true}' in result.output

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)

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

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

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

ai_review/tests/suites/libs/config/test_prompt.py

@@ -2,56 +2,136 @@ from pathlib import Path
 
 import pytest
 
-from ai_review.libs.config.prompt import PromptConfig
+from ai_review.libs.config.prompt import PromptConfig, resolve_prompt_files, resolve_system_prompt_files
 
 
-def test_inline_prompt_files_or_default_uses_defaults(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    dummy_file = tmp_path / "dummy.md"
-    dummy_file.write_text("DUMMY")
-    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
-
-    config = PromptConfig()
-    result = config.inline_prompt_files_or_default
+# ---------- resolve_prompt_files ----------
 
+def test_resolve_prompt_files_returns_given_list(tmp_path: Path):
+    dummy_file = tmp_path / "file.md"
+    result = resolve_prompt_files([dummy_file], "default_inline.md")
     assert result == [dummy_file]
-    assert config.load_inline() == ["DUMMY"]
 
 
-def test_system_inline_prompts_none_returns_global(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
-    dummy_file = tmp_path / "global.md"
-    dummy_file.write_text("GLOBAL")
+def test_resolve_prompt_files_loads_default_when_none(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    dummy_file = tmp_path / "inline_default.md"
+    dummy_file.write_text("INLINE_DEFAULT")
     monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
 
-    config = PromptConfig(system_inline_prompt_files=None)
-    result = config.system_inline_prompt_files_or_default
+    result = resolve_prompt_files(None, "default_inline.md")
+    assert result == [dummy_file]
 
+
+# ---------- resolve_system_prompt_files ----------
+
+def test_resolve_system_prompt_files_none_returns_global(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys.md"
+    dummy_file.write_text("SYS")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    result = resolve_system_prompt_files(None, include=True, default_file="default_system_inline.md")
     assert result == [dummy_file]
-    assert config.load_system_inline() == ["GLOBAL"]
 
 
-def test_system_inline_prompts_include_true(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+def test_resolve_system_prompt_files_include_true(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
     global_file = tmp_path / "global.md"
     global_file.write_text("GLOBAL")
     custom_file = tmp_path / "custom.md"
-    custom_file.write_text("CUSTOM")
     monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: global_file)
 
-    config = PromptConfig(system_inline_prompt_files=[custom_file], include_inline_system_prompts=True)
-    result = config.system_inline_prompt_files_or_default
-
-    assert global_file in result and custom_file in result
-    assert config.load_system_inline() == ["GLOBAL", "CUSTOM"]
+    result = resolve_system_prompt_files([custom_file], include=True, default_file="default_system_inline.md")
+    assert result == [global_file, custom_file]
 
 
-def test_system_inline_prompts_include_false(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+def test_resolve_system_prompt_files_include_false(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
     global_file = tmp_path / "global.md"
     global_file.write_text("GLOBAL")
     custom_file = tmp_path / "custom.md"
-    custom_file.write_text("CUSTOM")
     monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: global_file)
 
-    config = PromptConfig(system_inline_prompt_files=[custom_file], include_inline_system_prompts=False)
-    result = config.system_inline_prompt_files_or_default
-
+    result = resolve_system_prompt_files([custom_file], include=False, default_file="default_system_inline.md")
     assert result == [custom_file]
-    assert config.load_system_inline() == ["CUSTOM"]
+
+
+# ---------- Prompts ---------
+
+def test_load_context_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "context.md"
+    dummy_file.write_text("CTX")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.context_prompt_files_or_default == [dummy_file]
+    assert config.load_context() == ["CTX"]
+
+
+def test_load_summary_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "summary.md"
+    dummy_file.write_text("SUM")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.summary_prompt_files_or_default == [dummy_file]
+    assert config.load_summary() == ["SUM"]
+
+
+def test_load_inline_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "inline_reply.md"
+    dummy_file.write_text("INL_R")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.inline_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_inline_reply() == ["INL_R"]
+
+
+def test_load_summary_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "summary_reply.md"
+    dummy_file.write_text("SUM_R")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.summary_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_summary_reply() == ["SUM_R"]
+
+
+# ---------- System Prompts ----------
+
+def test_load_system_context_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_context.md"
+    dummy_file.write_text("SYS_CTX")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_context_prompt_files_or_default == [dummy_file]
+    assert config.load_system_context() == ["SYS_CTX"]
+
+
+def test_load_system_summary_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_summary.md"
+    dummy_file.write_text("SYS_SUM")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_summary_prompt_files_or_default == [dummy_file]
+    assert config.load_system_summary() == ["SYS_SUM"]
+
+
+def test_load_system_inline_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_inline_reply.md"
+    dummy_file.write_text("SYS_IR")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_inline_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_system_inline_reply() == ["SYS_IR"]
+
+
+def test_load_system_summary_reply_prompts(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    dummy_file = tmp_path / "sys_summary_reply.md"
+    dummy_file.write_text("SYS_SR")
+    monkeypatch.setattr("ai_review.libs.config.prompt.load_resource", lambda **_: dummy_file)
+
+    config = PromptConfig()
+    assert config.system_summary_reply_prompt_files_or_default == [dummy_file]
+    assert config.load_system_summary_reply() == ["SYS_SR"]

ai_review/tests/suites/libs/http/test_paginate.py

@@ -0,0 +1,95 @@
+import pytest
+from httpx import Response, Request
+from pydantic import BaseModel
+
+from ai_review.libs.http.paginate import paginate
+
+
+class DummySchema(BaseModel):
+    value: int
+
+
+def make_response(data: dict) -> Response:
+    return Response(
+        json=data,
+        request=Request("GET", "http://test"),
+        status_code=200,
+    )
+
+
+@pytest.mark.asyncio
+async def test_single_page():
+    async def fetch_page(_: int) -> Response:
+        return make_response({"items": [1, 2, 3]})
+
+    def extract_items(response: Response) -> list[DummySchema]:
+        return [DummySchema(value=value) for value in response.json()["items"]]
+
+    def has_next_page(_: Response) -> bool:
+        return False
+
+    items = await paginate(fetch_page, extract_items, has_next_page)
+    assert len(items) == 3
+    assert [item.value for item in items] == [1, 2, 3]
+
+
+@pytest.mark.asyncio
+async def test_multiple_pages():
+    async def fetch_page(page: int) -> Response:
+        return make_response({"items": [page]})
+
+    def extract_items(response: Response):
+        return [DummySchema(value=value) for value in response.json()["items"]]
+
+    def has_next_page(response: Response) -> bool:
+        return response.json()["items"][0] < 3
+
+    items = await paginate(fetch_page, extract_items, has_next_page)
+    assert [item.value for item in items] == [1, 2, 3]
+
+
+@pytest.mark.asyncio
+async def test_extract_items_error():
+    async def fetch_page(_: int) -> Response:
+        return make_response({"items": [1]})
+
+    def extract_items(_: Response):
+        raise ValueError("bad json")
+
+    def has_next_page(_: Response) -> bool:
+        return False
+
+    with pytest.raises(RuntimeError) as exc:
+        await paginate(fetch_page, extract_items, has_next_page)
+    assert "Failed to extract items" in str(exc.value)
+
+
+@pytest.mark.asyncio
+async def test_max_pages_exceeded():
+    async def fetch_page(page: int) -> Response:
+        return make_response({"items": [page]})
+
+    def extract_items(response: Response):
+        return [DummySchema(value=value) for value in response.json()["items"]]
+
+    def has_next_page(_: Response) -> bool:
+        return True
+
+    with pytest.raises(RuntimeError) as exc:
+        await paginate(fetch_page, extract_items, has_next_page, max_pages=2)
+    assert "Pagination exceeded" in str(exc.value)
+
+
+@pytest.mark.asyncio
+async def test_empty_items():
+    async def fetch_page(_: int) -> Response:
+        return make_response({"items": []})
+
+    def extract_items(_: Response):
+        return []
+
+    def has_next_page(_: Response) -> bool:
+        return False
+
+    result = await paginate(fetch_page, extract_items, has_next_page)
+    assert result == []