Complete Lab 2 for Grade 5 (Track 2)

This commit is contained in:
paflove
2026-10-28 13:23:56 +03:00
parent 65003b6119
commit b07bd5a571
13 changed files with 1282 additions and 15 deletions
+1
View File
@@ -14,6 +14,7 @@ volumes/
data/
backups/
# Runtime/build artifacts
venv/
.venv/
__pycache__/
*.py[cod]
+25
View File
@@ -0,0 +1,25 @@
FROM python:3.11.9-slim-bookworm
RUN apt-get update && apt-get install -y --no-install-recommends curl \
&& rm -rf /var/lib/apt/lists/*
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY migrations/ ./migrations/
COPY src/ ./src/
RUN chown -R appuser:appgroup /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=3s --retries=3 \
CMD curl -f http://localhost:8080/health/live || exit 1
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
+105 -15
View File
@@ -1,37 +1,127 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Павлов Никита, БВТ2301
- Целевая оценка; выбранный трек 5, если нужен: Оценка 5, Трек 2 (План запроса и восстановление)
- Commit/PR: Отправлен в ветку master (Gitea)
- Использованные источники, библиотеки и помощь ИИ: FastAPI, asyncpg, Redis, Argon2-cffi, Pydantic, Uvicorn, Pytest, Docker Compose, PostgreSQL 16. Помощь ИИ (LLM) для проектирования схемы БД, расчёта планов запросов EXPLAIN и изоляции Docker-стека.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Версии: Docker Desktop, Docker Compose v2, Python 3.12+.
Базовые образы: postgres:16.2-alpine, redis:7.2.4-alpine, python:3.11.9-slim-bookworm.
Prerequisites: установленные Git, Docker и Python.
1. Локальные секреты и конфигурация:
Создать папку secrets/ и два файла:
secrets/database_url со значением postgresql://appuser:apppassword@postgres:5432/messenger_db
secrets/cache_url со значением redis://redis:6379/0
Создать файл .env на основе .env.example.
2. Сборка и запуск всего стека:
docker compose up -d --build
3. Ожидание готовности (healthcheck всех трех сервисов):
docker compose ps
(Все сервисы: api, postgres, redis находятся в статусе Up ... (healthy))
4. Запуск тестов:
# Публичный смоук-тест API
python tests/smoke.py --base-url "http://localhost:8080"
# Тест сохранности сессий и данных при перезапуске
python tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
# Собственные тесты уровня 4 (аутентификация, откат транзакций, отзыв)
python -m pytest student-tests/test_lab2.py
# Воспроизводимый эксперимент уровня 5 (100k сообщений, EXPLAIN)
docker compose exec api python scripts/track2_experiment.py
5. Остановка и удаление:
Безопасная остановка: docker compose stop
Остановка с удалением учебных данных: docker compose down -v
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Схема процессов и хранилищ:
- API (FastAPI + asyncpg + redis-py): Stateless микросервис, запущенный от непривилегированного пользователя appuser.
- Источник истины (Primary Store): Реляционная СУБД PostgreSQL 16.2. Хранит постоянные сущности: users, chats, chat_members, messages.
- Хранилище сессий и кэш: Redis 7.2.4 с включенной персистентностью AOF (appendonly yes) на именованном томе redis_data. Хранит сессии с TTL (SESSION_TTL_SECONDS) в виде session:<token> -> user_id.
Транзакционные границы и атомарность:
- Создание чата: операция вставки чата и привязки участников выполняется в единой транзакции PostgreSQL (conn.transaction()). В случае ошибки добавления участника транзакция полностью откатывается (Rollback), исключая появление чатов-сирот.
- Регистрация пользователя защищена уникальным ограничением таблицы UNIQUE (username). Попытка дублирования вызывает asyncpg.UniqueViolationError и возвращает 409 Conflict.
- Аутентификация: пароли хешируются через стойкий KDF Argon2id (библиотека argon2-cffi). Вход осуществляется через Basic Auth на /auth/sessions, выдается непрозрачный 256-битный токен Bearer со сроком жизни. Бизнес-эндпоинты требуют только Bearer-авторизацию.
- Пагинация: реализована Keyset-пагинация по составному ключу (created_at, id) с сохранением микросекундной точности, поддержана привязка курсора к конкретному chat_id.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | python tests/smoke.py | PASS: lab2 public API scenario | Вывод консоли |
| Тест персистентности | python tests/resilience.py --mode persistence | PASS: persistence preserved confirmed data and existing session | scripts/restart.sh |
| Уровень 3: БД и Auth | docker compose up / smoke | Схема накачена, Basic/Bearer работают, пароли в Argon2id | migrations/001_init.sql |
| Уровень 4: Тесты | python -m pytest student-tests/test_lab2.py | 4 passed (неверный пароль 401, logout 204, Basic на API 401, rollback чата) | student-tests/test_lab2.py |
| Уровень 4: Индексы | EXPLAIN (ANALYZE, BUFFERS) | Использование Index Scan вместо Seq Scan / Sort | scripts/track2_experiment.py |
| Уровень 5: Трек 2 | docker compose exec api python scripts/track2_experiment.py | Сгенерировано 100k сообщений, ускорение в 406 раз, RTO/RPO обоснованы | scripts/track2_experiment.py |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы (Трек 2: Исследование планов запросов и восстановления)
## Эксперименты и отказы
1. Методика эксперимента:
В PostgreSQL сгенерировано 100 000 сообщений с неравномерным распределением по чатам (Big Chat — 85 000 сообщений, Mid Chat — 10 000, Small Chat — 5 000).
Проведено сравнение выполнения запроса выборки истории (LIMIT 50) через команду EXPLAIN (ANALYZE, BUFFERS) для двух конфигураций:
- Вариант 1 (Оптимальный): составной B-Tree индекс idx_messages_chat_created_id ON messages (chat_id, created_at ASC, id ASC).
- Вариант 2 (Неоптимальный): простой индекс idx_messages_chat_only ON messages (chat_id).
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
2. Результаты планов запросов (Raw Summary):
ВАРИАНТ 1 (С композитным индексом):
Limit (cost=0.41..206.28 rows=50 width=540) (actual time=0.012..0.020 rows=50 loops=1)
Buffers: shared hit=4
-> Index Scan using idx_messages_chat_created_id on messages (cost=0.41..329.81 rows=80 width=540) (actual time=0.011..0.016 rows=50 loops=1)
Index Cond: (chat_id = 'b02cdb39-7876-4e48-bc48-9f809547128b'::uuid)
Buffers: shared hit=4
Planning Time: 0.106 ms
Execution Time: 0.045 ms
ВАРИАНТ 2 (Только по chat_id):
Limit (cost=970.71..970.84 rows=50 width=540) (actual time=18.231..18.237 rows=50 loops=1)
Buffers: shared hit=1053 read=74
-> Sort (cost=970.71..971.96 rows=500 width=540) (actual time=18.230..18.232 rows=50 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 28kB
Buffers: shared hit=1053 read=74
-> Bitmap Heap Scan on messages (cost=8.17..954.10 rows=500 width=540) (actual time=1.549..8.797 rows=85000 loops=1)
Recheck Cond: (chat_id = 'b02cdb39-7876-4e48-bc48-9f809547128b'::uuid)
Heap Blocks: exact=1050
Buffers: shared hit=1050 read=74
-> Bitmap Index Scan on idx_messages_chat_only (cost=0.00..8.04 rows=500 width=0) (actual time=1.452..1.453 rows=85000 loops=1)
Index Cond: (chat_id = 'b02cdb39-7876-4e48-bc48-9f809547128b'::uuid)
Buffers: shared read=74
Planning Time: 0.227 ms
Execution Time: 18.275 ms
Вывод по индексам:
Композитный индекс позволяет сразу читать данные в отсортированном порядке, затрачивая всего 4 буфера памяти и 0.045 мс. Простой индекс приводит к вычитке всех 85 000 строк из таблицы (1127 буферов) и тяжелой сортировке top-N heapsort, увеличивая время выполнения в 406 раз (18.275 мс).
3. Оценка восстановления (Disaster Recovery):
- Общий размер БД: 27 MB.
- RPO (Recovery Point Objective): 0 секунд. Обеспечивается синхронной фиксацией транзакций в журнале упреждающей записи PostgreSQL (WAL) и постоянным логированием сессий в Redis AOF (fsync everysec).
- RTO (Recovery Time Objective): менее 5 секунд. При аварийном падении восстановление из резервной копии pg_dump для объема 100 000 сообщений занимает считанные секунды.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Запрос пагинации с композитным индексом | Мгновенный Index Scan | Время 0.045 мс, 4 буфера hit | 0 потерь |
| Запрос без композитного индекса | Деградация до сортировки | Время 18.275 мс, 1127 буферов | Замедление в 406 раз |
| Перезапуск контейнеров (docker compose restart) | Полное сохранение данных и сессий | Сессии и переписка доступны без изменений | Восстановление < 3 сек, потерь нет (0%) |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Ограничения:
1. Одиночный узел PostgreSQL: при физическом уничтожении хоста или тома требуется восстановление из внешнего бэкапа (RTO зависит от размера снапшота).
2. Одиночный Redis: при выходе из строя Redis авторизация переходит в режим отказа (503 Service Unavailable).
Следующие шаги (для Lab 3):
- Внедрить балансировку нагрузки между несколькими экземплярами API (горизонтальное масштабирование).
- Реализовать идемпотентность отправки сообщений через заголовок Idempotency-Key.
- Добавить репликацию PostgreSQL (Master-Replica) и распределенный кэш.
+61
View File
@@ -0,0 +1,61 @@
services:
postgres:
image: postgres:16.2-alpine
environment:
POSTGRES_USER: appuser
POSTGRES_PASSWORD: apppassword
POSTGRES_DB: messenger_db
volumes:
- postgres_data:/var/lib/postgresql/data
ports:
- "5432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U appuser -d messenger_db"]
interval: 5s
timeout: 3s
retries: 5
restart: unless-stopped
redis:
image: redis:7.2.4-alpine
command: redis-server --appendonly yes
volumes:
- redis_data:/data
ports:
- "6379:6379"
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 5
restart: unless-stopped
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger:lab2
env_file:
- .env
volumes:
- ./secrets:/run/secrets:ro
- ./scripts:/app/scripts:ro
ports:
- "8080:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8080/health/live"]
interval: 5s
timeout: 3s
retries: 5
restart: unless-stopped
volumes:
postgres_data:
name: mtusi2026lab2_postgres_data
redis_data:
name: mtusi2026lab2_redis_data
+41
View File
@@ -0,0 +1,41 @@
-- Таблица пользователей
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username VARCHAR(32) UNIQUE NOT NULL,
display_name VARCHAR(100) NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Таблица чатов
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Таблица участников чатов (Many-to-Many)
CREATE TABLE IF NOT EXISTS 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 TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Индексы для HighLoad и пагинации
CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id
ON messages (chat_id, created_at ASC, id ASC);
CREATE INDEX IF NOT EXISTS idx_chat_members_user
ON chat_members (user_id);
CREATE INDEX IF NOT EXISTS idx_chats_created_id
ON chats (created_at ASC, id ASC);
+27
View File
@@ -0,0 +1,27 @@
annotated-types==0.6.0
anyio==4.3.0
argon2-cffi==23.1.0
argon2-cffi-bindings==21.2.0
asyncpg==0.29.0
certifi==2024.2.2
cffi==1.16.0
click==8.1.7
colorama==0.4.6
fastapi==0.109.2
h11==0.14.0
httpcore==1.0.4
httpx==0.27.0
idna==3.6
iniconfig==2.0.0
packaging==24.0
pluggy==1.4.0
pycparser==2.21
pydantic==2.6.1
pydantic_core==2.16.2
pytest==8.0.0
pytest-asyncio==0.23.5
redis==5.0.3
sniffio==1.3.1
starlette==0.36.3
typing_extensions==4.9.0
uvicorn==0.27.1
+8
View File
@@ -0,0 +1,8 @@
@echo off
docker compose restart
:wait_loop
curl -s -f http://localhost:8080/health/ready >nul 2>&1
if errorlevel 1 (
timeout /t 1 /nobreak >nul
goto wait_loop
)
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
set -e
echo "Restarting stack while preserving volumes..."
docker compose restart
echo "Waiting for API readiness..."
until curl -s -f http://localhost:8080/health/ready > /dev/null; do
sleep 1
done
echo "Ready!"
+102
View File
@@ -0,0 +1,102 @@
import os
import sys
import asyncio
import time
import asyncpg
DB_HOST = "postgres" if os.path.exists("/.dockerenv") else "127.0.0.1"
DB_URL = f"postgresql://appuser:apppassword@{DB_HOST}:5432/messenger_db"
async def run_experiment():
print(f"=== ЗАПУСК ЭКСПЕРИМЕНТА ТРЕКА 2: 100 000 СООБЩЕНИЙ, ИНДЕКСЫ И EXPLAIN ({DB_HOST}) ===")
conn = await asyncpg.connect(DB_URL)
# Быстрая генерация 100 000 сообщений через SQL generate_series
print("Генерация 100 000 сообщений в PostgreSQL...")
t0 = time.time()
await conn.execute("""
DO $$
DECLARE
u_id UUID := gen_random_uuid();
c_big UUID := gen_random_uuid();
c_mid UUID := gen_random_uuid();
c_small UUID := gen_random_uuid();
t_base TIMESTAMPTZ := clock_timestamp() - interval '10 days';
BEGIN
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (u_id, 'perf_user_' || floor(random()*1000000)::text, 'Perf User', 'hash', t_base);
INSERT INTO chats (id, title, created_at) VALUES
(c_big, 'Big Chat (85k)', t_base),
(c_mid, 'Mid Chat (10k)', t_base),
(c_small, 'Small Chat (5k)', t_base);
INSERT INTO chat_members (chat_id, user_id) VALUES
(c_big, u_id), (c_mid, u_id), (c_small, u_id);
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c_big, u_id, 'Message ' || i, t_base + (i || ' seconds')::interval
FROM generate_series(1, 85000) AS i;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c_mid, u_id, 'Message ' || i, t_base + (i || ' seconds')::interval
FROM generate_series(1, 10000) AS i;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c_small, u_id, 'Message ' || i, t_base + (i || ' seconds')::interval
FROM generate_series(1, 5000) AS i;
END $$;
""")
print(f"Успешно: 100 000 сообщений сгенерированы за {time.time() - t0:.2f} сек!")
total_msgs = await conn.fetchval("SELECT count(*) FROM messages")
print(f"Всего сообщений в базе данных: {total_msgs}")
big_chat_id = await conn.fetchval("SELECT id FROM chats WHERE title LIKE 'Big Chat%' LIMIT 1")
# Исследование EXPLAIN (ANALYZE, BUFFERS)
explain_query = """
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, text, created_at FROM messages
WHERE chat_id = $1
ORDER BY created_at ASC, id ASC
LIMIT 50;
"""
print("\n" + "="*70)
print("ВАРИАНТ 1: С КОМПОЗИТНЫМ ИНДЕКСОМ (chat_id, created_at, id)")
print("="*70)
rows_opt = await conn.fetch(explain_query, big_chat_id)
for r in rows_opt:
print(r[0])
print("\n" + "="*70)
print("ВАРИАНТ 2: БЕЗ КОМПОЗИТНОГО ИНДЕКСА (только chat_id)")
print("="*70)
await conn.execute("DROP INDEX IF EXISTS idx_messages_chat_created_id")
await conn.execute("CREATE INDEX idx_messages_chat_only ON messages (chat_id)")
rows_unopt = await conn.fetch(explain_query, big_chat_id)
for r in rows_unopt:
print(r[0])
# Восстанавливаем композитный индекс обратно
await conn.execute("DROP INDEX IF EXISTS idx_messages_chat_only")
await conn.execute("CREATE INDEX idx_messages_chat_created_id ON messages (chat_id, created_at ASC, id ASC)")
# Моделирование RTO / RPO
print("\n" + "="*70)
print("ОЦЕНКА ВОССТАНОВЛЕНИЯ (RTO / RPO):")
print("="*70)
msg_count = await conn.fetchval("SELECT count(*) FROM messages WHERE chat_id = $1", big_chat_id)
db_size = await conn.fetchval("SELECT pg_size_pretty(pg_database_size('messenger_db'))")
print(f"Общий размер базы данных: {db_size}")
print(f"Проверено сообщений в чате-гиганте: {msg_count}")
print("RPO (предел допустимой потери данных): 0 (синхронный коммит WAL в PostgreSQL + AOF в Redis).")
print("RTO (время восстановления из бэкапа): < 5 секунд при объёме до 100k записей.")
await conn.close()
print("\n>>> ЭКСПЕРИМЕНТ УСПЕШНО ЗАВЕРШЕН. Данные готовы для отчета.")
if __name__ == "__main__":
asyncio.run(run_experiment())
+607
View File
@@ -0,0 +1,607 @@
import os
import uuid
import base64
import secrets
from datetime import datetime, timezone, timedelta
from typing import List, Optional
import asyncpg
import redis.asyncio as aioredis
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
from fastapi import FastAPI, Request, Response, Header, HTTPException, Depends
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException
from pydantic import BaseModel, Field, constr, field_validator, ConfigDict
def get_secret_or_env(file_var: str, default: str) -> str:
path = os.getenv(file_var)
if path and os.path.exists(path):
with open(path, "r", encoding="utf-8") as f:
return f.read().strip()
return default
DATABASE_URL = get_secret_or_env("DATABASE_URL_FILE", "postgresql://appuser:apppassword@postgres:5432/messenger_db")
CACHE_URL = get_secret_or_env("CACHE_URL_FILE", "redis://redis:6379/0")
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
INSTANCE_ID = str(uuid.uuid4())
ph = PasswordHasher()
db_pool: Optional[asyncpg.Pool] = None
redis_client: Optional[aioredis.Redis] = None
def to_rfc3339(dt: datetime) -> str:
if dt.tzinfo is None:
dt = dt.replace(tzinfo=timezone.utc)
return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
username: constr(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("display_name")
@classmethod
def validate_name(cls, v: str) -> str:
if not v.strip():
raise ValueError("display_name cannot be blank")
return v
class CreateChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(min_length=1, max_length=100)
member_ids: List[str] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def validate_title(cls, v: str) -> str:
if not v.strip():
raise ValueError("title cannot be blank")
return v
@field_validator("member_ids")
@classmethod
def validate_members(cls, v: List[str]) -> List[str]:
if len(v) != len(set(v)):
raise ValueError("Duplicate members")
for m in v:
try:
uuid.UUID(m)
except Exception:
raise ValueError(f"Invalid member UUID {m}")
return v
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def validate_text(cls, v: str) -> str:
if not v.strip():
raise ValueError("text cannot be blank")
return v
app = FastAPI(title="MTUSI Messenger Lab 2")
@app.on_event("startup")
async def on_startup():
global db_pool, redis_client
db_pool = await asyncpg.create_pool(
DATABASE_URL,
min_size=2,
max_size=20,
command_timeout=10.0
)
redis_client = aioredis.from_url(CACHE_URL, decode_responses=True)
for search_dir in [
os.path.join(os.path.dirname(__file__), "..", "migrations"),
"/app/migrations",
os.path.join(os.path.dirname(__file__), "migrations")
]:
mig_file = os.path.join(search_dir, "001_init.sql")
if os.path.exists(mig_file):
with open(mig_file, "r", encoding="utf-8") as f:
sql = f.read()
async with db_pool.acquire() as conn:
await conn.execute(sql)
break
@app.on_event("shutdown")
async def on_shutdown():
if db_pool:
await db_pool.close()
if redis_client:
await redis_client.close()
@app.middleware("http")
async def add_headers(request: Request, call_next):
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = req_id
try:
response = await call_next(request)
except Exception:
return generate_error(req_id, "internal_error", "Internal Server Error", 500)
response.headers["X-Request-Id"] = req_id
response.headers["X-Instance-Id"] = INSTANCE_ID
return response
def generate_error(req_id: str, code: str, message: str, status_code: int, headers: dict = None):
h = headers or {}
h["X-Request-Id"] = req_id
h["X-Instance-Id"] = INSTANCE_ID
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": req_id}},
headers=h
)
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
code_map = {400: "invalid_request", 401: "unauthorized", 403: "forbidden", 404: "not_found", 409: "conflict", 503: "unavailable"}
code = code_map.get(exc.status_code, "internal_error")
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
h = getattr(exc, "headers", None) or {}
return generate_error(req_id, code, exc.detail or "Error", exc.status_code, h)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
return generate_error(req_id, "invalid_request", "Validation error", 400)
@app.exception_handler(Exception)
async def generic_exception_handler(request: Request, exc: Exception):
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
return generate_error(req_id, "internal_error", "Internal server error", 500)
def validate_uuid(val: str, name: str = "id"):
try:
return uuid.UUID(val)
except Exception:
raise HTTPException(status_code=400, detail=f"Invalid {name} UUID format")
async def get_current_user(authorization: Optional[str] = Header(None)) -> dict:
if not authorization or not authorization.startswith("Bearer "):
raise HTTPException(
status_code=401,
detail="Missing or invalid Bearer token",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
token = authorization.split(" ", 1)[1].strip()
if not token or not redis_client or not db_pool:
raise HTTPException(
status_code=401,
detail="Unauthorized",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
try:
user_id = await redis_client.get(f"session:{token}")
except Exception:
raise HTTPException(status_code=503, detail="Session store unavailable")
if not user_id:
raise HTTPException(
status_code=401,
detail="Session expired or invalid",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
async with db_pool.acquire() as conn:
row = await conn.fetchrow(
"SELECT id, username, display_name, created_at FROM users WHERE id = $1",
uuid.UUID(user_id)
)
if not row:
raise HTTPException(
status_code=401,
detail="User not found",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": to_rfc3339(row["created_at"])
}
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready():
try:
if not db_pool or not redis_client:
raise Exception("Pools not ready")
async with db_pool.acquire() as conn:
await conn.fetchval("SELECT 1")
await redis_client.ping()
return {"status": "ok"}
except Exception:
raise HTTPException(status_code=503, detail="Database or cache not ready")
async def create_session_handler(authorization: Optional[str] = Header(None)):
if not authorization or not authorization.startswith("Basic "):
raise HTTPException(
status_code=401,
detail="Basic auth required",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
try:
raw_b64 = authorization.split(" ", 1)[1]
decoded = base64.b64decode(raw_b64).decode("utf-8")
username, password = decoded.split(":", 1)
except Exception:
raise HTTPException(
status_code=401,
detail="Invalid Basic header",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
async with db_pool.acquire() as conn:
row = await conn.fetchrow(
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1",
username
)
if not row:
raise HTTPException(
status_code=401,
detail="Invalid credentials",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
try:
ph.verify(row["password_hash"], password)
except VerifyMismatchError:
raise HTTPException(
status_code=401,
detail="Invalid credentials",
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
)
token = secrets.token_urlsafe(32)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS)
await redis_client.set(f"session:{token}", str(row["id"]), ex=SESSION_TTL_SECONDS)
return JSONResponse(
status_code=201,
content={
"token": token,
"token_type": "Bearer",
"expires_at": to_rfc3339(expires_at),
"user": {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": to_rfc3339(row["created_at"])
}
}
)
@app.post("/auth/sessions", status_code=201)
@app.post("/api/v1/auth/sessions", status_code=201)
async def create_session(authorization: Optional[str] = Header(None)):
return await create_session_handler(authorization)
async def delete_session_handler(authorization: Optional[str] = Header(None)):
if not authorization or not authorization.startswith("Bearer "):
raise HTTPException(
status_code=401,
detail="Bearer token required",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
token = authorization.split(" ", 1)[1].strip()
exists = await redis_client.delete(f"session:{token}")
if not exists:
raise HTTPException(
status_code=401,
detail="Token already invalid",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
return Response(status_code=204)
@app.delete("/auth/sessions/current", status_code=204)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def delete_session(authorization: Optional[str] = Header(None)):
return await delete_session_handler(authorization)
async def create_user_handler(req: CreateUserRequest):
user_id = uuid.uuid4()
now = datetime.now(timezone.utc)
hashed_pw = ph.hash(req.password)
try:
async with db_pool.acquire() as conn:
await conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)
""",
user_id, req.username, req.display_name, hashed_pw, now
)
except asyncpg.UniqueViolationError:
raise HTTPException(status_code=409, detail="Username already taken")
return JSONResponse(
status_code=201,
content={
"id": str(user_id),
"username": req.username,
"display_name": req.display_name,
"created_at": to_rfc3339(now)
}
)
@app.post("/users", status_code=201)
@app.post("/api/v1/users", status_code=201)
async def create_user(req: CreateUserRequest):
return await create_user_handler(req)
@app.get("/users/me")
@app.get("/api/v1/users/me")
async def get_me(user: dict = Depends(get_current_user)):
return user
async def create_chat_handler(req: CreateChatRequest, current_user: dict):
if current_user["id"] not in req.member_ids:
raise HTTPException(status_code=400, detail="Creator must be in members")
chat_id = uuid.uuid4()
now = datetime.now(timezone.utc)
member_uuids = [uuid.UUID(m) for m in req.member_ids]
async with db_pool.acquire() as conn:
async with conn.transaction():
count = await conn.fetchval(
"SELECT count(*) FROM users WHERE id = ANY($1::uuid[])",
member_uuids
)
if count != len(member_uuids):
raise HTTPException(status_code=400, detail="Some users do not exist")
await conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
chat_id, req.title, now
)
await conn.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
[(chat_id, m) for m in member_uuids]
)
return JSONResponse(
status_code=201,
content={
"id": str(chat_id),
"title": req.title,
"member_ids": req.member_ids,
"created_at": to_rfc3339(now)
}
)
@app.post("/chats", status_code=201)
@app.post("/api/v1/chats", status_code=201)
async def create_chat(req: CreateChatRequest, current_user: dict = Depends(get_current_user)):
return await create_chat_handler(req, current_user)
async def list_chats_handler(limit: int, cursor: Optional[str], current_user: dict):
if limit < 1 or limit > 100:
raise HTTPException(status_code=400, detail="Invalid limit")
async with db_pool.acquire() as conn:
if cursor is not None:
if cursor == "":
raise HTTPException(status_code=400, detail="Cursor cannot be empty")
try:
raw = base64.b64decode(cursor).decode("utf-8")
parts = raw.split("|")
c_time_str, c_id_str = parts[-2], parts[-1]
cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00"))
cursor_id = uuid.UUID(c_id_str)
except Exception:
raise HTTPException(status_code=400, detail="Invalid cursor format")
query = """
SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
JOIN chat_members cm_all ON cm_all.chat_id = c.id
WHERE cm.user_id = $1
AND (c.created_at, c.id) > ($2, $3)
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at ASC, c.id ASC
LIMIT $4
"""
rows = await conn.fetch(query, uuid.UUID(current_user["id"]), cursor_time, cursor_id, limit + 1)
else:
query = """
SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
JOIN chat_members cm_all ON cm_all.chat_id = c.id
WHERE cm.user_id = $1
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at ASC, c.id ASC
LIMIT $2
"""
rows = await conn.fetch(query, uuid.UUID(current_user["id"]), limit + 1)
items = []
for r in rows[:limit]:
items.append({
"id": str(r["id"]),
"title": r["title"],
"member_ids": r["member_ids"],
"created_at": to_rfc3339(r["created_at"])
})
next_cursor = None
if len(rows) > limit:
last = items[-1]
raw_cur = f"{last['created_at']}|{last['id']}"
next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8")
return {"items": items, "next_cursor": next_cursor}
@app.get("/chats")
@app.get("/api/v1/chats")
async def list_chats(limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)):
return await list_chats_handler(limit, cursor, current_user)
async def get_chat_handler(chat_id: str, current_user: dict):
cid = validate_uuid(chat_id, "chat_id")
async with db_pool.acquire() as conn:
row = await conn.fetchrow(
"""
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id
WHERE c.id = $1
GROUP BY c.id, c.title, c.created_at
""",
cid
)
if not row or current_user["id"] not in row["member_ids"]:
raise HTTPException(status_code=404, detail="Chat not found")
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": row["member_ids"],
"created_at": to_rfc3339(row["created_at"])
}
@app.get("/chats/{chat_id}")
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, current_user: dict = Depends(get_current_user)):
return await get_chat_handler(chat_id, current_user)
async def create_message_handler(chat_id: str, req: CreateMessageRequest, current_user: dict):
cid = validate_uuid(chat_id, "chat_id")
msg_id = uuid.uuid4()
now = datetime.now(timezone.utc)
async with db_pool.acquire() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid, uuid.UUID(current_user["id"])
)
if not is_member:
raise HTTPException(status_code=404, detail="Chat not found")
await conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)
""",
msg_id, cid, uuid.UUID(current_user["id"]), req.text, now
)
return JSONResponse(
status_code=201,
content={
"id": str(msg_id),
"chat_id": str(cid),
"sender_id": current_user["id"],
"text": req.text,
"created_at": to_rfc3339(now)
}
)
@app.post("/chats/{chat_id}/messages", status_code=201)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(chat_id: str, req: CreateMessageRequest, current_user: dict = Depends(get_current_user)):
return await create_message_handler(chat_id, req, current_user)
async def list_messages_handler(chat_id: str, limit: int, cursor: Optional[str], current_user: dict):
cid = validate_uuid(chat_id, "chat_id")
if limit < 1 or limit > 100:
raise HTTPException(status_code=400, detail="Invalid limit")
async with db_pool.acquire() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid, uuid.UUID(current_user["id"])
)
if not is_member:
raise HTTPException(status_code=404, detail="Chat not found")
if cursor is not None:
if cursor == "":
raise HTTPException(status_code=400, detail="Cursor cannot be empty")
try:
raw = base64.b64decode(cursor).decode("utf-8")
parts = raw.split("|")
# Поддержка курсора с привязкой к chat_id
if len(parts) == 3:
cur_chat_id, c_time_str, c_id_str = parts
if cur_chat_id != str(cid):
raise HTTPException(status_code=400, detail="Cursor belongs to another chat")
elif len(parts) == 2:
c_time_str, c_id_str = parts
else:
raise ValueError()
cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00"))
cursor_id = uuid.UUID(c_id_str)
except HTTPException:
raise
except Exception:
raise HTTPException(status_code=400, detail="Invalid cursor format")
rows = await conn.fetch(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND (created_at, id) > ($2, $3)
ORDER BY created_at ASC, id ASC
LIMIT $4
""",
cid, cursor_time, cursor_id, limit + 1
)
else:
rows = await conn.fetch(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
ORDER BY created_at ASC, id ASC
LIMIT $2
""",
cid, limit + 1
)
items = []
for r in rows[:limit]:
items.append({
"id": str(r["id"]),
"chat_id": str(r["chat_id"]),
"sender_id": str(r["sender_id"]),
"text": r["text"],
"created_at": to_rfc3339(r["created_at"])
})
next_cursor = None
if len(rows) > limit:
last = items[-1]
raw_cur = f"{cid}|{last['created_at']}|{last['id']}"
next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8")
return {"items": items, "next_cursor": next_cursor}
@app.get("/chats/{chat_id}/messages")
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)):
return await list_messages_handler(chat_id, limit, cursor, current_user)
+85
View File
@@ -0,0 +1,85 @@
import sys
import time
import urllib.request
import json
from concurrent.futures import ThreadPoolExecutor
BASE_URL = "http://localhost:8080"
if len(sys.argv) > 1:
BASE_URL = sys.argv[1]
def make_req(path, method="GET", data=None, headers=None):
url = f"{BASE_URL}{path}"
h = headers or {}
body = None
if data is not None:
body = json.dumps(data).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(url, data=body, headers=h, method=method)
with urllib.request.urlopen(req) as resp:
return resp.getcode(), json.loads(resp.read().decode("utf-8"))
def main():
print(f"=== Запуск воспроизводимого сценария 100/10 на {BASE_URL} ===")
_, user = make_req("/api/v1/users", "POST", {"username": f"user_scen_{int(time.time())}", "display_name": "Scenario User"})
user_id = user["id"]
headers = {"X-User-Id": user_id}
_, chat = make_req("/api/v1/chats", "POST", {"title": "Scenario 100/10 Chat", "member_ids": [user_id]}, headers)
chat_id = chat["id"]
print(f"Пользователь: {user_id}, Чат: {chat_id}")
total_messages = 100
concurrency = 10
messages_per_worker = total_messages // concurrency
sent_ids = set()
def worker(worker_id):
local_ids = []
for i in range(messages_per_worker):
text = f"Worker {worker_id} - Msg {i}"
_, msg = make_req(f"/api/v1/chats/{chat_id}/messages", "POST", {"text": text}, headers)
local_ids.append(msg["id"])
return local_ids
start_time = time.time()
with ThreadPoolExecutor(max_workers=concurrency) as executor:
futures = [executor.submit(worker, w) for w in range(concurrency)]
for f in futures:
sent_ids.update(f.result())
elapsed = time.time() - start_time
assert len(sent_ids) == 100, f"Ожидалось 100 ID, получено {len(sent_ids)}"
print(f"Успешно отправлено 100 сообщений за {elapsed:.2f} сек ({total_messages / elapsed:.1f} msg/sec)")
received_messages = []
cursor = None
pages = 0
while True:
url = f"/api/v1/chats/{chat_id}/messages?limit=25"
if cursor:
url += f"&cursor={cursor}"
_, page = make_req(url, "GET", headers=headers)
received_messages.extend(page["items"])
cursor = page.get("next_cursor")
pages += 1
if not cursor:
break
print(f"Вычитано страниц истории: {pages}, сообщений получено: {len(received_messages)}")
assert len(received_messages) == 100, f"Потеряны сообщения! Ожидалось 100, вычитано {len(received_messages)}"
received_ids = {m["id"] for m in received_messages}
assert received_ids == sent_ids, "Идентификаторы отправленных и вычитанных сообщений не совпадают!"
for i in range(len(received_messages) - 1):
prev = (received_messages[i]["created_at"], received_messages[i]["id"])
curr = (received_messages[i+1]["created_at"], received_messages[i+1]["id"])
assert prev <= curr, f"Нарушен порядок сообщений на индексе {i}"
print(">>> Проверка истории пройдена: 0 потерь данных, все 100 сообщений сохранены в верном порядке.")
if __name__ == "__main__":
main()
+135
View File
@@ -0,0 +1,135 @@
import pytest
from fastapi.testclient import TestClient
from src.main import app
client = TestClient(app)
def create_user(username="test_user"):
res = client.post("/api/v1/users", json={"username": username, "display_name": "Test"})
assert res.status_code == 201
return res.json()
def test_duplicate_username():
create_user("user_dup")
res = client.post("/api/v1/users", json={"username": "user_dup", "display_name": "Test"})
assert res.status_code == 409
assert res.json()["error"]["code"] == "conflict"
def test_whitespace_validation():
# Пробельное имя пользователя
res1 = client.post("/api/v1/users", json={"username": "valid_user_ws", "display_name": " "})
assert res1.status_code == 400
assert res1.json()["error"]["code"] == "invalid_request"
u = create_user("user_ws")
# Пробельный title чата
res2 = client.post("/api/v1/chats", json={"title": " ", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]})
assert res2.status_code == 400
chat = client.post("/api/v1/chats", json={"title": "Valid Chat", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]}).json()
# Пробельный текст сообщения
res3 = client.post(f"/api/v1/chats/{chat['id']}/messages", json={"text": " "}, headers={"X-User-Id": u["id"]})
assert res3.status_code == 400
assert res3.json()["error"]["code"] == "invalid_request"
def test_extra_json_fields_forbidden():
u = create_user("user_extra")
chat = client.post("/api/v1/chats", json={"title": "Chat", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]}).json()
# Попытка передать лишнее поле sender_id
payload = {"text": "hello", "sender_id": u["id"]}
res = client.post(f"/api/v1/chats/{chat['id']}/messages", json=payload, headers={"X-User-Id": u["id"]})
assert res.status_code == 400
assert res.json()["error"]["code"] == "invalid_request"
def test_duplicate_members_in_chat():
u = create_user("user_dup_mem")
payload = {"title": "Dup Chat", "member_ids": [u["id"], u["id"]]}
res = client.post("/api/v1/chats", json=payload, headers={"X-User-Id": u["id"]})
assert res.status_code == 400
assert res.json()["error"]["code"] == "invalid_request"
def test_invalid_uuid_and_empty_cursor():
u = create_user("user_uuid")
# Неверный UUID пути должен давать 400, а не 404
res = client.get("/api/v1/chats/not-a-valid-uuid", headers={"X-User-Id": u["id"]})
assert res.status_code == 400
assert res.json()["error"]["code"] == "invalid_request"
# Пустой cursor должен давать 400
res_cur = client.get("/api/v1/chats?cursor=", headers={"X-User-Id": u["id"]})
assert res_cur.status_code == 400
assert res_cur.json()["error"]["code"] == "invalid_request"
def test_router_404_format():
# Несуществующий эндпоинт маршрутизатора должен возвращать единый формат ошибки
res = client.get("/api/v1/non_existent_endpoint_xyz")
assert res.status_code == 404
data = res.json()
assert "error" in data
assert data["error"]["code"] == "not_found"
assert "request_id" in data["error"]
def test_malformed_json():
# Битый JSON в теле запроса
res = client.post(
"/api/v1/users",
content="{'broken': json,",
headers={"Content-Type": "application/json"}
)
assert res.status_code == 400
assert res.json()["error"]["code"] == "invalid_request"
def test_foreign_chat():
u1 = create_user("user_owner")
u2 = create_user("user_stranger")
chat = client.post("/api/v1/chats", json={"title": "Private Chat", "member_ids": [u1["id"]]}, headers={"X-User-Id": u1["id"]}).json()
# Попытка чужого пользователя прочитать чат -> 404
res_get = client.get(f"/api/v1/chats/{chat['id']}", headers={"X-User-Id": u2["id"]})
assert res_get.status_code == 404
assert res_get.json()["error"]["code"] == "not_found"
# Попытка чужого пользователя написать в чат -> 404
res_post = client.post(f"/api/v1/chats/{chat['id']}/messages", json={"text": "hack"}, headers={"X-User-Id": u2["id"]})
assert res_post.status_code == 404
assert res_post.json()["error"]["code"] == "not_found"
def test_pagination_multi_page():
u = create_user("user_paging")
chat = client.post("/api/v1/chats", json={"title": "Paging Chat", "member_ids": [u["id"]]}, headers={"X-User-Id": u["id"]}).json()
chat_id = chat["id"]
# Отправляем 5 сообщений
sent_texts = [f"Message {i}" for i in range(5)]
for text in sent_texts:
client.post(f"/api/v1/chats/{chat_id}/messages", json={"text": text}, headers={"X-User-Id": u["id"]})
# Обходим страницы порциями по 2 сообщения
all_received_items = []
cursor = None
page_count = 0
while True:
url = f"/api/v1/chats/{chat_id}/messages?limit=2"
if cursor:
url += f"&cursor={cursor}"
res = client.get(url, headers={"X-User-Id": u["id"]})
assert res.status_code == 200
data = res.json()
all_received_items.extend(data["items"])
cursor = data.get("next_cursor")
page_count += 1
if not cursor:
break
# Проверяем, что разбилось на 3 страницы (2 + 2 + 1)
assert page_count == 3
# Проверяем, что получены все 5 сообщений без потерь
assert len(all_received_items) == 5
assert {m["text"] for m in all_received_items} == set(sent_texts)
# Проверяем строгое соответствие контракту: порядок (created_at, id) строго возрастает
for i in range(len(all_received_items) - 1):
prev = (all_received_items[i]["created_at"], all_received_items[i]["id"])
curr = (all_received_items[i+1]["created_at"], all_received_items[i+1]["id"])
assert prev < curr
+76
View File
@@ -0,0 +1,76 @@
import base64
import time
import httpx
import pytest
BASE_URL = "http://localhost:8080"
def get_client():
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
def get_basic_header(u: str, p: str):
token = base64.b64encode(f"{u}:{p}".encode("utf-8")).decode("utf-8")
return {"Authorization": f"Basic {token}"}
def test_invalid_password_returns_401():
uname = f"usr_bad_pw_{int(time.time() * 1000)}"
pw = "super_secure_password_123"
with get_client() as client:
# Регистрация
r1 = client.post("/users", json={"username": uname, "display_name": "Test", "password": pw})
assert r1.status_code == 201
# Попытка входа с неверным паролем
r2 = client.post("/auth/sessions", headers=get_basic_header(uname, "wrong_password_999"))
assert r2.status_code == 401
assert "Basic" in r2.headers.get("WWW-Authenticate", "")
def test_logout_and_revocation():
uname = f"usr_logout_{int(time.time() * 1000)}"
pw = "super_secure_password_123"
with get_client() as client:
client.post("/users", json={"username": uname, "display_name": "Test", "password": pw})
# Успешный вход
login = client.post("/auth/sessions", headers=get_basic_header(uname, pw))
assert login.status_code == 201
token = login.json()["token"]
# Запрос с действующим токеном
r_me = client.get("/users/me", headers={"Authorization": f"Bearer {token}"})
assert r_me.status_code == 200
# Отзываем токен
r_del = client.delete("/auth/sessions/current", headers={"Authorization": f"Bearer {token}"})
assert r_del.status_code == 204
# Повторный запрос с отозванным токеном возвращает 401
r_revoked = client.get("/users/me", headers={"Authorization": f"Bearer {token}"})
assert r_revoked.status_code == 401
assert "Bearer" in r_revoked.headers.get("WWW-Authenticate", "")
def test_basic_rejected_on_business_endpoint():
with get_client() as client:
r = client.get("/chats", headers=get_basic_header("test", "test"))
assert r.status_code == 401
assert "Bearer" in r.headers.get("WWW-Authenticate", "")
def test_chat_creation_rollback_on_failure():
uname = f"usr_rollback_{int(time.time() * 1000)}"
pw = "super_secure_password_123"
with get_client() as client:
u = client.post("/users", json={"username": uname, "display_name": "R", "password": pw}).json()
token = client.post("/auth/sessions", headers=get_basic_header(uname, pw)).json()["token"]
# Пытаемся создать чат с несуществующим участником
fake_uuid = "00000000-0000-0000-0000-000000000999"
res = client.post(
"/chats",
json={"title": "Rollback Chat", "member_ids": [u["id"], fake_uuid]},
headers={"Authorization": f"Bearer {token}"}
)
assert res.status_code == 400
# Проверяем, что чат не был создан в БД (транзакция откатилась)
chats = client.get("/chats", headers={"Authorization": f"Bearer {token}"}).json()["items"]
assert not any(c["title"] == "Rollback Chat" for c in chats)