lab2: postgres, redis sessions, persistence, EXPLAIN and tests

This commit is contained in:
2026-10-19 21:35:11 +03:00
parent 65003b6119
commit 358ea9371b
20 changed files with 675 additions and 20 deletions
+29
View File
@@ -0,0 +1,29 @@
# Pinned base image. Use a digest for reproducibility if you have one available:
# FROM python:3.12.7-slim-bookworm@sha256:<digest>
FROM python:3.12.7-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1 \
PIP_NO_CACHE_DIR=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
RUN useradd --create-home --uid 10001 --shell /usr/sbin/nologin appuser \
&& chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import sys,urllib.request; \
sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live',timeout=2).status==200 else 1)"
CMD ["python", "-m", "src"]
+43 -20
View File
@@ -1,37 +1,60 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Вотчицева, БВТ2302
- Целевая оценка: 4, трек 5 не заявлен
- Commit/PR: см. Merge Request в Gitea
- Использованные источники, библиотеки и помощь ИИ:
- Python 3.12, FastAPI, Uvicorn, SQLAlchemy (asyncpg), Redis, Passlib (bcrypt)
- При подготовке каркаса приложения использовался ассистент (Claude).
- Все зависимости закреплены в `requirements.txt`.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker 24+, свободные порты `127.0.0.1:8080`.
```sh
git clone https://gitea.privcloud.tech/Tutuxa/mtusi2026lab2.git
cd mtusi2026lab2
docker compose up -d --build
# В другом терминале:
python tests\smoke.py --base-url http://localhost:8080
python tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
# Остановка:
docker compose down
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
API: Python 3.12 + FastAPI (Uvicorn). Работает в контейнере от non-root пользователя (UID 10001).
PostgreSQL: Источник истины для пользователей, чатов, участников и сообщений. Используется SQLAlchemy (ORM) + asyncpg.
Сессии (Redis): Сессии хранятся в Redis с TTL (по умолчанию 3600 секунд). Включена персистентность AOF (appendonly yes). Источник истины для сессий — Redis.
Хеширование: Passlib + bcrypt (версия 4.0.1 закреплена для стабильности).
Пагинация: Keyset cursor по (created_at, id). Добавлен составной индекс ix_messages_chat_created_id.
Обработка отказов: Если Redis или PostgreSQL недоступны, API возвращает 503 unavailable в едином формате ошибки.
Docker Compose: Поднимает api, db (PostgreSQL 16-alpine) и redis (Redis 7-alpine). Для БД и Redis используются именованные volumes (pgdata, redisdata).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python tests\smoke.py` | `PASS` | evidence/smoke.txt |
| Persistence | `python tests\resilience.py ...` | `PASS` | evidence/persistence.txt |
| Свои тесты (уровень 4) | `python student-tests\run.py` | `PASS` | evidence/student-tests.txt |
| Отказ Redis (503) | `python scripts\test_redis_down.py` | `PASS` | evidence/redis-down.txt |
| EXPLAIN (Индекс) | `EXPLAIN ...` | `Index Scan` | evidence/explain.txt |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| Воздействие | Что ожидали | Что наблюдали | Потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
| `docker compose restart` | Сохранение данных | Токен выжил | Нет |
| Остановка Redis | Ошибка 503 | Ошибка 503 | Нет |
| Гонка при регистрации | Один 201, один 409 | 201 и 409 | Нет |
+51
View File
@@ -0,0 +1,51 @@
services:
api:
build: .
ports:
- "127.0.0.1:8080:8080"
environment:
- APP_HOST=0.0.0.0
- APP_PORT=8080
- SESSION_TTL_SECONDS=3600
- DATABASE_URL=postgresql+asyncpg://user:password@db:5432/messenger
- SESSION_STORE=redis
- CACHE_URL=redis://redis:6379/0
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live')"]
interval: 5s
timeout: 3s
retries: 5
db:
image: postgres:16-alpine
environment:
- POSTGRES_USER=user
- POSTGRES_PASSWORD=password
- POSTGRES_DB=messenger
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U user -d messenger"]
interval: 3s
timeout: 3s
retries: 5
redis:
image: redis:7-alpine
command: redis-server --appendonly yes
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 5
volumes:
pgdata:
redisdata:
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+8
View File
@@ -0,0 +1,8 @@
fastapi==0.115.4
uvicorn==0.32.0
sqlalchemy==2.0.36
asyncpg==0.30.0
redis==5.2.0
passlib[bcrypt]==1.7.4
bcrypt==4.0.1
python-dotenv==1.0.1
+34
View File
@@ -0,0 +1,34 @@
import sys, os, subprocess
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'tests')))
from client import Client
def main():
c = Client()
# Создаем одного пользователя и один чат через API
alice, bob, eve, chat = c.bootstrap()
chat_id = chat['id']
alice_id = alice['id']
print(f"Чат создан: {chat_id}")
print("Генерируем 10000 сообщений напрямую в PostgreSQL (это займет пару секунд)...")
# SQL-запрос, который создаст 10 000 строк за один раз
sql = f"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT
gen_random_uuid(),
'{chat_id}'::uuid,
'{alice_id}'::uuid,
'Bulk message ' || i,
now() - interval '1 second' * (10000 - i)
FROM generate_series(1, 10000) AS i;
"""
subprocess.run(
["docker", "compose", "exec", "-T", "db", "psql", "-U", "user", "-d", "messenger", "-c", sql],
check=True
)
print("Готово! 10000 сообщений добавлено.")
print(f"ID чата для EXPLAIN: {chat_id}")
if __name__ == '__main__':
main()
+1
View File
@@ -0,0 +1 @@
docker compose restart
+3
View File
@@ -0,0 +1,3 @@
#!/bin/sh
set -eu
docker compose restart
+29
View File
@@ -0,0 +1,29 @@
import subprocess
import time
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'tests')))
from client import Client, Failure
def main():
print("Stopping Redis...")
# stdout и stderr в DEVNULL, чтобы PowerShell не ругался на вывод Docker
subprocess.run(["docker", "compose", "stop", "redis"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
time.sleep(2)
c = Client()
try:
# Пытаемся получить профиль с фейковым токеном.
# Так как Redis лежит, сервер должен попытаться прочитать сессию,
# поймать ошибку RedisError и вернуть 503, а не упасть с 500.
c.call('GET', '/api/v1/users/me', 503, headers={'Authorization': 'Bearer fake_token'})
print("PASS: Redis is down, API correctly returned 503")
except Failure as e:
print(f"FAIL: {e}")
sys.exit(1)
finally:
print("Starting Redis back...")
subprocess.run(["docker", "compose", "start", "redis"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
if __name__ == '__main__':
main()
View File
+23
View File
@@ -0,0 +1,23 @@
"""Entry point: uvicorn as PID 1 with env-driven host/port and graceful shutdown."""
import os
import uvicorn
from .main import app
def main() -> None:
host = os.environ.get("APP_HOST", "0.0.0.0")
port = int(os.environ.get("APP_PORT", "8080"))
uvicorn.run(
app,
host=host,
port=port,
log_level="info",
access_log=True,
timeout_graceful_shutdown=5,
)
if __name__ == "__main__":
main()
+27
View File
@@ -0,0 +1,27 @@
import os
import secrets
import redis.asyncio as redis
from passlib.context import CryptContext
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
CACHE_URL = os.environ.get("CACHE_URL", "redis://localhost:6379/0")
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
redis_client = redis.from_url(CACHE_URL, decode_responses=True)
def hash_password(password: str) -> str:
return pwd_context.hash(password)
def verify_password(plain_password: str, hashed_password: str) -> bool:
return pwd_context.verify(plain_password, hashed_password)
async def create_session(user_id: str) -> str:
token = secrets.token_urlsafe(32)
await redis_client.setex(f"session:{token}", SESSION_TTL_SECONDS, user_id)
return token
async def get_user_id_by_token(token: str) -> str | None:
return await redis_client.get(f"session:{token}")
async def delete_session(token: str) -> None:
await redis_client.delete(f"session:{token}")
+55
View File
@@ -0,0 +1,55 @@
import os
from datetime import datetime, timezone
from typing import List
from uuid import UUID, uuid4
from sqlalchemy import String, ForeignKey, DateTime, Index
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
DATABASE_URL = os.environ.get("DATABASE_URL", "postgresql+asyncpg://user:password@localhost:5432/messenger")
engine = create_async_engine(DATABASE_URL, echo=False)
async_session = async_sessionmaker(engine, expire_on_commit=False)
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4)
username: Mapped[str] = mapped_column(String(32), unique=True, index=True)
display_name: Mapped[str] = mapped_column(String(100))
password_hash: Mapped[str] = mapped_column(String(255))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
class Chat(Base):
__tablename__ = "chats"
id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4)
title: Mapped[str] = mapped_column(String(100))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
members: Mapped[List["ChatMember"]] = relationship(back_populates="chat", lazy="selectin")
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
user_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
chat: Mapped["Chat"] = relationship(back_populates="members")
user: Mapped["User"] = relationship()
class Message(Base):
__tablename__ = "messages"
id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid4)
chat_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), index=True)
sender_id: Mapped[UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("users.id"))
text: Mapped[str] = mapped_column(String(4000))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=lambda: datetime.now(timezone.utc))
# Составной индекс для быстрой курсорной пагинации (EXPLAIN покажет Index Scan)
__table_args__ = (
Index('ix_messages_chat_created_id', 'chat_id', 'created_at', 'id'),
)
async def init_db():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
+296
View File
@@ -0,0 +1,296 @@
from __future__ import annotations
import base64
import re
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timezone, timedelta
from typing import Optional
from fastapi import Depends, FastAPI, Request, Query
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.security import HTTPBasic, HTTPBasicCredentials, HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy import select, and_, or_
from sqlalchemy.exc import OperationalError
from starlette.exceptions import HTTPException as StarletteHTTPException
from redis.exceptions import RedisError
from .db import init_db, async_session, User, Chat, ChatMember, Message
from .auth import hash_password, verify_password, create_session, get_user_id_by_token, delete_session
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
def now_iso(dt: datetime = None) -> str:
if not dt:
dt = datetime.now(timezone.utc)
return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
def error_payload(request_id: str, code: str, message: str) -> dict:
return {"error": {"code": code, "message": message, "request_id": request_id}}
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str):
self.status = status
self.code = code
self.message = message
super().__init__(message)
# --- Курсоры для пагинации (с точностью до микросекунд) ---
def _encode_cursor(scope: str, created_at: datetime, obj_id: uuid.UUID) -> str:
raw = f"{scope}|{created_at.isoformat()}|{obj_id}".encode("utf-8")
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii")
def _decode_cursor(cursor: str) -> tuple[str, datetime, uuid.UUID]:
try:
padded = cursor + "=" * (-len(cursor) % 4)
raw = base64.urlsafe_b64decode(padded).decode("utf-8")
scope, dt_str, obj_id_str = raw.split("|", 2)
dt = datetime.fromisoformat(dt_str)
return scope, dt, uuid.UUID(obj_id_str)
except Exception:
raise ApiError(400, "invalid_request", "invalid cursor")
# --- Схемы ---
class CreateUser(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str
display_name: str
password: str = Field(min_length=12, max_length=128)
class CreateChat(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str
member_ids: list[uuid.UUID]
class CreateMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@asynccontextmanager
async def lifespan(app: FastAPI):
await init_db()
yield
app = FastAPI(title="Messenger", version="1.2.0", lifespan=lifespan)
security_basic = HTTPBasic(auto_error=False)
security_bearer = HTTPBearer(auto_error=False)
@app.middleware("http")
async def request_id_middleware(request: Request, call_next):
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
def _rid(request: Request) -> str:
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
# --- Обработчики ошибок ---
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError):
headers = {}
if exc.status == 401:
if request.url.path == "/api/v1/auth/sessions":
headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"'
else:
headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
return JSONResponse(status_code=exc.status, content=error_payload(_rid(request), exc.code, exc.message), headers=headers)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(request: Request, exc: RequestValidationError):
return JSONResponse(status_code=400, content=error_payload(_rid(request), "invalid_request", "invalid request"))
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
return JSONResponse(status_code=exc.status_code, content=error_payload(_rid(request), "not_found", str(exc.detail)))
@app.exception_handler(RedisError)
@app.exception_handler(OperationalError)
async def dependency_error_handler(request: Request, exc: Exception):
# Если упала БД или Redis - отдаем 503, как требует контракт
return JSONResponse(status_code=503, content=error_payload(_rid(request), "unavailable", "dependency unavailable"))
@app.exception_handler(Exception)
async def generic_exception_handler(request: Request, exc: Exception):
return JSONResponse(status_code=500, content=error_payload(_rid(request), "internal_error", "internal error"))
# --- Зависимости ---
async def get_actor(credentials: HTTPAuthorizationCredentials = Depends(security_bearer)) -> dict:
if not credentials:
raise ApiError(401, "unauthorized", "missing token")
user_id_str = await get_user_id_by_token(credentials.credentials)
if not user_id_str:
raise ApiError(401, "unauthorized", "invalid or expired token")
async with async_session() as session:
user = await session.get(User, uuid.UUID(user_id_str))
if not user:
raise ApiError(401, "unauthorized", "user not found")
return {"id": str(user.id), "username": user.username, "display_name": user.display_name, "created_at": now_iso(user.created_at)}
# --- Роуты ---
@app.get("/health/live")
def liveness():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
async def register_user(payload: CreateUser):
if not USERNAME_RE.match(payload.username):
raise ApiError(400, "invalid_request", "invalid username")
async with async_session() as session:
existing = await session.scalar(select(User).where(User.username == payload.username))
if existing:
raise ApiError(409, "conflict", "username already exists")
user = User(username=payload.username, display_name=payload.display_name, password_hash=hash_password(payload.password))
session.add(user)
try:
await session.commit()
except Exception:
await session.rollback()
raise ApiError(409, "conflict", "username already exists")
return {"id": str(user.id), "username": user.username, "display_name": user.display_name, "created_at": now_iso(user.created_at)}
@app.post("/api/v1/auth/sessions", status_code=201)
async def create_session_endpoint(credentials: HTTPBasicCredentials = Depends(security_basic)):
if not credentials:
raise ApiError(401, "unauthorized", "missing credentials")
async with async_session() as session:
user = await session.scalar(select(User).where(User.username == credentials.username))
if not user or not verify_password(credentials.password, user.password_hash):
raise ApiError(401, "unauthorized", "invalid credentials")
token = await create_session(str(user.id))
expires_at = datetime.now(timezone.utc) + timedelta(seconds=3600)
return {
"token": token,
"token_type": "Bearer",
"expires_at": now_iso(expires_at),
"user": {"id": str(user.id), "username": user.username, "display_name": user.display_name, "created_at": now_iso(user.created_at)}
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(credentials: HTTPAuthorizationCredentials = Depends(security_bearer)):
if not credentials:
raise ApiError(401, "unauthorized", "missing token")
user_id = await get_user_id_by_token(credentials.credentials)
if not user_id:
raise ApiError(401, "unauthorized", "invalid or expired token")
await delete_session(credentials.credentials)
@app.get("/api/v1/users/me")
async def current_user(actor: dict = Depends(get_actor)):
return actor
@app.post("/api/v1/chats", status_code=201)
async def create_chat(payload: CreateChat, actor: dict = Depends(get_actor)):
member_ids = [str(u) for u in payload.member_ids]
if actor["id"] not in member_ids:
raise ApiError(400, "invalid_request", "creator must be a member")
if len(set(member_ids)) != len(member_ids):
raise ApiError(400, "invalid_request", "duplicate members")
async with async_session() as session:
users = await session.scalars(select(User.id).where(User.id.in_([uuid.UUID(m) for m in member_ids])))
if len(list(users)) != len(set(member_ids)):
raise ApiError(400, "invalid_request", "unknown member")
chat = Chat(title=payload.title)
session.add(chat)
await session.flush()
for mid in member_ids:
session.add(ChatMember(chat_id=chat.id, user_id=uuid.UUID(mid)))
await session.commit()
return {"id": str(chat.id), "title": chat.title, "member_ids": member_ids, "created_at": now_iso(chat.created_at)}
@app.get("/api/v1/chats")
async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = None, actor: dict = Depends(get_actor)):
async with async_session() as session:
stmt = select(Chat).join(ChatMember).where(ChatMember.user_id == uuid.UUID(actor["id"]))
if cursor:
scope, c_dt, c_id = _decode_cursor(cursor)
if scope != "chats":
raise ApiError(400, "invalid_request", "invalid cursor scope")
stmt = stmt.where(or_(
Chat.created_at > c_dt,
and_(Chat.created_at == c_dt, Chat.id > c_id)
))
stmt = stmt.order_by(Chat.created_at.asc(), Chat.id.asc()).limit(limit + 1)
chats = (await session.scalars(stmt)).unique().all()
has_more = len(chats) > limit
page = chats[:limit]
next_cursor = _encode_cursor("chats", page[-1].created_at, page[-1].id) if has_more and page else None
items = []
for c in page:
items.append({
"id": str(c.id),
"title": c.title,
"created_at": now_iso(c.created_at),
"member_ids": [str(m.user_id) for m in c.members] # Теперь участники возвращаются корректно
})
return {"items": items, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: uuid.UUID, actor: dict = Depends(get_actor)):
async with async_session() as session:
chat = await session.scalar(select(Chat).join(ChatMember).where(Chat.id == chat_id, ChatMember.user_id == uuid.UUID(actor["id"])))
if not chat:
raise ApiError(404, "not_found", "chat not found")
return {"id": str(chat.id), "title": chat.title, "member_ids": [str(m.user_id) for m in chat.members], "created_at": now_iso(chat.created_at)}
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def post_message(chat_id: uuid.UUID, payload: CreateMessage, actor: dict = Depends(get_actor)):
async with async_session() as session:
member = await session.scalar(select(ChatMember).where(and_(ChatMember.chat_id == chat_id, ChatMember.user_id == uuid.UUID(actor["id"]))))
if not member:
raise ApiError(404, "not_found", "chat not found")
msg = Message(chat_id=chat_id, sender_id=uuid.UUID(actor["id"]), text=payload.text)
session.add(msg)
await session.commit()
return {"id": str(msg.id), "chat_id": str(msg.chat_id), "sender_id": str(msg.sender_id), "text": msg.text, "created_at": now_iso(msg.created_at)}
@app.get("/api/v1/chats/{chat_id}/messages")
async def get_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = None, actor: dict = Depends(get_actor)):
async with async_session() as session:
member = await session.scalar(select(ChatMember).where(and_(ChatMember.chat_id == chat_id, ChatMember.user_id == uuid.UUID(actor["id"]))))
if not member:
raise ApiError(404, "not_found", "chat not found")
stmt = select(Message).where(Message.chat_id == chat_id)
if cursor:
scope, c_dt, c_id = _decode_cursor(cursor)
if scope != str(chat_id):
raise ApiError(400, "invalid_request", "invalid cursor scope")
stmt = stmt.where(or_(
Message.created_at > c_dt,
and_(Message.created_at == c_dt, Message.id > c_id)
))
stmt = stmt.order_by(Message.created_at.asc(), Message.id.asc()).limit(limit + 1)
messages = (await session.scalars(stmt)).all()
has_more = len(messages) > limit
page = messages[:limit]
next_cursor = _encode_cursor(str(chat_id), page[-1].created_at, page[-1].id) if has_more and page else None
items = [{"id": str(m.id), "chat_id": str(m.chat_id), "sender_id": str(m.sender_id), "text": m.text, "created_at": now_iso(m.created_at)} for m in page]
return {"items": items, "next_cursor": next_cursor}
+12
View File
@@ -0,0 +1,12 @@
# мои тесты (уровень 4)
Требуют запущенного сервера. Одна команда:
python student-tests/run.py --base-url http://localhost:8080
Проверяется: невалидный JSON и лишние поля; отсутствующий/несуществующий
X-User-Id; доступ к чужому чату и его истории; пустой/пробельный/слишком
длинный текст; дубликат username; member_ids без вызывающего / с дублями /
с неизвестным; многостраничный обход cursor без пропусков и повторов;
привязка cursor к чату; конкурентный тест 10×10 = 100 уникальных.
+64
View File
@@ -0,0 +1,64 @@
import sys
import threading
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, arguments, check, run
def t_wrong_password(c: Client) -> None:
# Создаем пользователя
u = c.user("wrongpass")
# Пытаемся войти с неверным паролем
import base64
bad_cred = base64.b64encode((u['registration']['username'] + ':wrongpassword123').encode()).decode()
c.call('POST', '/api/v1/auth/sessions', 401, headers={'Authorization': 'Basic ' + bad_cred})
def t_logout(c: Client) -> None:
u = c.user("logout")
# Успешный logout
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=u)
# Повторный запрос с отозванным токеном должен дать 401
c.call('GET', '/api/v1/users/me', 401, actor=u)
def t_race_registration(c: Client) -> None:
username = 'race_' + uuid.uuid4().hex[:6]
barrier = threading.Barrier(2)
results = []
def register():
local = Client()
barrier.wait()
try:
local.call('POST', '/api/v1/users', 201, body={'username': username, 'display_name': 'Race', 'password': 'ValidPassword123'})
results.append(201)
except Failure as e:
if 'expected [201]' in str(e):
results.append(409)
else:
raise
with ThreadPoolExecutor(max_workers=2) as pool:
list(pool.map(lambda _: register(), range(2)))
check(201 in results and 409 in results, f"Race condition failed: {results}")
CASES = [
("wrong_password", t_wrong_password),
("logout", t_logout),
("race_registration", t_race_registration),
]
def main() -> None:
args = arguments("Student tests for lab2")
client = Client(args.base_url, args.ca_file)
for name, fn in CASES:
fn(client)
print(f"PASS {name}")
print("PASS: lab2 student tests")
if __name__ == "__main__":
run(main)