207 lines
11 KiB
Python
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()
|