import asyncio import time from datetime import datetime from hashlib import sha256 from uuid import UUID import pytest from redis.asyncio import Redis from sqlalchemy import select from conftest import actor, bearer, keyed, make_chat, register, resolve, running_app, scalar from messenger.identity.application.ports import SessionDirectory from messenger.identity.domain.models import Session from messenger.identity.infrastructure.postgres import PostgresSessionRepository, SessionRow from messenger.identity.infrastructure.valkey import CachedSessionDirectory from messenger.shared.application.errors import Unavailable BEARER = 'Bearer realm="messenger"' def key_of(token: str) -> str: return f"session:{sha256(token.encode()).hexdigest()}" def token_of(user: dict) -> str: return actor(user)["Authorization"].split()[1] async def test_second_check_is_served_from_cache(valkey: dict[str, str]) -> None: cache = Redis.from_url(valkey["url"]) async with running_app(cache_url=valkey["url"]) as http: alice = await register(http, "alice") assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200 hits = (await cache.info("stats"))["keyspace_hits"] assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200 assert (await cache.info("stats"))["keyspace_hits"] == hits + 1 key = key_of(token_of(alice)) stored = str(await cache.get(key)) expires_at: datetime = await scalar( select(SessionRow.expires_at).where(SessionRow.user_id == UUID(alice["id"])) ) assert alice["id"] in stored and token_of(alice) not in stored assert await cache.pexpiretime(key) <= int(expires_at.timestamp() * 1000) await cache.aclose() async def test_logout_writes_tombstone_before_database(valkey: dict[str, str]) -> None: cache = Redis.from_url(valkey["url"]) async with running_app(cache_url=valkey["url"]) as http: alice = await register(http, "alice") assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200 assert ( await http.delete("/api/v1/auth/sessions/current", headers=actor(alice)) ).status_code == 204 assert await cache.get(key_of(token_of(alice))) == b"-" response = await http.get("/api/v1/users/me", headers=actor(alice)) assert response.status_code == 401 assert response.headers["WWW-Authenticate"] == BEARER await cache.aclose() async def test_logout_rejected_by_database_changes_nothing( valkey: dict[str, str], monkeypatch: pytest.MonkeyPatch ) -> None: async def broken(self: PostgresSessionRepository, token_hash: bytes) -> None: raise Unavailable("PostgreSQL недоступен") cache = Redis.from_url(valkey["url"]) logout = "/api/v1/auth/sessions/current" async with running_app(cache_url=valkey["url"]) as http: alice = await register(http, "alice") assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200 with monkeypatch.context() as patch: patch.setattr(PostgresSessionRepository, "remove", broken) failed = await http.delete(logout, headers=actor(alice)) assert failed.status_code == 503 assert failed.json()["error"]["code"] == "unavailable" assert await cache.get(key_of(token_of(alice))) is None assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200 assert (await http.delete(logout, headers=actor(alice))).status_code == 204 assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 401 await cache.aclose() async def test_fill_racing_with_logout_does_not_revive_token(valkey: dict[str, str]) -> None: async with running_app(cache_url=valkey["url"]) as http: alice = await register(http, "alice") directory = await resolve(http, SessionDirectory) assert isinstance(directory, CachedSessionDirectory) origin = directory._origin stale: list[Session | None] = [] entered, released = asyncio.Event(), asyncio.Event() class SlowOrigin: async def find(self, token_hash: bytes, now: datetime) -> Session | None: stale.append(await origin.find(token_hash, now)) entered.set() await released.wait() return stale[-1] directory._origin = SlowOrigin() reader = asyncio.create_task(http.get("/api/v1/users/me", headers=actor(alice))) await entered.wait() directory._origin = origin assert ( await http.delete("/api/v1/auth/sessions/current", headers=actor(alice)) ).status_code == 204 released.set() assert (await reader).status_code == 200 assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 401 async def test_flushall_loses_nothing(valkey: dict[str, str]) -> None: cache = Redis.from_url(valkey["url"]) async with running_app(cache_url=valkey["url"]) as http: alice = await register(http, "alice") bob = await register(http, "bob") assert ( await http.delete("/api/v1/auth/sessions/current", headers=actor(bob)) ).status_code == 204 await cache.flushall() assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200 assert (await http.get("/api/v1/users/me", headers=actor(bob))).status_code == 401 await cache.aclose() async def test_unreachable_cache_is_bypassed_without_anonymous_access() -> None: async with running_app(cache_url="redis://127.0.0.1:1/0") as http: alice = await register(http, "alice") started = time.perf_counter() me = await http.get("/api/v1/users/me", headers=actor(alice)) stranger = await http.get("/api/v1/users/me", headers=bearer("x" * 43)) elapsed = time.perf_counter() - started ready = await http.get("/health/ready") chat = await make_chat(http, alice) posted = await http.post( f"/api/v1/chats/{chat['id']}/messages", json={"text": "без кэша"}, headers=keyed(alice) ) logout = await http.delete("/api/v1/auth/sessions/current", headers=actor(alice)) still = await http.get("/api/v1/users/me", headers=actor(alice)) assert me.json() == alice assert stranger.status_code == 401 assert stranger.headers["WWW-Authenticate"] == BEARER assert elapsed < 1 assert ready.status_code == 200 assert posted.status_code == 201 assert logout.status_code == 503 assert logout.json()["error"]["code"] == "unavailable" assert still.status_code == 200