test: расширить unit и smoke покрытие ключевых модулей

- Добавлены тесты для limits, refresh guard, routes health и metrics

- Добавлены тесты для database/redis и модуля метрик

- Усилены сценарии jwt, password и auth service

- Добавлены unit тесты для task и tag сервисов

Author: RomanVetrov

tests/unit/limits/test_service.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import cast
+from unittest.mock import AsyncMock
+
+import pytest
+from fastapi import HTTPException
+from redis.asyncio import Redis
+
+from app.limits.service import enforce_rate_limit
+
+
+@pytest.fixture
+def fake_redis() -> Redis:
+    """Создаёт фейковый Redis-клиент для проверки логики rate limit."""
+    redis = cast(Redis, AsyncMock(spec=Redis))
+    redis.eval = AsyncMock()
+    redis.ttl = AsyncMock()
+    return redis
+
+
+@pytest.mark.asyncio
+async def test_enforce_rate_limit_allows_requests_within_limit(
+    fake_redis: Redis,
+) -> None:
+    """Проверяет, что при current <= limit функция не выбрасывает исключение."""
+    cast(AsyncMock, fake_redis.eval).return_value = 5
+
+    await enforce_rate_limit(
+        fake_redis,
+        key="rl:test:ip:127.0.0.1",
+        limit=5,
+        window_seconds=60,
+    )
+
+    cast(AsyncMock, fake_redis.ttl).assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_enforce_rate_limit_raises_429_with_retry_after(
+    fake_redis: Redis,
+) -> None:
+    """Проверяет, что превышение лимита даёт 429 и корректный Retry-After."""
+    cast(AsyncMock, fake_redis.eval).return_value = 11
+    cast(AsyncMock, fake_redis.ttl).return_value = 15
+
+    with pytest.raises(HTTPException) as exc:
+        await enforce_rate_limit(
+            fake_redis,
+            key="rl:test:ip:127.0.0.1",
+            limit=10,
+            window_seconds=60,
+        )
+
+    assert exc.value.status_code == 429
+    assert exc.value.headers == {"Retry-After": "15"}
+    assert "15 сек." in exc.value.detail
+
+
+@pytest.mark.asyncio
+async def test_enforce_rate_limit_fallbacks_retry_after_to_one(
+    fake_redis: Redis,
+) -> None:
+    """Проверяет fallback Retry-After=1, если Redis вернул TTL <= 0."""
+    cast(AsyncMock, fake_redis.eval).return_value = 3
+    cast(AsyncMock, fake_redis.ttl).return_value = 0
+
+    with pytest.raises(HTTPException) as exc:
+        await enforce_rate_limit(
+            fake_redis,
+            key="rl:test:ip:127.0.0.1",
+            limit=2,
+            window_seconds=60,
+        )
+
+    assert exc.value.status_code == 429
+    assert exc.value.headers == {"Retry-After": "1"}

tests/unit/routes/test_health_routes.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import cast
+from unittest.mock import AsyncMock
+
+import pytest
+from redis.asyncio import Redis
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.routes.health import db_health, redis_health
+
+
+@pytest.fixture
+def fake_redis() -> Redis:
+    """Создаёт фейковый Redis для smoke-тестов health-роута."""
+    redis = cast(Redis, AsyncMock(spec=Redis))
+    redis.ping = AsyncMock()
+    return redis
+
+
+@pytest.fixture
+def fake_session() -> AsyncSession:
+    """Создаёт фейковую AsyncSession для smoke-тестов health-роута."""
+    session = cast(AsyncSession, AsyncMock(spec=AsyncSession))
+    session.execute = AsyncMock()
+    return session
+
+
+@pytest.mark.asyncio
+async def test_redis_health_reports_ok(fake_redis: Redis) -> None:
+    """Проверяет, что /health/redis возвращает ok, когда Redis отвечает True."""
+    cast(AsyncMock, fake_redis.ping).return_value = True
+
+    result = await redis_health(redis=fake_redis)
+
+    assert result == {"redis": "ok"}
+
+
+@pytest.mark.asyncio
+async def test_redis_health_reports_down(fake_redis: Redis) -> None:
+    """Проверяет, что /health/redis возвращает down, когда Redis отвечает False."""
+    cast(AsyncMock, fake_redis.ping).return_value = False
+
+    result = await redis_health(redis=fake_redis)
+
+    assert result == {"redis": "down"}
+
+
+@pytest.mark.asyncio
+async def test_db_health_executes_ping_query(fake_session: AsyncSession) -> None:
+    """Проверяет, что /health/db выполняет SELECT 1 и возвращает ok."""
+    result = await db_health(session=fake_session)
+
+    assert result == {"db": "ok"}
+    cast(AsyncMock, fake_session.execute).assert_awaited_once()

tests/unit/routes/test_metrics_route.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+import pytest
+
+from app.routes import metrics as metrics_route
+
+
+@pytest.mark.asyncio
+async def test_metrics_route_returns_response_from_render_metrics(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет, что /metrics возвращает body и media_type, полученные из render_metrics."""
+    render_metrics = Mock(
+        return_value=(b"# test metrics\n", "text/plain; version=0.0.4")
+    )
+    monkeypatch.setattr(metrics_route, "render_metrics", render_metrics)
+
+    response = await metrics_route.metrics()
+
+    assert response.body == b"# test metrics\n"
+    assert response.media_type == "text/plain; version=0.0.4"

tests/unit/security/test_dependences.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from typing import Any, cast
+from unittest.mock import AsyncMock, Mock
+from uuid import uuid4
+
+import pytest
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.user import User
+from app.security import dependences as auth_dep
+from app.security.jwt import TokenData, TokenInvalid
+
+
+@pytest.fixture
+def fake_session() -> AsyncSession:
+    """Создаёт фейковую AsyncSession для unit-тестов зависимости авторизации."""
+    return cast(AsyncSession, AsyncMock(spec=AsyncSession))
+
+
+def _make_user(*, is_active: bool = True) -> User:
+    """Создаёт лёгкий объект пользователя для тестирования веток get_current_user."""
+    return cast(
+        User,
+        SimpleNamespace(
+            id=uuid4(),
+            email="user@example.com",
+            hashed_password="hashed",
+            is_active=is_active,
+            created_at=datetime.now(UTC),
+        ),
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_returns_active_user(
+    fake_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет успешный путь: валидный токен и активный пользователь возвращаются как результат."""
+    user = _make_user(is_active=True)
+    decode_access_token = Mock(
+        return_value=TokenData(sub=str(user.id), payload={"type": "access"})
+    )
+    get_user_by_id = AsyncMock(return_value=user)
+    monkeypatch.setattr(auth_dep, "decode_access_token", cast(Any, decode_access_token))
+    monkeypatch.setattr(auth_dep, "get_user_by_id", cast(Any, get_user_by_id))
+
+    result = await auth_dep.get_current_user(token="access-token", session=fake_session)
+
+    assert result is user
+    get_user_by_id.assert_awaited_once_with(fake_session, user.id)
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_raises_401_for_invalid_token(
+    fake_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет, что невалидный токен приводит к 401 и заголовку WWW-Authenticate."""
+    decode_access_token = Mock(side_effect=TokenInvalid("bad token"))
+    monkeypatch.setattr(auth_dep, "decode_access_token", cast(Any, decode_access_token))
+
+    with pytest.raises(HTTPException) as exc:
+        await auth_dep.get_current_user(token="broken-token", session=fake_session)
+
+    assert exc.value.status_code == 401
+    assert exc.value.headers == {"WWW-Authenticate": "Bearer"}
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_raises_401_for_invalid_subject(
+    fake_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет ветку с некорректным sub в токене: должен возвращаться 401."""
+    decode_access_token = Mock(
+        return_value=TokenData(sub="not-a-uuid", payload={"type": "access"})
+    )
+    monkeypatch.setattr(auth_dep, "decode_access_token", cast(Any, decode_access_token))
+
+    with pytest.raises(HTTPException) as exc:
+        await auth_dep.get_current_user(token="access-token", session=fake_session)
+
+    assert exc.value.status_code == 401
+    assert exc.value.detail == "Некорректный идентификатор в токене"
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_raises_401_when_user_not_found(
+    fake_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет, что при отсутствии пользователя в БД зависимость возвращает 401."""
+    user_id = uuid4()
+    decode_access_token = Mock(
+        return_value=TokenData(sub=str(user_id), payload={"type": "access"})
+    )
+    get_user_by_id = AsyncMock(return_value=None)
+    monkeypatch.setattr(auth_dep, "decode_access_token", cast(Any, decode_access_token))
+    monkeypatch.setattr(auth_dep, "get_user_by_id", cast(Any, get_user_by_id))
+
+    with pytest.raises(HTTPException) as exc:
+        await auth_dep.get_current_user(token="access-token", session=fake_session)
+
+    assert exc.value.status_code == 401
+    assert exc.value.detail == "Сессия недействительна (пользователь не найден)"
+
+
+@pytest.mark.asyncio
+async def test_get_current_user_raises_403_for_inactive_user(
+    fake_session: AsyncSession,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет, что неактивный пользователь получает 403 в зависимости get_current_user."""
+    user = _make_user(is_active=False)
+    decode_access_token = Mock(
+        return_value=TokenData(sub=str(user.id), payload={"type": "access"})
+    )
+    get_user_by_id = AsyncMock(return_value=user)
+    monkeypatch.setattr(auth_dep, "decode_access_token", cast(Any, decode_access_token))
+    monkeypatch.setattr(auth_dep, "get_user_by_id", cast(Any, get_user_by_id))
+
+    with pytest.raises(HTTPException) as exc:
+        await auth_dep.get_current_user(token="access-token", session=fake_session)
+
+    assert exc.value.status_code == 403
+    assert exc.value.detail == "Аккаунт заблокирован. Обратитесь в поддержку."

tests/unit/security/test_jwt.py

@@ -6,6 +6,7 @@
 import pytest
 
 from app.config import settings
+from app.security import jwt as jwt_service
 from app.security.jwt import (
     TokenExpired,
     TokenInvalid,
@@ -21,6 +22,7 @@ def _unix_now() -> int:
 
 
 def test_create_and_decode_access_token_roundtrip() -> None:
+    """Проверяет, что access-токен корректно создаётся и декодируется обратно."""
     token = create_access_token(subject="user-123")
 
     decoded = decode_access_token(token)
@@ -30,13 +32,15 @@ def test_create_and_decode_access_token_roundtrip() -> None:
 
 
 def test_decode_access_token_rejects_refresh_token() -> None:
+    """Проверяет, что refresh-токен нельзя декодировать как access-токен."""
     refresh_token, _ = create_refresh_token(subject="user-123")
 
     with pytest.raises(TokenInvalid, match="Ожидался access токен"):
         decode_access_token(refresh_token)
 
 
 def test_decode_refresh_token_requires_jti() -> None:
+    """Проверяет, что refresh-токен без jti отвергается как невалидный."""
     payload = {
         "sub": "user-123",
         "iat": _unix_now(),
@@ -54,10 +58,68 @@ def test_decode_refresh_token_requires_jti() -> None:
 
 
 def test_decode_access_token_raises_for_expired_token() -> None:
+    """Проверяет, что истёкший access-токен приводит к TokenExpired."""
     expired_token = create_access_token(
         subject="user-123",
         expires_delta=timedelta(seconds=-1),
     )
 
     with pytest.raises(TokenExpired, match="истёк"):
         decode_access_token(expired_token)
+
+
+def test_create_access_token_merges_extra_claims() -> None:
+    """Проверяет, что custom claims попадают в payload access-токена."""
+    token = create_access_token(
+        subject="user-123",
+        extra_claims={"role": "admin"},
+    )
+
+    decoded = decode_access_token(token)
+
+    assert decoded.payload["role"] == "admin"
+
+
+def test_decode_access_token_rejects_non_string_subject(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Проверяет, что _decode_token отклоняет payload с нестроковым sub."""
+    monkeypatch.setattr(
+        jwt_service.jwt,
+        "decode",
+        lambda **_: {
+            "sub": 123,
+            "iat": _unix_now(),
+            "exp": _unix_now() + 60,
+            "type": "access",
+        },
+    )
+
+    with pytest.raises(TokenInvalid, match="Ошибка субъекта"):
+        decode_access_token("token")
+
+
+def test_decode_access_token_rejects_unknown_token_type() -> None:
+    """Проверяет, что токен с произвольным type отклоняется как невалидный."""
+    payload = {
+        "sub": "user-123",
+        "iat": _unix_now(),
+        "exp": _unix_now() + 60,
+        "type": "unknown",
+    }
+    token = jwt.encode(
+        payload=payload,
+        key=settings.SECRET_KEY,
+        algorithm=settings.ALGORITHM,
+    )
+
+    with pytest.raises(TokenInvalid, match="Некорректный тип токена"):
+        decode_access_token(token)
+
+
+def test_decode_refresh_token_rejects_access_token_type() -> None:
+    """Проверяет, что access-токен нельзя декодировать как refresh-токен."""
+    access_token = create_access_token(subject="user-123")
+
+    with pytest.raises(TokenInvalid, match="Ожидался refresh токен"):
+        decode_refresh_token(access_token)