feat: перевести API на password/Basic/Bearer и PostgreSQL с Redis-кэшем

Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
This commit is contained in:
Evgeny Bushkov
2026-10-23 18:07:09 +03:00
co-authored by aider
parent 3e152d4175
commit 785fde833f
18 changed files with 856 additions and 176 deletions
+9 -6
View File
@@ -1,11 +1,14 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# DSN для PostgreSQL. В compose.yaml подставляется из secrets/database_url.
DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger
# Redis используется как кэш сессий; источник истины — PostgreSQL.
CACHE_URL=redis://redis:6379/0
# Таймауты (секунды) для БД и Redis.
DB_POOL_MIN=1
DB_POOL_MAX=10
DB_CONNECT_TIMEOUT=3
REDIS_SOCKET_TIMEOUT=1
+15
View File
@@ -0,0 +1,15 @@
FROM python:3.12-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
EXPOSE 8080
CMD ["python", "-m", "app.main"]
+10 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence test-unit up down
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,12 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-unit:
$(PYTHON) tests/test_unit.py --base-url "$(BASE_URL)"
up:
docker compose --env-file .env up -d --build
down:
docker compose --env-file .env down
+52 -13
View File
@@ -1,37 +1,76 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Целевая оценка: **4** (трек 5 не заявляется)
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: официальная документация FastAPI, psycopg 3, psycopg_pool, redis-py, argon2-cffi, PostgreSQL; помощь ИИ — генерация каркаса кода и текста отчёта, проверка и адаптация вручную.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker Engine 24+, Docker Compose v2, Python 3.9+ (для тестов), `make`.
```sh
cp .env.example .env
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# дождаться /health/ready (healthcheck в compose)
make test BASE_URL=http://localhost:8080
make test-unit BASE_URL=http://localhost:8080
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080
```
Версии образов закреплены: `postgres:16.4-alpine`, `redis:7.4-alpine`, `python:3.12-slim`. Миграции применяются автоматически при старте API (`app/db.py::apply_migrations`), идемпотентно через таблицу `schema_migrations`.
Безопасная остановка: `docker compose down` (volumes сохраняются). Намеренное удаление учебных данных: `docker compose down -v` — только осознанно, теряет все данные.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **Процессы**: `api` (FastAPI/uvicorn), `postgres` (источник истины), `redis` (кэш сессий с TTL).
- **Источник истины**: PostgreSQL. Таблицы `users`, `chats`, `chat_members`, `messages`, `sessions`, `schema_migrations`. PK/FK, `UNIQUE(username)`, составной PK `(chat_id, user_id)`.
- **Транзакционные границы**: создание чата — одна транзакция (INSERT chats + INSERT chat_members). Создание сообщения — одна транзакция. Создание сессии — одна транзакция.
- **Аутентификация**: `POST /api/v1/users` принимает `password` (12–128 символов), хранится Argon2id-хеш. `POST /api/v1/auth/sessions` — только Basic, выдаёт opaque Bearer-токен (256 бит, `secrets.token_urlsafe(32)`); в БД хранится SHA-256 от токена. `DELETE /api/v1/auth/sessions/current` отзывает сессию. `X-User-Id` игнорируется.
- **Сессии**: источник истины — `sessions` в PostgreSQL; Redis — кэш `session:<sha256>` с TTL = остаток жизни сессии. При недоступности Redis — fallback на БД (не принимаем анонимов). При logout инвалидируется и БД, и кэш.
- **Пул и таймауты**: `psycopg_pool.ConnectionPool` (`DB_POOL_MIN`/`DB_POOL_MAX`), `DB_CONNECT_TIMEOUT`; Redis `socket_timeout`/`socket_connect_timeout` = `REDIS_SOCKET_TIMEOUT`.
- **Индекс истории**: `messages_chat_created_idx (chat_id, created_at, id)` под keyset-пагинацию. Проверка — `scripts/explain_history.sql`.
- **Соответствие `.env.example`**: `DATABASE_URL`, `CACHE_URL`, `SESSION_TTL_SECONDS`, `DB_POOL_MIN/MAX`, `DB_CONNECT_TIMEOUT`, `REDIS_SOCKET_TIMEOUT` — используются напрямую в `app/db.py`, `app/sessions.py`, `app/main.py`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke (уровень 3) | `make test` | PASS: lab2 public API scenario | вывод консоли |
| Persistence (уровень 3) | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: persistence preserved confirmed data and existing session | вывод консоли |
| Миграции с нуля | `docker compose down -v && docker compose up -d --build` | API стартует, `schema_migrations` содержит 001/002 | `docker compose exec postgres psql -U messenger -c "select * from schema_migrations"` |
| Redis используется для сессий с TTL | `docker compose exec redis redis-cli TTL session:<hash>` | TTL > 0, уменьшается | вывод консоли |
| Параметризованные запросы | код `app/store.py`, `app/sessions.py` | все запросы через `%s` | исходники |
| Ограниченный пул и таймауты | `app/db.py`, `app/main.py` | `DB_POOL_MAX`, `DB_CONNECT_TIMEOUT`, `REDIS_SOCKET_TIMEOUT` | исходники |
| Гонка регистрации username | `tests/test_unit.py::test_duplicate_username` | 201 + 409 | `make test-unit` |
| Rollback составной операции | `app/store.py::create_chat` — `conn.transaction()` | при ошибке вставки участника чат не создаётся | исходники |
| Индекс истории + EXPLAIN | `psql "$DATABASE_URL" -f scripts/explain_history.sql` | Index Scan по `messages_chat_created_idx` | вывод EXPLAIN |
| Expiry при коротком TTL | `SESSION_TTL_SECONDS=2 docker compose up -d api` + `make test-unit` | 401 после истечения | вывод консоли |
| Logout | `tests/test_unit.py::test_logout_revokes_session` | 204, затем 401 | `make test-unit` |
| Неверный пароль | `tests/test_unit.py::test_wrong_password_returns_401` | 401 | `make test-unit` |
| Недоступность Redis | `docker compose stop redis` + `make test` | smoke проходит (fallback на БД) | вывод консоли |
| Недоступность БД | `docker compose stop postgres` + `curl /health/ready` | 503 `unavailable` | вывод консоли |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Гипотеза: при остановке Redis API продолжает обслуживать запросы (кэш — не источник истины); при остановке PostgreSQL `/health/ready` возвращает 503, бизнес-запросы — 500/503 без утечки деталей.
Hardware: локальная машина разработчика (Windows 11, Docker Desktop). Объём данных: синтетические пользователи/чаты/сообщения из тестов. Профиль нагрузки: `tests/load.py --duration 30 --concurrency 4` (closed-loop, ограничен клиентом).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose restart api postgres redis` (volumes сохранены) | данные и сессии сохранены | PASS persistence | ~5–10 с, потерь нет |
| `docker compose stop redis` | API работает, сессии из БД | smoke PASS | восстановление после `start redis` |
| `docker compose stop postgres` | `/health/ready` → 503 | 503 `unavailable` | после `start postgres` — 200 |
| `SESSION_TTL_SECONDS=2` | сессия истекает | 401 после истечения | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Redis — кэш, не источник истины; при его недоступности latency сессий растёт (каждый запрос идёт в БД).
- Нет репликации PostgreSQL и балансировщика — уровень 3+ (failover) не заявляется.
- Нет idempotency-key для сообщений (lab3), нет вложений (lab4), нет фоновой обработки (lab5).
- `tests/load.py` — closed-loop, страдает coordinated omission; не доказывает максимальную пропускную способность.
- Трек 5 не выполнялся.
+53
View File
@@ -0,0 +1,53 @@
"""Пул соединений PostgreSQL и применение миграций."""
import logging
import os
from pathlib import Path
import psycopg
from psycopg_pool import ConnectionPool
logger = logging.getLogger("messenger.db")
MIGRATIONS_DIR = Path(__file__).resolve().parents[1] / "migrations"
def make_pool() -> ConnectionPool:
dsn = os.environ.get("DATABASE_URL")
if not dsn:
raise RuntimeError("DATABASE_URL is not set")
pool = ConnectionPool(
conninfo=dsn,
min_size=int(os.environ.get("DB_POOL_MIN", "1")),
max_size=int(os.environ.get("DB_POOL_MAX", "10")),
timeout=float(os.environ.get("DB_CONNECT_TIMEOUT", "3")),
kwargs={"autocommit": False},
open=False,
)
pool.open(wait=True, timeout=float(os.environ.get("DB_CONNECT_TIMEOUT", "3")))
return pool
def apply_migrations(pool: ConnectionPool) -> None:
"""Идемпотентно применяет *.sql из migrations/ в лексикографическом порядке."""
with pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version TEXT PRIMARY KEY,"
" applied_at TIMESTAMPTZ NOT NULL DEFAULT now())"
)
conn.commit()
cur.execute("SELECT version FROM schema_migrations")
applied = {row[0] for row in cur.fetchall()}
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
version = path.stem
if version in applied:
continue
logger.info("applying migration %s", version)
sql = path.read_text(encoding="utf-8")
with conn.transaction():
with conn.cursor() as cur:
cur.execute(sql)
cur.execute(
"INSERT INTO schema_migrations(version) VALUES (%s)", (version,)
)
+128 -46
View File
@@ -1,10 +1,15 @@
"""HTTP-обработчики FastAPI для lab1."""
"""HTTP-обработчики FastAPI для lab2: Basic/Bearer, PostgreSQL, Redis-кэш сессий."""
import base64
import binascii
import logging
from typing import Any
from fastapi import APIRouter, Body, Header, Query, Request
from fastapi.responses import JSONResponse
from .errors import ApiError
from .security import hash_password, verify_password
from .sessions import SessionStore
from .store import Store
from .validation import (
encode_cursor,
@@ -18,19 +23,48 @@ from .validation import (
router = APIRouter()
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def get_store(request: Request) -> Store:
return request.app.state.store
def current_user_id(request: Request, x_user_id: str | None) -> str:
"""lab1: X-User-Id — идентификатор существующего пользователя."""
if not x_user_id:
raise ApiError(401, "unauthorized", "Требуется X-User-Id")
store = get_store(request)
if store.get_user(x_user_id) is None:
raise ApiError(401, "unauthorized", "Неизвестный пользователь")
return x_user_id
def get_sessions(request: Request) -> SessionStore:
return request.app.state.sessions
def _unauthorized(message: str, challenge: str) -> ApiError:
err = ApiError(401, "unauthorized", message)
err.challenge = challenge # type: ignore[attr-defined]
return err
def current_user_id(request: Request, authorization: str | None) -> str:
"""lab2: только Bearer. X-User-Id игнорируется."""
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token:
raise _unauthorized("Пустой Bearer-токен", BEARER_CHALLENGE)
user_id = get_sessions(request).resolve(token)
if user_id is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user_id
def _parse_basic(authorization: str | None) -> tuple[str, str]:
if not authorization or not authorization.lower().startswith("basic "):
raise _unauthorized("Требуется Basic-аутентификация", BASIC_CHALLENGE)
try:
decoded = base64.b64decode(authorization[6:].strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
if ":" not in decoded:
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
username, password = decoded.split(":", 1)
return username, password
@router.get("/health/live")
@@ -39,25 +73,78 @@ def health_live() -> dict[str, str]:
@router.get("/health/ready")
def health_ready() -> dict[str, str]:
return {"status": "ok"}
def health_ready(request: Request) -> JSONResponse:
"""Ready, если доступна БД (обязательный синхронный путь). Redis — кэш."""
try:
with get_store(request).pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("SELECT 1")
cur.fetchone()
except Exception as exc: # noqa: BLE001
logger_ready = logging.getLogger("messenger.ready")
logger_ready.warning("readiness failed: %s", type(exc).__name__)
raise ApiError(503, "unavailable", "Зависимость недоступна")
return JSONResponse({"status": "ok"})
@router.post("/api/v1/users", status_code=201)
def register_user(request: Request, body: Any = Body(...)) -> JSONResponse:
username, display_name = validate_create_user(body)
username, display_name, password = validate_create_user(body)
store = get_store(request)
user = store.create_user(username, display_name)
user = store.create_user(username, display_name, hash_password(password))
if user is None:
raise ApiError(409, "conflict", "username уже занят")
return JSONResponse(user, status_code=201)
@router.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
username, password = _parse_basic(authorization)
store = get_store(request)
found = store.get_user_by_username(username)
if found is None:
# Одинаковый 401 для неверного username и пароля.
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
user, password_hash = found
if not verify_password(password_hash, password):
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
session = get_sessions(request).create(user["id"])
return JSONResponse(
{
"token": session["token"],
"token_type": "Bearer",
"expires_at": session["expires_at"],
"user": user,
},
status_code=201,
)
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token or get_sessions(request).resolve(token) is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
get_sessions(request).revoke(token)
return JSONResponse(status_code=204)
@router.get("/api/v1/users/me")
def current_user(request: Request, x_user_id: str | None = Header(default=None)) -> dict[str, Any]:
user_id = current_user_id(request, x_user_id)
def current_user(
request: Request, authorization: str | None = Header(default=None)
) -> dict[str, Any]:
user_id = current_user_id(request, authorization)
user = get_store(request).get_user(user_id)
assert user is not None
if user is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user
@@ -65,9 +152,9 @@ def current_user(request: Request, x_user_id: str | None = Header(default=None))
def create_chat(
request: Request,
body: Any = Body(...),
x_user_id: str | None = Header(default=None),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, x_user_id)
caller = current_user_id(request, authorization)
title, member_ids = validate_create_chat(body, caller)
store = get_store(request)
for mid in member_ids:
@@ -82,33 +169,33 @@ def list_chats(
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
x_user_id: str | None = Header(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, x_user_id)
caller = current_user_id(request, authorization)
page_size = parse_limit(limit)
scope = f"chats:{caller}"
after = parse_cursor(cursor, scope)
items = get_store(request).list_chats_for(caller)
if after is not None:
items = [c for c in items if (c["created_at"], c["id"]) > after]
page = items[:page_size]
items, has_more = get_store(request).list_chats_for(caller, page_size, after)
next_cursor = None
if len(items) > page_size and page:
last = page[-1]
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": page, "next_cursor": next_cursor}
return {"items": items, "next_cursor": next_cursor}
@router.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
request: Request,
x_user_id: str | None = Header(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, x_user_id)
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
chat = get_store(request).get_chat(chat_id)
if chat is None or caller not in chat["member_ids"]:
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
chat = store.get_chat(chat_id)
if chat is None:
raise ApiError(404, "not_found", "Чат не найден")
return chat
@@ -118,13 +205,12 @@ def create_message(
chat_id: str,
request: Request,
body: Any = Body(...),
x_user_id: str | None = Header(default=None),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, x_user_id)
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
chat = store.get_chat(chat_id)
if chat is None or caller not in chat["member_ids"]:
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
text = validate_create_message(body)
message = store.add_message(chat_id, caller, text)
@@ -137,23 +223,19 @@ def list_messages(
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
x_user_id: str | None = Header(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, x_user_id)
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
chat = store.get_chat(chat_id)
if chat is None or caller not in chat["member_ids"]:
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
page_size = parse_limit(limit)
scope = f"messages:{chat_id}"
after = parse_cursor(cursor, scope)
items = store.list_messages(chat_id)
if after is not None:
items = [m for m in items if (m["created_at"], m["id"]) > after]
page = items[:page_size]
items, has_more = store.list_messages(chat_id, page_size, after)
next_cursor = None
if len(items) > page_size and page:
last = page[-1]
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": page, "next_cursor": next_cursor}
return {"items": items, "next_cursor": next_cursor}
+26 -3
View File
@@ -3,13 +3,16 @@ import logging
import os
import uuid
import redis
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from .db import apply_migrations, make_pool
from .errors import ApiError, error_body
from .handlers import router
from .sessions import SessionStore
from .store import Store
logging.basicConfig(
@@ -18,8 +21,24 @@ logging.basicConfig(
)
logger = logging.getLogger("messenger")
app = FastAPI(title="MTUSI Messenger", version="1.1.0")
app.state.store = Store()
app = FastAPI(title="MTUSI Messenger", version="1.2.0")
_pool = make_pool()
apply_migrations(_pool)
_cache: redis.Redis | None = None
_cache_url = os.environ.get("CACHE_URL")
if _cache_url:
_cache = redis.Redis.from_url(
_cache_url,
socket_timeout=float(os.environ.get("REDIS_SOCKET_TIMEOUT", "1")),
socket_connect_timeout=float(os.environ.get("REDIS_SOCKET_TIMEOUT", "1")),
decode_responses=False,
)
app.state.pool = _pool
app.state.store = Store(_pool)
app.state.sessions = SessionStore(_pool, _cache)
app.include_router(router)
@@ -41,10 +60,14 @@ async def request_id_middleware(request: Request, call_next):
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError) -> JSONResponse:
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
headers = {"X-Request-Id": request_id}
challenge = getattr(exc, "challenge", None)
if challenge:
headers["WWW-Authenticate"] = challenge
return JSONResponse(
error_body(exc.code, exc.message, request_id),
status_code=exc.status,
headers={"X-Request-Id": request_id},
headers=headers,
)
+29
View File
@@ -0,0 +1,29 @@
"""Хеширование паролей (Argon2id) и генерация opaque-токенов сессий."""
import hashlib
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
return _hasher.hash(password)
def verify_password(password_hash: str, password: str) -> bool:
try:
return _hasher.verify(password_hash, password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
def new_token() -> str:
"""256 бит энтропии, URL-safe."""
return secrets.token_urlsafe(32)
def token_hash(token: str) -> str:
"""В БД/Redis храним только SHA-256 от токена, не сам токен."""
return hashlib.sha256(token.encode("utf-8")).hexdigest()
+129
View File
@@ -0,0 +1,129 @@
"""Сессии: PostgreSQL — источник истины, Redis — кэш с TTL.
При недоступности Redis работаем напрямую с БД (не принимаем анонимов).
При logout инвалидируем и БД, и кэш.
"""
import logging
import os
from datetime import datetime, timedelta, timezone
from typing import Any
import redis
from psycopg_pool import ConnectionPool
from .security import new_token, token_hash
logger = logging.getLogger("messenger.sessions")
def _now() -> datetime:
return datetime.now(timezone.utc)
def _ttl_seconds() -> int:
return int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
class SessionStore:
def __init__(self, pool: ConnectionPool, cache: redis.Redis | None) -> None:
self.pool = pool
self.cache = cache
# --- кэш --------------------------------------------------------------
def _cache_get(self, th: str) -> dict[str, Any] | None:
if self.cache is None:
return None
try:
raw = self.cache.hgetall("session:" + th)
except redis.RedisError as exc:
logger.warning("redis get failed: %s", type(exc).__name__)
return None
if not raw:
return None
return {
"user_id": raw[b"user_id"].decode(),
"expires_at": raw[b"expires_at"].decode(),
}
def _cache_put(self, th: str, user_id: str, expires_at: datetime) -> None:
if self.cache is None:
return
ttl = max(1, int((expires_at - _now()).total_seconds()))
try:
pipe = self.cache.pipeline()
pipe.hset(
"session:" + th,
mapping={
"user_id": user_id,
"expires_at": expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
},
)
pipe.expire("session:" + th, ttl)
pipe.execute()
except redis.RedisError as exc:
logger.warning("redis put failed: %s", type(exc).__name__)
def _cache_del(self, th: str) -> None:
if self.cache is None:
return
try:
self.cache.delete("session:" + th)
except redis.RedisError as exc:
logger.warning("redis del failed: %s", type(exc).__name__)
# --- публичный API ----------------------------------------------------
def create(self, user_id: str) -> dict[str, Any]:
token = new_token()
th = token_hash(token)
expires_at = _now() + timedelta(seconds=_ttl_seconds())
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO sessions(token_hash, user_id, created_at, expires_at)"
" VALUES (%s, %s, now(), %s)",
(th, user_id, expires_at),
)
conn.commit()
self._cache_put(th, user_id, expires_at)
return {
"token": token,
"expires_at": expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
}
def resolve(self, token: str) -> str | None:
"""Возвращает user_id для действующей сессии или None."""
th = token_hash(token)
cached = self._cache_get(th)
if cached is not None:
try:
exp = datetime.strptime(cached["expires_at"], "%Y-%m-%dT%H:%M:%SZ").replace(
tzinfo=timezone.utc
)
except ValueError:
exp = None
if exp is not None and exp > _now():
return cached["user_id"]
self._cache_del(th)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT user_id, expires_at FROM sessions WHERE token_hash = %s",
(th,),
)
row = cur.fetchone()
if row is None:
return None
user_id, expires_at = row
if expires_at <= _now():
self.revoke(token)
return None
self._cache_put(th, str(user_id), expires_at)
return str(user_id)
def revoke(self, token: str) -> None:
th = token_hash(token)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("DELETE FROM sessions WHERE token_hash = %s", (th,))
conn.commit()
self._cache_del(th)
+174 -59
View File
@@ -1,9 +1,11 @@
"""Потокобезопасное in-memory хранилище пользователей, чатов и сообщений."""
import threading
"""Хранилище на PostgreSQL: пользователи, чаты, участники, сообщения."""
import uuid
from datetime import datetime, timezone
from typing import Any
import psycopg
from psycopg_pool import ConnectionPool
def utc_now() -> str:
"""RFC 3339 UTC с суффиксом Z, секунды — как в примерах контракта."""
@@ -14,75 +16,188 @@ def new_id() -> str:
return str(uuid.uuid4())
class Store:
"""Все данные живут в памяти одного процесса и исчезают при рестарте."""
def _iso(dt: datetime) -> str:
return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def __init__(self) -> None:
self._lock = threading.RLock()
self.users: dict[str, dict[str, Any]] = {}
self.usernames: dict[str, str] = {}
self.chats: dict[str, dict[str, Any]] = {}
self.messages: dict[str, list[dict[str, Any]]] = {}
def _user_row(row: tuple) -> dict[str, Any]:
uid, username, display_name, created_at = row
return {
"id": str(uid),
"username": username,
"display_name": display_name,
"created_at": _iso(created_at),
}
def _chat_row(row: tuple, member_ids: list[str]) -> dict[str, Any]:
cid, title, created_at = row
return {
"id": str(cid),
"title": title,
"member_ids": member_ids,
"created_at": _iso(created_at),
}
def _message_row(row: tuple) -> dict[str, Any]:
mid, chat_id, sender_id, text, created_at = row
return {
"id": str(mid),
"chat_id": str(chat_id),
"sender_id": str(sender_id),
"text": text,
"created_at": _iso(created_at),
}
class Store:
"""Все данные в PostgreSQL; соединения берутся из пула."""
def __init__(self, pool: ConnectionPool) -> None:
self.pool = pool
# --- пользователи -----------------------------------------------------
def create_user(self, username: str, display_name: str) -> dict[str, Any]:
with self._lock:
if username in self.usernames:
return None # сигнал конфликта
user = {
"id": new_id(),
"username": username,
"display_name": display_name,
"created_at": utc_now(),
}
self.users[user["id"]] = user
self.usernames[username] = user["id"]
return dict(user)
def create_user(
self, username: str, display_name: str, password_hash: str
) -> dict[str, Any] | None:
user_id = new_id()
try:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO users(id, username, display_name, password_hash, created_at)"
" VALUES (%s, %s, %s, %s, now())"
" RETURNING id, username, display_name, created_at",
(user_id, username, display_name, password_hash),
)
row = cur.fetchone()
conn.commit()
except psycopg.errors.UniqueViolation:
return None
return _user_row(row)
def get_user(self, user_id: str) -> dict[str, Any] | None:
with self._lock:
user = self.users.get(user_id)
return dict(user) if user else None
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
(user_id,),
)
row = cur.fetchone()
return _user_row(row) if row else None
def get_user_by_username(self, username: str) -> tuple[dict[str, Any], str] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, username, display_name, created_at, password_hash"
" FROM users WHERE username = %s",
(username,),
)
row = cur.fetchone()
if row is None:
return None
return _user_row(row[:4]), row[4]
# --- чаты -------------------------------------------------------------
def create_chat(self, title: str, member_ids: list[str]) -> dict[str, Any]:
with self._lock:
chat = {
"id": new_id(),
"title": title,
"member_ids": list(member_ids),
"created_at": utc_now(),
}
self.chats[chat["id"]] = chat
self.messages[chat["id"]] = []
return dict(chat)
chat_id = new_id()
with self.pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
cur.execute(
"INSERT INTO chats(id, title, created_at) VALUES (%s, %s, now())"
" RETURNING id, title, created_at",
(chat_id, title),
)
row = cur.fetchone()
cur.executemany(
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
[(chat_id, mid) for mid in member_ids],
)
return _chat_row(row, list(member_ids))
def _members(self, cur, chat_id: str) -> list[str]:
cur.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
(chat_id,),
)
return [str(r[0]) for r in cur.fetchall()]
def get_chat(self, chat_id: str) -> dict[str, Any] | None:
with self._lock:
chat = self.chats.get(chat_id)
return dict(chat) if chat else None
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,)
)
row = cur.fetchone()
if row is None:
return None
members = self._members(cur, chat_id)
return _chat_row(row, members)
def list_chats_for(self, user_id: str) -> list[dict[str, Any]]:
with self._lock:
items = [dict(c) for c in self.chats.values() if user_id in c["member_ids"]]
items.sort(key=lambda c: (c["created_at"], c["id"]))
return items
def is_member(self, chat_id: str, user_id: str) -> bool:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
)
return cur.fetchone() is not None
def list_chats_for(
self, user_id: str, limit: int, after: tuple[str, str] | None
) -> tuple[list[dict[str, Any]], bool]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
sql = (
"SELECT c.id, c.title, c.created_at FROM chats c"
" JOIN chat_members m ON m.chat_id = c.id"
" WHERE m.user_id = %s"
)
params: list[Any] = [user_id]
if after is not None:
sql += " AND (c.created_at, c.id) > (%s, %s)"
params.extend(after)
sql += " ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
cur.execute(sql, params)
rows = cur.fetchall()
items = []
for row in rows[:limit]:
items.append(_chat_row(row, self._members(cur, str(row[0]))))
return items, len(rows) > limit
# --- сообщения --------------------------------------------------------
def add_message(self, chat_id: str, sender_id: str, text: str) -> dict[str, Any]:
with self._lock:
message = {
"id": new_id(),
"chat_id": chat_id,
"sender_id": sender_id,
"text": text,
"created_at": utc_now(),
}
self.messages.setdefault(chat_id, []).append(message)
return dict(message)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO messages(id, chat_id, sender_id, text, created_at)"
" VALUES (%s, %s, %s, %s, now())"
" RETURNING id, chat_id, sender_id, text, created_at",
(new_id(), chat_id, sender_id, text),
)
row = cur.fetchone()
conn.commit()
return _message_row(row)
def list_messages(self, chat_id: str) -> list[dict[str, Any]]:
with self._lock:
items = [dict(m) for m in self.messages.get(chat_id, [])]
items.sort(key=lambda m: (m["created_at"], m["id"]))
return items
def list_messages(
self, chat_id: str, limit: int, after: tuple[str, str] | None
) -> tuple[list[dict[str, Any]], bool]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
sql = (
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
" WHERE chat_id = %s"
)
params: list[Any] = [chat_id]
if after is not None:
sql += " AND (created_at, id) > (%s, %s)"
params.extend(after)
sql += " ORDER BY created_at, id LIMIT %s"
params.append(limit + 1)
cur.execute(sql, params)
rows = cur.fetchall()
return [_message_row(r) for r in rows[:limit]], len(rows) > limit
+13 -13
View File
@@ -8,10 +8,6 @@ from .errors import ApiError
USERNAME_RE = re.compile(r"\A[a-z0-9_]{3,32}\Z")
# Уникальный идентификатор жизни процесса: cursors, выданные до рестарта,
# становятся недействительными.
CURSOR_EPOCH = uuid.uuid4().hex
def _is_blank(value: str) -> bool:
return value.strip() == ""
@@ -28,16 +24,19 @@ def reject_extra(body: dict[str, Any], allowed: set[str]) -> None:
raise ApiError(400, "invalid_request", "Неизвестные поля в теле запроса")
def validate_create_user(body: Any) -> tuple[str, str]:
def validate_create_user(body: Any) -> tuple[str, str, str]:
body = require_object(body)
reject_extra(body, {"username", "display_name"})
reject_extra(body, {"username", "display_name", "password"})
username = body.get("username")
display_name = body.get("display_name")
password = body.get("password")
if not isinstance(username, str) or not USERNAME_RE.match(username):
raise ApiError(400, "invalid_request", "Некорректный username")
if not isinstance(display_name, str) or not (1 <= len(display_name) <= 100) or _is_blank(display_name):
raise ApiError(400, "invalid_request", "Некорректный display_name")
return username, display_name
if not isinstance(password, str) or not (12 <= len(password) <= 128):
raise ApiError(400, "invalid_request", "Пароль должен быть 12..128 символов")
return username, display_name, password
def validate_create_chat(body: Any, caller_id: str) -> tuple[str, list[str]]:
@@ -96,9 +95,10 @@ def parse_limit(raw: str | None, default: int = 50) -> int:
def parse_cursor(raw: str | None, scope: str) -> tuple[str, str] | None:
"""Cursor — непрозрачная строка base64url от 'epoch|scope|created_at|id'.
"""Cursor — непрозрачная строка base64url от 'scope|created_at|id'.
Cursor привязан к ресурсу (scope) и к жизни процесса (epoch).
Cursor привязан к ресурсу (scope). Значения created_at/id — из БД,
поэтому cursor переживает рестарт процесса.
"""
if raw is None:
return None
@@ -107,10 +107,10 @@ def parse_cursor(raw: str | None, scope: str) -> tuple[str, str] | None:
except Exception:
raise ApiError(400, "invalid_request", "Некорректный cursor")
parts = decoded.split("|")
if len(parts) != 4:
if len(parts) != 3:
raise ApiError(400, "invalid_request", "Некорректный cursor")
epoch, cursor_scope, created_at, item_id = parts
if epoch != CURSOR_EPOCH or cursor_scope != scope:
cursor_scope, created_at, item_id = parts
if cursor_scope != scope:
raise ApiError(400, "invalid_request", "Некорректный cursor")
if not created_at or not item_id:
raise ApiError(400, "invalid_request", "Некорректный cursor")
@@ -118,5 +118,5 @@ def parse_cursor(raw: str | None, scope: str) -> tuple[str, str] | None:
def encode_cursor(created_at: str, item_id: str, scope: str) -> str:
raw = "|".join([CURSOR_EPOCH, scope, created_at, item_id]).encode("utf-8")
raw = "|".join([scope, created_at, item_id]).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii")
+50
View File
@@ -0,0 +1,50 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD: messenger
POSTGRES_DB: messenger
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 3s
retries: 20
redis:
image: redis:7.4-alpine
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 20
api:
build: .
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
SESSION_TTL_SECONDS: "3600"
DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger
CACHE_URL: redis://redis:6379/0
ports:
- "8080:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200 else 1)"]
interval: 5s
timeout: 3s
retries: 20
volumes:
pgdata:
redisdata:
+32
View File
@@ -0,0 +1,32 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Индекс под keyset-пагинацию истории чата: (chat_id, created_at, id).
CREATE INDEX messages_chat_created_idx ON messages(chat_id, created_at, id);
+9
View File
@@ -0,0 +1,9 @@
CREATE TABLE sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX sessions_user_idx ON sessions(user_id);
CREATE INDEX sessions_expires_idx ON sessions(expires_at);
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.115.6
uvicorn[standard]==0.32.1
psycopg[binary]==3.2.3
psycopg-pool==3.2.4
redis==5.2.1
argon2-cffi==23.1.0
+8
View File
@@ -0,0 +1,8 @@
-- Ожидаем Index Scan по messages_chat_created_idx, без Seq Scan всей истории.
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-000000000000'
AND (created_at, id) > ('2026-01-01T00:00:00Z', '00000000-0000-4000-8000-000000000000')
ORDER BY created_at, id
LIMIT 51;
+16
View File
@@ -0,0 +1,16 @@
#!/bin/sh
set -eu
# Перезапускает API и все используемые хранилища, сохраняя volumes.
# Не выполняет down -v, не flush-ит Redis, не пересоздаёт данные.
docker compose restart api postgres redis
# Ждём готовности API (тест сам ждёт /health/ready, но полезно и здесь).
i=0
while [ "$i" -lt 60 ]; do
if docker compose exec -T api python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200 else 1)" >/dev/null 2>&1; then
exit 0
fi
i=$((i+1))
sleep 1
done
echo "api did not become ready" >&2
exit 1
+97 -35
View File
@@ -28,10 +28,15 @@ BASE_URL = (
).rstrip("/")
def request(method, path, body=None, user_id=None, raw=None, content_type="application/json"):
def request(method, path, body=None, token=None, raw=None, content_type="application/json",
basic=None, extra_headers=None):
headers = {"Accept": "application/json"}
if user_id:
headers["X-User-Id"] = user_id
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
if extra_headers:
headers.update(extra_headers)
data = None
if raw is not None:
data = raw
@@ -51,9 +56,17 @@ def request(method, path, body=None, user_id=None, raw=None, content_type="appli
def make_user(label):
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
status, user = request("POST", "/api/v1/users", {"username": username, "display_name": "Тест " + label})
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Тест " + label, "password": password},
)
assert status == 201, (status, user)
return user
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
return {"user": user, "token": session["token"], "basic": basic, "password": password}
class MessengerTests(unittest.TestCase):
@@ -65,8 +78,8 @@ class MessengerTests(unittest.TestCase):
status, chat = request(
"POST",
"/api/v1/chats",
{"title": "Тестовый чат", "member_ids": [cls.alice["id"], cls.bob["id"]]},
user_id=cls.alice["id"],
{"title": "Тестовый чат", "member_ids": [cls.alice["user"]["id"], cls.bob["user"]["id"]]},
token=cls.alice["token"],
)
assert status == 201, (status, chat)
cls.chat = chat
@@ -76,13 +89,13 @@ class MessengerTests(unittest.TestCase):
"POST",
"/api/v1/chats/" + self.chat["id"] + "/messages",
raw=b"{not json",
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_foreign_chat_returns_404(self):
status, body = request("GET", "/api/v1/chats/" + self.chat["id"], user_id=self.eve["id"])
status, body = request("GET", "/api/v1/chats/" + self.chat["id"], token=self.eve["token"])
self.assertEqual(status, 404)
self.assertEqual(body["error"]["code"], "not_found")
@@ -91,25 +104,74 @@ class MessengerTests(unittest.TestCase):
"POST",
"/api/v1/chats/" + self.chat["id"] + "/messages",
{"text": " "},
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_duplicate_username(self):
username = "u_dup_" + uuid.uuid4().hex[:10]
first = request("POST", "/api/v1/users", {"username": username, "display_name": "Первый"})
password = "T3st-" + uuid.uuid4().hex
first = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Первый", "password": password},
)
self.assertEqual(first[0], 201)
second = request("POST", "/api/v1/users", {"username": username, "display_name": "Второй"})
second = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Второй", "password": password},
)
self.assertEqual(second[0], 409)
self.assertEqual(second[1]["error"]["code"], "conflict")
def test_short_password_rejected(self):
status, body = request(
"POST",
"/api/v1/users",
{"username": "u_short_" + uuid.uuid4().hex[:8], "display_name": "X", "password": "short"},
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_wrong_password_returns_401(self):
bad = base64.b64encode(
(self.alice["user"]["username"] + ":wrong-password-123").encode()
).decode()
status, body = request("POST", "/api/v1/auth/sessions", basic=bad)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_basic_not_accepted_on_business_endpoint(self):
status, body = request("GET", "/api/v1/users/me", basic=self.alice["basic"])
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_x_user_id_ignored(self):
status, body = request(
"GET",
"/api/v1/users/me",
token=self.alice["token"],
extra_headers={"X-User-Id": self.eve["user"]["id"]},
)
self.assertEqual(status, 200)
self.assertEqual(body["id"], self.alice["user"]["id"])
def test_logout_revokes_session(self):
user = make_user("logout")
status, _ = request("DELETE", "/api/v1/auth/sessions/current", token=user["token"])
self.assertEqual(status, 204)
status, body = request("GET", "/api/v1/users/me", token=user["token"])
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_pagination_walks_all_pages(self):
chat = request(
"POST",
"/api/v1/chats",
{"title": "Пагинация", "member_ids": [self.alice["id"], self.bob["id"]]},
user_id=self.alice["id"],
{"title": "Пагинация", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
sent = []
for i in range(7):
@@ -117,7 +179,7 @@ class MessengerTests(unittest.TestCase):
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "msg-%d" % i},
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 201)
sent.append(msg["id"])
@@ -127,7 +189,7 @@ class MessengerTests(unittest.TestCase):
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=2"
if cursor:
path += "&cursor=" + cursor
status, page = request("GET", path, user_id=self.bob["id"])
status, page = request("GET", path, token=self.bob["token"])
self.assertEqual(status, 200)
collected.extend(m["id"] for m in page["items"])
cursor = page["next_cursor"]
@@ -139,26 +201,26 @@ class MessengerTests(unittest.TestCase):
chat_a = request(
"POST",
"/api/v1/chats",
{"title": "Cursor A", "member_ids": [self.alice["id"], self.bob["id"]]},
user_id=self.alice["id"],
{"title": "Cursor A", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
chat_b = request(
"POST",
"/api/v1/chats",
{"title": "Cursor B", "member_ids": [self.alice["id"], self.bob["id"]]},
user_id=self.alice["id"],
{"title": "Cursor B", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
for i in range(3):
request(
"POST",
"/api/v1/chats/" + chat_a["id"] + "/messages",
{"text": "a-%d" % i},
user_id=self.alice["id"],
token=self.alice["token"],
)
status, page = request(
"GET",
"/api/v1/chats/" + chat_a["id"] + "/messages?limit=1",
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 200)
cursor = page["next_cursor"]
@@ -166,14 +228,14 @@ class MessengerTests(unittest.TestCase):
status, body = request(
"GET",
"/api/v1/chats/" + chat_b["id"] + "/messages?limit=1&cursor=" + cursor,
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_cursor_bound_to_endpoint(self):
status, page = request(
"GET", "/api/v1/chats?limit=1", user_id=self.alice["id"]
"GET", "/api/v1/chats?limit=1", token=self.alice["token"]
)
self.assertEqual(status, 200)
cursor = page["next_cursor"]
@@ -181,7 +243,7 @@ class MessengerTests(unittest.TestCase):
status, body = request(
"GET",
"/api/v1/chats/" + self.chat["id"] + "/messages?limit=1&cursor=" + cursor,
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
@@ -191,25 +253,25 @@ class MessengerTests(unittest.TestCase):
status, body = request(
"GET",
"/api/v1/chats/" + self.chat["id"] + "/messages?cursor=" + garbage,
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_invalid_chat_id_returns_400(self):
status, body = request("GET", "/api/v1/chats/not-a-uuid", user_id=self.alice["id"])
status, body = request("GET", "/api/v1/chats/not-a-uuid", token=self.alice["token"])
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
status, body = request(
"POST",
"/api/v1/chats/not-a-uuid/messages",
{"text": "hi"},
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
status, body = request(
"GET", "/api/v1/chats/not-a-uuid/messages", user_id=self.alice["id"]
"GET", "/api/v1/chats/not-a-uuid/messages", token=self.alice["token"]
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
@@ -218,7 +280,7 @@ class MessengerTests(unittest.TestCase):
status, body = request(
"POST",
"/api/v1/users",
{"username": "abc\n", "display_name": "Имя"},
{"username": "abc\n", "display_name": "Имя", "password": "T3st-" + uuid.uuid4().hex},
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
@@ -228,7 +290,7 @@ class MessengerTests(unittest.TestCase):
"POST",
"/api/v1/users",
raw=b"\xff",
user_id=self.alice["id"],
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
@@ -239,8 +301,8 @@ class MessengerTests(unittest.TestCase):
chat = request(
"POST",
"/api/v1/chats",
{"title": "Конкурентность", "member_ids": [self.alice["id"], self.bob["id"]]},
user_id=self.alice["id"],
{"title": "Конкурентность", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
errors = []
lock = threading.Lock()
@@ -251,7 +313,7 @@ class MessengerTests(unittest.TestCase):
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "w%d-%d" % (worker_id, i)},
user_id=self.alice["id"],
token=self.alice["token"],
)
if status != 201:
with lock:
@@ -264,7 +326,7 @@ class MessengerTests(unittest.TestCase):
t.join()
self.assertEqual(errors, [])
status, page = request(
"GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", user_id=self.alice["id"]
"GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", token=self.alice["token"]
)
self.assertEqual(status, 200)
ids = [m["id"] for m in page["items"]]