ЛР 2 - БПИ2304 - Алексеева Мария - на 4 #11
+20
-28
@@ -1,32 +1,24 @@
|
||||
# Local/private state
|
||||
# Секреты
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
secrets/
|
||||
certs/private/
|
||||
*.key
|
||||
*.p12
|
||||
*.pfx
|
||||
*.jks
|
||||
*.pem
|
||||
*.tfstate*
|
||||
volumes/
|
||||
data/
|
||||
backups/
|
||||
# Runtime/build artifacts
|
||||
.venv/
|
||||
|
||||
# Python
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
node_modules/
|
||||
dist/
|
||||
build/
|
||||
target/
|
||||
bin/
|
||||
obj/
|
||||
coverage/
|
||||
*.pyc
|
||||
*.pyo
|
||||
|
||||
# Виртуальное окружение
|
||||
.venv/
|
||||
venv/
|
||||
|
||||
# Тесты
|
||||
.pytest_cache/
|
||||
|
||||
# Логи и результаты
|
||||
*.log
|
||||
student-tests/evidence/
|
||||
|
||||
# Прочее
|
||||
.DS_Store
|
||||
.idea/
|
||||
.vscode/
|
||||
# Keep small, sanitized evidence summaries in evidence/ under version control.
|
||||
# Inspect git diff --cached: ignore rules are not a secret scanner.
|
||||
|
||||
# Local editor
|
||||
.cursor/
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
FROM python:3.11-slim
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
RUN apt-get update \
|
||||
&& apt-get install -y --no-install-recommends build-essential libpq-dev curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY alembic.ini .
|
||||
COPY alembic ./alembic
|
||||
COPY src ./src
|
||||
|
||||
RUN useradd -m -u 1000 app && chown -R app:app /app
|
||||
USER app
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=15s --retries=5 \
|
||||
CMD curl -fsS http://127.0.0.1:8080/health/live || exit 1
|
||||
|
||||
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,96 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Автор, группа: Алексеева Мария, БПИ2304
|
||||
- Целевая оценка: 4
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: официальная документация FastAPI, SQLAlchemy 2.0, Alembic, PostgreSQL, Redis. Код написан с использованием DeepSeek.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Требуется Docker 29+ и Docker Compose v2. Python 3.9+ нужен только для запуска публичных тестов с хоста.
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# в .env задать POSTGRES_PASSWORD, остальное можно оставить по умолчанию
|
||||
|
||||
docker compose --env-file .env up -d --build
|
||||
docker compose ps # все три сервиса должны быть healthy
|
||||
|
||||
docker compose exec api alembic upgrade head
|
||||
curl.exe http://localhost:8080/health/live # {"status":"ok"}
|
||||
|
||||
python tests/smoke.py --base-url http://localhost:8080
|
||||
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
|
||||
Остановка: docker compose down (volumes сохраняются). Полный сброс учебных данных: docker compose down -v.
|
||||
|
||||
.env содержит только локальные учебные значения и находится в .gitignore
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент → FastAPI (uvicorn) → PostgreSQL (источник истины) → Redis (сессии, TTL)
|
||||
|
||||
PostgreSQL — источник истины. Все пользователи, чаты, участники и сообщения хранятся здесь. Создание чата и его участников выполняется в одной транзакции.
|
||||
|
||||
Redis — сессии с TTL (SESSION_TTL_SECONDS, по умолчанию 3600). Persistence включён (--appendonly yes), сессии переживают рестарт.
|
||||
|
||||
Пароли хешируются Argon2id (passlib).
|
||||
|
||||
Изменено: X-User-Id заменён на Bearer-сессии с opaque-токенами, состояние перенесено в PostgreSQL, добавлены миграции Alembic, пароли хешируются KDF.
|
||||
|
||||
Переменные .env.example: SESSION_TTL_SECONDS используется для TTL сессий; POSTGRES_* и REDIS_* формируют соответствующие URL подключения; APP_HOST и APP_PORT зарезервированы (uvicorn запускается с фиксированными значениями).
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|Критерий| Команда |Результат|
|
||||
|Публичный smoke| python tests/smoke.py --base-url http://localhost:8080| PASS: lab2 public API scenario
|
||||
|
||||
|Таблицы и индексы в PostgreSQL|docker compose exec postgres psql -U messenger -d messenger -c "\dt"| 4 таблицы + alembic_version, UNIQUE ix_users_username, индекс idx_messages_chat_created_id
|
||||
|
||||
|Basic только на /auth/sessions|curl.exe -i http://localhost:8080/api/v1/users/me -H "Authorization: Basic ..."| 401, WWW-Authenticate: Bearer
|
||||
|
||||
|Bearer на защищённых endpoint| curl.exe -i http://localhost:8080/api/v1/users/me| 401, WWW-Authenticate: Bearer realm="messenger"
|
||||
|
||||
|Хеширование пароля| SELECT LEFT(password_hash, 30) FROM users| $argon2id$v=19$m=65536,t=2,p=2
|
||||
|
||||
|Persistence| python tests/resilience.py --mode persistence ... |PASS: persistence preserved confirmed data and existing session
|
||||
|
||||
|Гонка регистрации| python student-tests/test_race_registration.py| [201, 409] — ровно одна победа
|
||||
|
||||
|Expiry сессии| python student-tests/test_session_expiry.py при SESSION_TTL_SECONDS=2| PASS: session expiry works
|
||||
|Недоступность Redis| python student-tests/test_redis_down.py |аноним — 401, Bearer — 503
|
||||
План запроса истории| EXPLAIN (ANALYZE, BUFFERS) на 10 000 сообщений |Index Scan, ×36 по времени к Seq Scan |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Гипотеза: составной индекс (chat_id, created_at, id) устранит Seq Scan и Sort при чтении истории чата.
|
||||
|
||||
Условия: учебный ноутбук (Windows 11, Docker Desktop, 4 vCPU, 8 GiB RAM). В messages 10 000 записей в одном чате.
|
||||
|
||||
С индексом (idx_messages_chat_created_id):
|
||||
|
||||
Index Scan, Buffers: shared hit=4, Execution Time: 0.046 ms.
|
||||
|
||||
Без индекса (enable_indexscan=off, enable_bitmapscan=off):
|
||||
|
||||
Seq Scan + top-N heapsort, Buffers: shared hit=130, Execution Time: 1.652 ms.
|
||||
|
||||
Итог: ускорение ×36 по времени и ×32 по I/O.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
|
||||
| Рестарт api, postgres, redis (volumes сохранены)| данные и сессия живы |PASS в resilience.py| ~10 с, потерь нет
|
||||
|
||||
|Остановка Redis| аноним 401, Bearer 503 |так и есть |~2 с после docker compose start redis
|
||||
|
||||
|Гонка регистрации |одна 201, одна 409 |так и есть во всех запусках |—
|
||||
|
||||
|Expiry при TTL=2 |токен истекает |401 после ожидания |—
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Выдерживается: рестарт API/PostgreSQL/Redis, истечение сессий, недоступность Redis, гонка регистрации.
|
||||
|
||||
Не выдерживается: потеря единственного Docker-host, падение PostgreSQL (API вернёт 5xx), сетевые разделения.
|
||||
|
||||
Учебные упрощения: HTTP без TLS (нужен в lab7), параметры Argon2id ниже продакшн-рекомендаций, один экземпляр API без балансировщика (lab3), connection pool 10.
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
[alembic]
|
||||
script_location = alembic
|
||||
prepend_sys_path = .
|
||||
version_path_separator = os
|
||||
sqlalchemy.url =
|
||||
|
||||
[loggers]
|
||||
keys = root,sqlalchemy,alembic
|
||||
|
||||
[handlers]
|
||||
keys = console
|
||||
|
||||
[formatters]
|
||||
keys = generic
|
||||
|
||||
[logger_root]
|
||||
level = WARN
|
||||
handlers = console
|
||||
qualname =
|
||||
|
||||
[logger_sqlalchemy]
|
||||
level = WARN
|
||||
handlers =
|
||||
qualname = sqlalchemy.engine
|
||||
|
||||
[logger_alembic]
|
||||
level = INFO
|
||||
handlers =
|
||||
qualname = alembic
|
||||
|
||||
[handler_console]
|
||||
class = StreamHandler
|
||||
args = (sys.stderr,)
|
||||
level = NOTSET
|
||||
formatter = generic
|
||||
|
||||
[formatter_generic]
|
||||
format = %(levelname)-5.5s [%(name)s] %(message)s
|
||||
datefmt = %H:%M:%S
|
||||
@@ -0,0 +1,60 @@
|
||||
import asyncio
|
||||
from logging.config import fileConfig
|
||||
|
||||
from sqlalchemy import pool
|
||||
from sqlalchemy.engine import Connection
|
||||
from sqlalchemy.ext.asyncio import async_engine_from_config
|
||||
|
||||
from alembic import context
|
||||
|
||||
from src.core.config import settings
|
||||
from src.db.base import Base
|
||||
from src.models import models # noqa: F401 — регистрируем модели в Base.metadata
|
||||
|
||||
config = context.config
|
||||
config.set_main_option("sqlalchemy.url", settings.database_url)
|
||||
|
||||
if config.config_file_name is not None:
|
||||
fileConfig(config.config_file_name)
|
||||
|
||||
target_metadata = Base.metadata
|
||||
|
||||
|
||||
def run_migrations_offline() -> None:
|
||||
url = config.get_main_option("sqlalchemy.url")
|
||||
context.configure(
|
||||
url=url,
|
||||
target_metadata=target_metadata,
|
||||
literal_binds=True,
|
||||
dialect_opts={"paramstyle": "named"},
|
||||
compare_type=True,
|
||||
)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
def do_run_migrations(connection: Connection) -> None:
|
||||
context.configure(
|
||||
connection=connection,
|
||||
target_metadata=target_metadata,
|
||||
compare_type=True,
|
||||
)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
async def run_migrations_online() -> None:
|
||||
connectable = async_engine_from_config(
|
||||
config.get_section(config.config_ini_section, {}),
|
||||
prefix="sqlalchemy.",
|
||||
poolclass=pool.NullPool,
|
||||
)
|
||||
async with connectable.connect() as connection:
|
||||
await connection.run_sync(do_run_migrations)
|
||||
await connectable.dispose()
|
||||
|
||||
|
||||
if context.is_offline_mode():
|
||||
run_migrations_offline()
|
||||
else:
|
||||
asyncio.run(run_migrations_online())
|
||||
@@ -0,0 +1,25 @@
|
||||
"""${message}
|
||||
|
||||
Revision ID: ${up_revision}
|
||||
Revises: ${down_revision | comma,n}
|
||||
Create Date: ${create_date}
|
||||
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
${imports if imports else ""}
|
||||
|
||||
revision: str = ${repr(up_revision)}
|
||||
down_revision: Union[str, None] = ${repr(down_revision)}
|
||||
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
|
||||
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
${upgrades if upgrades else "pass"}
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
${downgrades if downgrades else "pass"}
|
||||
@@ -0,0 +1,67 @@
|
||||
"""init tables
|
||||
|
||||
Revision ID: 71c939ad8254
|
||||
Revises:
|
||||
Create Date: 2026-10-02 12:04:30.713963
|
||||
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
revision: str = '71c939ad8254'
|
||||
down_revision: Union[str, None] = None
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.create_table('chats',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('title', sa.String(length=100), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_table('users',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('username', sa.String(length=32), nullable=False),
|
||||
sa.Column('display_name', sa.String(length=100), nullable=False),
|
||||
sa.Column('password_hash', sa.Text(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
|
||||
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name='ck_users_username_format'),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
|
||||
op.create_table('chat_members',
|
||||
sa.Column('chat_id', sa.UUID(), nullable=False),
|
||||
sa.Column('user_id', sa.UUID(), nullable=False),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
|
||||
sa.PrimaryKeyConstraint('chat_id', 'user_id')
|
||||
)
|
||||
op.create_table('messages',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('chat_id', sa.UUID(), nullable=False),
|
||||
sa.Column('sender_id', sa.UUID(), nullable=False),
|
||||
sa.Column('text', sa.Text(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
|
||||
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
|
||||
# ### end Alembic commands ###
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.drop_index('idx_messages_chat_created_id', table_name='messages')
|
||||
op.drop_table('messages')
|
||||
op.drop_table('chat_members')
|
||||
op.drop_index(op.f('ix_users_username'), table_name='users')
|
||||
op.drop_table('users')
|
||||
op.drop_table('chats')
|
||||
# ### end Alembic commands ###
|
||||
@@ -0,0 +1,54 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||||
POSTGRES_DB: ${POSTGRES_DB}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
networks: [backend]
|
||||
|
||||
redis:
|
||||
image: redis:7.4-alpine
|
||||
command: ["redis-server", "--appendonly", "yes"]
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
networks: [backend]
|
||||
|
||||
api:
|
||||
build: .
|
||||
env_file: .env
|
||||
environment:
|
||||
POSTGRES_HOST: postgres
|
||||
REDIS_HOST: redis
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
ports:
|
||||
- "8080:8080"
|
||||
volumes:
|
||||
- ./src:/app/src
|
||||
- ./alembic:/app/alembic
|
||||
- ./alembic.ini:/app/alembic.ini
|
||||
networks: [backend]
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
|
||||
networks:
|
||||
backend:
|
||||
driver: bridge
|
||||
@@ -0,0 +1,10 @@
|
||||
fastapi==0.115.0
|
||||
uvicorn[standard]==0.32.0
|
||||
sqlalchemy[asyncio]==2.0.36
|
||||
asyncpg==0.30.0
|
||||
alembic==1.13.3
|
||||
pydantic==2.9.2
|
||||
pydantic-settings==2.5.2
|
||||
passlib[argon2]==1.7.4
|
||||
argon2-cffi==23.1.0
|
||||
redis==5.1.1
|
||||
@@ -0,0 +1,24 @@
|
||||
@echo off
|
||||
setlocal
|
||||
|
||||
cd /d "%~dp0\.."
|
||||
|
||||
echo [restart] restarting api, postgres, redis (volumes preserved)...
|
||||
docker compose --env-file .env restart api postgres redis
|
||||
if errorlevel 1 (
|
||||
echo [restart] docker compose restart failed
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo [restart] waiting for api to become healthy...
|
||||
setlocal enabledelayedexpansion
|
||||
for /L %%i in (1,1,60) do (
|
||||
for /f "delims=" %%s in ('docker inspect --format="{{.State.Health.Status}}" mtusi2026lab2-api-1 2^>nul') do set STATUS=%%s
|
||||
if "!STATUS!"=="healthy" (
|
||||
echo [restart] api is healthy after %%is
|
||||
exit /b 0
|
||||
)
|
||||
timeout /t 1 /nobreak >nul
|
||||
)
|
||||
echo [restart] api did not become healthy within 60s
|
||||
exit /b 1
|
||||
@@ -0,0 +1,18 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
docker compose --env-file .env restart api postgres redis
|
||||
|
||||
for i in $(seq 1 60); do
|
||||
status=$(docker inspect --format='{{.State.Health.Status}}' mtusi2026lab2-api-1 2>/dev/null || echo "unknown")
|
||||
if [ "$status" = "healthy" ]; then
|
||||
echo "api is healthy after ${i}s"
|
||||
exit 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
|
||||
echo "api did not become healthy within 60s" >&2
|
||||
exit 1
|
||||
+131
@@ -0,0 +1,131 @@
|
||||
import base64
|
||||
import binascii
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from fastapi import APIRouter, Depends, Header, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.api.deps import get_current_user
|
||||
from src.core.config import settings
|
||||
from src.core.redis import get_redis
|
||||
from src.core.security import verify_password
|
||||
from src.db.session import get_db
|
||||
from src.models.models import User
|
||||
from src.schemas.schemas import SessionResponse, UserResponse
|
||||
from src.services import sessions as sessions_service
|
||||
from src.services import users as users_service
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"])
|
||||
|
||||
|
||||
def _rid(request: Request) -> str:
|
||||
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
|
||||
|
||||
def _error(
|
||||
status_code: int,
|
||||
code: str,
|
||||
message: str,
|
||||
request: Request,
|
||||
challenge: str | None = None,
|
||||
) -> JSONResponse:
|
||||
rid = _rid(request)
|
||||
headers = {"X-Request-Id": rid}
|
||||
if challenge:
|
||||
headers["WWW-Authenticate"] = challenge
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
def _parse_basic(authorization: str | None) -> tuple[str, str] | None:
|
||||
if not authorization or not authorization.lower().startswith("basic "):
|
||||
return None
|
||||
encoded = authorization.split(" ", 1)[1].strip()
|
||||
try:
|
||||
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError):
|
||||
return None
|
||||
if ":" not in decoded:
|
||||
return None
|
||||
username, password = decoded.split(":", 1)
|
||||
return username, password
|
||||
|
||||
|
||||
@router.post("", status_code=201)
|
||||
async def create_session(
|
||||
request: Request,
|
||||
authorization: str | None = Header(default=None),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
redis: aioredis.Redis = Depends(get_redis),
|
||||
):
|
||||
credentials = _parse_basic(authorization)
|
||||
if credentials is None:
|
||||
return _error(
|
||||
401, "unauthorized", "invalid credentials", request,
|
||||
challenge='Basic realm="messenger", charset="UTF-8"',
|
||||
)
|
||||
|
||||
username, password = credentials
|
||||
user = await users_service.get_user_by_username(db, username)
|
||||
if user is None or not verify_password(password, user.password_hash):
|
||||
return _error(
|
||||
401, "unauthorized", "invalid credentials", request,
|
||||
challenge='Basic realm="messenger", charset="UTF-8"',
|
||||
)
|
||||
|
||||
try:
|
||||
token = await sessions_service.create_session(redis, user.id)
|
||||
except (aioredis.RedisError, ConnectionError, OSError):
|
||||
return _error(
|
||||
503, "unavailable", "session store unavailable", request,
|
||||
)
|
||||
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(
|
||||
seconds=settings.session_ttl_seconds
|
||||
)
|
||||
|
||||
payload = SessionResponse(
|
||||
token=token,
|
||||
token_type="Bearer",
|
||||
expires_at=expires_at,
|
||||
user=UserResponse.model_validate(user),
|
||||
)
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content=payload.model_dump(mode="json"),
|
||||
headers={"X-Request-Id": _rid(request)},
|
||||
)
|
||||
|
||||
|
||||
@router.delete("/current", status_code=204)
|
||||
async def revoke_current_session(
|
||||
request: Request,
|
||||
authorization: str | None = Header(default=None),
|
||||
current_user: User = Depends(get_current_user),
|
||||
redis: aioredis.Redis = Depends(get_redis),
|
||||
):
|
||||
token = authorization.split(" ", 1)[1].strip()
|
||||
try:
|
||||
await sessions_service.revoke_session(redis, token)
|
||||
except (aioredis.RedisError, ConnectionError, OSError):
|
||||
return _error(
|
||||
503, "unavailable", "session store unavailable", request,
|
||||
)
|
||||
return JSONResponse(
|
||||
status_code=204,
|
||||
content=None,
|
||||
headers={"X-Request-Id": _rid(request)},
|
||||
)
|
||||
@@ -0,0 +1,107 @@
|
||||
import uuid
|
||||
|
||||
from fastapi import APIRouter, Depends, Query, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.api.deps import get_current_user
|
||||
from src.db.session import get_db
|
||||
from src.models.models import User
|
||||
from src.schemas.schemas import (
|
||||
ChatPage,
|
||||
ChatResponse,
|
||||
CreateChatRequest,
|
||||
)
|
||||
from src.services import chats as chats_service
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
|
||||
|
||||
|
||||
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
|
||||
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
|
||||
|
||||
async def _build_chat_response(
|
||||
db: AsyncSession,
|
||||
chat,
|
||||
) -> ChatResponse:
|
||||
member_ids = await chats_service.get_member_ids(db, chat.id)
|
||||
return ChatResponse(
|
||||
id=chat.id,
|
||||
title=chat.title,
|
||||
member_ids=member_ids,
|
||||
created_at=chat.created_at,
|
||||
)
|
||||
|
||||
|
||||
@router.post("", status_code=201, response_model=ChatResponse)
|
||||
async def create_chat(
|
||||
payload: CreateChatRequest,
|
||||
request: Request,
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
try:
|
||||
chat = await chats_service.create_chat(
|
||||
db=db,
|
||||
title=payload.title,
|
||||
member_ids=payload.member_ids,
|
||||
caller_id=current_user.id,
|
||||
)
|
||||
except chats_service.CallerNotInMembersError:
|
||||
return _error(
|
||||
400, "invalid_request", "caller must be in member_ids", request
|
||||
)
|
||||
except chats_service.UnknownMemberError:
|
||||
return _error(
|
||||
400, "invalid_request", "unknown member_id", request
|
||||
)
|
||||
|
||||
return await _build_chat_response(db, chat)
|
||||
|
||||
|
||||
@router.get("", response_model=ChatPage)
|
||||
async def list_chats(
|
||||
request: Request,
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: str | None = Query(default=None),
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
try:
|
||||
rows, next_cursor = await chats_service.list_chats_for_user(
|
||||
db=db,
|
||||
user_id=current_user.id,
|
||||
limit=limit,
|
||||
cursor=cursor,
|
||||
)
|
||||
except ValueError:
|
||||
return _error(400, "invalid_request", "invalid cursor", request)
|
||||
|
||||
items = [await _build_chat_response(db, chat) for chat in rows]
|
||||
return ChatPage(items=items, next_cursor=next_cursor)
|
||||
|
||||
|
||||
@router.get("/{chat_id}", response_model=ChatResponse)
|
||||
async def get_chat(
|
||||
chat_id: uuid.UUID,
|
||||
request: Request,
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
|
||||
if chat is None:
|
||||
return _error(404, "not_found", "chat not found", request)
|
||||
return await _build_chat_response(db, chat)
|
||||
@@ -0,0 +1,54 @@
|
||||
import uuid
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
from fastapi import Depends, Header, HTTPException, status
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.core.redis import get_redis
|
||||
from src.db.session import get_db
|
||||
from src.models.models import User
|
||||
from src.services import sessions as sessions_service
|
||||
from src.services import users as users_service
|
||||
|
||||
|
||||
async def get_current_user(
|
||||
authorization: str | None = Header(default=None),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
redis: aioredis.Redis = Depends(get_redis),
|
||||
) -> User:
|
||||
if not authorization or not authorization.lower().startswith("bearer "):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="unauthorized",
|
||||
)
|
||||
|
||||
token = authorization.split(" ", 1)[1].strip()
|
||||
if not token:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="unauthorized",
|
||||
)
|
||||
|
||||
try:
|
||||
user_id = await sessions_service.get_session_user_id(redis, token)
|
||||
except (aioredis.RedisError, ConnectionError, OSError):
|
||||
# Redis недоступен → не пропускаем запрос, отдаём 503.
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
detail="session store unavailable",
|
||||
)
|
||||
|
||||
if user_id is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="unauthorized",
|
||||
)
|
||||
|
||||
user = await users_service.get_user_by_id(db, user_id)
|
||||
if user is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="unauthorized",
|
||||
)
|
||||
|
||||
return user
|
||||
@@ -0,0 +1,26 @@
|
||||
import uuid
|
||||
|
||||
from fastapi import APIRouter, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("/health/live")
|
||||
async def live(request: Request):
|
||||
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
return JSONResponse(
|
||||
{"status": "ok"},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
|
||||
|
||||
@router.get("/health/ready")
|
||||
async def ready(request: Request):
|
||||
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
# Пока зависимостей нет — всегда говорим ok.
|
||||
# Позже здесь будем проверять доступность PostgreSQL и Redis.
|
||||
return JSONResponse(
|
||||
{"status": "ok"},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
@@ -0,0 +1,82 @@
|
||||
import uuid
|
||||
|
||||
from fastapi import APIRouter, Depends, Query, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.api.deps import get_current_user
|
||||
from src.db.session import get_db
|
||||
from src.models.models import User
|
||||
from src.schemas.schemas import (
|
||||
CreateMessageRequest,
|
||||
MessagePage,
|
||||
MessageResponse,
|
||||
)
|
||||
from src.services import chats as chats_service
|
||||
from src.services import messages as messages_service
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
|
||||
|
||||
|
||||
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
|
||||
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
|
||||
|
||||
@router.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse)
|
||||
async def create_message(
|
||||
chat_id: uuid.UUID,
|
||||
payload: CreateMessageRequest,
|
||||
request: Request,
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
|
||||
if chat is None:
|
||||
return _error(404, "not_found", "chat not found", request)
|
||||
|
||||
message = await messages_service.create_message(
|
||||
db=db,
|
||||
chat_id=chat.id,
|
||||
sender_id=current_user.id,
|
||||
text=payload.text,
|
||||
)
|
||||
return MessageResponse.model_validate(message)
|
||||
|
||||
|
||||
@router.get("/{chat_id}/messages", response_model=MessagePage)
|
||||
async def list_messages(
|
||||
chat_id: uuid.UUID,
|
||||
request: Request,
|
||||
limit: int = Query(default=50, ge=1, le=100),
|
||||
cursor: str | None = Query(default=None),
|
||||
current_user: User = Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
|
||||
if chat is None:
|
||||
return _error(404, "not_found", "chat not found", request)
|
||||
|
||||
try:
|
||||
rows, next_cursor = await messages_service.list_messages(
|
||||
db=db,
|
||||
chat_id=chat.id,
|
||||
limit=limit,
|
||||
cursor=cursor,
|
||||
)
|
||||
except ValueError:
|
||||
return _error(400, "invalid_request", "invalid cursor", request)
|
||||
|
||||
items = [MessageResponse.model_validate(m) for m in rows]
|
||||
return MessagePage(items=items, next_cursor=next_cursor)
|
||||
@@ -0,0 +1,58 @@
|
||||
import uuid
|
||||
|
||||
from fastapi import APIRouter, Depends, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.api.deps import get_current_user
|
||||
from src.db.session import get_db
|
||||
from src.models.models import User
|
||||
from src.schemas.schemas import (
|
||||
CreateUserRequest,
|
||||
UserResponse,
|
||||
)
|
||||
from src.services import users as users_service
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/users", tags=["users"])
|
||||
|
||||
|
||||
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
|
||||
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
|
||||
|
||||
@router.post("", status_code=201, response_model=UserResponse)
|
||||
async def register_user(
|
||||
payload: CreateUserRequest,
|
||||
request: Request,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
try:
|
||||
user = await users_service.create_user(
|
||||
db=db,
|
||||
username=payload.username,
|
||||
display_name=payload.display_name,
|
||||
password=payload.password,
|
||||
)
|
||||
except users_service.UsernameTakenError:
|
||||
return _error(409, "conflict", "username already taken", request)
|
||||
|
||||
return UserResponse.model_validate(user)
|
||||
|
||||
|
||||
@router.get("/me", response_model=UserResponse)
|
||||
async def get_me(
|
||||
current_user: User = Depends(get_current_user),
|
||||
):
|
||||
return UserResponse.model_validate(current_user)
|
||||
@@ -0,0 +1,39 @@
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
model_config = SettingsConfigDict(
|
||||
env_file=".env",
|
||||
env_file_encoding="utf-8",
|
||||
extra="ignore",
|
||||
)
|
||||
|
||||
app_host: str = "0.0.0.0"
|
||||
app_port: int = 8080
|
||||
app_env: str = "lab"
|
||||
|
||||
session_ttl_seconds: int = 3600
|
||||
|
||||
postgres_user: str
|
||||
postgres_password: str
|
||||
postgres_db: str
|
||||
postgres_host: str = "postgres"
|
||||
postgres_port: int = 5432
|
||||
|
||||
redis_host: str = "redis"
|
||||
redis_port: int = 6379
|
||||
redis_db: int = 0
|
||||
|
||||
@property
|
||||
def database_url(self) -> str:
|
||||
return (
|
||||
f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}"
|
||||
f"@{self.postgres_host}:{self.postgres_port}/{self.postgres_db}"
|
||||
)
|
||||
|
||||
@property
|
||||
def redis_url(self) -> str:
|
||||
return f"redis://{self.redis_host}:{self.redis_port}/{self.redis_db}"
|
||||
|
||||
|
||||
settings = Settings()
|
||||
@@ -0,0 +1,16 @@
|
||||
import uuid
|
||||
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
from starlette.requests import Request
|
||||
|
||||
|
||||
class RequestIdMiddleware(BaseHTTPMiddleware):
|
||||
"""Гарантирует, что каждый ответ содержит X-Request-Id."""
|
||||
|
||||
async def dispatch(self, request: Request, call_next):
|
||||
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
request.state.request_id = rid
|
||||
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = rid
|
||||
return response
|
||||
@@ -0,0 +1,16 @@
|
||||
from collections.abc import AsyncGenerator
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
|
||||
from src.core.config import settings
|
||||
|
||||
redis_client: aioredis.Redis = aioredis.from_url(
|
||||
settings.redis_url,
|
||||
encoding="utf-8",
|
||||
decode_responses=True,
|
||||
max_connections=50,
|
||||
)
|
||||
|
||||
|
||||
async def get_redis() -> AsyncGenerator[aioredis.Redis, None]:
|
||||
yield redis_client
|
||||
@@ -0,0 +1,28 @@
|
||||
import secrets
|
||||
|
||||
from passlib.context import CryptContext
|
||||
|
||||
_pwd_context = CryptContext(
|
||||
schemes=["argon2"],
|
||||
deprecated="auto",
|
||||
argon2__time_cost=2,
|
||||
argon2__memory_cost=65536, # 64 MiB
|
||||
argon2__parallelism=2,
|
||||
argon2__type="ID", # Argon2id
|
||||
)
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return _pwd_context.hash(password)
|
||||
|
||||
|
||||
def verify_password(password: str, password_hash: str) -> bool:
|
||||
try:
|
||||
return _pwd_context.verify(password, password_hash)
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
|
||||
def generate_session_token() -> str:
|
||||
# 32 байта = 256 бит энтропии, hex = 64 символа
|
||||
return secrets.token_urlsafe(48)
|
||||
@@ -0,0 +1,6 @@
|
||||
from sqlalchemy.orm import DeclarativeBase
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
"""Общий базовый класс для всех ORM-моделей."""
|
||||
pass
|
||||
@@ -0,0 +1,34 @@
|
||||
from collections.abc import AsyncGenerator
|
||||
|
||||
from sqlalchemy.ext.asyncio import (
|
||||
AsyncSession,
|
||||
async_sessionmaker,
|
||||
create_async_engine,
|
||||
)
|
||||
|
||||
from src.core.config import settings
|
||||
|
||||
engine = create_async_engine(
|
||||
settings.database_url,
|
||||
echo=False,
|
||||
pool_size=10,
|
||||
max_overflow=20,
|
||||
pool_pre_ping=True,
|
||||
pool_recycle=1800,
|
||||
)
|
||||
|
||||
async_session_factory = async_sessionmaker(
|
||||
engine,
|
||||
class_=AsyncSession,
|
||||
expire_on_commit=False,
|
||||
autoflush=False,
|
||||
)
|
||||
|
||||
|
||||
async def get_db() -> AsyncGenerator[AsyncSession, None]:
|
||||
async with async_session_factory() as session:
|
||||
try:
|
||||
yield session
|
||||
except Exception:
|
||||
await session.rollback()
|
||||
raise
|
||||
+93
@@ -0,0 +1,93 @@
|
||||
import uuid
|
||||
|
||||
from fastapi import FastAPI, HTTPException, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
from src.api import auth, chats, health, messages, users
|
||||
from src.core.middleware import RequestIdMiddleware
|
||||
|
||||
app = FastAPI(
|
||||
title="MTUSI Messenger — lab2",
|
||||
version="1.2.0",
|
||||
)
|
||||
|
||||
app.add_middleware(RequestIdMiddleware)
|
||||
|
||||
app.include_router(health.router)
|
||||
app.include_router(users.router)
|
||||
app.include_router(auth.router)
|
||||
app.include_router(chats.router)
|
||||
app.include_router(messages.router)
|
||||
|
||||
|
||||
def _rid(request: Request) -> str:
|
||||
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
|
||||
|
||||
def _code_for(status_code: int) -> str:
|
||||
return {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
413: "payload_too_large",
|
||||
415: "unsupported_media_type",
|
||||
429: "rate_limited",
|
||||
503: "unavailable",
|
||||
500: "internal_error",
|
||||
}.get(status_code, "internal_error")
|
||||
|
||||
|
||||
@app.exception_handler(HTTPException)
|
||||
async def http_exception_with_request_id(request: Request, exc: HTTPException):
|
||||
rid = _rid(request)
|
||||
response = JSONResponse(
|
||||
status_code=exc.status_code,
|
||||
content={
|
||||
"error": {
|
||||
"code": _code_for(exc.status_code),
|
||||
"message": exc.detail if isinstance(exc.detail, str) else "error",
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
if exc.status_code == 401:
|
||||
response.headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
|
||||
if exc.headers:
|
||||
for k, v in exc.headers.items():
|
||||
response.headers.setdefault(k, v)
|
||||
return response
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
rid = _rid(request)
|
||||
return JSONResponse(
|
||||
status_code=400,
|
||||
content={
|
||||
"error": {
|
||||
"code": "invalid_request",
|
||||
"message": "invalid request",
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def unhandled_exception_handler(request: Request, exc):
|
||||
rid = _rid(request)
|
||||
return JSONResponse(
|
||||
status_code=500,
|
||||
content={
|
||||
"error": {
|
||||
"code": "internal_error",
|
||||
"message": "internal error",
|
||||
"request_id": rid,
|
||||
}
|
||||
},
|
||||
headers={"X-Request-Id": rid},
|
||||
)
|
||||
@@ -0,0 +1,104 @@
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import (
|
||||
CheckConstraint,
|
||||
DateTime,
|
||||
ForeignKey,
|
||||
Index,
|
||||
String,
|
||||
Text,
|
||||
func,
|
||||
)
|
||||
from sqlalchemy.dialects.postgresql import UUID
|
||||
from sqlalchemy.orm import Mapped, mapped_column, relationship
|
||||
|
||||
from src.db.base import Base
|
||||
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = "users"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
|
||||
)
|
||||
username: Mapped[str] = mapped_column(
|
||||
String(32), unique=True, nullable=False, index=True
|
||||
)
|
||||
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
|
||||
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=func.now(), nullable=False
|
||||
)
|
||||
|
||||
__table_args__ = (
|
||||
CheckConstraint(
|
||||
"username ~ '^[a-z0-9_]{3,32}$'",
|
||||
name="ck_users_username_format",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = "chats"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
|
||||
)
|
||||
title: Mapped[str] = mapped_column(String(100), nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=func.now(), nullable=False
|
||||
)
|
||||
|
||||
members: Mapped[list["ChatMember"]] = relationship(
|
||||
back_populates="chat", cascade="all, delete-orphan"
|
||||
)
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
__tablename__ = "chat_members"
|
||||
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True),
|
||||
ForeignKey("chats.id", ondelete="CASCADE"),
|
||||
primary_key=True,
|
||||
)
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True),
|
||||
ForeignKey("users.id", ondelete="CASCADE"),
|
||||
primary_key=True,
|
||||
)
|
||||
|
||||
chat: Mapped["Chat"] = relationship(back_populates="members")
|
||||
|
||||
|
||||
class Message(Base):
|
||||
__tablename__ = "messages"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
|
||||
)
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True),
|
||||
ForeignKey("chats.id", ondelete="CASCADE"),
|
||||
nullable=False,
|
||||
)
|
||||
sender_id: Mapped[uuid.UUID] = mapped_column(
|
||||
UUID(as_uuid=True),
|
||||
ForeignKey("users.id", ondelete="CASCADE"),
|
||||
nullable=False,
|
||||
)
|
||||
text: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=func.now(), nullable=False
|
||||
)
|
||||
|
||||
__table_args__ = (
|
||||
# Ключевой индекс для пагинации истории (оценка 4).
|
||||
Index(
|
||||
"idx_messages_chat_created_id",
|
||||
"chat_id",
|
||||
"created_at",
|
||||
"id",
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,105 @@
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
|
||||
# ---------- Health ----------
|
||||
|
||||
class HealthResponse(BaseModel):
|
||||
status: str = "ok"
|
||||
|
||||
|
||||
# ---------- Errors ----------
|
||||
|
||||
class ErrorBody(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
error: ErrorBody
|
||||
|
||||
|
||||
# ---------- Users ----------
|
||||
|
||||
USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$"
|
||||
|
||||
|
||||
class CreateUserRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
|
||||
|
||||
username: str = Field(pattern=USERNAME_PATTERN)
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
|
||||
class UserResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True, extra="forbid")
|
||||
|
||||
id: uuid.UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
# ---------- Sessions ----------
|
||||
|
||||
class SessionResponse(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
token: str
|
||||
token_type: str = "Bearer"
|
||||
expires_at: datetime
|
||||
user: UserResponse
|
||||
|
||||
|
||||
# ---------- Chats ----------
|
||||
|
||||
class CreateChatRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
|
||||
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class ChatResponse(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
id: uuid.UUID
|
||||
title: str
|
||||
member_ids: list[uuid.UUID]
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
items: list[ChatResponse]
|
||||
next_cursor: str | None
|
||||
|
||||
|
||||
# ---------- Messages ----------
|
||||
|
||||
class CreateMessageRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
|
||||
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
|
||||
class MessageResponse(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True, extra="forbid")
|
||||
|
||||
id: uuid.UUID
|
||||
chat_id: uuid.UUID
|
||||
sender_id: uuid.UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
items: list[MessageResponse]
|
||||
next_cursor: str | None
|
||||
@@ -0,0 +1,124 @@
|
||||
import base64
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import and_, or_, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.models.models import Chat, ChatMember, Message
|
||||
|
||||
|
||||
class UnknownMemberError(Exception):
|
||||
"""Хотя бы один member_id не существует в users."""
|
||||
|
||||
|
||||
class CallerNotInMembersError(Exception):
|
||||
"""Вызывающий не входит в member_ids."""
|
||||
|
||||
|
||||
class ChatNotFoundError(Exception):
|
||||
"""Чат не существует или недоступен."""
|
||||
|
||||
|
||||
async def create_chat(
|
||||
db: AsyncSession,
|
||||
title: str,
|
||||
member_ids: list[uuid.UUID],
|
||||
caller_id: uuid.UUID,
|
||||
) -> Chat:
|
||||
unique_ids = set(member_ids)
|
||||
if caller_id not in unique_ids:
|
||||
raise CallerNotInMembersError()
|
||||
|
||||
# Проверяем, что все users существуют
|
||||
from src.models.models import User
|
||||
result = await db.execute(select(User.id).where(User.id.in_(unique_ids)))
|
||||
existing = {row[0] for row in result.all()}
|
||||
missing = unique_ids - existing
|
||||
if missing:
|
||||
raise UnknownMemberError()
|
||||
|
||||
chat = Chat(title=title)
|
||||
db.add(chat)
|
||||
await db.flush() # получаем chat.id
|
||||
|
||||
for uid in unique_ids:
|
||||
db.add(ChatMember(chat_id=chat.id, user_id=uid))
|
||||
|
||||
await db.commit()
|
||||
await db.refresh(chat)
|
||||
return chat
|
||||
|
||||
|
||||
async def get_chat_for_user(
|
||||
db: AsyncSession,
|
||||
chat_id: uuid.UUID,
|
||||
user_id: uuid.UUID,
|
||||
) -> Chat | None:
|
||||
stmt = (
|
||||
select(Chat)
|
||||
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
||||
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
|
||||
)
|
||||
result = await db.execute(stmt)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def get_member_ids(
|
||||
db: AsyncSession,
|
||||
chat_id: uuid.UUID,
|
||||
) -> list[uuid.UUID]:
|
||||
stmt = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
|
||||
result = await db.execute(stmt)
|
||||
return [row[0] for row in result.all()]
|
||||
|
||||
|
||||
# ---------- Пагинация списка чатов ----------
|
||||
|
||||
def encode_cursor(created_at: datetime, chat_id: uuid.UUID) -> str:
|
||||
raw = f"{created_at.isoformat()}|{chat_id}"
|
||||
return base64.urlsafe_b64encode(raw.encode()).decode()
|
||||
|
||||
|
||||
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
|
||||
ts_str, id_str = raw.split("|", 1)
|
||||
return datetime.fromisoformat(ts_str), uuid.UUID(id_str)
|
||||
except (ValueError, UnicodeDecodeError) as exc:
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
|
||||
async def list_chats_for_user(
|
||||
db: AsyncSession,
|
||||
user_id: uuid.UUID,
|
||||
limit: int,
|
||||
cursor: str | None,
|
||||
) -> tuple[list[Chat], str | None]:
|
||||
stmt = (
|
||||
select(Chat)
|
||||
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
||||
.where(ChatMember.user_id == user_id)
|
||||
.order_by(Chat.created_at.asc(), Chat.id.asc())
|
||||
.limit(limit + 1)
|
||||
)
|
||||
|
||||
if cursor:
|
||||
cursor_ts, cursor_id = decode_cursor(cursor)
|
||||
stmt = stmt.where(
|
||||
or_(
|
||||
Chat.created_at > cursor_ts,
|
||||
and_(Chat.created_at == cursor_ts, Chat.id > cursor_id),
|
||||
)
|
||||
)
|
||||
|
||||
result = await db.execute(stmt)
|
||||
rows = list(result.scalars().all())
|
||||
|
||||
next_cursor: str | None = None
|
||||
if len(rows) > limit:
|
||||
last = rows[limit - 1]
|
||||
next_cursor = encode_cursor(last.created_at, last.id)
|
||||
rows = rows[:limit]
|
||||
|
||||
return rows, next_cursor
|
||||
@@ -0,0 +1,76 @@
|
||||
import base64
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import and_, or_, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.models.models import Message
|
||||
|
||||
|
||||
def encode_cursor(created_at: datetime, message_id: uuid.UUID) -> str:
|
||||
raw = f"{created_at.isoformat()}|{message_id}"
|
||||
return base64.urlsafe_b64encode(raw.encode()).decode()
|
||||
|
||||
|
||||
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
|
||||
ts_str, id_str = raw.split("|", 1)
|
||||
return datetime.fromisoformat(ts_str), uuid.UUID(id_str)
|
||||
except (ValueError, UnicodeDecodeError) as exc:
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
|
||||
async def create_message(
|
||||
db: AsyncSession,
|
||||
chat_id: uuid.UUID,
|
||||
sender_id: uuid.UUID,
|
||||
text: str,
|
||||
) -> Message:
|
||||
message = Message(
|
||||
chat_id=chat_id,
|
||||
sender_id=sender_id,
|
||||
text=text,
|
||||
)
|
||||
db.add(message)
|
||||
await db.commit()
|
||||
await db.refresh(message)
|
||||
return message
|
||||
|
||||
|
||||
async def list_messages(
|
||||
db: AsyncSession,
|
||||
chat_id: uuid.UUID,
|
||||
limit: int,
|
||||
cursor: str | None,
|
||||
) -> tuple[list[Message], str | None]:
|
||||
stmt = (
|
||||
select(Message)
|
||||
.where(Message.chat_id == chat_id)
|
||||
.order_by(Message.created_at.asc(), Message.id.asc())
|
||||
.limit(limit + 1)
|
||||
)
|
||||
|
||||
if cursor:
|
||||
cursor_ts, cursor_id = decode_cursor(cursor)
|
||||
stmt = stmt.where(
|
||||
or_(
|
||||
Message.created_at > cursor_ts,
|
||||
and_(
|
||||
Message.created_at == cursor_ts,
|
||||
Message.id > cursor_id,
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
result = await db.execute(stmt)
|
||||
rows = list(result.scalars().all())
|
||||
|
||||
next_cursor: str | None = None
|
||||
if len(rows) > limit:
|
||||
last = rows[limit - 1]
|
||||
next_cursor = encode_cursor(last.created_at, last.id)
|
||||
rows = rows[:limit]
|
||||
|
||||
return rows, next_cursor
|
||||
@@ -0,0 +1,50 @@
|
||||
import uuid
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
|
||||
from src.core.config import settings
|
||||
from src.core.security import generate_session_token
|
||||
|
||||
KEY_PREFIX = "session:"
|
||||
|
||||
|
||||
def _key(token: str) -> str:
|
||||
return KEY_PREFIX + token
|
||||
|
||||
|
||||
async def create_session(
|
||||
redis: aioredis.Redis,
|
||||
user_id: uuid.UUID,
|
||||
ttl_seconds: int | None = None,
|
||||
) -> str:
|
||||
token = generate_session_token()
|
||||
ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds
|
||||
await redis.set(_key(token), str(user_id), ex=ttl)
|
||||
return token
|
||||
|
||||
|
||||
async def get_session_user_id(
|
||||
redis: aioredis.Redis,
|
||||
token: str,
|
||||
) -> uuid.UUID | None:
|
||||
value = await redis.get(_key(token))
|
||||
if value is None:
|
||||
return None
|
||||
try:
|
||||
return uuid.UUID(value)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
async def revoke_session(redis: aioredis.Redis, token: str) -> None:
|
||||
await redis.delete(_key(token))
|
||||
|
||||
|
||||
async def touch_session(
|
||||
redis: aioredis.Redis,
|
||||
token: str,
|
||||
ttl_seconds: int | None = None,
|
||||
) -> None:
|
||||
"""Продлить TTL сессии (опционально)."""
|
||||
ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds
|
||||
await redis.expire(_key(token), ttl)
|
||||
@@ -0,0 +1,51 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.core.security import hash_password
|
||||
from src.models.models import User
|
||||
|
||||
|
||||
class UsernameTakenError(Exception):
|
||||
"""Username уже занят."""
|
||||
|
||||
|
||||
async def create_user(
|
||||
db: AsyncSession,
|
||||
username: str,
|
||||
display_name: str,
|
||||
password: str,
|
||||
) -> User:
|
||||
user = User(
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
password_hash=hash_password(password),
|
||||
)
|
||||
db.add(user)
|
||||
try:
|
||||
await db.commit()
|
||||
except IntegrityError as exc:
|
||||
await db.rollback()
|
||||
raise UsernameTakenError(username) from exc
|
||||
await db.refresh(user)
|
||||
return user
|
||||
|
||||
|
||||
async def get_user_by_username(
|
||||
db: AsyncSession,
|
||||
username: str,
|
||||
) -> User | None:
|
||||
stmt = select(User).where(User.username == username)
|
||||
result = await db.execute(stmt)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def get_user_by_id(
|
||||
db: AsyncSession,
|
||||
user_id: uuid.UUID,
|
||||
) -> User | None:
|
||||
stmt = select(User).where(User.id == user_id)
|
||||
result = await db.execute(stmt)
|
||||
return result.scalar_one_or_none()
|
||||
@@ -0,0 +1,56 @@
|
||||
"""Test: concurrent registration of the same username must produce exactly one 201 and one 409."""
|
||||
import base64
|
||||
import json
|
||||
import threading
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
|
||||
BASE = "http://localhost:8080"
|
||||
|
||||
|
||||
def post_user(username: str, password: str):
|
||||
body = json.dumps({
|
||||
"username": username,
|
||||
"display_name": "Race Test",
|
||||
"password": password,
|
||||
}).encode()
|
||||
req = urllib.request.Request(
|
||||
BASE + "/api/v1/users",
|
||||
data=body,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
return resp.status, resp.read().decode()
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.read().decode()
|
||||
|
||||
|
||||
def main():
|
||||
username = "race_" + uuid.uuid4().hex[:8]
|
||||
password = "RaceTestPassword123"
|
||||
results = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def worker():
|
||||
status, body = post_user(username, password)
|
||||
with lock:
|
||||
results.append((status, body))
|
||||
|
||||
threads = [threading.Thread(target=worker) for _ in range(2)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
|
||||
statuses = [s for s, _ in results]
|
||||
print("Statuses:", statuses)
|
||||
assert sorted(statuses) == [201, 409], f"expected [201, 409], got {statuses}"
|
||||
print("PASS: race registration — one 201, one 409")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,65 @@
|
||||
"""Test: when Redis is down, protected endpoints return 503, not 500."""
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
|
||||
BASE = "http://localhost:8080"
|
||||
|
||||
|
||||
def call(method, path, headers=None):
|
||||
h = {"Accept": "application/json"}
|
||||
h.update(headers or {})
|
||||
req = urllib.request.Request(BASE + path, headers=h, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
return resp.status, resp.read().decode()
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.read().decode()
|
||||
|
||||
|
||||
def stop_redis():
|
||||
subprocess.run(["docker", "compose", "stop", "redis"], check=True, capture_output=True)
|
||||
|
||||
|
||||
def start_redis():
|
||||
subprocess.run(["docker", "compose", "start", "redis"], check=True, capture_output=True)
|
||||
# Ждём, пока Redis станет healthy
|
||||
for _ in range(30):
|
||||
p = subprocess.run(
|
||||
["docker", "inspect", "--format={{.State.Health.Status}}", "mtusi2026lab2-redis-1"],
|
||||
capture_output=True, text=True,
|
||||
)
|
||||
if p.stdout.strip() == "healthy":
|
||||
return
|
||||
time.sleep(1)
|
||||
raise RuntimeError("redis did not become healthy")
|
||||
|
||||
|
||||
def main():
|
||||
# Проверяем, что без токена всё ещё 401 (не 500)
|
||||
try:
|
||||
stop_redis()
|
||||
time.sleep(2)
|
||||
|
||||
# 1. Аноним не должен пройти (401, не 503 — токена нет)
|
||||
status, body = call("GET", "/api/v1/users/me")
|
||||
assert status == 401, f"anonymous request without token should be 401, got {status} {body}"
|
||||
print("Anonymous without token: 401 (correct)")
|
||||
|
||||
# 2. С фиктивным токеном — 503 (Redis недоступен), не 500
|
||||
status, body = call("GET", "/api/v1/users/me", headers={
|
||||
"Authorization": "Bearer faketoken12345",
|
||||
})
|
||||
assert status == 503, f"with fake token and Redis down should be 503, got {status} {body}"
|
||||
print("With token, Redis down: 503 (correct)")
|
||||
print("PASS: Redis unavailability handled correctly")
|
||||
finally:
|
||||
start_redis()
|
||||
print("Redis restarted")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,69 @@
|
||||
"""Test: session expires after SESSION_TTL_SECONDS."""
|
||||
import base64
|
||||
import json
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
|
||||
BASE = "http://localhost:8080"
|
||||
EXPECTED_TTL = 2 # секунды
|
||||
|
||||
|
||||
def call(method, path, body=None, headers=None):
|
||||
h = {"Accept": "application/json"}
|
||||
h.update(headers or {})
|
||||
data = None
|
||||
if body is not None:
|
||||
data = json.dumps(body).encode()
|
||||
h["Content-Type"] = "application/json"
|
||||
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
return resp.status, json.loads(resp.read().decode() or "{}")
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, json.loads(e.read().decode() or "{}")
|
||||
|
||||
|
||||
def main():
|
||||
# 1. Регистрируем пользователя
|
||||
username = "exp_" + uuid.uuid4().hex[:8]
|
||||
password = "ExpiryTestPass123"
|
||||
status, user = call("POST", "/api/v1/users", {
|
||||
"username": username,
|
||||
"display_name": "Expiry Test",
|
||||
"password": password,
|
||||
})
|
||||
assert status == 201, f"register failed: {status} {user}"
|
||||
|
||||
# 2. Логинимся
|
||||
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
|
||||
status, session = call("POST", "/api/v1/auth/sessions", headers={
|
||||
"Authorization": "Basic " + cred,
|
||||
})
|
||||
assert status == 201, f"login failed: {status} {session}"
|
||||
token = session["token"]
|
||||
print(f"Got token; waiting {EXPECTED_TTL + 2}s for expiry...")
|
||||
|
||||
# 3. Проверяем, что токен сразу работает
|
||||
status, _ = call("GET", "/api/v1/users/me", headers={
|
||||
"Authorization": "Bearer " + token,
|
||||
})
|
||||
assert status == 200, f"token should work immediately, got {status}"
|
||||
print("Token works immediately: OK")
|
||||
|
||||
# 4. Ждём больше TTL
|
||||
time.sleep(EXPECTED_TTL + 2)
|
||||
|
||||
# 5. Проверяем, что токен больше не работает
|
||||
status, body = call("GET", "/api/v1/users/me", headers={
|
||||
"Authorization": "Bearer " + token,
|
||||
})
|
||||
assert status == 401, f"expired token should give 401, got {status} {body}"
|
||||
print("Token rejected after TTL: OK")
|
||||
print("PASS: session expiry works")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user