forked from mtusi2026/mtusi2026lab2
Messages survive restart in Postgres, and bearer sessions persist in Valkey with AOF. Co-authored-by: Cursor <cursoragent@cursor.com>
240 lines
8.4 KiB
Python
240 lines
8.4 KiB
Python
#!/usr/bin/env python3
|
|
"""Проверки уровня 4 для lab2. Сервер уже должен слушать BASE_URL."""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import base64
|
|
import json
|
|
import subprocess
|
|
import time
|
|
import uuid
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
from urllib.error import HTTPError
|
|
from urllib.parse import quote
|
|
from urllib.request import Request, urlopen
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
|
|
|
|
class Failure(AssertionError):
|
|
pass
|
|
|
|
|
|
def call(base, method, path, body=None, headers=None, expected=None):
|
|
data = None
|
|
h = {"Accept": "application/json"}
|
|
if body is not None:
|
|
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
|
h["Content-Type"] = "application/json"
|
|
h.update(headers or {})
|
|
request = Request(base + path, data=data, headers=h, method=method)
|
|
try:
|
|
response = urlopen(request, timeout=20)
|
|
status, payload_bytes, rh = response.status, response.read(), response.headers
|
|
except HTTPError as exc:
|
|
status, payload_bytes, rh = exc.code, exc.read(), exc.headers
|
|
payload = json.loads(payload_bytes) if payload_bytes else None
|
|
if expected is not None and status != expected:
|
|
raise Failure("%s %s: expected %s, got %s" % (method, path.split("?")[0], expected, status))
|
|
if not rh.get("X-Request-Id"):
|
|
raise Failure("missing X-Request-Id")
|
|
return status, rh, payload
|
|
|
|
|
|
def register(base, username=None, password=None):
|
|
username = username or ("u_" + uuid.uuid4().hex[:12])
|
|
password = password or ("T3st-" + uuid.uuid4().hex)
|
|
_, _, user = call(base, "POST", "/api/v1/users", {
|
|
"username": username,
|
|
"display_name": "Тест " + username[:12],
|
|
"password": password,
|
|
}, expected=201)
|
|
return user, password
|
|
|
|
|
|
def login(base, username, password):
|
|
raw = base64.b64encode((username + ":" + password).encode()).decode()
|
|
_, rh, session = call(
|
|
base, "POST", "/api/v1/auth/sessions",
|
|
headers={"Authorization": "Basic " + raw}, expected=201)
|
|
return session, rh
|
|
|
|
|
|
def auth(token):
|
|
return {"Authorization": "Bearer " + token}
|
|
|
|
|
|
def test_wrong_password(base):
|
|
user, _password = register(base)
|
|
bad = base64.b64encode((user["username"] + ":wrong-password").encode()).decode()
|
|
_, rh, body = call(
|
|
base, "POST", "/api/v1/auth/sessions",
|
|
headers={"Authorization": "Basic " + bad}, expected=401)
|
|
if not rh.get("WWW-Authenticate", "").lower().startswith("basic"):
|
|
raise Failure("wrong password must challenge Basic")
|
|
if body["error"]["code"] != "unauthorized":
|
|
raise Failure("wrong password code")
|
|
print("PASS wrong_password")
|
|
|
|
|
|
def test_logout(base):
|
|
user, password = register(base)
|
|
session, _rh = login(base, user["username"], password)
|
|
call(base, "DELETE", "/api/v1/auth/sessions/current",
|
|
headers=auth(session["token"]), expected=204)
|
|
_, rh, _body = call(base, "GET", "/api/v1/users/me",
|
|
headers=auth(session["token"]), expected=401)
|
|
if not rh.get("WWW-Authenticate", "").lower().startswith("bearer"):
|
|
raise Failure("revoked session must challenge Bearer")
|
|
print("PASS logout")
|
|
|
|
|
|
def test_x_user_id_ignored(base):
|
|
alice, alice_password = register(base)
|
|
eve, _eve_password = register(base)
|
|
session, _rh = login(base, alice["username"], alice_password)
|
|
headers = auth(session["token"])
|
|
headers["X-User-Id"] = eve["id"]
|
|
_, _, me = call(base, "GET", "/api/v1/users/me", headers=headers, expected=200)
|
|
if me["id"] != alice["id"]:
|
|
raise Failure("X-User-Id changed the session user")
|
|
call(base, "GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]}, expected=401)
|
|
print("PASS x_user_id")
|
|
|
|
|
|
def test_duplicate_race(base):
|
|
username = "u_" + uuid.uuid4().hex[:12]
|
|
password = "T3st-" + uuid.uuid4().hex
|
|
|
|
def once(_idx):
|
|
return call(base, "POST", "/api/v1/users", {
|
|
"username": username,
|
|
"display_name": "Гонка",
|
|
"password": password,
|
|
})[0]
|
|
|
|
with ThreadPoolExecutor(max_workers=8) as pool:
|
|
codes = list(pool.map(once, range(8)))
|
|
if codes.count(201) != 1 or codes.count(409) != 7:
|
|
raise Failure("duplicate username race: %s" % codes)
|
|
print("PASS duplicate_race")
|
|
|
|
|
|
def test_chat_rollback(base):
|
|
user, password = register(base)
|
|
session, _rh = login(base, user["username"], password)
|
|
title = "rollback-" + uuid.uuid4().hex[:8]
|
|
missing = str(uuid.uuid4())
|
|
call(base, "POST", "/api/v1/chats", {
|
|
"title": title,
|
|
"member_ids": [user["id"], missing],
|
|
}, headers=auth(session["token"]), expected=400)
|
|
_, _, page = call(base, "GET", "/api/v1/chats?limit=100",
|
|
headers=auth(session["token"]), expected=200)
|
|
if any(item["title"] == title for item in page["items"]):
|
|
raise Failure("rolled back chat is still visible")
|
|
print("PASS chat_rollback")
|
|
|
|
|
|
def test_bad_cursor_and_limit(base):
|
|
user, password = register(base)
|
|
session, _rh = login(base, user["username"], password)
|
|
_, _, chat = call(base, "POST", "/api/v1/chats", {
|
|
"title": "Страницы",
|
|
"member_ids": [user["id"]],
|
|
}, headers=auth(session["token"]), expected=201)
|
|
headers = auth(session["token"])
|
|
call(base, "GET", "/api/v1/chats/%s/messages?limit=" % chat["id"],
|
|
headers=headers, expected=400)
|
|
token = base64.urlsafe_b64encode(
|
|
("%s|not-a-timestamp|not-a-uuid" % chat["id"]).encode()
|
|
).decode().rstrip("=")
|
|
call(base, "GET", "/api/v1/chats/%s/messages?cursor=%s" % (chat["id"], quote(token, safe="")),
|
|
headers=headers, expected=400)
|
|
print("PASS bad_cursor_and_limit")
|
|
|
|
|
|
def test_expiry(base):
|
|
user, password = register(base)
|
|
session, _rh = login(base, user["username"], password)
|
|
expires = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
|
|
wait = (expires - datetime.now(timezone.utc)).total_seconds() + 1
|
|
if wait > 30:
|
|
raise Failure("SESSION_TTL_SECONDS is too large for the expiry check (%.0fs)" % wait)
|
|
time.sleep(max(wait, 0))
|
|
call(base, "GET", "/api/v1/users/me", headers=auth(session["token"]), expected=401)
|
|
print("PASS expiry")
|
|
|
|
|
|
def compose(args):
|
|
subprocess.run(
|
|
["docker", "compose", "--env-file", ".env", *args],
|
|
cwd=ROOT, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
|
|
|
|
def wait_ready(base, timeout=60):
|
|
deadline = time.time() + timeout
|
|
while time.time() < deadline:
|
|
try:
|
|
call(base, "GET", "/health/ready", expected=200)
|
|
return
|
|
except Failure:
|
|
time.sleep(0.5)
|
|
raise Failure("service did not become ready")
|
|
|
|
|
|
def test_dependencies(base):
|
|
user, password = register(base)
|
|
session, _rh = login(base, user["username"], password)
|
|
headers = auth(session["token"])
|
|
try:
|
|
compose(["stop", "valkey"])
|
|
time.sleep(1)
|
|
call(base, "GET", "/health/ready", expected=503)
|
|
call(base, "GET", "/api/v1/users/me", headers=headers, expected=503)
|
|
call(base, "GET", "/api/v1/users/me", expected=401)
|
|
finally:
|
|
compose(["start", "valkey"])
|
|
wait_ready(base)
|
|
call(base, "GET", "/api/v1/users/me", headers=headers, expected=200)
|
|
try:
|
|
compose(["stop", "postgres"])
|
|
time.sleep(1)
|
|
call(base, "GET", "/health/ready", expected=503)
|
|
call(base, "GET", "/api/v1/users/me", headers=headers, expected=503)
|
|
finally:
|
|
compose(["start", "postgres"])
|
|
wait_ready(base)
|
|
call(base, "GET", "/api/v1/users/me", headers=headers, expected=200)
|
|
print("PASS dependencies")
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--base-url", default="http://localhost:8080")
|
|
parser.add_argument("--expiry", action="store_true")
|
|
parser.add_argument("--deps", action="store_true")
|
|
args = parser.parse_args()
|
|
base = args.base_url.rstrip("/")
|
|
test_wrong_password(base)
|
|
test_logout(base)
|
|
test_x_user_id_ignored(base)
|
|
test_duplicate_race(base)
|
|
test_chat_rollback(base)
|
|
test_bad_cursor_and_limit(base)
|
|
if args.expiry:
|
|
test_expiry(base)
|
|
if args.deps:
|
|
test_dependencies(base)
|
|
print("ALL STUDENT TESTS PASSED")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
main()
|
|
except (Failure, OSError, subprocess.CalledProcessError) as exc:
|
|
print("FAIL:", exc)
|
|
raise SystemExit(1)
|