forked from mtusi2026/mtusi2026lab2
180 lines
6.0 KiB
Python
180 lines
6.0 KiB
Python
import asyncio
|
|
from datetime import datetime
|
|
|
|
from httpx import AsyncClient
|
|
|
|
from app.main import create_app
|
|
from tests.conftest import make_client
|
|
from tests.helpers import (
|
|
PASSWORD,
|
|
assert_request_id,
|
|
basic_header,
|
|
bearer,
|
|
create_user,
|
|
login,
|
|
register,
|
|
)
|
|
|
|
|
|
async def test_login_returns_opaque_bearer_session(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
response = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], user["password"]),
|
|
)
|
|
|
|
assert response.status_code == 201
|
|
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 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_request_id(response)
|
|
|
|
|
|
async def test_each_login_issues_a_different_token(client: AsyncClient):
|
|
user = await register(client)
|
|
first = await login(client, user)
|
|
second = await login(client, user)
|
|
|
|
assert first["token"] != second["token"]
|
|
|
|
|
|
async def test_password_with_colon_works(client: AsyncClient):
|
|
user = await register(client, password="pass:with:colons-123")
|
|
|
|
assert (await login(client, user))["token"]
|
|
|
|
|
|
async def test_unicode_password_works(client: AsyncClient):
|
|
user = await register(client, password="Пароль-с-юникодом-🔑-123")
|
|
|
|
assert (await login(client, user))["token"]
|
|
|
|
|
|
async def test_wrong_password_and_unknown_user_look_identical(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
wrong_password = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header(user["username"], "wrong-password-123"),
|
|
)
|
|
unknown_user = await client.post(
|
|
"/api/v1/auth/sessions",
|
|
headers=basic_header("no_such_user", "wrong-password-123"),
|
|
)
|
|
|
|
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_request_id(response)
|
|
assert wrong_password.json()["error"]["message"] == unknown_user.json()["error"]["message"]
|
|
|
|
|
|
async def test_login_requires_basic_scheme(client: AsyncClient):
|
|
user = await register(client)
|
|
session = await login(client, user)
|
|
|
|
for headers in ({}, bearer(session), {"Authorization": "Basic !!!not-base64"}):
|
|
response = await client.post("/api/v1/auth/sessions", headers=headers)
|
|
assert response.status_code == 401
|
|
assert response.headers["WWW-Authenticate"].startswith("Basic")
|
|
|
|
|
|
async def test_business_endpoints_require_bearer(client: AsyncClient):
|
|
user = await register(client)
|
|
|
|
for headers in (
|
|
{},
|
|
basic_header(user["username"], user["password"]),
|
|
{"Authorization": "Bearer "},
|
|
{"Authorization": "Bearer unknown-token-value"},
|
|
{"X-User-Id": user["id"]},
|
|
):
|
|
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_request_id(response)
|
|
|
|
|
|
async def test_x_user_id_cannot_override_bearer_identity(client: AsyncClient):
|
|
alice = await create_user(client)
|
|
eve = await create_user(client)
|
|
|
|
response = await client.get(
|
|
"/api/v1/users/me",
|
|
headers={**bearer(alice), "X-User-Id": eve["id"]},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
assert response.json()["id"] == alice["id"]
|
|
|
|
|
|
async def test_logout_revokes_only_current_session(client: AsyncClient):
|
|
user = await register(client)
|
|
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.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))
|
|
|
|
assert first.status_code == 204
|
|
assert first.content == b""
|
|
assert again.status_code == 401
|
|
|
|
|
|
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
|
|
|
|
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()
|
|
|
|
|
|
async def test_token_is_not_stored_in_plaintext(client: AsyncClient, db_engine):
|
|
from sqlalchemy import text
|
|
|
|
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()
|
|
|
|
assert stored and session["token"] not in stored
|
|
|
|
|
|
async def test_password_is_not_stored_in_plaintext(client: AsyncClient, db_engine):
|
|
from sqlalchemy import text
|
|
|
|
await register(client, username="hash_check")
|
|
|
|
async with db_engine.connect() as connection:
|
|
result = await connection.execute(
|
|
text("SELECT password_hash FROM users WHERE username = 'hash_check'")
|
|
)
|
|
stored = result.scalar_one()
|
|
|
|
assert PASSWORD not in stored
|
|
assert stored.startswith("$argon2id$")
|