"""Собственные тесты 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 {}) if method == "POST" and path.endswith("/messages") and headers is None: h["Idempotency-Key"] = uuid.uuid4().hex # lab3: ключ обязателен; тесты без ключа — в test_idempotency.py 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()