Files
mtusi2026lab2/student-tests/test_api.py
T

207 lines
11 KiB
Python

"""Собственные тесты lab2 против запущенного стенда (docker compose up -d).
python -m unittest discover -s student-tests -v # BASE_URL по умолчанию http://127.0.0.1:8080
Тесты используют только синтетические данные и ничего не удаляют. Проверки expiry и недоступности
зависимостей лежат отдельно (test_expiry.py, test_dependencies.py): они управляют контейнерами.
"""
import base64
import json
import os
import subprocess
import unittest
import urllib.error
import urllib.request
import uuid
from concurrent.futures import ThreadPoolExecutor
from urllib.parse import quote
BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
ROOT = os.path.join(os.path.dirname(__file__), "..")
def call(method, path, body=None, token=None, headers=None, raw=None):
h = dict(headers or {})
data = raw
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
h.setdefault("Content-Type", "application/json")
if token:
h["Authorization"] = "Bearer " + token
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
status, hdrs, payload = resp.status, resp.headers, resp.read()
except urllib.error.HTTPError as err:
status, hdrs, payload = err.code, err.headers, err.read()
return status, hdrs, (json.loads(payload) if payload else None)
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
def register(prefix="u"):
name = "%s_%s" % (prefix, uuid.uuid4().hex[:12])
password = "Pa55:word-" + uuid.uuid4().hex # двоеточие в пароле допустимо
status, _, user = call("POST", "/api/v1/users", {"username": name, "display_name": "Имя " + name, "password": password})
assert status == 201, user
status, _, session = call("POST", "/api/v1/auth/sessions", headers=basic(name, password))
assert status == 201, session
return {"user": user, "password": password, "token": session["token"], "session": session}
def psql(sql):
out = subprocess.run(["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", "psql", "-U", "messenger",
"-d", "messenger", "-Atc", sql], cwd=ROOT, capture_output=True, text=True, check=True)
return out.stdout.strip()
class AuthTest(unittest.TestCase):
def assertError(self, result, status, code):
self.assertEqual(result[0], status, result[2])
self.assertEqual(result[2]["error"]["code"], code)
self.assertEqual(result[2]["error"]["request_id"], result[1]["X-Request-Id"])
def test_register_validation(self):
base = {"username": "val_" + uuid.uuid4().hex[:8], "display_name": "x", "password": "p" * 12}
for patch in ({"password": "short"}, {"password": "p" * 129}, {"password": 12345678901234}, {"extra": 1},
{"username": "BAD"}, {"display_name": " "}):
body = dict(base, **patch)
self.assertError(call("POST", "/api/v1/users", body), 400, "invalid_request")
missing = {k: v for k, v in base.items() if k != "password"}
self.assertError(call("POST", "/api/v1/users", missing), 400, "invalid_request")
self.assertEqual(call("POST", "/api/v1/users", dict(base, password="я" * 12))[0], 201) # 12 code points
def test_password_is_not_exposed_or_stored_plain(self):
actor = register()
self.assertEqual(set(actor["user"]), {"id", "username", "display_name", "created_at"})
stored = psql("SELECT password_hash FROM users WHERE username = '%s'" % actor["user"]["username"])
self.assertTrue(stored.startswith("$argon2id$"), stored[:12])
self.assertNotIn(actor["password"], stored)
def test_wrong_password_and_unknown_user_are_indistinguishable(self):
actor = register()
wrong = call("POST", "/api/v1/auth/sessions", headers=basic(actor["user"]["username"], "wrong-password-123"))
unknown = call("POST", "/api/v1/auth/sessions", headers=basic("nobody_" + uuid.uuid4().hex[:8], "wrong-password-123"))
for r in (wrong, unknown):
self.assertError(r, 401, "unauthorized")
self.assertEqual(r[1]["WWW-Authenticate"], 'Basic realm="messenger", charset="UTF-8"')
self.assertEqual(wrong[2]["error"]["message"], unknown[2]["error"]["message"])
for bad in ({}, {"Authorization": "Basic !!!"}, {"Authorization": "Basic " + base64.b64encode(b"nocolon").decode()},
{"Authorization": "Bearer abc"}):
self.assertEqual(call("POST", "/api/v1/auth/sessions", headers=bad)[0], 401)
def test_bearer_rules(self):
actor = register()
self.assertEqual(call("GET", "/api/v1/users/me", token=actor["token"])[2], actor["user"])
for headers in ({}, basic(actor["user"]["username"], actor["password"]), {"X-User-Id": actor["user"]["id"]},
{"Authorization": "Bearer " + "A" * 43}, {"Authorization": "Bearer short"}):
r = call("GET", "/api/v1/users/me", headers=headers)
self.assertError(r, 401, "unauthorized")
self.assertEqual(r[1]["WWW-Authenticate"], 'Bearer realm="messenger"')
other = register()
me = call("GET", "/api/v1/users/me", token=actor["token"], headers={"X-User-Id": other["user"]["id"]})[2]
self.assertEqual(me["id"], actor["user"]["id"]) # X-User-Id игнорируется
def test_session_shape_entropy_and_logout(self):
actor = register()
s = actor["session"]
self.assertEqual(s["token_type"], "Bearer")
self.assertGreaterEqual(len(s["token"]), 43) # 32 байта в base64url = 256 бит
self.assertNotIn(actor["user"]["id"], s["token"])
self.assertNotEqual(register()["token"], s["token"])
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", token=s["token"])[0], 204)
self.assertError(call("GET", "/api/v1/users/me", token=s["token"]), 401, "unauthorized")
self.assertError(call("DELETE", "/api/v1/auth/sessions/current", token=s["token"]), 401, "unauthorized")
def test_logout_revokes_in_database_and_cache(self):
actor = register()
call("GET", "/api/v1/users/me", token=actor["token"]) # прогреваем кэш
call("DELETE", "/api/v1/auth/sessions/current", token=actor["token"])
revoked = psql("SELECT count(*) FROM sessions s JOIN users u ON u.id = s.user_id "
"WHERE u.username = '%s' AND s.revoked_at IS NOT NULL" % actor["user"]["username"])
self.assertEqual(revoked, "1")
def test_token_only_stored_as_hash(self):
actor = register()
count = psql("SELECT count(*) FROM sessions WHERE token_hash = '\\x00'::bytea OR encode(token_hash,'escape') = '%s'" % actor["token"])
self.assertEqual(count, "0")
def test_concurrent_registration_of_same_username(self):
name = "race_" + uuid.uuid4().hex[:10]
body = {"username": name, "display_name": "x", "password": "racing-password-1"}
with ThreadPoolExecutor(12) as pool:
codes = sorted(pool.map(lambda _: call("POST", "/api/v1/users", body)[0], range(12)))
self.assertEqual(codes, [201] + [409] * 11)
self.assertEqual(psql("SELECT count(*) FROM users WHERE username = '%s'" % name), "1")
class DataTest(unittest.TestCase):
def test_chat_creation_is_atomic(self):
a = register()
before = psql("SELECT (SELECT count(*) FROM chats) || '/' || (SELECT count(*) FROM chat_members)")
ghost = str(uuid.uuid4())
r = call("POST", "/api/v1/chats", {"title": "откат", "member_ids": [a["user"]["id"], ghost]}, token=a["token"])
self.assertEqual(r[0], 400)
after = psql("SELECT (SELECT count(*) FROM chats) || '/' || (SELECT count(*) FROM chat_members)")
self.assertEqual(before, after, "после неудачного создания не должно остаться чата или участников")
ok = call("POST", "/api/v1/chats", {"title": "ок", "member_ids": [a["user"]["id"]]}, token=a["token"])
self.assertEqual(ok[0], 201)
def test_foreign_chat_empty_message_bad_json(self):
a, b, eve = register(), register(), register()
chat = call("POST", "/api/v1/chats", {"title": "ЛС", "member_ids": [a["user"]["id"], b["user"]["id"]]}, a["token"])[2]
path = "/api/v1/chats/%s/messages" % chat["id"]
self.assertEqual(call("POST", path, {"text": "чужое"}, eve["token"])[0], 404)
self.assertEqual(call("GET", path, token=eve["token"])[0], 404)
self.assertEqual(call("POST", path, {"text": " "}, a["token"])[0], 400)
self.assertEqual(call("POST", path, raw=b"{oops", token=a["token"], headers={"Content-Type": "application/json"})[0], 400)
self.assertEqual(call("POST", path, {"text": "x", "sender_id": b["user"]["id"]}, a["token"])[0], 400)
sent = call("POST", path, {"text": "Привет 👋"}, a["token"])[2]
self.assertEqual(sent["sender_id"], a["user"]["id"])
def test_multi_page_history_and_cursor_binding(self):
a, b = register(), register()
chat = call("POST", "/api/v1/chats", {"title": "стр", "member_ids": [a["user"]["id"], b["user"]["id"]]}, a["token"])[2]
other = call("POST", "/api/v1/chats", {"title": "др", "member_ids": [a["user"]["id"]]}, a["token"])[2]
path = "/api/v1/chats/%s/messages" % chat["id"]
sent = [call("POST", path, {"text": "m%d" % i}, (a if i % 2 else b)["token"])[2] for i in range(23)]
walked, cursor, pages = [], None, 0
while True:
q = "?limit=%d" % (5 if pages % 2 == 0 else 8) + ("&cursor=" + quote(cursor, safe="") if cursor else "")
page = call("GET", path + q, token=b["token"])[2]
walked += page["items"]
pages += 1
cursor = page["next_cursor"]
if not cursor:
break
self.assertEqual(walked, sent)
self.assertGreaterEqual(pages, 3)
first = call("GET", path + "?limit=1", token=a["token"])[2]["next_cursor"]
r = call("GET", "/api/v1/chats/%s/messages?cursor=%s" % (other["id"], quote(first, safe="")), token=a["token"])
self.assertEqual(r[0], 400)
def test_parallel_writes_from_many_clients(self):
users = [register() for _ in range(5)]
chat = call("POST", "/api/v1/chats", {"title": "гонки", "member_ids": [u["user"]["id"] for u in users]}, users[0]["token"])[2]
path = "/api/v1/chats/%s/messages" % chat["id"]
def client(u):
return [call("POST", path, {"text": "%s-%d" % (u["user"]["username"], i)}, u["token"])[0] for i in range(20)]
with ThreadPoolExecutor(5) as pool:
codes = [c for part in pool.map(client, users) for c in part]
self.assertEqual(codes, [201] * 100)
total, cursor = [], None
while True:
page = call("GET", path + "?limit=100" + ("&cursor=" + quote(cursor, safe="") if cursor else ""), token=users[0]["token"])[2]
total += page["items"]
cursor = page["next_cursor"]
if not cursor:
break
self.assertEqual(len({m["id"] for m in total}), 100)
if __name__ == "__main__":
unittest.main()