forked from mtusi2026/mtusi2026lab4
339 lines
12 KiB
Python
339 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""Собственные тесты уровня 4: негативные сценарии и конкурентная запись.
|
|
|
|
Запуск: python3 tests/test_unit.py
|
|
Требует запущенный сервер (по умолчанию http://localhost:8080).
|
|
"""
|
|
import argparse
|
|
import base64
|
|
import json
|
|
import os
|
|
import sys
|
|
import threading
|
|
import unittest
|
|
import urllib.error
|
|
import urllib.request
|
|
import uuid
|
|
|
|
_parser = argparse.ArgumentParser(description="Собственные тесты уровня 4")
|
|
_parser.add_argument("--base-url", default=None)
|
|
_args, _unknown = _parser.parse_known_args()
|
|
# unittest.main() читает sys.argv сам и не знает про --base-url — убираем его.
|
|
sys.argv = [sys.argv[0]] + _unknown
|
|
|
|
BASE_URL = (
|
|
_args.base_url
|
|
or os.environ.get("BASE_URL")
|
|
or "http://localhost:8080"
|
|
).rstrip("/")
|
|
|
|
|
|
def request(method, path, body=None, token=None, raw=None, content_type="application/json",
|
|
basic=None, extra_headers=None):
|
|
headers = {"Accept": "application/json"}
|
|
if token:
|
|
headers["Authorization"] = "Bearer " + token
|
|
if basic:
|
|
headers["Authorization"] = "Basic " + basic
|
|
if extra_headers:
|
|
headers.update(extra_headers)
|
|
data = None
|
|
if raw is not None:
|
|
data = raw
|
|
headers["Content-Type"] = content_type
|
|
elif body is not None:
|
|
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
|
headers["Content-Type"] = "application/json"
|
|
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=10) as resp:
|
|
payload = resp.read()
|
|
return resp.status, json.loads(payload) if payload else None
|
|
except urllib.error.HTTPError as err:
|
|
payload = err.read()
|
|
return err.code, json.loads(payload) if payload else None
|
|
|
|
|
|
def make_user(label):
|
|
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
|
|
password = "T3st-" + uuid.uuid4().hex
|
|
status, user = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
{"username": username, "display_name": "Тест " + label, "password": password},
|
|
)
|
|
assert status == 201, (status, user)
|
|
basic = base64.b64encode((username + ":" + password).encode()).decode()
|
|
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
|
|
assert status == 201, (status, session)
|
|
return {"user": user, "token": session["token"], "basic": basic, "password": password}
|
|
|
|
|
|
class MessengerTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.alice = make_user("alice")
|
|
cls.bob = make_user("bob")
|
|
cls.eve = make_user("eve")
|
|
status, chat = request(
|
|
"POST",
|
|
"/api/v1/chats",
|
|
{"title": "Тестовый чат", "member_ids": [cls.alice["user"]["id"], cls.bob["user"]["id"]]},
|
|
token=cls.alice["token"],
|
|
)
|
|
assert status == 201, (status, chat)
|
|
cls.chat = chat
|
|
|
|
def test_invalid_json(self):
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/chats/" + self.chat["id"] + "/messages",
|
|
raw=b"{not json",
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_foreign_chat_returns_404(self):
|
|
status, body = request("GET", "/api/v1/chats/" + self.chat["id"], token=self.eve["token"])
|
|
self.assertEqual(status, 404)
|
|
self.assertEqual(body["error"]["code"], "not_found")
|
|
|
|
def test_empty_message_rejected(self):
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/chats/" + self.chat["id"] + "/messages",
|
|
{"text": " "},
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_duplicate_username(self):
|
|
username = "u_dup_" + uuid.uuid4().hex[:10]
|
|
password = "T3st-" + uuid.uuid4().hex
|
|
first = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
{"username": username, "display_name": "Первый", "password": password},
|
|
)
|
|
self.assertEqual(first[0], 201)
|
|
second = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
{"username": username, "display_name": "Второй", "password": password},
|
|
)
|
|
self.assertEqual(second[0], 409)
|
|
self.assertEqual(second[1]["error"]["code"], "conflict")
|
|
|
|
def test_short_password_rejected(self):
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
{"username": "u_short_" + uuid.uuid4().hex[:8], "display_name": "X", "password": "short"},
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_wrong_password_returns_401(self):
|
|
bad = base64.b64encode(
|
|
(self.alice["user"]["username"] + ":wrong-password-123").encode()
|
|
).decode()
|
|
status, body = request("POST", "/api/v1/auth/sessions", basic=bad)
|
|
self.assertEqual(status, 401)
|
|
self.assertEqual(body["error"]["code"], "unauthorized")
|
|
|
|
def test_basic_not_accepted_on_business_endpoint(self):
|
|
status, body = request("GET", "/api/v1/users/me", basic=self.alice["basic"])
|
|
self.assertEqual(status, 401)
|
|
self.assertEqual(body["error"]["code"], "unauthorized")
|
|
|
|
def test_x_user_id_ignored(self):
|
|
status, body = request(
|
|
"GET",
|
|
"/api/v1/users/me",
|
|
token=self.alice["token"],
|
|
extra_headers={"X-User-Id": self.eve["user"]["id"]},
|
|
)
|
|
self.assertEqual(status, 200)
|
|
self.assertEqual(body["id"], self.alice["user"]["id"])
|
|
|
|
def test_logout_revokes_session(self):
|
|
user = make_user("logout")
|
|
status, _ = request("DELETE", "/api/v1/auth/sessions/current", token=user["token"])
|
|
self.assertEqual(status, 204)
|
|
status, body = request("GET", "/api/v1/users/me", token=user["token"])
|
|
self.assertEqual(status, 401)
|
|
self.assertEqual(body["error"]["code"], "unauthorized")
|
|
|
|
def test_pagination_walks_all_pages(self):
|
|
chat = request(
|
|
"POST",
|
|
"/api/v1/chats",
|
|
{"title": "Пагинация", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
|
|
token=self.alice["token"],
|
|
)[1]
|
|
sent = []
|
|
for i in range(7):
|
|
status, msg = request(
|
|
"POST",
|
|
"/api/v1/chats/" + chat["id"] + "/messages",
|
|
{"text": "msg-%d" % i},
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 201)
|
|
sent.append(msg["id"])
|
|
collected = []
|
|
cursor = None
|
|
while True:
|
|
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=2"
|
|
if cursor:
|
|
path += "&cursor=" + cursor
|
|
status, page = request("GET", path, token=self.bob["token"])
|
|
self.assertEqual(status, 200)
|
|
collected.extend(m["id"] for m in page["items"])
|
|
cursor = page["next_cursor"]
|
|
if not cursor:
|
|
break
|
|
self.assertEqual(collected, sent)
|
|
|
|
def test_cursor_bound_to_resource(self):
|
|
chat_a = request(
|
|
"POST",
|
|
"/api/v1/chats",
|
|
{"title": "Cursor A", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
|
|
token=self.alice["token"],
|
|
)[1]
|
|
chat_b = request(
|
|
"POST",
|
|
"/api/v1/chats",
|
|
{"title": "Cursor B", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
|
|
token=self.alice["token"],
|
|
)[1]
|
|
for i in range(3):
|
|
request(
|
|
"POST",
|
|
"/api/v1/chats/" + chat_a["id"] + "/messages",
|
|
{"text": "a-%d" % i},
|
|
token=self.alice["token"],
|
|
)
|
|
status, page = request(
|
|
"GET",
|
|
"/api/v1/chats/" + chat_a["id"] + "/messages?limit=1",
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 200)
|
|
cursor = page["next_cursor"]
|
|
self.assertIsNotNone(cursor)
|
|
status, body = request(
|
|
"GET",
|
|
"/api/v1/chats/" + chat_b["id"] + "/messages?limit=1&cursor=" + cursor,
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_cursor_bound_to_endpoint(self):
|
|
status, page = request(
|
|
"GET", "/api/v1/chats?limit=1", token=self.alice["token"]
|
|
)
|
|
self.assertEqual(status, 200)
|
|
cursor = page["next_cursor"]
|
|
self.assertIsNotNone(cursor)
|
|
status, body = request(
|
|
"GET",
|
|
"/api/v1/chats/" + self.chat["id"] + "/messages?limit=1&cursor=" + cursor,
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_cursor_garbage_rejected(self):
|
|
garbage = base64.urlsafe_b64encode(b"x|y").decode("ascii")
|
|
status, body = request(
|
|
"GET",
|
|
"/api/v1/chats/" + self.chat["id"] + "/messages?cursor=" + garbage,
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_invalid_chat_id_returns_400(self):
|
|
status, body = request("GET", "/api/v1/chats/not-a-uuid", token=self.alice["token"])
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/chats/not-a-uuid/messages",
|
|
{"text": "hi"},
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
status, body = request(
|
|
"GET", "/api/v1/chats/not-a-uuid/messages", token=self.alice["token"]
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_username_with_trailing_newline_rejected(self):
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
{"username": "abc\n", "display_name": "Имя", "password": "T3st-" + uuid.uuid4().hex},
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
|
|
def test_invalid_body_bytes_contract_error(self):
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
raw=b"\xff",
|
|
token=self.alice["token"],
|
|
)
|
|
self.assertEqual(status, 400)
|
|
self.assertEqual(body["error"]["code"], "invalid_request")
|
|
self.assertIn("message", body["error"])
|
|
self.assertIn("request_id", body["error"])
|
|
|
|
def test_concurrent_writes_are_unique(self):
|
|
chat = request(
|
|
"POST",
|
|
"/api/v1/chats",
|
|
{"title": "Конкурентность", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
|
|
token=self.alice["token"],
|
|
)[1]
|
|
errors = []
|
|
lock = threading.Lock()
|
|
|
|
def worker(worker_id):
|
|
for i in range(10):
|
|
status, body = request(
|
|
"POST",
|
|
"/api/v1/chats/" + chat["id"] + "/messages",
|
|
{"text": "w%d-%d" % (worker_id, i)},
|
|
token=self.alice["token"],
|
|
)
|
|
if status != 201:
|
|
with lock:
|
|
errors.append((status, body))
|
|
|
|
threads = [threading.Thread(target=worker, args=(w,)) for w in range(10)]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
self.assertEqual(errors, [])
|
|
status, page = request(
|
|
"GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", token=self.alice["token"]
|
|
)
|
|
self.assertEqual(status, 200)
|
|
ids = [m["id"] for m in page["items"]]
|
|
self.assertEqual(len(ids), 100)
|
|
self.assertEqual(len(set(ids)), 100)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|