174 lines
5.7 KiB
Python
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
|