xai-review 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

ai_review/tests/fixtures/services/llm.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+import pytest
+
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
+
+
+class FakeLLMClient(LLMClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        self.calls.append(("chat", {"prompt": prompt, "prompt_system": prompt_system}))
+
+        return ChatResultSchema(
+            text=self.responses.get("text", "FAKE_RESPONSE"),
+            total_tokens=self.responses.get("total_tokens", 42),
+            prompt_tokens=self.responses.get("prompt_tokens", 21),
+            completion_tokens=self.responses.get("completion_tokens", 21),
+        )
+
+
+@pytest.fixture
+def fake_llm_client() -> FakeLLMClient:
+    return FakeLLMClient()

ai_review/tests/fixtures/services/prompt.py

@@ -0,0 +1,43 @@
+import pytest
+
+from ai_review.services.diff.schema import DiffFileSchema
+from ai_review.services.prompt.schema import PromptContextSchema
+from ai_review.services.prompt.types import PromptServiceProtocol
+
+
+class FakePromptService(PromptServiceProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    def prepare_prompt(self, prompts: list[str], context: PromptContextSchema) -> str:
+        self.calls.append(("prepare_prompt", {"prompts": prompts, "context": context}))
+        return "FAKE_PROMPT"
+
+    def build_inline_request(self, diff: DiffFileSchema, context: PromptContextSchema) -> str:
+        self.calls.append(("build_inline_request", {"diff": diff, "context": context}))
+        return f"INLINE_PROMPT_FOR_{diff.file}"
+
+    def build_summary_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        self.calls.append(("build_summary_request", {"diffs": diffs, "context": context}))
+        return "SUMMARY_PROMPT"
+
+    def build_context_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        self.calls.append(("build_context_request", {"diffs": diffs, "context": context}))
+        return "CONTEXT_PROMPT"
+
+    def build_system_inline_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_inline_request", {"context": context}))
+        return "SYSTEM_INLINE_PROMPT"
+
+    def build_system_context_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_context_request", {"context": context}))
+        return "SYSTEM_CONTEXT_PROMPT"
+
+    def build_system_summary_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_summary_request", {"context": context}))
+        return "SYSTEM_SUMMARY_PROMPT"
+
+
+@pytest.fixture
+def fake_prompt_service() -> FakePromptService:
+    return FakePromptService()

ai_review/tests/fixtures/services/review/inline.py

@@ -0,0 +1,25 @@
+import pytest
+
+from ai_review.services.review.inline.schema import InlineCommentListSchema, InlineCommentSchema
+from ai_review.services.review.inline.types import InlineCommentServiceProtocol
+
+
+class FakeInlineCommentService(InlineCommentServiceProtocol):
+    def __init__(self, comments: list[InlineCommentSchema] | None = None):
+        self.calls: list[tuple[str, dict]] = []
+        self.comments = comments or [
+            InlineCommentSchema(file="main.py", line=1, message="Test comment"),
+        ]
+
+    def parse_model_output(self, output: str) -> InlineCommentListSchema:
+        self.calls.append(("parse_model_output", {"output": output}))
+        return InlineCommentListSchema(root=self.comments)
+
+    def try_parse_model_output(self, raw: str) -> InlineCommentListSchema | None:
+        self.calls.append(("try_parse_model_output", {"raw": raw}))
+        return InlineCommentListSchema(root=self.comments)
+
+
+@pytest.fixture
+def fake_inline_comment_service() -> FakeInlineCommentService:
+    return FakeInlineCommentService()

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

@@ -0,0 +1,19 @@
+import pytest
+
+from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.summary.types import SummaryCommentServiceProtocol
+
+
+class FakeSummaryCommentService(SummaryCommentServiceProtocol):
+    def __init__(self, text: str = "This is a summary comment"):
+        self.text = text
+        self.calls: list[tuple[str, dict]] = []
+
+    def parse_model_output(self, output: str) -> SummaryCommentSchema:
+        self.calls.append(("parse_model_output", {"output": output}))
+        return SummaryCommentSchema(text=self.text)
+
+
+@pytest.fixture
+def fake_summary_comment_service() -> FakeSummaryCommentService:
+    return FakeSummaryCommentService()

ai_review/tests/fixtures/services/vcs.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+import pytest
+
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
+)
+
+
+class FakeVCSClient(VCSClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, tuple, dict]] = []
+        self.responses = responses or {}
+
+    async def get_review_info(self) -> ReviewInfoSchema:
+        self.calls.append(("get_review_info", (), {}))
+        return self.responses.get(
+            "get_review_info",
+            ReviewInfoSchema(changed_files=["file.py"], base_sha="A", head_sha="B")
+        )
+
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        self.calls.append(("get_general_comments", (), {}))
+        return self.responses.get("get_general_comments", [])
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        self.calls.append(("get_inline_comments", (), {}))
+        return self.responses.get("get_inline_comments", [])
+
+    async def create_general_comment(self, message: str) -> None:
+        self.calls.append(("create_general_comment", (message,), {}))
+        if error := self.responses.get("create_general_comment_error"):
+            raise error
+
+        return self.responses.get("create_general_comment_result", None)
+
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
+        self.calls.append(("create_inline_comment", (file, line, message), {}))
+        if error := self.responses.get("create_inline_comment_error"):
+            raise error
+
+        return self.responses.get("create_inline_comment_result", None)
+
+
+@pytest.fixture
+def fake_vcs_client() -> FakeVCSClient:
+    return FakeVCSClient()

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
@@ -69,16 +69,16 @@ def test_render_file_returns_unsupported(monkeypatch: pytest.MonkeyPatch, fake_d
 
 
 def test_render_files_invokes_render_file(
-        fake_git: FakeGitService,
         fake_diff: Diff,
         monkeypatch: pytest.MonkeyPatch,
+        fake_git_service: FakeGitService,
 ) -> None:
     monkeypatch.setattr("ai_review.services.diff.service.DiffParser.parse", lambda _: fake_diff)
     monkeypatch.setattr(config.settings.review, "mode", ReviewMode.FULL_FILE_DIFF)
 
-    fake_git.responses["get_diff_for_file"] = "fake-diff"
+    fake_git_service.responses["get_diff_for_file"] = "fake-diff"
 
-    out = DiffService.render_files(git=fake_git, base_sha="A", head_sha="B", files=["b/x"])
+    out = DiffService.render_files(git=fake_git_service, base_sha="A", head_sha="B", files=["b/x"])
     assert out
     assert out[0].file == "b/x"
     assert out[0].diff.startswith("# No matching lines for mode")

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 ----------
@@ -55,23 +55,23 @@ def test_find_diff_file_not_found_returns_none() -> None:
 
 # ---------- read_snapshot ----------
 
-def test_read_snapshot_prefers_git(monkeypatch: pytest.MonkeyPatch, fake_git: FakeGitService) -> None:
-    fake_git.responses["get_file_at_commit"] = "from git"
-    monkeypatch.setattr(tools, "GitService", lambda: fake_git)
+def test_read_snapshot_prefers_git(monkeypatch: pytest.MonkeyPatch, fake_git_service: FakeGitService) -> None:
+    fake_git_service.responses["get_file_at_commit"] = "from git"
+    monkeypatch.setattr(tools, "GitService", lambda: fake_git_service)
 
     assert tools.read_snapshot("foo.py", head_sha="HEAD") == "from git"
 
 
 def test_read_snapshot_fallback_to_filesystem(
         tmp_path: Path,
-        fake_git: FakeGitService,
         monkeypatch: pytest.MonkeyPatch,
+        fake_git_service: FakeGitService,
 ) -> None:
     file = tmp_path / "file.txt"
     file.write_text("hello")
 
-    fake_git.responses["get_file_at_commit"] = None
-    monkeypatch.setattr(tools, "GitService", lambda: fake_git)
+    fake_git_service.responses["get_file_at_commit"] = None
+    monkeypatch.setattr(tools, "GitService", lambda: fake_git_service)
 
     result = tools.read_snapshot(str(file))
     assert result == "hello"
@@ -79,11 +79,11 @@ def test_read_snapshot_fallback_to_filesystem(
 
 def test_read_snapshot_returns_none_if_missing(
         tmp_path: Path,
-        fake_git: FakeGitService,
         monkeypatch: pytest.MonkeyPatch,
+        fake_git_service: FakeGitService,
 ) -> None:
-    fake_git.responses["get_file_at_commit"] = None
-    monkeypatch.setattr(tools, "GitService", lambda: fake_git)
+    fake_git_service.responses["get_file_at_commit"] = None
+    monkeypatch.setattr(tools, "GitService", lambda: fake_git_service)
 
     assert tools.read_snapshot(str(tmp_path / "nope.txt")) is None
 

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

@@ -0,0 +1,93 @@
+import pytest
+
+from ai_review.services.cost.schema import CostReportSchema
+from ai_review.services.hook.constants import HookType
+from ai_review.services.hook.service import HookService
+
+
+@pytest.fixture
+def hook_service() -> HookService:
+    """Return a fresh HookService instance for each test."""
+    return HookService()
+
+
+@pytest.mark.asyncio
+async def test_inject_and_emit_simple(hook_service: HookService):
+    """
+    Should register hook and invoke it with emitted args.
+    """
+    results = []
+
+    async def sample_hook(arg1: str, arg2: int):
+        results.append((arg1, arg2))
+
+    hook_service.inject_hook(HookType.ON_CHAT_START, sample_hook)
+    await hook_service.emit(HookType.ON_CHAT_START, "hi", 42)
+
+    assert results == [("hi", 42)]
+
+
+@pytest.mark.asyncio
+async def test_emit_without_hooks_does_nothing(hook_service: HookService):
+    """
+    If no hooks are registered, emit should silently return.
+    """
+    await hook_service.emit(HookType.ON_CHAT_COMPLETE, "text")
+
+
+@pytest.mark.asyncio
+async def test_emit_handles_hook_exception(monkeypatch: pytest.MonkeyPatch, hook_service: HookService):
+    """
+    Should catch exceptions in hook and log them, without breaking flow.
+    """
+    errors = []
+
+    async def failing_hook():
+        raise ValueError("Boom!")
+
+    def fake_logger_exception(message: str):
+        errors.append(message)
+
+    monkeypatch.setattr("ai_review.services.hook.service.logger.exception", fake_logger_exception)
+    hook_service.inject_hook(HookType.ON_CHAT_COMPLETE, failing_hook)
+
+    await hook_service.emit(HookType.ON_CHAT_COMPLETE)
+    assert any("Boom!" in message for message in errors)
+
+
+@pytest.mark.asyncio
+async def test_on_chat_start_decorator_registers_hook(hook_service: HookService):
+    """
+    Using @on_chat_start should register the callback.
+    """
+    results = []
+
+    @hook_service.on_chat_start
+    async def chat_start_hook(prompt: str, prompt_system: str):
+        results.append((prompt, prompt_system))
+
+    await hook_service.emit_chat_start("Hello", "SYS")
+    assert results == [("Hello", "SYS")]
+
+
+@pytest.mark.asyncio
+async def test_on_chat_complete_decorator_registers_hook(hook_service: HookService):
+    """
+    Using @on_chat_complete should register and trigger hook.
+    """
+    results = []
+
+    @hook_service.on_chat_complete
+    async def chat_complete_hook(result: str, report: CostReportSchema | None):
+        results.append((result, report))
+
+    cost_report = CostReportSchema(
+        model="gpt",
+        prompt_tokens=10,
+        completion_tokens=100,
+        total_cost=26,
+        input_cost=10.5,
+        output_cost=15.5
+    )
+    await hook_service.emit_chat_complete("done", cost_report)
+    assert results == [("done", cost_report)]

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()

ai_review/tests/suites/services/review/inline/test_schema.py

@@ -1,3 +1,5 @@
+import pytest
+
 from ai_review.config import settings
 from ai_review.services.review.inline.schema import (
     InlineCommentSchema,
@@ -7,14 +9,14 @@ from ai_review.services.review.inline.schema import (
 
 def test_normalize_file_and_message():
     comment = InlineCommentSchema(file=" \\src\\main.py ", line=10, message="  fix bug  ")
-    assert comment.file == "src/main.py"  # нормализуется и слеши, и пробелы
-    assert comment.message == "fix bug"  # пробелы убраны
+    assert comment.file == "src/main.py"
+    assert comment.message == "fix bug"
 
 
 def test_body_without_suggestion():
     comment = InlineCommentSchema(file="a.py", line=1, message="use f-string")
     assert comment.body == "use f-string"
-    assert settings.review.inline_tag not in comment.body  # тег ещё не добавлен
+    assert settings.review.inline_tag not in comment.body
 
 
 def test_body_with_suggestion():
@@ -31,18 +33,17 @@ def test_body_with_suggestion():
     assert comment.body == expected
 
 
-def test_body_with_tag(monkeypatch):
+def test_body_with_tag(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(settings.review, "inline_tag", "#ai-inline")
     comment = InlineCommentSchema(file="a.py", line=3, message="something")
     assert comment.body_with_tag.endswith("\n\n#ai-inline")
+    assert settings.review.inline_tag not in comment.body
 
 
-def test_fallback_body_with_tag(monkeypatch):
+def test_fallback_body(monkeypatch: pytest.MonkeyPatch):
     monkeypatch.setattr(settings.review, "inline_tag", "#ai-inline")
     comment = InlineCommentSchema(file="a.py", line=42, message="missing check")
-    body = comment.fallback_body_with_tag
-    assert body.startswith("**a.py:42** — missing check")
-    assert "#ai-inline" in body
+    assert comment.fallback_body.startswith("**a.py:42** — missing check")
 
 
 def test_dedup_key_differs_on_message_and_suggestion():
@@ -53,7 +54,7 @@ def test_dedup_key_differs_on_message_and_suggestion():
 
 def test_list_dedupe_removes_duplicates():
     c1 = InlineCommentSchema(file="a.py", line=1, message="msg one")
-    c2 = InlineCommentSchema(file="a.py", line=1, message="msg one")  # дубликат
+    c2 = InlineCommentSchema(file="a.py", line=1, message="msg one")
     c3 = InlineCommentSchema(file="a.py", line=2, message="msg two")
 
     comment_list = InlineCommentListSchema(root=[c1, c2, c3])

ai_review/tests/suites/services/review/summary/test_schema.py

@@ -18,5 +18,4 @@ def test_body_with_tag_appends_tag(monkeypatch):
     body = comment.body_with_tag
     assert body.startswith("Review passed")
     assert body.endswith("\n\n#ai-summary")
-    # убедимся, что перенос строки присутствует
     assert "\n\n#ai-summary" in body