Files
mtusi2026lab5/student-tests/test_sessions.py
T
2026-11-07 16:10:32 +03:00

174 lines
5.7 KiB
Python

"""Сессии в 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 conftest import close_app, make_client
from 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