xai-review 0.3.0__py3-none-any.whl

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

@@ -0,0 +1,31 @@
+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)
+
+
+def test_get_claude_http_client_builds_ok():
+    claude_http_client = get_claude_http_client()
+
+    assert isinstance(claude_http_client, ClaudeHTTPClient)
+    assert isinstance(claude_http_client.client, AsyncClient)

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

@@ -0,0 +1,59 @@
+from ai_review.clients.claude.schema import (
+    ClaudeUsageSchema,
+    ClaudeContentSchema,
+    ClaudeMessageSchema,
+    ClaudeChatRequestSchema,
+    ClaudeChatResponseSchema,
+)
+
+
+# ---------- ClaudeUsageSchema ----------
+
+def test_usage_total_tokens_property():
+    usage = ClaudeUsageSchema(input_tokens=10, output_tokens=5)
+    assert usage.total_tokens == 15
+
+
+# ---------- ClaudeChatResponseSchema ----------
+
+def test_first_text_returns_text():
+    resp = ClaudeChatResponseSchema(
+        id="123",
+        role="assistant",
+        usage=ClaudeUsageSchema(input_tokens=3, output_tokens=7),
+        content=[
+            ClaudeContentSchema(type="text", text=" hello world 1 "),
+            ClaudeContentSchema(type="text", text=" hello world 2 "),
+        ],
+    )
+    assert resp.first_text == "hello world 1"
+
+
+def test_first_text_empty_if_no_content():
+    resp = ClaudeChatResponseSchema(
+        id="123",
+        role="assistant",
+        usage=ClaudeUsageSchema(input_tokens=1, output_tokens=2),
+        content=[],
+    )
+    assert resp.first_text == ""
+
+
+# ---------- ClaudeChatRequestSchema ----------
+
+def test_chat_request_schema_builds_ok():
+    msg = ClaudeMessageSchema(role="user", content="hello")
+    req = ClaudeChatRequestSchema(
+        model="claude-3-sonnet",
+        system="You are a helpful assistant",
+        messages=[msg],
+        max_tokens=512,
+        temperature=0.3,
+    )
+
+    assert req.model == "claude-3-sonnet"
+    assert req.system == "You are a helpful assistant"
+    assert req.messages[0].role == "user"
+    assert req.messages[0].content == "hello"
+    assert req.max_tokens == 512
+    assert req.temperature == 0.3

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

@@ -0,0 +1,30 @@
+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)
+
+
+def test_get_gemini_http_client_builds_ok():
+    gemini_http_client = get_gemini_http_client()
+
+    assert isinstance(gemini_http_client, GeminiHTTPClient)
+    assert isinstance(gemini_http_client.client, AsyncClient)

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

@@ -0,0 +1,105 @@
+from ai_review.clients.gemini.schema import (
+    GeminiPartSchema,
+    GeminiUsageSchema,
+    GeminiContentSchema,
+    GeminiCandidateSchema,
+    GeminiGenerationConfigSchema,
+    GeminiChatRequestSchema,
+    GeminiChatResponseSchema,
+)
+
+
+# ---------- GeminiUsageSchema ----------
+
+def test_usage_total_tokens_prefers_total_tokens_count():
+    usage = GeminiUsageSchema(
+        prompt_token_count=10,
+        total_tokens_count=99,
+        candidates_token_count=5,
+        output_thoughts_token_count=3,
+    )
+    assert usage.total_tokens == 99  # приоритет у totalTokenCount
+
+
+def test_usage_total_tokens_falls_back_to_sum():
+    usage = GeminiUsageSchema(
+        prompt_token_count=10,
+        candidates_token_count=5,
+        output_thoughts_token_count=3,
+    )
+    # 10 + 5 + 3
+    assert usage.total_tokens == 18
+
+
+def test_usage_prompt_tokens_and_completion_from_candidates():
+    usage = GeminiUsageSchema(
+        prompt_token_count=7,
+        candidates_token_count=2,
+    )
+    assert usage.prompt_tokens == 7
+    assert usage.completion_tokens == 2
+
+
+def test_usage_completion_tokens_from_output_thoughts():
+    usage = GeminiUsageSchema(
+        prompt_token_count=7,
+        output_thoughts_token_count=5,
+    )
+    assert usage.completion_tokens == 5
+
+
+def test_usage_completion_tokens_none_if_not_provided():
+    usage = GeminiUsageSchema(prompt_token_count=7)
+    assert usage.completion_tokens is None
+
+
+# ---------- GeminiChatResponseSchema ----------
+
+def test_first_text_returns_text():
+    resp = GeminiChatResponseSchema(
+        usage=GeminiUsageSchema(prompt_token_count=3, total_tokens_count=5),
+        candidates=[
+            GeminiCandidateSchema(
+                content=GeminiContentSchema(
+                    role="model",
+                    parts=[GeminiPartSchema(text=" hello world ")],
+                )
+            )
+        ],
+    )
+    assert resp.first_text == "hello world"
+
+
+def test_first_text_empty_if_no_candidates():
+    resp = GeminiChatResponseSchema(
+        usage=GeminiUsageSchema(prompt_token_count=1, total_tokens_count=2),
+        candidates=[],
+    )
+    assert resp.first_text == ""
+
+
+def test_first_text_empty_if_parts_missing():
+    resp = GeminiChatResponseSchema(
+        usage=GeminiUsageSchema(prompt_token_count=1, total_tokens_count=2),
+        candidates=[
+            GeminiCandidateSchema(content=GeminiContentSchema(role="model", parts=[]))
+        ],
+    )
+    assert resp.first_text == ""
+
+
+# ---------- GeminiChatRequestSchema ----------
+
+def test_chat_request_schema_builds_ok():
+    content = GeminiContentSchema(role="user", parts=[GeminiPartSchema(text="hi")])
+    gen_cfg = GeminiGenerationConfigSchema(temperature=0.5, max_output_tokens=128)
+
+    req = GeminiChatRequestSchema(
+        contents=[content],
+        generation_config=gen_cfg,
+        system_instruction=GeminiContentSchema(role="system", parts=[GeminiPartSchema(text="sys")]),
+    )
+
+    assert req.contents[0].parts[0].text == "hi"
+    assert req.generation_config.max_output_tokens == 128
+    assert req.system_instruction.parts[0].text == "sys"

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

@@ -0,0 +1,30 @@
+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)
+
+
+def test_get_openai_http_client_builds_ok():
+    openai_http_client = get_openai_http_client()
+
+    assert isinstance(openai_http_client, OpenAIHTTPClient)
+    assert isinstance(openai_http_client.client, AsyncClient)

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

@@ -0,0 +1,53 @@
+from ai_review.clients.openai.schema import (
+    OpenAIUsageSchema,
+    OpenAIMessageSchema,
+    OpenAIChoiceSchema,
+    OpenAIChatRequestSchema,
+    OpenAIChatResponseSchema,
+)
+
+
+# ---------- OpenAIChatResponseSchema ----------
+
+def test_first_text_returns_text():
+    resp = OpenAIChatResponseSchema(
+        usage=OpenAIUsageSchema(total_tokens=5, prompt_tokens=2, completion_tokens=3),
+        choices=[
+            OpenAIChoiceSchema(
+                message=OpenAIMessageSchema(role="assistant", content=" hello world ")
+            )
+        ],
+    )
+    assert resp.first_text == "hello world"
+
+
+def test_first_text_empty_if_no_choices():
+    resp = OpenAIChatResponseSchema(
+        usage=OpenAIUsageSchema(total_tokens=1, prompt_tokens=1, completion_tokens=0),
+        choices=[],
+    )
+    assert resp.first_text == ""
+
+
+def test_first_text_strips_and_handles_empty_content():
+    resp = OpenAIChatResponseSchema(
+        usage=OpenAIUsageSchema(total_tokens=1, prompt_tokens=1, completion_tokens=0),
+        choices=[OpenAIChoiceSchema(message=OpenAIMessageSchema(role="assistant", content="   "))],
+    )
+    assert resp.first_text == ""
+
+
+# ---------- OpenAIChatRequestSchema ----------
+
+def test_chat_request_schema_builds_ok():
+    msg = OpenAIMessageSchema(role="user", content="hello")
+    req = OpenAIChatRequestSchema(
+        model="gpt-4o-mini",
+        messages=[msg],
+        max_tokens=100,
+        temperature=0.3,
+    )
+    assert req.model == "gpt-4o-mini"
+    assert req.messages[0].content == "hello"
+    assert req.max_tokens == 100
+    assert req.temperature == 0.3

ai_review/tests/suites/libs/diff/test_models.py

@@ -0,0 +1,105 @@
+import pytest
+
+from ai_review.libs.diff.models import (
+    DiffLine,
+    DiffLineType,
+    DiffRange,
+    DiffHunk,
+    DiffFile,
+    Diff,
+    FileMode,
+)
+
+
+# ---------- fixtures ----------
+
+@pytest.fixture
+def diff_file_modified() -> DiffFile:
+    """
+    Create a DiffFile with a single hunk containing:
+      - one unchanged line "A"
+      - one removed line "X"
+      - one unchanged line "B"
+      - one added line "Y"
+    """
+    orig_lines = [
+        DiffLine(DiffLineType.UNCHANGED, 1, "A", 1),
+        DiffLine(DiffLineType.REMOVED, 2, "X", 2),
+        DiffLine(DiffLineType.UNCHANGED, 3, "B", 3),
+    ]
+    new_lines = [
+        DiffLine(DiffLineType.UNCHANGED, 1, "A", 1),
+        DiffLine(DiffLineType.UNCHANGED, 2, "B", 2),
+        DiffLine(DiffLineType.ADDED, 3, "Y", 3),
+    ]
+
+    hunk = DiffHunk(
+        header="test hunk",
+        orig_range=DiffRange(start=1, length=3, lines=orig_lines),
+        new_range=DiffRange(start=1, length=3, lines=new_lines),
+        lines=[*orig_lines, new_lines[-1]],
+    )
+
+    return DiffFile(
+        header="diff --git a/file b/file",
+        mode=FileMode.MODIFIED,
+        orig_name="a/file",
+        new_name="b/file",
+        hunks=[hunk],
+    )
+
+
+@pytest.fixture
+def diff_with_modified_file(diff_file_modified: DiffFile) -> Diff:
+    """Return a Diff object containing a single modified file."""
+    return Diff(files=[diff_file_modified], raw="raw-diff-here")
+
+
+# ---------- tests ----------
+
+def test_added_and_removed_lines(diff_file_modified: DiffFile) -> None:
+    """added_new_lines/removed_old_lines should return correct DiffLine objects."""
+    added = [line.content for line in diff_file_modified.added_new_lines()]
+    removed = [line.content for line in diff_file_modified.removed_old_lines()]
+
+    assert added == ["Y"]
+    assert removed == ["X"]
+
+
+def test_added_and_removed_line_numbers(diff_file_modified: DiffFile) -> None:
+    """added_line_numbers/removed_line_numbers should return correct sets of numbers."""
+    assert diff_file_modified.added_line_numbers() == {3}
+    assert diff_file_modified.removed_line_numbers() == {2}
+
+
+def test_diff_summary(diff_with_modified_file: Diff) -> None:
+    """Diff.summary should include file mode, file name, and hunk info."""
+    summary = diff_with_modified_file.summary()
+
+    assert "MODIFIED b/file" in summary
+    assert "Hunk: test hunk" in summary
+    assert "(4 lines)" in summary  # total lines in hunk.lines
+
+
+def test_changed_lines_and_files(diff_with_modified_file: Diff) -> None:
+    """changed_lines should map added line numbers; changed_files should list modified files."""
+    changed = diff_with_modified_file.changed_lines()
+    files = diff_with_modified_file.changed_files()
+
+    assert changed == {"b/file": [3]}
+    assert files == ["b/file"]
+
+
+def test_changed_files_skips_deleted(diff_file_modified: DiffFile) -> None:
+    """Files with mode=DELETED should not appear in changed_files or changed_lines."""
+    deleted_file = DiffFile(
+        header="diff --git a/deleted b/deleted",
+        mode=FileMode.DELETED,
+        orig_name="a/deleted",
+        new_name="b/deleted",
+        hunks=[],
+    )
+    diff = Diff(files=[diff_file_modified, deleted_file], raw="raw")
+
+    assert "b/deleted" not in diff.changed_files()
+    assert "b/deleted" not in diff.changed_lines()

ai_review/tests/suites/libs/diff/test_parser.py

@@ -0,0 +1,115 @@
+from ai_review.libs.diff.models import FileMode, DiffLineType, DiffFile
+from ai_review.libs.diff.parser import DiffParser
+
+
+# ---------- helpers ----------
+
+
+def parse_and_get_file(raw_diff: str) -> DiffFile:
+    """Helper: parse diff and return the first file."""
+    diff = DiffParser.parse(raw_diff)
+    assert diff.files, "Expected at least one parsed file"
+    return diff.files[0]
+
+
+# ---------- tests ----------
+
+def test_parse_added_lines_only() -> None:
+    """Should correctly parse diff with only added lines."""
+    raw_diff = """diff --git a/x b/x
+index 0000000..1111111 100644
+--- a/x
++++ b/x
+@@ -0,0 +1,2 @@
++line1
++line2
+"""
+    file = parse_and_get_file(raw_diff)
+
+    assert file.mode == FileMode.MODIFIED
+    assert file.orig_name == "x"
+    assert file.new_name == "x"
+    assert len(file.hunks) == 1
+
+    added_lines: list[str] = [
+        line.content for line in file.hunks[0].new_range.lines if line.type is DiffLineType.ADDED
+    ]
+    assert added_lines == ["line1", "line2"]
+
+
+def test_parse_removed_lines_only() -> None:
+    """Should correctly parse diff with only removed lines."""
+    raw_diff = """diff --git a/x b/x
+index 2222222..3333333 100644
+--- a/x
++++ b/x
+@@ -1,2 +0,0 @@
+-line1
+-line2
+"""
+    file = parse_and_get_file(raw_diff)
+
+    assert file.mode == FileMode.MODIFIED
+    removed_lines: list[str] = [
+        line.content for line in file.hunks[0].orig_range.lines if line.type is DiffLineType.REMOVED
+    ]
+    assert removed_lines == ["line1", "line2"]
+
+
+def test_parse_added_and_removed_lines() -> None:
+    """Should parse diff with added, removed and unchanged lines."""
+    raw_diff = """diff --git a/x b/x
+index 4444444..5555555 100644
+--- a/x
++++ b/x
+@@ -1,3 +1,3 @@
+ line1
+-line2
++line2_changed
+ line3
+"""
+    file = parse_and_get_file(raw_diff)
+    hunk = file.hunks[0]
+
+    assert [line.content for line in hunk.lines] == [
+        "line1",
+        "line2",
+        "line2_changed",
+        "line3",
+    ]
+    assert hunk.lines[0].type == DiffLineType.UNCHANGED
+    assert hunk.lines[1].type == DiffLineType.REMOVED
+    assert hunk.lines[2].type == DiffLineType.ADDED
+    assert hunk.lines[3].type == DiffLineType.UNCHANGED
+
+
+def test_parse_new_file_mode() -> None:
+    """Should mark file as NEW when old side is /dev/null."""
+    raw_diff = """diff --git a/x b/x
+new file mode 100644
+--- /dev/null
++++ b/x
+@@ -0,0 +1,1 @@
++new line
+"""
+    file = parse_and_get_file(raw_diff)
+
+    assert file.mode == FileMode.NEW
+    assert file.new_name == "x"
+    assert [line.content for line in file.hunks[0].new_range.lines] == ["new line"]
+
+
+def test_parse_deleted_file_mode() -> None:
+    """Should mark file as DELETED when new side is /dev/null."""
+    raw_diff = """diff --git a/x b/x
+deleted file mode 100644
+--- a/x
++++ /dev/null
+@@ -1,1 +0,0 @@
+-old line
+"""
+    file = parse_and_get_file(raw_diff)
+
+    assert file.mode == FileMode.DELETED
+    assert file.orig_name == "x"
+    assert [line.content for line in file.hunks[0].orig_range.lines] == ["old line"]

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

@@ -0,0 +1,62 @@
+import pytest
+
+from ai_review.libs.diff import tools
+from ai_review.libs.diff.models import DiffLineType
+
+
+# ---------- tests: is_source_line ----------
+
+def test_is_source_line_regular_added():
+    """Should return True for a normal added line (+content)."""
+    assert tools.is_source_line("+foo") is True
+
+
+def test_is_source_line_regular_removed():
+    """Should return True for a normal removed line (-content)."""
+    assert tools.is_source_line("-bar") is True
+
+
+def test_is_source_line_regular_unchanged():
+    """Should return True for a normal unchanged line (space prefix)."""
+    assert tools.is_source_line(" baz") is True
+
+
+def test_is_source_line_no_newline_marker():
+    """Should return False for the special diff marker line."""
+    assert tools.is_source_line(r"") is False
+
+
+def test_is_source_line_empty_or_headers():
+    """Should return False for empty line or diff headers (---/+++)."""
+    assert tools.is_source_line("") is False
+    assert tools.is_source_line("--- a/file.py") is False
+    assert tools.is_source_line("+++ b/file.py") is False
+
+
+# ---------- tests: get_line_type ----------
+
+def test_get_line_type_added():
+    """Should classify '+' prefix as ADDED."""
+    assert tools.get_line_type("+foo") == DiffLineType.ADDED
+
+
+def test_get_line_type_removed():
+    """Should classify '-' prefix as REMOVED."""
+    assert tools.get_line_type("-bar") == DiffLineType.REMOVED
+
+
+def test_get_line_type_unchanged():
+    """Should classify ' ' prefix as UNCHANGED."""
+    assert tools.get_line_type(" baz") == DiffLineType.UNCHANGED
+
+
+def test_get_line_type_empty_raises():
+    """Should raise ValueError if line is empty."""
+    with pytest.raises(ValueError):
+        tools.get_line_type("")
+
+
+def test_get_line_type_unknown_prefix_raises():
+    """Should raise ValueError if line starts with unknown prefix."""
+    with pytest.raises(ValueError):
+        tools.get_line_type("@@ -1,2 +1,2 @@")