feat: добавить dashboard и readiness

- добавить endpoint /api/v1/dashboard с параллельной агрегацией данных
- добавить readiness-check для БД и Redis
- покрыть новые ручки API- и unit-тестами

Author: RomanVetrov

app/main.py

@@ -7,6 +7,7 @@
 from app.middleware import LoggingMiddleware, MetricsMiddleware, RequestIDMiddleware
 from app.redis import redis_client
 from app.routes.auth import router as auth_router
+from app.routes.dashboard import router as dashboard_router
 from app.routes.health import router as health_router
 from app.routes.metrics import router as metrics_router
 from app.routes.tags import router as tags_router
@@ -46,5 +47,6 @@ async def lifespan(app: FastAPI):
 app.include_router(metrics_router)
 app.include_router(auth_router, prefix=API_V1_PREFIX)
 app.include_router(health_router, prefix=API_V1_PREFIX)
+app.include_router(dashboard_router, prefix=API_V1_PREFIX)
 app.include_router(tasks_router, prefix=API_V1_PREFIX)
 app.include_router(tags_router, prefix=API_V1_PREFIX)

app/repositories/task_repo.py

@@ -3,7 +3,7 @@
 from collections.abc import Sequence
 from uuid import UUID
 
-from sqlalchemy import asc, desc, or_, select
+from sqlalchemy import asc, desc, func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.task import Task
@@ -67,6 +67,22 @@ async def get_tasks_by_user(
     return result.scalars().all()
 
 
+async def get_task_counts_by_status(
+    session: AsyncSession, user: User
+) -> dict[str, int]:
+    """Возвращает количество задач пользователя по статусам (todo, in_progress, done)."""
+    stmt = (
+        select(Task.status, func.count(Task.id))
+        .where(Task.user_id == user.id)
+        .group_by(Task.status)
+    )
+    result = await session.execute(stmt)
+    counts = {"todo": 0, "in_progress": 0, "done": 0}
+    for status_val, count in result.all():
+        counts[status_val] = count
+    return counts
+
+
 async def create_task(session: AsyncSession, user: User, **data) -> Task:
     """Создаёт задачу для пользователя."""
     task = Task(**data, user_id=user.id)

app/routes/dashboard.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.get_or_404 import CurrentUser
+from app.repositories import task_repo
+from app.schemas.dashboard import DashboardRead, TaskCountsByStatus
+from app.schemas.tag import TagRead
+from app.schemas.task import TaskListFilters, TaskRead
+from app.services import tag as tag_service
+from app.services import task as task_service
+
+router = APIRouter(prefix="/dashboard", tags=["dashboard"])
+DbSession = Annotated[AsyncSession, Depends(get_db)]
+
+# Ограниченный набор задач для дашборда (последние по дате создания).
+_DASHBOARD_TASK_LIMIT = 10
+
+
+@router.get("", summary="Дашборд: задачи, теги и счётчики по статусам")
+async def get_dashboard(
+    current_user: CurrentUser,
+    session: DbSession,
+) -> DashboardRead:
+    """Возвращает задачи (с лимитом), теги и счётчики задач по статусам.
+    Три независимых чтения выполняются параллельно (asyncio.gather).
+    """
+    filters = TaskListFilters(limit=_DASHBOARD_TASK_LIMIT, offset=0)
+    tasks_result, tags_result, counts_result = await asyncio.gather(
+        task_service.get_user_tasks(session, current_user, filters),
+        tag_service.list_tags(session),
+        task_repo.get_task_counts_by_status(session, current_user),
+    )
+    return DashboardRead(
+        tasks=[TaskRead.model_validate(t) for t in tasks_result],
+        tags=[TagRead.model_validate(t) for t in tags_result],
+        counts_by_status=TaskCountsByStatus(**counts_result),
+    )

app/routes/health.py

@@ -1,6 +1,7 @@
+import asyncio
 from typing import Annotated, Awaitable, cast
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Response
 from redis.asyncio import Redis
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -23,3 +24,36 @@ async def redis_health(redis: RedisClient) -> dict[str, str]:
 async def db_health(session: DbSession) -> dict[str, str]:
     await session.execute(text("SELECT 1"))
     return {"db": "ok"}
+
+
+@router.get("/ready")
+async def readiness(
+    redis: RedisClient, session: DbSession, response: Response
+) -> dict[str, str]:
+    """Проверка готовности: БД и Redis параллельно. Время ответа ≈ max(db, redis)."""
+    db_result, redis_result = await asyncio.gather(
+        _check_db(session),
+        _check_redis(redis),
+    )
+    status_db, status_redis = db_result["db"], redis_result["redis"]
+    if status_db == "ok" and status_redis == "ok":
+        response.status_code = 200
+    else:
+        response.status_code = 503
+    return {"db": status_db, "redis": status_redis}
+
+
+async def _check_db(session: DbSession) -> dict[str, str]:
+    try:
+        await session.execute(text("SELECT 1"))
+        return {"db": "ok"}
+    except Exception:
+        return {"db": "down"}
+
+
+async def _check_redis(redis: RedisClient) -> dict[str, str]:
+    try:
+        ok = await cast(Awaitable[bool], redis.ping())
+        return {"redis": "ok" if ok else "down"}
+    except Exception:
+        return {"redis": "down"}

app/schemas/dashboard.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from app.schemas.tag import TagRead
+from app.schemas.task import TaskRead
+
+
+class TaskCountsByStatus(BaseModel):
+    """Количество задач пользователя по статусам."""
+
+    todo: int = 0
+    in_progress: int = 0
+    done: int = 0
+
+
+class DashboardRead(BaseModel):
+    """Данные дашборда: последние задачи, все теги, счётчики по статусам."""
+
+    tasks: list[TaskRead]
+    tags: list[TagRead]
+    counts_by_status: TaskCountsByStatus

tests/api/conftest.py

@@ -4,6 +4,7 @@
 from datetime import UTC, datetime
 from types import SimpleNamespace
 from typing import cast
+from unittest.mock import AsyncMock
 from uuid import uuid4
 
 import pytest
@@ -16,6 +17,8 @@
 from app.models.user import User
 from app.redis import get_redis
 from app.routes.auth import router as auth_router
+from app.routes.dashboard import router as dashboard_router
+from app.routes.health import router as health_router
 from app.routes.tags import router as tags_router
 from app.routes.tasks import router as tasks_router
 from app.security.dependences import get_current_user
@@ -34,6 +37,13 @@ def __init__(self) -> None:
         self.raise_on_get = False
         self.raise_on_set = False
         self.raise_on_delete = False
+        self.raise_on_ping = False
+
+    async def ping(self) -> bool:
+        """Эмуляция Redis PING для health-check."""
+        if self.raise_on_ping:
+            raise RedisConnectionError("Ошибка соединения с Redis")
+        return True
 
     async def eval(
         self, script: str, number_of_keys: int, key: str, window_seconds: int
@@ -93,8 +103,10 @@ async def delete(self, *keys: str) -> int:
 
 @pytest.fixture
 def fake_session() -> object:
-    """Возвращает объект-заглушку сессии для API-тестов."""
-    return object()
+    """Возвращает объект-заглушку сессии для API-тестов (с execute для health)."""
+    session = AsyncMock()
+    session.execute = AsyncMock()
+    return session
 
 
 @pytest.fixture
@@ -123,6 +135,8 @@ def api_app(fake_session: object, fake_redis: FakeRedis, current_user: User) ->
     """Собирает тестовое FastAPI-приложение с override зависимостей."""
     app = FastAPI()
     app.include_router(auth_router, prefix="/api/v1")
+    app.include_router(health_router, prefix="/api/v1")
+    app.include_router(dashboard_router, prefix="/api/v1")
     app.include_router(tasks_router, prefix="/api/v1")
     app.include_router(tags_router, prefix="/api/v1")
 

tests/api/test_dashboard_routes.py

@@ -0,0 +1,55 @@
+"""API-тесты для dashboard endpoint."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+from httpx import AsyncClient
+
+from app.routes import dashboard as dashboard_routes
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_dashboard_200_returns_tasks_tags_and_counts(
+    client: AsyncClient,
+    current_user,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """GET /dashboard возвращает 200 и тело с tasks, tags, counts_by_status."""
+    from app.services import tag as tag_service
+    from app.services import task as task_service
+
+    from tests.api.test_tasks_routes import _make_task, _make_tag
+
+    task = _make_task(current_user, title="Dashboard task")
+    tag = _make_tag(name="dashboard-tag")
+    monkeypatch.setattr(
+        task_service,
+        "get_user_tasks",
+        AsyncMock(return_value=[task]),
+    )
+    monkeypatch.setattr(
+        tag_service,
+        "list_tags",
+        AsyncMock(return_value=[tag]),
+    )
+    monkeypatch.setattr(
+        dashboard_routes.task_repo,
+        "get_task_counts_by_status",
+        AsyncMock(return_value={"todo": 1, "in_progress": 0, "done": 0}),
+    )
+
+    response = await client.get("/api/v1/dashboard")
+
+    assert response.status_code == 200
+    body = response.json()
+    assert "tasks" in body
+    assert "tags" in body
+    assert "counts_by_status" in body
+    assert len(body["tasks"]) == 1
+    assert body["tasks"][0]["title"] == "Dashboard task"
+    assert len(body["tags"]) == 1
+    assert body["tags"][0]["name"] == "dashboard-tag"
+    assert body["counts_by_status"] == {"todo": 1, "in_progress": 0, "done": 0}

tests/api/test_readiness.py

@@ -0,0 +1,27 @@
+"""API-тесты для readiness endpoint."""
+
+from __future__ import annotations
+
+import pytest
+from httpx import AsyncClient
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_readiness_200_when_both_ok(client: AsyncClient) -> None:
+    """GET /health/ready возвращает 200 и ok для db и redis."""
+    response = await client.get("/api/v1/health/ready")
+    assert response.status_code == 200
+    body = response.json()
+    assert body["db"] == "ok"
+    assert body["redis"] == "ok"
+
+
+async def test_readiness_503_when_redis_down(client: AsyncClient, fake_redis) -> None:
+    """GET /health/ready возвращает 503, когда Redis недоступен."""
+    fake_redis.raise_on_ping = True
+    response = await client.get("/api/v1/health/ready")
+    assert response.status_code == 503
+    body = response.json()
+    assert body["db"] == "ok"
+    assert body["redis"] == "down"

tests/unit/routes/test_health_routes.py

@@ -4,10 +4,17 @@
 from unittest.mock import AsyncMock
 
 import pytest
+from fastapi import Response
 from redis.asyncio import Redis
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.routes.health import db_health, redis_health
+from app.routes.health import (
+    _check_db,
+    _check_redis,
+    db_health,
+    readiness,
+    redis_health,
+)
 
 
 @pytest.fixture
@@ -53,3 +60,56 @@ async def test_db_health_executes_ping_query(fake_session: AsyncSession) -> None
 
     assert result == {"db": "ok"}
     cast(AsyncMock, fake_session.execute).assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_check_db_returns_down_on_exception(fake_session: AsyncSession) -> None:
+    """_check_db возвращает db=down при исключении."""
+    cast(AsyncMock, fake_session.execute).side_effect = Exception("connection lost")
+    result = await _check_db(fake_session)
+    assert result == {"db": "down"}
+
+
+@pytest.mark.asyncio
+async def test_check_redis_returns_down_on_exception(fake_redis: Redis) -> None:
+    """_check_redis возвращает redis=down при исключении."""
+    cast(AsyncMock, fake_redis.ping).side_effect = Exception("connection refused")
+    result = await _check_redis(fake_redis)
+    assert result == {"redis": "down"}
+
+
+@pytest.mark.asyncio
+async def test_readiness_200_when_both_ok(
+    fake_redis: Redis, fake_session: AsyncSession
+) -> None:
+    """Readiness возвращает 200 и ok для db и redis, когда оба источника доступны."""
+    cast(AsyncMock, fake_redis.ping).return_value = True
+    response = Response()
+    result = await readiness(redis=fake_redis, session=fake_session, response=response)
+    assert result == {"db": "ok", "redis": "ok"}
+    assert response.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_readiness_503_when_db_down(
+    fake_redis: Redis, fake_session: AsyncSession
+) -> None:
+    """Readiness возвращает 503, когда БД недоступна."""
+    cast(AsyncMock, fake_redis.ping).return_value = True
+    cast(AsyncMock, fake_session.execute).side_effect = Exception("db down")
+    response = Response()
+    result = await readiness(redis=fake_redis, session=fake_session, response=response)
+    assert result == {"db": "down", "redis": "ok"}
+    assert response.status_code == 503
+
+
+@pytest.mark.asyncio
+async def test_readiness_503_when_redis_down(
+    fake_redis: Redis, fake_session: AsyncSession
+) -> None:
+    """Readiness возвращает 503, когда Redis недоступен."""
+    cast(AsyncMock, fake_redis.ping).side_effect = Exception("redis down")
+    response = Response()
+    result = await readiness(redis=fake_redis, session=fake_session, response=response)
+    assert result == {"db": "ok", "redis": "down"}
+    assert response.status_code == 503