From 8ad0bb69475f3fb0d2507cf85caf531749cd3a23 Mon Sep 17 00:00:00 2001 From: gytall Date: Mon, 26 Oct 2026 23:02:39 +0300 Subject: [PATCH] add tests --- Makefile | 92 ++++++++-- alembic.ini | 1 + app/storage/types.py | 3 +- compose.yaml | 6 +- .../versions/abd273076068_add_counters.py | 33 ++++ requirements.txt | 3 +- scripts/restart.sh | 24 ++- tests/conftest.py | 74 ++++++-- tests/helpers.py | 2 +- tests/test_auth.py | 126 +++++++++++-- tests/test_chats.py | 32 ++-- tests/test_concurrency.py | 170 ++++++++++++++++- tests/test_errors.py | 6 +- tests/test_failures.py | 93 ++++++++++ tests/test_health.py | 6 +- tests/test_history_plan.py | 78 ++++++++ tests/test_limits.py | 25 ++- tests/test_messages.py | 53 +++--- tests/test_migrations.py | 24 ++- tests/test_pagination.py | 137 ++++++++++++++ tests/test_sessions.py | 173 ++++++++++++++++++ tests/test_users.py | 2 +- 22 files changed, 1042 insertions(+), 121 deletions(-) create mode 100644 migrations/versions/abd273076068_add_counters.py create mode 100644 tests/test_failures.py create mode 100644 tests/test_history_plan.py create mode 100644 tests/test_pagination.py create mode 100644 tests/test_sessions.py diff --git a/Makefile b/Makefile index 4f4ba54b..b6460d63 100644 --- a/Makefile +++ b/Makefile @@ -1,22 +1,47 @@ -include .env -PYTHON ?= python3 +PYTHON ?= $(if $(wildcard venv/bin/python),venv/bin/python,python3) BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(DB_PASSWORD)@localhost:5432/$(DB_NAME)_test -export TEST_DATABASE_URL +COMPOSE = docker compose --env-file .env + +TEST_PROJECT ?= $(notdir $(CURDIR))-test +TEST_API_PORT ?= 18080 +TEST_DB_PORT ?= 15432 +TEST_REDIS_PORT ?= 16379 +TEST_BASE_URL = http://localhost:$(TEST_API_PORT) +TEST_ENV = COMPOSE_PROJECT_NAME=$(TEST_PROJECT) API_HOST_PORT=$(TEST_API_PORT) \ + DB_HOST_PORT=$(TEST_DB_PORT) REDIS_HOST_PORT=$(TEST_REDIS_PORT) +TEST_COMPOSE = $(TEST_ENV) $(COMPOSE) + +TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test +TEST_REDIS_HOST ?= localhost +TEST_REDIS_PASSWORD ?= $(REDIS_PASSWORD) +TEST_REDIS_DB ?= 15 +export TEST_DATABASE_URL TEST_REDIS_HOST TEST_REDIS_PORT TEST_REDIS_PASSWORD TEST_REDIS_DB + +define wait_ready + @for i in $$(seq 1 90); do \ + curl -sf "$(1)/health/ready" >/dev/null && exit 0; sleep 1; \ + done; echo "API $(1) не готов за 90 секунд" >&2; exit 1 +endef .PHONY: help check validate test load test-persistence \ - up down logs db-up migrate migration \ - test-own test-limits test-concurrency test-migrations + up down restart ps logs migrate migration \ + test-stand-up test-stand-down test-stand-destroy test-stand-ps \ + test-stand-smoke test-stand-persistence db-up \ + test-own test-docker test-limits test-concurrency test-migrations test-all help: - @echo "Курс: check | validate | test (smoke по BASE_URL) | load | test-persistence ACTION_SCRIPT=scripts/restart.sh" - @echo "Стенд: up | down | logs | db-up (только PostgreSQL + тестовая БД) | migrate" - @echo "Свои: test-own | test-limits | test-concurrency | test-migrations | migration m='описание'" + @echo "Курс: check | validate | test (smoke по BASE_URL) | load | test-persistence ACTION_SCRIPT=scripts/restart.sh" + @echo "Основной: up | down | restart | ps | logs | migrate | migration m='описание'" + @echo "Тестовый: test-stand-up | test-stand-down | test-stand-destroy | test-stand-ps" + @echo " test-stand-smoke | test-stand-persistence" + @echo "Тесты: test-own | test-docker | test-limits | test-concurrency | test-migrations" + @echo "Всё: test-all (стенд + pytest + smoke + persistence на тестовом стенде)" check: $(PYTHON) scripts/check_contract.py @@ -35,27 +60,58 @@ test-persistence: $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) up: - docker compose --env-file .env up -d --build + $(COMPOSE) up -d --build + $(call wait_ready,$(BASE_URL)) down: - docker compose down + $(COMPOSE) down + +restart: + scripts/restart.sh + $(call wait_ready,$(BASE_URL)) + +ps: + $(COMPOSE) ps logs: - docker compose logs -f api - -db-up: - docker compose up -d --wait postgres - docker compose exec -T postgres sh -c 'createdb -U "$$POSTGRES_USER" "$$POSTGRES_DB"_test 2>&1 | grep -v "already exists"; true' + $(COMPOSE) logs -f api migrate: - docker compose run --rm migrate + $(COMPOSE) run --rm --build migrate migration: - $(PYTHON) -m alembic revision --autogenerate -m "$(m)" + DB_HOST=localhost $(PYTHON) -m alembic revision --autogenerate -m "$(m)" + +test-stand-up: + $(TEST_COMPOSE) up -d --build + $(call wait_ready,$(TEST_BASE_URL)) + $(TEST_COMPOSE) exec -T postgres sh -c 'createdb -U "$$POSTGRES_USER" "$$POSTGRES_DB"_test 2>&1 | grep -v "already exists"; true' + +db-up: test-stand-up + +test-stand-down: + $(TEST_COMPOSE) down + +test-stand-destroy: + $(TEST_COMPOSE) down -v + +test-stand-ps: + $(TEST_COMPOSE) ps + +test-stand-smoke: + $(PYTHON) tests/smoke.py --base-url "$(TEST_BASE_URL)" + +test-stand-persistence: + $(TEST_COMPOSE) ps + $(TEST_ENV) $(PYTHON) tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "$(TEST_BASE_URL)" + $(TEST_COMPOSE) ps test-own: $(PYTHON) -m pytest tests -q +test-docker: + $(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest tests -q + test-limits: $(PYTHON) -m pytest tests/test_limits.py -q @@ -64,3 +120,5 @@ test-concurrency: test-migrations: $(PYTHON) -m pytest tests/test_migrations.py -q + +test-all: test-stand-up test-docker test-stand-smoke test-stand-persistence diff --git a/alembic.ini b/alembic.ini index 7ed8c3b9..f95b20ac 100644 --- a/alembic.ini +++ b/alembic.ini @@ -1,6 +1,7 @@ [alembic] script_location = migrations prepend_sys_path = . +path_separator = os [loggers] keys = root,sqlalchemy,alembic diff --git a/app/storage/types.py b/app/storage/types.py index ff32c4aa..e0357cfa 100644 --- a/app/storage/types.py +++ b/app/storage/types.py @@ -1,5 +1,6 @@ +"""Общие типы слоя хранения.""" + from datetime import datetime from uuid import UUID -# Позиция в keyset-пагинации: (created_at, id) последнего виденного элемента. Position = tuple[datetime, UUID] diff --git a/compose.yaml b/compose.yaml index 5c74bde3..e8fa00a4 100644 --- a/compose.yaml +++ b/compose.yaml @@ -9,7 +9,7 @@ services: volumes: - pgdata:/var/lib/postgresql/data ports: - - "127.0.0.1:5432:5432" + - "127.0.0.1:${DB_HOST_PORT:-5432}:5432" healthcheck: test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] interval: 5s @@ -34,7 +34,7 @@ services: volumes: - redisdata:/data ports: - - "127.0.0.1:6379:6379" + - "127.0.0.1:${REDIS_HOST_PORT:-6379}:6379" healthcheck: test: ["CMD-SHELL", "redis-cli -a \"$$REDIS_PASSWORD\" --no-auth-warning ping | grep -q PONG"] interval: 5s @@ -57,7 +57,7 @@ services: restart: unless-stopped env_file: .env ports: - - "127.0.0.1:8080:8080" + - "127.0.0.1:${API_HOST_PORT:-8080}:8080" depends_on: postgres: condition: service_healthy diff --git a/migrations/versions/abd273076068_add_counters.py b/migrations/versions/abd273076068_add_counters.py new file mode 100644 index 00000000..9c809b06 --- /dev/null +++ b/migrations/versions/abd273076068_add_counters.py @@ -0,0 +1,33 @@ +"""add counters + +Revision ID: abd273076068 +Revises: db06fd3126ff +Create Date: 2026-10-26 22:01:01.910396 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +revision: str = 'abd273076068' +down_revision: Union[str, None] = 'db06fd3126ff' +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('counters', + sa.Column('name', sa.String(length=64), nullable=False), + sa.Column('value', sa.BigInteger(), nullable=False), + sa.PrimaryKeyConstraint('name', name=op.f('pk_counters')) + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('counters') + # ### end Alembic commands ### diff --git a/requirements.txt b/requirements.txt index 291f2ada..3f730efd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -46,4 +46,5 @@ argon2-cffi==25.1.0 redis==8.1.0 greenlet pydantic-settings -pytest-asyncio +pytest-asyncio==1.4.1 +httpx==0.28.1 diff --git a/scripts/restart.sh b/scripts/restart.sh index 1913171b..55ac006c 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -2,5 +2,25 @@ set -eu cd "$(dirname "$0")/.." -docker compose restart postgres -docker compose restart api +compose() { + docker compose --env-file .env "$@" +} + +wait_healthy() { + for service in "$@"; do + attempts=0 + until [ "$(compose ps --format '{{.Health}}' "$service")" = "healthy" ]; do + attempts=$((attempts + 1)) + if [ "$attempts" -ge 60 ]; then + echo "$service не стал healthy за 60 секунд" >&2 + exit 1 + fi + sleep 1 + done + done +} + +compose restart postgres redis +wait_healthy postgres redis +compose restart api +wait_healthy api diff --git a/tests/conftest.py b/tests/conftest.py index e03b2950..489646b5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,12 +1,11 @@ -"""Фикстуры для async-тестов с РЕАЛЬНОЙ PostgreSQL (SQLite не подходит). +"""Фикстуры async-тестов на реальных PostgreSQL и Redis. -Перед запуском: `make db-up` (postgres + база _test). +Перед запуском: `make test-stand-up` (тестовый стенд и база _test). Переменные: TEST_DATABASE_URL по умолчанию postgresql+asyncpg://messenger:messenger@localhost:5432/messenger_test TEST_USE_MIGRATIONS=1 строить схему через `alembic upgrade head` вместо Base.metadata.create_all - -Все тесты и async-фикстуры живут в ОДНОМ event loop (pytest.ini: loop_scope=session), -поэтому пул соединений, созданный в фикстуре, можно использовать в тестах. + TEST_REDIS_HOST/PORT/PASSWORD/DB по умолчанию localhost:6379, база 15 + DOCKER_TESTS=1 включить тесты, которые перезапускают контейнеры compose """ import asyncio @@ -17,11 +16,16 @@ import httpx import pytest from alembic import command from alembic.config import Config +from fastapi import FastAPI +from redis.asyncio import Redis +from redis.exceptions import RedisError from sqlalchemy import text +from sqlalchemy.exc import SQLAlchemyError from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine from sqlalchemy.pool import NullPool from app.core.config import Settings +from app.core.redis import create_redis_client from app.main import create_app from app.models import Base @@ -34,6 +38,15 @@ def _database_url() -> str: return os.environ.get("TEST_DATABASE_URL", DEFAULT_TEST_DATABASE_URL) +def _redis_settings() -> dict[str, object]: + return { + "redis_host": os.environ.get("TEST_REDIS_HOST", "localhost"), + "redis_port": int(os.environ.get("TEST_REDIS_PORT", "6379")), + "redis_password": os.environ.get("TEST_REDIS_PASSWORD") or None, + "redis_db": int(os.environ.get("TEST_REDIS_DB", "15")), + } + + def _alembic_config(url: str) -> Config: config = Config("alembic.ini") config.set_main_option("sqlalchemy.url", url.replace("%", "%%")) @@ -51,6 +64,12 @@ async def reset_schema(engine: AsyncEngine) -> None: await connection.execute(text("DROP TABLE IF EXISTS alembic_version")) +async def close_app(app: FastAPI) -> None: + """ASGITransport не запускает lifespan, поэтому ресурсы приложения закрываются явно.""" + await app.state.redis.aclose() + await app.state.engine.dispose() + + @pytest.fixture(scope="session") def database_url() -> str: return _database_url() @@ -62,10 +81,10 @@ async def db_engine(database_url: str) -> AsyncIterator[AsyncEngine]: try: async with engine.connect() as connection: await connection.execute(text("SELECT 1")) - except Exception as error: # noqa: BLE001 + except (SQLAlchemyError, OSError) as error: pytest.exit( f"PostgreSQL недоступна по {engine.url.render_as_string(hide_password=True)}: " - f"{type(error).__name__}. Выполните `make db-up`.", + f"{type(error).__name__}. Выполните `make test-stand-up`.", returncode=2, ) @@ -81,12 +100,33 @@ async def db_engine(database_url: str) -> AsyncIterator[AsyncEngine]: await engine.dispose() +@pytest.fixture(scope="session") +async def redis_client() -> AsyncIterator[Redis]: + settings = build_settings(_database_url()) + if settings.redis_db == 0: + pytest.exit("TEST_REDIS_DB=0 запрещён: тесты очищают базу Redis.", returncode=2) + + client = create_redis_client(settings) + try: + await client.ping() + except (RedisError, OSError) as error: + pytest.exit( + f"Redis недоступен: {type(error).__name__}. Выполните `make test-stand-up`.", + returncode=2, + ) + + yield client + await client.flushdb() + await client.aclose() + + @pytest.fixture(autouse=True) -async def clean_db(db_engine: AsyncEngine) -> None: +async def clean_db(db_engine: AsyncEngine, redis_client: Redis) -> None: names = ", ".join(f'"{table.name}"' for table in Base.metadata.sorted_tables) if names: async with db_engine.begin() as connection: await connection.execute(text(f"TRUNCATE {names} RESTART IDENTITY CASCADE")) + await redis_client.flushdb() def build_settings(database_url: str, **overrides: object) -> Settings: @@ -101,6 +141,7 @@ def build_settings(database_url: str, **overrides: object) -> Settings: "session_ttl_seconds": 300, "db_pool_size": 10, "db_max_overflow": 10, + **_redis_settings(), } values.update(overrides) return Settings(_env_file=None, **values) # type: ignore[arg-type] @@ -114,15 +155,20 @@ def settings(database_url: str) -> Settings: @pytest.fixture def make_settings(database_url: str) -> Callable[..., Settings]: def factory(**overrides: object) -> Settings: - return build_settings(database_url, **overrides) + url = str(overrides.pop("database_url", database_url)) + return build_settings(url, **overrides) return factory -def make_client(app, *, raise_app_exceptions: bool = True, timeout: float = 30) -> httpx.AsyncClient: - """ASGITransport не запускает lifespan, поэтому engine закрывает вызывающий (см. fixtures).""" +def make_client( + app, *, raise_app_exceptions: bool = True, timeout: float = 30 +) -> httpx.AsyncClient: + """ASGITransport не запускает lifespan, поэтому ресурсы закрывает вызывающий (close_app).""" return httpx.AsyncClient( - transport=httpx.ASGITransport(app=app, raise_app_exceptions=raise_app_exceptions), + transport=httpx.ASGITransport( + app=app, raise_app_exceptions=raise_app_exceptions + ), base_url="http://testserver", timeout=timeout, ) @@ -143,11 +189,11 @@ def app(settings: Settings): async def client(app) -> AsyncIterator[httpx.AsyncClient]: async with make_client(app) as test_client: yield test_client - await app.state.engine.dispose() + await close_app(app) @pytest.fixture async def client_no_raise(app) -> AsyncIterator[httpx.AsyncClient]: async with make_client(app, raise_app_exceptions=False) as test_client: yield test_client - await app.state.engine.dispose() + await close_app(app) diff --git a/tests/helpers.py b/tests/helpers.py index 76dd761a..79a898ff 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -3,7 +3,7 @@ from uuid import uuid4 from httpx import AsyncClient -PASSWORD = "Correct-horse-battery-1" # синтетический пароль, только для тестов +PASSWORD = "Correct-horse-battery-1" def basic_header(username: str, password: str) -> dict[str, str]: diff --git a/tests/test_auth.py b/tests/test_auth.py index bdd49e69..d2617694 100644 --- a/tests/test_auth.py +++ b/tests/test_auth.py @@ -1,10 +1,11 @@ import asyncio +import hashlib from datetime import datetime from httpx import AsyncClient from app.main import create_app -from tests.conftest import make_client +from tests.conftest import close_app, make_client from tests.helpers import ( PASSWORD, assert_request_id, @@ -28,11 +29,11 @@ async def test_login_returns_opaque_bearer_session(client: AsyncClient): body = response.json() assert set(body) == {"token", "token_type", "expires_at", "user"} assert body["token_type"] == "Bearer" - assert len(body["token"]) >= 43 # 256 бит в base64url + assert len(body["token"]) >= 43 assert body["token"] not in (user["id"], user["username"]) assert body["user"]["id"] == user["id"] assert body["expires_at"].endswith("Z") - assert datetime.fromisoformat(body["expires_at"].replace("Z", "+00:00")) + assert datetime.fromisoformat(body["expires_at"]) assert_request_id(response) @@ -71,9 +72,14 @@ async def test_wrong_password_and_unknown_user_look_identical(client: AsyncClien for response in (wrong_password, unknown_user): assert response.status_code == 401 assert response.json()["error"]["code"] == "unauthorized" - assert response.headers["WWW-Authenticate"].startswith('Basic realm="messenger"') + assert response.headers["WWW-Authenticate"].startswith( + 'Basic realm="messenger"' + ) assert_request_id(response) - assert wrong_password.json()["error"]["message"] == unknown_user.json()["error"]["message"] + assert ( + wrong_password.json()["error"]["message"] + == unknown_user.json()["error"]["message"] + ) async def test_login_requires_basic_scheme(client: AsyncClient): @@ -99,7 +105,9 @@ async def test_business_endpoints_require_bearer(client: AsyncClient): response = await client.get("/api/v1/users/me", headers=headers) assert response.status_code == 401, headers assert response.json()["error"]["code"] == "unauthorized" - assert response.headers["WWW-Authenticate"].startswith('Bearer realm="messenger"') + assert response.headers["WWW-Authenticate"].startswith( + 'Bearer realm="messenger"' + ) assert_request_id(response) @@ -121,17 +129,27 @@ async def test_logout_revokes_only_current_session(client: AsyncClient): first = await login(client, user) second = await login(client, user) - assert (await client.delete("/api/v1/auth/sessions/current", headers=bearer(first))).status_code == 204 + assert ( + await client.delete("/api/v1/auth/sessions/current", headers=bearer(first)) + ).status_code == 204 - assert (await client.get("/api/v1/users/me", headers=bearer(first))).status_code == 401 - assert (await client.get("/api/v1/users/me", headers=bearer(second))).status_code == 200 + assert ( + await client.get("/api/v1/users/me", headers=bearer(first)) + ).status_code == 401 + assert ( + await client.get("/api/v1/users/me", headers=bearer(second)) + ).status_code == 200 async def test_logout_twice_returns_401(client: AsyncClient): session = await create_user(client) - first = await client.delete("/api/v1/auth/sessions/current", headers=bearer(session)) - again = await client.delete("/api/v1/auth/sessions/current", headers=bearer(session)) + first = await client.delete( + "/api/v1/auth/sessions/current", headers=bearer(session) + ) + again = await client.delete( + "/api/v1/auth/sessions/current", headers=bearer(session) + ) assert first.status_code == 204 assert first.content == b"" @@ -142,26 +160,27 @@ async def test_session_expires_after_ttl(make_settings): app = create_app(make_settings(session_ttl_seconds=2)) async with make_client(app) as client: session = await create_user(client) - assert (await client.get("/api/v1/users/me", headers=bearer(session))).status_code == 200 + assert ( + await client.get("/api/v1/users/me", headers=bearer(session)) + ).status_code == 200 await asyncio.sleep(3) response = await client.get("/api/v1/users/me", headers=bearer(session)) assert response.status_code == 401 assert response.headers["WWW-Authenticate"].startswith("Bearer") - await app.state.engine.dispose() + await close_app(app) -async def test_token_is_not_stored_in_plaintext(client: AsyncClient, db_engine): - from sqlalchemy import text - +async def test_token_is_stored_only_as_sha256_key(client: AsyncClient, redis_client): session = await create_user(client) - async with db_engine.connect() as connection: - result = await connection.execute(text("SELECT token_hash FROM sessions")) - stored = result.scalars().all() + keys = [key async for key in redis_client.scan_iter("session:*")] + token_hash = hashlib.sha256(session["token"].encode()).hexdigest() - assert stored and session["token"] not in stored + assert keys == [f"session:{token_hash}"] + assert await redis_client.get(keys[0]) == session["id"] + assert all(session["token"] not in key for key in keys) async def test_password_is_not_stored_in_plaintext(client: AsyncClient, db_engine): @@ -177,3 +196,70 @@ async def test_password_is_not_stored_in_plaintext(client: AsyncClient, db_engin assert PASSWORD not in stored assert stored.startswith("$argon2id$") + + +async def test_login_rejects_out_of_range_password_like_wrong_password( + client: AsyncClient, +): + user = await register(client) + reference = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], "wrong-password-123"), + ) + + for password in ("x" * 11, "x" * 129, ""): + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], password), + ) + assert response.status_code == 401 + assert ( + response.json()["error"]["message"] == reference.json()["error"]["message"] + ) + assert ( + response.headers["WWW-Authenticate"] + == reference.headers["WWW-Authenticate"] + ) + + +async def test_malformed_basic_credentials_return_401(client: AsyncClient): + import base64 + + def raw(value: bytes) -> dict[str, str]: + return {"Authorization": "Basic " + base64.b64encode(value).decode()} + + for headers in ( + raw(b"no-colon-here"), + raw(b":password-without-user"), + raw(b"\xff\xfe:invalid-utf8"), + {"Authorization": "Basic"}, + {"Authorization": "Digest abc"}, + ): + response = await client.post("/api/v1/auth/sessions", headers=headers) + assert response.status_code == 401, headers + assert response.headers["WWW-Authenticate"].startswith("Basic") + + +async def test_unknown_user_takes_comparable_time_to_wrong_password( + client: AsyncClient, +): + import statistics + import time + + user = await register(client) + + async def measure(username: str) -> float: + samples = [] + for _ in range(5): + started = time.perf_counter() + await client.post( + "/api/v1/auth/sessions", + headers=basic_header(username, "wrong-password-123"), + ) + samples.append(time.perf_counter() - started) + return statistics.median(samples) + + wrong_password = await measure(user["username"]) + unknown_user = await measure("no_such_user") + + assert unknown_user > wrong_password * 0.5 diff --git a/tests/test_chats.py b/tests/test_chats.py index 1a94b897..37d312ae 100644 --- a/tests/test_chats.py +++ b/tests/test_chats.py @@ -142,7 +142,9 @@ async def test_nonexistent_chat_returns_404(client: AsyncClient): assert_request_id(response) -async def test_failed_chat_creation_leaves_no_partial_data(client: AsyncClient, db_engine): +async def test_failed_chat_creation_leaves_no_partial_data( + client: AsyncClient, db_engine +): """Атомарность: неизвестный участник -> нет ни чата, ни записей членства.""" from sqlalchemy import text @@ -155,7 +157,9 @@ async def test_failed_chat_creation_leaves_no_partial_data(client: AsyncClient, assert response.status_code == 400 async with db_engine.connect() as connection: - chats = (await connection.execute(text("SELECT count(*) FROM chats"))).scalar_one() + chats = ( + await connection.execute(text("SELECT count(*) FROM chats")) + ).scalar_one() members = ( await connection.execute(text("SELECT count(*) FROM chat_members")) ).scalar_one() @@ -167,14 +171,18 @@ async def test_chat_list_pagination_and_order(client: AsyncClient): chats = [await create_chat(client, alice, title=f"chat-{i}") for i in range(5)] page1 = (await client.get("/api/v1/chats?limit=2", headers=bearer(alice))).json() - page2 = (await client.get( - f"/api/v1/chats?limit=2&cursor={quote(page1['next_cursor'], safe='')}", - headers=bearer(alice), - )).json() - page3 = (await client.get( - f"/api/v1/chats?limit=2&cursor={quote(page2['next_cursor'], safe='')}", - headers=bearer(alice), - )).json() + page2 = ( + await client.get( + f"/api/v1/chats?limit=2&cursor={quote(page1['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + page3 = ( + await client.get( + f"/api/v1/chats?limit=2&cursor={quote(page2['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() ids = [c["id"] for page in (page1, page2, page3) for c in page["items"]] assert ids == [c["id"] for c in chats] @@ -183,4 +191,6 @@ async def test_chat_list_pagination_and_order(client: AsyncClient): async def test_chat_endpoints_require_bearer(client: AsyncClient): assert (await client.get("/api/v1/chats")).status_code == 401 - assert (await client.post("/api/v1/chats", json={"title": "x", "member_ids": []})).status_code in (401, 400) + assert ( + await client.post("/api/v1/chats", json={"title": "x", "member_ids": []}) + ).status_code in (401, 400) diff --git a/tests/test_concurrency.py b/tests/test_concurrency.py index a45cb03d..c498871f 100644 --- a/tests/test_concurrency.py +++ b/tests/test_concurrency.py @@ -7,12 +7,16 @@ from uuid import uuid4 from sqlalchemy import text from app.main import create_app -from tests.conftest import make_client -from tests.helpers import PASSWORD, bearer, create_user +from tests.conftest import close_app, make_client +from tests.helpers import PASSWORD, basic_header, bearer, create_user, register -async def test_parallel_registration_of_same_username_creates_exactly_one_user(make_settings): - app = create_app(make_settings(max_in_flight=64, db_pool_size=20, db_max_overflow=20)) +async def test_parallel_registration_of_same_username_creates_exactly_one_user( + make_settings, +): + app = create_app( + make_settings(max_in_flight=64, db_pool_size=20, db_max_overflow=20) + ) async with make_client(app) as client: responses = await asyncio.gather( @@ -28,7 +32,7 @@ async def test_parallel_registration_of_same_username_creates_exactly_one_user(m for _ in range(16) ) ) - await app.state.engine.dispose() + await close_app(app) statuses = Counter(response.status_code for response in responses) assert statuses == Counter({201: 1, 409: 15}), statuses @@ -84,11 +88,13 @@ async def test_100_messages_from_10_clients(make_settings): items = history.json()["items"] assert len(items) == 100 assert len({m["id"] for m in items}) == 100 - await app.state.engine.dispose() + await close_app(app) async def test_chat_creation_in_parallel_is_atomic(make_settings, db_engine): - app = create_app(make_settings(max_in_flight=32, db_pool_size=20, db_max_overflow=20)) + app = create_app( + make_settings(max_in_flight=32, db_pool_size=20, db_max_overflow=20) + ) async with make_client(app) as client: alice = await create_user(client) @@ -104,11 +110,157 @@ async def test_chat_creation_in_parallel_is_atomic(make_settings, db_engine): ) ) assert all(r.status_code == 201 for r in responses) - await app.state.engine.dispose() + await close_app(app) async with db_engine.connect() as connection: - chats = (await connection.execute(text("SELECT count(*) FROM chats"))).scalar_one() + chats = ( + await connection.execute(text("SELECT count(*) FROM chats")) + ).scalar_one() members = ( await connection.execute(text("SELECT count(*) FROM chat_members")) ).scalar_one() assert chats == 10 and members == 20 + + +async def test_parallel_registration_of_distinct_usernames_all_succeed(make_settings): + app = create_app(make_settings(max_in_flight=64)) + async with make_client(app) as client: + responses = await asyncio.gather( + *( + client.post( + "/api/v1/users", + json={ + "username": f"distinct_{i}", + "display_name": "D", + "password": PASSWORD, + }, + ) + for i in range(12) + ) + ) + await close_app(app) + + assert [r.status_code for r in responses] == [201] * 12 + assert len({r.json()["id"] for r in responses}) == 12 + + +async def test_parallel_logins_issue_distinct_valid_tokens(make_settings): + app = create_app(make_settings(max_in_flight=64)) + async with make_client(app) as client: + user = await register(client) + responses = await asyncio.gather( + *( + client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + for _ in range(10) + ) + ) + tokens = [r.json()["token"] for r in responses] + checks = await asyncio.gather( + *( + client.get( + "/api/v1/users/me", headers={"Authorization": f"Bearer {token}"} + ) + for token in tokens + ) + ) + await close_app(app) + + assert all(r.status_code == 201 for r in responses) + assert len(set(tokens)) == 10 + assert all(r.status_code == 200 for r in checks) + + +async def test_parallel_logout_of_same_token_succeeds_once(make_settings): + app = create_app(make_settings(max_in_flight=64)) + async with make_client(app) as client: + session = await create_user(client) + responses = await asyncio.gather( + *( + client.delete("/api/v1/auth/sessions/current", headers=bearer(session)) + for _ in range(10) + ) + ) + await close_app(app) + + assert Counter(r.status_code for r in responses) == Counter({204: 1, 401: 9}) + + +async def test_message_limit_is_exact_under_concurrency(make_settings, db_engine): + app = create_app( + make_settings( + max_messages=5, max_in_flight=64, db_pool_size=20, db_max_overflow=20 + ) + ) + async with make_client(app) as client: + user = await create_user(client) + chat = ( + await client.post( + "/api/v1/chats", + headers=bearer(user), + json={"title": "limit", "member_ids": [user["id"]]}, + ) + ).json() + responses = await asyncio.gather( + *( + client.post( + f"/api/v1/chats/{chat['id']}/messages", + headers=bearer(user), + json={"text": f"m{i}"}, + ) + for i in range(20) + ) + ) + await close_app(app) + + assert Counter(r.status_code for r in responses) == Counter({201: 5, 503: 15}) + async with db_engine.connect() as connection: + stored = ( + await connection.execute(text("SELECT count(*) FROM messages")) + ).scalar_one() + counter = ( + await connection.execute( + text("SELECT value FROM counters WHERE name = 'messages'") + ) + ).scalar_one() + assert stored == counter == 5 + + +async def test_failed_chat_insert_rolls_back_whole_transaction( + make_settings, db_engine, monkeypatch +): + import app.domain.chats as chats_domain + + async def accept_everyone(_session, user_ids): + return set(user_ids) + + app = create_app(make_settings()) + async with make_client(app) as client: + alice = await create_user(client) + monkeypatch.setattr( + chats_domain.users_storage, "get_existing_user_ids", accept_everyone + ) + response = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "broken", "member_ids": [alice["id"], str(uuid4())]}, + ) + monkeypatch.undo() + after = await client.post( + "/api/v1/chats", + headers=bearer(alice), + json={"title": "ok", "member_ids": [alice["id"]]}, + ) + await close_app(app) + + assert response.status_code == 400 + assert after.status_code == 201 + async with db_engine.connect() as connection: + titles = (await connection.execute(text("SELECT title FROM chats"))).scalars() + members = ( + await connection.execute(text("SELECT count(*) FROM chat_members")) + ).scalar_one() + assert list(titles) == ["ok"] + assert members == 1 diff --git a/tests/test_errors.py b/tests/test_errors.py index cea533ba..510e9bf7 100644 --- a/tests/test_errors.py +++ b/tests/test_errors.py @@ -1,5 +1,5 @@ -import logging import json +import logging from httpx import AsyncClient @@ -52,7 +52,9 @@ async def test_method_not_allowed_preserves_405(client: AsyncClient): assert_request_id(response) -async def test_unhandled_exception_is_hidden_from_client(client_no_raise: AsyncClient, caplog): +async def test_unhandled_exception_is_hidden_from_client( + client_no_raise: AsyncClient, caplog +): with caplog.at_level(logging.ERROR, logger="app.errors.handlers"): response = await client_no_raise.get("/__test__/explode") diff --git a/tests/test_failures.py b/tests/test_failures.py new file mode 100644 index 00000000..7b28ee67 --- /dev/null +++ b/tests/test_failures.py @@ -0,0 +1,93 @@ +"""Недоступность Redis и PostgreSQL: ограниченный 503, без анонимного доступа.""" + +import time + +from app.main import create_app +from tests.conftest import close_app, make_client +from tests.helpers import PASSWORD, assert_request_id, basic_header, bearer, create_user + +ME = "/api/v1/users/me" +DEAD_DATABASE_URL = "postgresql+asyncpg://nobody:secretpass@127.0.0.1:1/none" + + +def assert_unavailable(response) -> None: + assert response.status_code == 503, response.text + assert response.json()["error"]["code"] == "unavailable" + assert "secretpass" not in response.text + assert "Traceback" not in response.text + assert_request_id(response) + + +async def test_redis_down_gives_503_for_login_and_protected_endpoints(make_settings): + alive = create_app(make_settings()) + async with make_client(alive) as client: + session = await create_user(client) + await close_app(alive) + + app = create_app(make_settings(redis_port=1, redis_connect_timeout_seconds=0.5)) + async with make_client(app, raise_app_exceptions=False) as client: + started = time.perf_counter() + protected = await client.get(ME, headers=bearer(session)) + elapsed = time.perf_counter() - started + + login = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(session["username"], session["password"]), + ) + logout = await client.delete( + "/api/v1/auth/sessions/current", headers=bearer(session) + ) + ready = await client.get("/health/ready") + live = await client.get("/health/live") + + await close_app(app) + + for response in (protected, login, logout, ready): + assert_unavailable(response) + assert live.status_code == 200 + assert elapsed < 3 + + +async def test_redis_down_keeps_registration_working(make_settings): + app = create_app(make_settings(redis_port=1, redis_connect_timeout_seconds=0.5)) + async with make_client(app, raise_app_exceptions=False) as client: + response = await client.post( + "/api/v1/users", + json={"username": "no_redis", "display_name": "N", "password": PASSWORD}, + ) + await close_app(app) + + assert response.status_code == 201 + + +async def test_database_down_with_valid_session_gives_503(make_settings): + alive = create_app(make_settings()) + async with make_client(alive) as client: + session = await create_user(client) + await close_app(alive) + + app = create_app( + make_settings(database_url=DEAD_DATABASE_URL, db_connect_timeout_seconds=1) + ) + async with make_client(app, raise_app_exceptions=False) as client: + protected = await client.get(ME, headers=bearer(session)) + chats = await client.get("/api/v1/chats", headers=bearer(session)) + login = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(session["username"], session["password"]), + ) + await close_app(app) + + for response in (protected, chats, login): + assert_unavailable(response) + + +async def test_dependency_failure_never_authenticates_anonymous_requests(make_settings): + app = create_app(make_settings(redis_port=1, redis_connect_timeout_seconds=0.5)) + async with make_client(app, raise_app_exceptions=False) as client: + no_token = await client.get(ME) + garbage = await client.get(ME, headers={"Authorization": "Bearer garbage"}) + await close_app(app) + + assert no_token.status_code == 401 + assert_unavailable(garbage) diff --git a/tests/test_health.py b/tests/test_health.py index 66b7de98..8b426370 100644 --- a/tests/test_health.py +++ b/tests/test_health.py @@ -1,7 +1,7 @@ from httpx import AsyncClient from app.main import create_app -from tests.conftest import make_client +from tests.conftest import close_app, make_client from tests.helpers import assert_request_id @@ -35,7 +35,7 @@ async def test_readiness_is_503_when_database_is_down(make_settings): assert ready.status_code == 503 assert ready.json()["error"]["code"] == "unavailable" assert_request_id(ready) - await app.state.engine.dispose() + await close_app(app) async def test_business_request_is_503_when_database_is_down(make_settings): @@ -54,7 +54,7 @@ async def test_business_request_is_503_when_database_is_down(make_settings): "password": "Correct-horse-battery-1", }, ) - await app.state.engine.dispose() + await close_app(app) assert response.status_code == 503 assert response.json()["error"]["code"] == "unavailable" diff --git a/tests/test_history_plan.py b/tests/test_history_plan.py new file mode 100644 index 00000000..6a8ff3cb --- /dev/null +++ b/tests/test_history_plan.py @@ -0,0 +1,78 @@ +"""План запроса истории на >= 10 000 сообщений: индекс без Sort и полного скана.""" + +import json +from datetime import datetime +from uuid import UUID + +from sqlalchemy import text +from sqlalchemy.ext.asyncio import AsyncEngine + +from tests.helpers import bearer, create_chat, create_user + +HISTORY_QUERY = """ +SELECT * FROM messages +WHERE chat_id = :chat_id AND (created_at, id) > (:after_created_at, :after_id) +ORDER BY created_at, id +LIMIT 51 +""" + + +def walk(node: dict) -> list[dict]: + nodes = [node] + for child in node.get("Plans", []): + nodes.extend(walk(child)) + return nodes + + +async def seed_messages( + engine: AsyncEngine, chat_id: str, sender_id: str, count: int +) -> None: + async with engine.begin() as connection: + await connection.execute( + text( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), :chat_id, :sender_id, 'message ' || g, + now() - make_interval(secs => :count - g) + FROM generate_series(1, :count) AS g + """ + ), + {"chat_id": chat_id, "sender_id": sender_id, "count": count}, + ) + await connection.execute(text("ANALYZE messages")) + + +async def test_history_page_uses_composite_index(client, db_engine: AsyncEngine): + alice = await create_user(client) + target = await create_chat(client, alice, title="target") + noise = await create_chat(client, alice, title="noise") + await seed_messages(db_engine, target["id"], alice["id"], 10_000) + await seed_messages(db_engine, noise["id"], alice["id"], 10_000) + + middle = ( + await client.get( + f"/api/v1/chats/{target['id']}/messages?limit=100", headers=bearer(alice) + ) + ).json()["items"][-1] + + async with db_engine.connect() as connection: + raw_plan = ( + await connection.execute( + text(f"EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) {HISTORY_QUERY}"), + { + "chat_id": UUID(target["id"]), + "after_created_at": datetime.fromisoformat(middle["created_at"]), + "after_id": UUID(middle["id"]), + }, + ) + ).scalar_one() + + plan = (raw_plan if isinstance(raw_plan, list) else json.loads(raw_plan))[0]["Plan"] + nodes = walk(plan) + node_types = {node["Node Type"] for node in nodes} + index_names = {node.get("Index Name") for node in nodes} + + assert "ix_messages_chat_id_created_at_id" in index_names + assert "Sort" not in node_types + assert "Seq Scan" not in node_types + assert all(node.get("Actual Rows", 0) <= 51 for node in nodes) diff --git a/tests/test_limits.py b/tests/test_limits.py index 01b72f94..0f3a0661 100644 --- a/tests/test_limits.py +++ b/tests/test_limits.py @@ -1,11 +1,11 @@ -"""Остаток трека «управляемая деградация»: MAX_IN_FLIGHT -> 429, MAX_MESSAGES -> 503.""" +"""Ограничения нагрузки: MAX_IN_FLIGHT -> 429, MAX_MESSAGES -> 503.""" import asyncio import httpx from app.main import create_app -from tests.conftest import make_client +from tests.conftest import close_app, make_client from tests.helpers import assert_request_id, bearer, create_chat, create_user @@ -24,16 +24,23 @@ async def test_message_limit_rejects_without_deleting_confirmed_messages(make_se url = f"/api/v1/chats/{chat['id']}/messages" for index in range(2): - ok = await client.post(url, headers=bearer(user), json={"text": f"confirmed-{index}"}) + ok = await client.post( + url, headers=bearer(user), json={"text": f"confirmed-{index}"} + ) assert ok.status_code == 201 - rejected = await client.post(url, headers=bearer(user), json={"text": "rejected"}) + rejected = await client.post( + url, headers=bearer(user), json={"text": "rejected"} + ) _assert_error(rejected, 503, "unavailable") history = await client.get(f"{url}?limit=100", headers=bearer(user)) assert history.status_code == 200 - assert [m["text"] for m in history.json()["items"]] == ["confirmed-0", "confirmed-1"] - await app.state.engine.dispose() + assert [m["text"] for m in history.json()["items"]] == [ + "confirmed-0", + "confirmed-1", + ] + await close_app(app) async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypatch): @@ -62,7 +69,9 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat url = f"/api/v1/chats/{chat['id']}/messages" held = [ - asyncio.create_task(client.post(url, headers=bearer(user), json={"text": f"held-{i}"})) + asyncio.create_task( + client.post(url, headers=bearer(user), json={"text": f"held-{i}"}) + ) for i in range(2) ] @@ -86,4 +95,4 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat recovered = await client.post(url, headers=bearer(user), json={"text": "after"}) assert recovered.status_code == 201 assert_request_id(recovered) - await app.state.engine.dispose() + await close_app(app) diff --git a/tests/test_messages.py b/tests/test_messages.py index fb657b8e..28ba8bd8 100644 --- a/tests/test_messages.py +++ b/tests/test_messages.py @@ -87,21 +87,28 @@ async def test_pagination_has_no_duplicates(client: AsyncClient): chat = await create_chat(client, alice) created = [ - (await _message(client, alice, chat, f"message-{index}")).json() for index in range(5) + (await _message(client, alice, chat, f"message-{index}")).json() + for index in range(5) ] - page1 = (await client.get( - f"/api/v1/chats/{chat['id']}/messages?limit=2", - headers=bearer(alice), - )).json() - page2 = (await client.get( - f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page1['next_cursor'], safe='')}", - headers=bearer(alice), - )).json() - page3 = (await client.get( - f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page2['next_cursor'], safe='')}", - headers=bearer(alice), - )).json() + page1 = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=2", + headers=bearer(alice), + ) + ).json() + page2 = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page1['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + page3 = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page2['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() ids = [item["id"] for page in (page1, page2, page3) for item in page["items"]] assert ids == [item["id"] for item in created] @@ -122,10 +129,12 @@ async def test_cursor_cannot_be_used_for_another_chat(client: AsyncClient): await _message(client, alice, chat_b, "b1") await _message(client, alice, chat_b, "b2") - page = (await client.get( - f"/api/v1/chats/{chat_a['id']}/messages?limit=1", - headers=bearer(alice), - )).json() + page = ( + await client.get( + f"/api/v1/chats/{chat_a['id']}/messages?limit=1", + headers=bearer(alice), + ) + ).json() response = await client.get( f"/api/v1/chats/{chat_b['id']}/messages?limit=1&cursor={quote(page['next_cursor'], safe='')}", @@ -205,11 +214,13 @@ async def test_messages_survive_new_login(client: AsyncClient): async def test_history_order_is_created_at_then_id(client: AsyncClient): alice = await create_user(client) chat = await create_chat(client, alice) - created = [_message(client, alice, chat, f"m{i}").json() for i in range(10)] + created = [(await _message(client, alice, chat, f"m{i}")).json() for i in range(10)] - listed = (await client.get( - f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(alice) - )).json()["items"] + listed = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(alice) + ) + ).json()["items"] assert [m["id"] for m in listed] == [m["id"] for m in created] keys = [(m["created_at"], m["id"]) for m in listed] diff --git a/tests/test_migrations.py b/tests/test_migrations.py index ef1c3727..8e73a66e 100644 --- a/tests/test_migrations.py +++ b/tests/test_migrations.py @@ -1,4 +1,4 @@ -"""Миграции с нуля: «миграции с нуля и повторный запуск без дублирования данных».""" +"""Миграции: применение с нуля, идемпотентный повтор, совпадение со схемой моделей.""" import pytest from alembic.autogenerate import compare_metadata @@ -8,7 +8,7 @@ from sqlalchemy import inspect, text from app.models import Base from tests.conftest import reset_schema, upgrade_head -EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "sessions"} +EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters"} @pytest.fixture @@ -24,11 +24,15 @@ async def migrated_engine(database_url, db_engine): async def test_upgrade_creates_all_tables(migrated_engine): async with migrated_engine.connect() as connection: - tables = await connection.run_sync(lambda sync: set(inspect(sync).get_table_names())) + tables = await connection.run_sync( + lambda sync: set(inspect(sync).get_table_names()) + ) assert EXPECTED_TABLES <= tables -async def test_upgrade_twice_is_idempotent_and_keeps_data(migrated_engine, database_url): +async def test_upgrade_twice_is_idempotent_and_keeps_data( + migrated_engine, database_url +): async with migrated_engine.begin() as connection: await connection.execute( text( @@ -41,17 +45,23 @@ async def test_upgrade_twice_is_idempotent_and_keeps_data(migrated_engine, datab async with migrated_engine.connect() as connection: count = ( - await connection.execute(text("SELECT count(*) FROM users WHERE username = 'keep_me'")) + await connection.execute( + text("SELECT count(*) FROM users WHERE username = 'keep_me'") + ) ).scalar_one() assert count == 1 async def test_models_and_migrations_are_in_sync(migrated_engine): def compare(sync_connection): - context = MigrationContext.configure(sync_connection, opts={"compare_type": True}) + context = MigrationContext.configure( + sync_connection, opts={"compare_type": True} + ) return compare_metadata(context, Base.metadata) async with migrated_engine.connect() as connection: diff = await connection.run_sync(compare) - assert diff == [], f"Создайте миграцию: alembic revision --autogenerate. Diff: {diff}" + assert diff == [], ( + f"Создайте миграцию: alembic revision --autogenerate. Diff: {diff}" + ) diff --git a/tests/test_pagination.py b/tests/test_pagination.py new file mode 100644 index 00000000..b5cbcc04 --- /dev/null +++ b/tests/test_pagination.py @@ -0,0 +1,137 @@ +"""Курсоры: непрозрачность, привязка к ресурсу и устойчивость к подделке.""" + +import base64 +import json +from urllib.parse import quote + +import pytest +from httpx import AsyncClient + +from tests.helpers import bearer, create_chat, create_user, send_message + + +def forged_cursor(**payload: str) -> str: + return base64.urlsafe_b64encode(json.dumps(payload).encode()).decode() + + +@pytest.mark.parametrize( + "cursor", + [ + "not-base64-%%%", + base64.urlsafe_b64encode(b"not json").decode(), + base64.urlsafe_b64encode(b"[1, 2, 3]").decode(), + forged_cursor(kind="messages"), + ], +) +async def test_garbage_cursor_returns_400(client: AsyncClient, cursor: str): + alice = await create_user(client) + chat = await create_chat(client, alice) + + for url in ( + f"/api/v1/chats?cursor={quote(cursor, safe='')}", + f"/api/v1/chats/{chat['id']}/messages?cursor={quote(cursor, safe='')}", + ): + response = await client.get(url, headers=bearer(alice)) + assert response.status_code == 400, url + assert response.json()["error"]["code"] == "invalid_request" + + +async def test_cursor_without_timezone_is_rejected(client: AsyncClient): + alice = await create_user(client) + cursor = forged_cursor( + kind="chats", + resource_id=alice["id"], + created_at="2026-01-01T00:00:00", + item_id="00000000-0000-4000-8000-000000000000", + ) + + response = await client.get( + f"/api/v1/chats?cursor={quote(cursor, safe='')}", headers=bearer(alice) + ) + + assert response.status_code == 400 + + +async def test_chat_list_cursor_is_bound_to_its_owner(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + for index in range(2): + await create_chat(client, alice, bob, title=f"shared-{index}") + + page = (await client.get("/api/v1/chats?limit=1", headers=bearer(alice))).json() + response = await client.get( + f"/api/v1/chats?limit=1&cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(bob), + ) + + assert response.status_code == 400 + + +async def test_messages_cursor_is_not_accepted_by_chat_list(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + for index in range(2): + await send_message(client, alice, chat, f"m{index}") + + page = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(alice) + ) + ).json() + response = await client.get( + f"/api/v1/chats?cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(alice), + ) + + assert response.status_code == 400 + + +async def test_limit_can_change_between_pages(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) + sent = [ + (await send_message(client, alice, chat, f"m{index}")).json() + for index in range(6) + ] + + first = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(alice) + ) + ).json() + rest = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100" + f"&cursor={quote(first['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + + assert [m["id"] for m in first["items"] + rest["items"]] == [m["id"] for m in sent] + assert rest["next_cursor"] is None + + +async def test_message_sent_after_reading_last_page_is_seen_with_cursor( + client: AsyncClient, +): + alice = await create_user(client) + chat = await create_chat(client, alice) + await send_message(client, alice, chat, "first") + await send_message(client, alice, chat, "second") + + page = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(alice) + ) + ).json() + new = (await send_message(client, alice, chat, "third")).json() + rest = ( + await client.get( + f"/api/v1/chats/{chat['id']}/messages?limit=100" + f"&cursor={quote(page['next_cursor'], safe='')}", + headers=bearer(alice), + ) + ).json() + + assert [m["text"] for m in rest["items"]] == ["second", "third"] + assert rest["items"][-1] == new diff --git a/tests/test_sessions.py b/tests/test_sessions.py new file mode 100644 index 00000000..3210ec55 --- /dev/null +++ b/tests/test_sessions.py @@ -0,0 +1,173 @@ +"""Сессии в Redis: TTL, абсолютный срок, отзыв, потеря и перезапуск хранилища.""" + +import asyncio +import hashlib +import os +import time +from datetime import datetime + +import pytest +from httpx import AsyncClient +from redis.asyncio import Redis + +from app.main import create_app +from tests.conftest import close_app, make_client +from tests.helpers import basic_header, bearer, create_user, register + +ME = "/api/v1/users/me" +LOGOUT = "/api/v1/auth/sessions/current" + + +def session_key(token: str) -> str: + return "session:" + hashlib.sha256(token.encode()).hexdigest() + + +async def test_session_key_ttl_matches_expires_at( + client: AsyncClient, redis_client: Redis +): + user = await register(client) + response = await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + body = response.json() + + expires_at = datetime.fromisoformat(body["expires_at"]) + expire_time_ms = await redis_client.pexpiretime(session_key(body["token"])) + + assert abs(expire_time_ms - expires_at.timestamp() * 1000) < 2 + assert 299_000 < await redis_client.pttl(session_key(body["token"])) <= 300_000 + + +async def test_session_ttl_is_absolute_and_not_extended_by_activity( + client: AsyncClient, redis_client: Redis +): + session = await create_user(client) + key = session_key(session["token"]) + expire_before = await redis_client.pexpiretime(key) + + for _ in range(5): + assert (await client.get(ME, headers=bearer(session))).status_code == 200 + + assert await redis_client.pexpiretime(key) == expire_before + + +async def test_logout_removes_session_key(client: AsyncClient, redis_client: Redis): + session = await create_user(client) + key = session_key(session["token"]) + assert await redis_client.exists(key) == 1 + + assert (await client.delete(LOGOUT, headers=bearer(session))).status_code == 204 + + assert await redis_client.exists(key) == 0 + assert (await client.get(ME, headers=bearer(session))).status_code == 401 + + +async def test_expired_session_is_rejected_everywhere(make_settings): + app = create_app(make_settings(session_ttl_seconds=1)) + async with make_client(app) as client: + session = await create_user(client) + assert (await client.get(ME, headers=bearer(session))).status_code == 200 + + await asyncio.sleep(1.5) + + for method, url in (("GET", ME), ("GET", "/api/v1/chats"), ("DELETE", LOGOUT)): + response = await client.request(method, url, headers=bearer(session)) + assert response.status_code == 401, (method, url) + assert response.headers["WWW-Authenticate"].startswith("Bearer") + await close_app(app) + + +async def test_relogin_after_expiry_issues_new_working_token(make_settings): + app = create_app(make_settings(session_ttl_seconds=1)) + async with make_client(app) as client: + user = await register(client) + first = ( + await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + ).json() + await asyncio.sleep(1.5) + second = ( + await client.post( + "/api/v1/auth/sessions", + headers=basic_header(user["username"], user["password"]), + ) + ).json() + + assert first["token"] != second["token"] + assert (await client.get(ME, headers=bearer(first))).status_code == 401 + assert (await client.get(ME, headers=bearer(second))).status_code == 200 + await close_app(app) + + +async def test_tampered_token_is_rejected(client: AsyncClient): + session = await create_user(client) + token = session["token"] + tampered = token[:-1] + ("A" if token[-1] != "A" else "B") + + response = await client.get(ME, headers={"Authorization": f"Bearer {tampered}"}) + + assert response.status_code == 401 + + +async def test_session_of_deleted_user_is_rejected(client: AsyncClient, db_engine): + from sqlalchemy import text + + session = await create_user(client) + async with db_engine.begin() as connection: + await connection.execute( + text("DELETE FROM users WHERE id = :id"), {"id": session["id"]} + ) + + response = await client.get(ME, headers=bearer(session)) + + assert response.status_code == 401 + + +async def test_redis_flush_invalidates_all_sessions( + client: AsyncClient, redis_client: Redis +): + alice = await create_user(client) + bob = await create_user(client) + + await redis_client.flushdb() + + for session in (alice, bob): + assert (await client.get(ME, headers=bearer(session))).status_code == 401 + + +@pytest.mark.skipif( + os.environ.get("DOCKER_TESTS") != "1", + reason="перезапускает контейнер redis из compose; включается DOCKER_TESTS=1", +) +async def test_sessions_survive_redis_restart(client: AsyncClient, redis_client: Redis): + active = await create_user(client) + revoked = await create_user(client) + assert (await client.delete(LOGOUT, headers=bearer(revoked))).status_code == 204 + + process = await asyncio.create_subprocess_exec( + "docker", + "compose", + "restart", + "redis", + stdout=asyncio.subprocess.DEVNULL, + stderr=asyncio.subprocess.DEVNULL, + ) + assert await process.wait() == 0 + + deadline = time.monotonic() + 30 + while True: + try: + await redis_client.ping() + break + except Exception: + if time.monotonic() > deadline: + raise + await asyncio.sleep(0.5) + + response = await client.get(ME, headers=bearer(active)) + assert response.status_code == 200 + assert response.json()["id"] == active["id"] + assert (await client.get(ME, headers=bearer(revoked))).status_code == 401 diff --git a/tests/test_users.py b/tests/test_users.py index 996b3006..6f49e0db 100644 --- a/tests/test_users.py +++ b/tests/test_users.py @@ -38,7 +38,7 @@ async def test_get_current_user(client: AsyncClient): {"username": "alice-123", "display_name": "Alice", "password": PASSWORD}, {"username": "AlicE", "display_name": "Alice", "password": PASSWORD}, {"username": "a" * 33, "display_name": "Alice", "password": PASSWORD}, - {"username": "alice", "display_name": "Alice"}, # нет пароля + {"username": "alice", "display_name": "Alice"}, {"username": "alice", "display_name": "Alice", "password": "x" * 11}, {"username": "alice", "display_name": "Alice", "password": "x" * 129}, ],