Files
mtusi2026lab2/tests/own.py
T

336 lines
11 KiB
Python

#!/usr/bin/env python3
"""Собственные проверки lab2 (оценка 4): auth, гонки, expiry, отказ Redis/DB."""
import base64
import os
import subprocess
import threading
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from urllib.parse import quote
from client import Client, Failure, arguments, check, run
ROOT = Path(__file__).resolve().parents[1]
def _password():
return "T3st-" + uuid.uuid4().hex
def test_invalid_json(c: Client):
resp = c.call(
"POST",
"/api/v1/users",
400,
raw=b"{not-json",
headers={"Content-Type": "application/json"},
schema="Error",
)
check(resp["json"]["error"]["code"] == "invalid_request", "expected invalid_request for bad JSON")
def test_wrong_password(c: Client):
alice = c.user("wp")
bad = base64.b64encode(
(alice["registration"]["username"] + ":wrong-password-xx").encode()
).decode()
resp = c.call(
"POST",
"/api/v1/auth/sessions",
401,
headers={"Authorization": "Basic " + bad},
schema="Error",
)
check(resp["json"]["error"]["code"] == "unauthorized", "wrong password must be 401")
check(
resp["headers"].get("WWW-Authenticate", "").lower().startswith("basic"),
"WWW-Authenticate Basic required",
)
def test_logout(c: Client):
alice = c.user("lo")
c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice)
c.call("GET", "/api/v1/users/me", 401, actor=alice, schema="Error")
def test_duplicate_username(c: Client):
name = "dup_" + uuid.uuid4().hex[:10]
password = _password()
body = {"username": name, "display_name": "Один", "password": password}
c.call("POST", "/api/v1/users", 201, body=body, schema="User")
resp = c.call("POST", "/api/v1/users", 409, body=body, schema="Error")
check(resp["json"]["error"]["code"] == "conflict", "expected conflict")
def test_username_race(c: Client):
"""Гонка регистрации одинакового username → ровно один 201, остальные 409."""
name = "race_" + uuid.uuid4().hex[:10]
password = _password()
body = {"username": name, "display_name": "Гонка", "password": password}
barrier = threading.Barrier(8)
results = []
def worker():
local = Client(c.base, timeout=20)
barrier.wait()
try:
resp = local.call("POST", "/api/v1/users", [201, 409], body=body)
results.append(resp["status"])
except Failure as exc:
results.append(str(exc))
with ThreadPoolExecutor(max_workers=8) as pool:
list(pool.map(lambda _: worker(), range(8)))
ok = [r for r in results if r == 201]
conflicted = [r for r in results if r == 409]
check(len(ok) == 1, "expected exactly one successful registration, got %r" % (results,))
check(len(conflicted) == 7, "expected seven conflicts, got %r" % (results,))
def test_foreign_chat(c: Client):
alice = c.user("own_a")
eve = c.user("own_e")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "Секрет", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
path = "/api/v1/chats/" + chat["id"]
c.call("GET", path, 404, actor=eve, schema="Error")
c.call("GET", path + "/messages", 404, actor=eve, schema="Error")
c.call("POST", path + "/messages", 404, actor=eve, body={"text": "взлом"}, schema="Error")
def test_empty_message(c: Client):
alice = c.user("own_empty")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "Тест", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
for text in ("", " ", "\n\t"):
resp = c.call(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
400,
actor=alice,
body={"text": text},
schema="Error",
)
check(resp["json"]["error"]["code"] == "invalid_request", "empty text must be 400")
def test_pagination_pages(c: Client):
alice = c.user("page_a")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "Страницы", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
created = []
for i in range(5):
created.append(c.message(alice, chat, "msg-%d" % i)["json"])
path = "/api/v1/chats/" + chat["id"] + "/messages"
collected = []
cursor = None
pages = 0
while True:
q = path + "?limit=2"
if cursor:
q += "&cursor=" + quote(cursor, safe="")
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
pages += 1
collected.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
check(pages >= 3, "expected several pages with limit=2 over 5 messages")
check(len(collected) == 5, "pagination must return all messages once")
from client import timestamp
expected = sorted(created, key=lambda m: (timestamp(m["created_at"]), uuid.UUID(m["id"]).int))
check(collected == expected, "pagination must return keyset order")
def test_session_expiry(c: Client):
"""Без schema-валидации клиента: иначе OpenAPI-parse съедает короткий TTL."""
import json
import urllib.error
import urllib.request
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if ttl > 5:
print("SKIP expiry: set SESSION_TTL_SECONDS<=5 on server and re-run")
return
username = "ttl_" + uuid.uuid4().hex[:10]
password = _password()
body = json.dumps(
{"username": username, "display_name": "TTL", "password": password}
).encode()
req = urllib.request.Request(
c.base + "/api/v1/users",
data=body,
headers={"Content-Type": "application/json", "Accept": "application/json"},
method="POST",
)
with urllib.request.urlopen(req, timeout=30) as resp:
check(resp.status == 201, "register for expiry")
cred = base64.b64encode((username + ":" + password).encode()).decode()
req = urllib.request.Request(
c.base + "/api/v1/auth/sessions",
data=b"",
headers={"Authorization": "Basic " + cred, "Accept": "application/json"},
method="POST",
)
with urllib.request.urlopen(req, timeout=30) as resp:
session = json.loads(resp.read())
token = session["token"]
req = urllib.request.Request(
c.base + "/api/v1/users/me",
headers={"Authorization": "Bearer " + token, "Accept": "application/json"},
)
with urllib.request.urlopen(req, timeout=10) as resp:
check(resp.status == 200, "session must work before expiry")
time.sleep(ttl + 1.5)
try:
urllib.request.urlopen(req, timeout=10)
raise Failure("session still valid after TTL")
except urllib.error.HTTPError as exc:
check(exc.code == 401, "expected 401 after TTL, got %s" % exc.code)
print("PASS: session expired after TTL=%d" % ttl)
def _compose(*args: str) -> None:
cmd = ["docker", "compose", "--env-file", str(ROOT / ".env"), "-f", str(ROOT / "compose.yaml"), *args]
subprocess.check_call(cmd, cwd=str(ROOT), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def test_redis_down_recovers(c: Client):
"""При недоступности Redis — 503, без «анонимного» доверия; после старта снова ready."""
try:
_compose("stop", "redis")
except (subprocess.CalledProcessError, FileNotFoundError) as exc:
print("SKIP redis-down: docker compose unavailable (%s)" % exc)
return
try:
deadline = time.monotonic() + 30
saw_503 = False
while time.monotonic() < deadline:
try:
c.call("GET", "/health/ready", 503, schema="Error")
saw_503 = True
break
except Failure:
time.sleep(0.5)
check(saw_503, "ready must become 503 when redis is down")
alice = None
# Protected path must not succeed as anonymous / must not 200.
try:
# Re-login impossible without redis; any bearer must fail closed.
c.call(
"GET",
"/api/v1/users/me",
[401, 503],
headers={"Authorization": "Bearer deadbeefdeadbeefdeadbeefdeadbeef"},
schema="Error",
)
except Failure as exc:
raise Failure("protected endpoint must fail closed when redis down: %s" % exc) from exc
finally:
_compose("start", "redis")
deadline = time.monotonic() + 60
while True:
try:
c.call("GET", "/health/ready", schema="Health")
break
except Failure:
check(time.monotonic() < deadline, "stack did not recover after redis start")
time.sleep(0.5)
print("PASS: redis down -> 503, then recovery")
def test_concurrency_100(c: Client):
alice = c.user("race_a")
bob = c.user("race_b")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "Гонка", "member_ids": [alice["id"], bob["id"]]},
schema="Chat",
)["json"]
barrier = threading.Barrier(10)
errors = []
def worker(worker_id: int):
local = Client(c.base, timeout=20)
actor = alice if worker_id % 2 == 0 else bob
barrier.wait()
for i in range(10):
try:
local.message(actor, chat, "race-%d-%d" % (worker_id, i))
except Failure as exc:
errors.append(str(exc))
with ThreadPoolExecutor(max_workers=10) as pool:
list(pool.map(worker, range(10)))
check(not errors, "concurrency errors: " + "; ".join(errors[:3]))
path = "/api/v1/chats/" + chat["id"] + "/messages"
collected = []
cursor = None
while True:
q = path + "?limit=100"
if cursor:
q += "&cursor=" + quote(cursor, safe="")
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
collected.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
check(len(collected) == 100, "expected 100 messages, got %d" % len(collected))
check(len(set(m["id"] for m in collected)) == 100, "expected 100 unique ids")
def main():
args = arguments("Own lab2 tests: auth, races, expiry, redis failure")
c = Client(args.base_url, args.ca_file, timeout=20)
c.call("GET", "/health/ready", schema="Health")
test_invalid_json(c)
print("PASS: invalid JSON")
test_wrong_password(c)
print("PASS: wrong password")
test_logout(c)
print("PASS: logout")
test_duplicate_username(c)
print("PASS: duplicate username")
test_username_race(c)
print("PASS: username registration race")
test_foreign_chat(c)
print("PASS: foreign chat -> 404")
test_empty_message(c)
print("PASS: empty message")
test_pagination_pages(c)
print("PASS: multi-page pagination")
test_concurrency_100(c)
print("PASS: concurrency 100")
test_session_expiry(c)
test_redis_down_recovers(c)
print("PASS: all own lab2 tests")
if __name__ == "__main__":
run(main)