forked from mtusi2026/mtusi2026lab2
Перенести тесты API из lab1 и добавить тесты аутентификации
This commit is contained in:
@@ -0,0 +1,82 @@
|
||||
"""Маленький HTTP-клиент для собственных тестов. Только стандартная библиотека."""
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
|
||||
|
||||
|
||||
def call(method, path, body=None, user=None, raw=None, headers=None, base_url=None):
|
||||
"""Возвращает (код ответа, разобранный JSON или None, заголовки)."""
|
||||
request_headers = {"Accept": "application/json"}
|
||||
if body is not None:
|
||||
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
||||
if raw is not None:
|
||||
request_headers["Content-Type"] = "application/json"
|
||||
if user is not None:
|
||||
request_headers["Authorization"] = "Bearer " + user["token"]
|
||||
request_headers.update(headers or {})
|
||||
request = urllib.request.Request((base_url or BASE_URL) + path, data=raw, headers=request_headers, method=method)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=15)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
with response:
|
||||
data = response.read()
|
||||
return response.status, json.loads(data) if data else None, response.headers
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
|
||||
|
||||
|
||||
def login(username, password, base_url=None):
|
||||
return call("POST", "/api/v1/auth/sessions", headers=basic(username, password), base_url=base_url)
|
||||
|
||||
|
||||
def user_body(**fields):
|
||||
"""Корректное тело регистрации со случайным username; поля можно переопределить."""
|
||||
body = {"username": "u_" + uuid.uuid4().hex[:12], "display_name": "Тест", "password": "Pw-" + uuid.uuid4().hex}
|
||||
body.update(fields)
|
||||
return body
|
||||
|
||||
|
||||
def new_user(prefix="t", base_url=None):
|
||||
"""Регистрирует синтетического пользователя и сразу входит. В словаре id, username, password и token."""
|
||||
body = user_body(username=prefix + "_" + uuid.uuid4().hex[:12], display_name="Тест " + prefix)
|
||||
status, user, _ = call("POST", "/api/v1/users", body, base_url=base_url)
|
||||
assert status == 201, status
|
||||
status, session, _ = login(body["username"], body["password"], base_url=base_url)
|
||||
assert status == 201, status
|
||||
return {**user, "password": body["password"], "token": session["token"], "user": user}
|
||||
|
||||
|
||||
def new_chat(owner, *others, title="Тестовый чат"):
|
||||
member_ids = [owner["id"]] + [other["id"] for other in others]
|
||||
status, chat, _ = call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=owner)
|
||||
assert status == 201, status
|
||||
return chat
|
||||
|
||||
|
||||
def send(user, chat, text):
|
||||
return call("POST", "/api/v1/chats/" + chat["id"] + "/messages", {"text": text}, user=user)
|
||||
|
||||
|
||||
def history(user, chat, limit):
|
||||
"""Обходит всю историю чата страницами по limit, возвращает сообщения и размеры страниц."""
|
||||
items, sizes, cursor = [], [], None
|
||||
while True:
|
||||
path = "/api/v1/chats/%s/messages?limit=%d" % (chat["id"], limit)
|
||||
if cursor:
|
||||
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
|
||||
status, page, _ = call("GET", path, user=user)
|
||||
assert status == 200, status
|
||||
items += page["items"]
|
||||
sizes.append(len(page["items"]))
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
return items, sizes
|
||||
@@ -0,0 +1,77 @@
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from api import call, new_chat, new_user, send
|
||||
|
||||
|
||||
class ForeignChatTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
|
||||
cls.chat = new_chat(cls.alice, cls.bob)
|
||||
cls.path = "/api/v1/chats/" + cls.chat["id"]
|
||||
send(cls.alice, cls.chat, "секрет")
|
||||
|
||||
def test_outsider_gets_404_everywhere(self):
|
||||
self.assertEqual(call("GET", self.path, user=self.eve)[0], 404)
|
||||
self.assertEqual(call("GET", self.path + "/messages", user=self.eve)[0], 404)
|
||||
status, body, _ = send(self.eve, self.chat, "я тут")
|
||||
self.assertEqual(status, 404)
|
||||
self.assertEqual(body["error"]["code"], "not_found")
|
||||
|
||||
def test_foreign_chat_looks_like_missing_chat(self):
|
||||
_, foreign, _ = call("GET", self.path, user=self.eve)
|
||||
_, missing, _ = call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=self.eve)
|
||||
self.assertEqual(foreign["error"]["message"], missing["error"]["message"])
|
||||
|
||||
def test_outsider_message_is_not_saved(self):
|
||||
send(self.eve, self.chat, "не должно появиться")
|
||||
_, page, _ = call("GET", self.path + "/messages", user=self.alice)
|
||||
self.assertNotIn("не должно появиться", [item["text"] for item in page["items"]])
|
||||
|
||||
def test_chat_is_not_listed_for_outsider(self):
|
||||
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.eve)
|
||||
self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]])
|
||||
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
|
||||
self.assertIn(self.chat["id"], [item["id"] for item in page["items"]])
|
||||
|
||||
def test_members_can_read_and_write(self):
|
||||
self.assertEqual(send(self.bob, self.chat, "ответ")[0], 201)
|
||||
self.assertEqual(call("GET", self.path, user=self.bob)[0], 200)
|
||||
|
||||
def test_bad_chat_id(self):
|
||||
self.assertEqual(call("GET", "/api/v1/chats/123", user=self.alice)[0], 400)
|
||||
|
||||
|
||||
class CreateChatTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.bob = new_user("alice"), new_user("bob")
|
||||
|
||||
def create(self, member_ids, title="Чат"):
|
||||
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)[0]
|
||||
|
||||
def test_creator_must_be_member(self):
|
||||
self.assertEqual(self.create([self.bob["id"]]), 400)
|
||||
|
||||
def test_duplicate_members(self):
|
||||
self.assertEqual(self.create([self.alice["id"], self.bob["id"], self.bob["id"]]), 400)
|
||||
|
||||
def test_unknown_member(self):
|
||||
self.assertEqual(self.create([self.alice["id"], str(uuid.uuid4())]), 400)
|
||||
|
||||
def test_empty_members(self):
|
||||
self.assertEqual(self.create([]), 400)
|
||||
|
||||
def test_blank_title(self):
|
||||
self.assertEqual(self.create([self.alice["id"]], title=" "), 400)
|
||||
|
||||
def test_failed_create_leaves_no_chat(self):
|
||||
_, before, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
|
||||
self.create([self.alice["id"], self.bob["id"], str(uuid.uuid4())])
|
||||
_, after, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
|
||||
self.assertEqual(before, after)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,130 @@
|
||||
import datetime
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from api import basic, call, login, new_user, user_body
|
||||
|
||||
|
||||
class LoginTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.body = user_body()
|
||||
_, cls.user, _ = call("POST", "/api/v1/users", cls.body)
|
||||
|
||||
def assert_basic_challenge(self, result):
|
||||
status, body, headers = result
|
||||
self.assertEqual(status, 401)
|
||||
self.assertEqual(body["error"]["code"], "unauthorized")
|
||||
self.assertTrue(headers["WWW-Authenticate"].startswith("Basic "))
|
||||
return body
|
||||
|
||||
def test_login(self):
|
||||
status, session, _ = login(self.body["username"], self.body["password"])
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(set(session), {"token", "token_type", "expires_at", "user"})
|
||||
self.assertEqual(session["token_type"], "Bearer")
|
||||
self.assertEqual(session["user"], self.user)
|
||||
self.assertGreaterEqual(len(session["token"]), 32)
|
||||
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
|
||||
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
|
||||
self.assertTrue(300 <= left <= 3600 + 5, left)
|
||||
|
||||
def test_token_is_opaque_and_unique(self):
|
||||
first = login(self.body["username"], self.body["password"])[1]["token"]
|
||||
second = login(self.body["username"], self.body["password"])[1]["token"]
|
||||
self.assertNotEqual(first, second)
|
||||
for token in (first, second):
|
||||
self.assertNotIn(self.user["id"], token)
|
||||
self.assertNotIn(self.body["username"], token)
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": token})[0], 200)
|
||||
|
||||
def test_wrong_password_and_unknown_user_look_the_same(self):
|
||||
wrong = self.assert_basic_challenge(login(self.body["username"], "wrong-password-123"))
|
||||
unknown = self.assert_basic_challenge(login("nobody_" + uuid.uuid4().hex[:8], self.body["password"]))
|
||||
self.assertEqual(wrong["error"]["message"], unknown["error"]["message"])
|
||||
|
||||
def test_malformed_credentials(self):
|
||||
token = login(self.body["username"], self.body["password"])[1]["token"]
|
||||
for header in (None, "Basic", "Basic !!!not-base64!!!", "Basic bm8tY29sb24=", "Bearer " + token, "Basic 0KU6"):
|
||||
with self.subTest(header=header):
|
||||
headers = {"Authorization": header} if header else {}
|
||||
self.assert_basic_challenge(call("POST", "/api/v1/auth/sessions", headers=headers))
|
||||
|
||||
def test_username_that_cannot_exist(self):
|
||||
for username in ("", "Has Space", "ab\u0000cd", "имя_кириллицей"):
|
||||
with self.subTest(username=username):
|
||||
self.assert_basic_challenge(login(username, self.body["password"]))
|
||||
|
||||
def test_colon_and_unicode_in_password(self):
|
||||
body = user_body(password="пароль:с:двоеточиями")
|
||||
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
|
||||
self.assertEqual(login(body["username"], body["password"])[0], 201)
|
||||
self.assert_basic_challenge(login(body["username"], "пароль"))
|
||||
|
||||
|
||||
class BearerTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.eve = new_user("alice"), new_user("eve")
|
||||
|
||||
def assert_bearer_challenge(self, result):
|
||||
status, body, headers = result
|
||||
self.assertEqual(status, 401)
|
||||
self.assertEqual(body["error"]["code"], "unauthorized")
|
||||
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
|
||||
|
||||
def test_no_token(self):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me"))
|
||||
|
||||
def test_unknown_tokens(self):
|
||||
for token in ("x" * 43, self.alice["id"], self.alice["username"], self.alice["token"][:-1]):
|
||||
with self.subTest(token=token[:8]):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
|
||||
|
||||
def test_basic_is_not_accepted_on_business_endpoints(self):
|
||||
headers = basic(self.alice["username"], self.alice["password"])
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers=headers))
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/chats", headers=headers))
|
||||
|
||||
def test_x_user_id_gives_no_access(self):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers={"X-User-Id": self.alice["id"]}))
|
||||
|
||||
def test_x_user_id_does_not_change_identity(self):
|
||||
status, me, _ = call("GET", "/api/v1/users/me", user=self.alice, headers={"X-User-Id": self.eve["id"]})
|
||||
self.assertEqual(status, 200)
|
||||
self.assertEqual(me, self.alice["user"])
|
||||
|
||||
def test_token_is_checked_before_anything_else(self):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/chats/not-a-uuid"))
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/chats?limit=0"))
|
||||
self.assert_bearer_challenge(call("POST", "/api/v1/chats", {"title": 5}))
|
||||
|
||||
|
||||
class LogoutTest(unittest.TestCase):
|
||||
def test_logout_revokes_only_current_session(self):
|
||||
user = new_user()
|
||||
other_token = login(user["username"], user["password"])[1]["token"]
|
||||
|
||||
status, body, _ = call("DELETE", "/api/v1/auth/sessions/current", user=user)
|
||||
self.assertEqual(status, 204)
|
||||
self.assertIsNone(body)
|
||||
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401)
|
||||
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user)[0], 401)
|
||||
# вторая сессия того же пользователя продолжает работать
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": other_token})[0], 200)
|
||||
|
||||
def test_login_again_after_logout(self):
|
||||
user = new_user()
|
||||
call("DELETE", "/api/v1/auth/sessions/current", user=user)
|
||||
status, session, _ = login(user["username"], user["password"])
|
||||
self.assertEqual(status, 201)
|
||||
self.assertNotEqual(session["token"], user["token"])
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=session)[0], 200)
|
||||
|
||||
def test_logout_requires_token(self):
|
||||
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current")[0], 401)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,63 @@
|
||||
"""Проверка гонок: 10 клиентов параллельно отправляют 100 сообщений в один чат."""
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from api import call, history, new_chat, new_user, send, user_body
|
||||
|
||||
CLIENTS = 10
|
||||
MESSAGES_PER_CLIENT = 10
|
||||
|
||||
|
||||
class ConcurrencyTest(unittest.TestCase):
|
||||
def test_100_messages_from_10_clients(self):
|
||||
users = [new_user("c%d" % number) for number in range(CLIENTS)]
|
||||
chat = new_chat(users[0], *users[1:])
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def client(number):
|
||||
barrier.wait() # все потоки стартуют одновременно
|
||||
results = []
|
||||
for index in range(MESSAGES_PER_CLIENT):
|
||||
results.append(send(users[number], chat, "клиент %d сообщение %d" % (number, index)))
|
||||
return results
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
results = [result for chunk in pool.map(client, range(CLIENTS)) for result in chunk]
|
||||
|
||||
total = CLIENTS * MESSAGES_PER_CLIENT
|
||||
self.assertEqual([status for status, _, _ in results], [201] * total)
|
||||
confirmed = {message["id"]: message for _, message, _ in results}
|
||||
self.assertEqual(len(confirmed), total)
|
||||
|
||||
items, _ = history(users[0], chat, limit=7)
|
||||
self.assertEqual(len(items), total)
|
||||
self.assertEqual(len({item["id"] for item in items}), total)
|
||||
self.assertEqual(len({item["text"] for item in items}), total)
|
||||
# каждое подтверждённое сообщение есть в истории без изменений
|
||||
self.assertEqual({item["id"]: item for item in items}, confirmed)
|
||||
keys = [(item["created_at"], item["id"]) for item in items]
|
||||
self.assertEqual(keys, sorted(keys))
|
||||
# сообщения одного клиента идут в том порядке, в котором он их отправлял
|
||||
for number in range(CLIENTS):
|
||||
own = [item["text"] for item in items if item["sender_id"] == users[number]["id"]]
|
||||
self.assertEqual(own, ["клиент %d сообщение %d" % (number, index) for index in range(MESSAGES_PER_CLIENT)])
|
||||
print("\nотправлено %d, подтверждено %d, в истории %d, уникальных id %d"
|
||||
% (total, len(confirmed), len(items), len({item["id"] for item in items})))
|
||||
|
||||
def test_same_username_registered_once(self):
|
||||
body = user_body(username="race_" + uuid.uuid4().hex[:8])
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def register(_):
|
||||
barrier.wait()
|
||||
return call("POST", "/api/v1/users", body)[0]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
statuses = sorted(pool.map(register, range(CLIENTS)))
|
||||
self.assertEqual(statuses, [201] + [409] * (CLIENTS - 1))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,102 @@
|
||||
import unittest
|
||||
import urllib.parse
|
||||
|
||||
from api import call, history, new_chat, new_user, send
|
||||
|
||||
|
||||
class MessagePaginationTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.user = new_user()
|
||||
cls.chat = new_chat(cls.user)
|
||||
cls.sent = [send(cls.user, cls.chat, "сообщение %d" % number)[1] for number in range(25)]
|
||||
cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages"
|
||||
|
||||
def test_walk_several_pages(self):
|
||||
items, sizes = history(self.user, self.chat, limit=10)
|
||||
self.assertEqual(sizes, [10, 10, 5])
|
||||
self.assertEqual(items, self.sent)
|
||||
|
||||
def test_no_duplicates_and_order(self):
|
||||
items, _ = history(self.user, self.chat, limit=7)
|
||||
ids = [item["id"] for item in items]
|
||||
self.assertEqual(len(ids), len(set(ids)))
|
||||
keys = [(item["created_at"], item["id"]) for item in items]
|
||||
self.assertEqual(keys, sorted(keys))
|
||||
|
||||
def test_exact_page_has_no_cursor(self):
|
||||
_, page, _ = call("GET", self.path + "?limit=25", user=self.user)
|
||||
self.assertEqual(len(page["items"]), 25)
|
||||
self.assertIsNone(page["next_cursor"])
|
||||
|
||||
def test_default_limit(self):
|
||||
_, page, _ = call("GET", self.path, user=self.user)
|
||||
self.assertEqual(len(page["items"]), 25)
|
||||
|
||||
def test_limit_can_change_between_pages(self):
|
||||
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
|
||||
cursor = urllib.parse.quote(first["next_cursor"], safe="")
|
||||
_, second, _ = call("GET", self.path + "?limit=100&cursor=" + cursor, user=self.user)
|
||||
self.assertEqual(first["items"] + second["items"], self.sent)
|
||||
|
||||
def test_bad_limit(self):
|
||||
for limit in ("0", "101", "-1", "abc", "1.5", ""):
|
||||
with self.subTest(limit=limit):
|
||||
self.assertEqual(call("GET", self.path + "?limit=" + limit, user=self.user)[0], 400)
|
||||
|
||||
def test_bad_cursor(self):
|
||||
for cursor in ("garbage", "", "e30=", "%D0%B9"):
|
||||
with self.subTest(cursor=cursor):
|
||||
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
|
||||
|
||||
def test_cursor_from_another_chat(self):
|
||||
other = new_chat(self.user, title="Другой чат")
|
||||
send(self.user, other, "раз")
|
||||
send(self.user, other, "два")
|
||||
_, page, _ = call("GET", "/api/v1/chats/" + other["id"] + "/messages?limit=1", user=self.user)
|
||||
cursor = urllib.parse.quote(page["next_cursor"], safe="")
|
||||
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
|
||||
|
||||
def test_new_message_appears_after_last_page(self):
|
||||
user = new_user()
|
||||
chat = new_chat(user)
|
||||
send(user, chat, "раз")
|
||||
send(user, chat, "два")
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
_, first, _ = call("GET", path + "?limit=1", user=user)
|
||||
_, created, _ = send(user, chat, "три")
|
||||
cursor = urllib.parse.quote(first["next_cursor"], safe="")
|
||||
_, rest, _ = call("GET", path + "?limit=100&cursor=" + cursor, user=user)
|
||||
self.assertEqual([item["text"] for item in rest["items"]], ["два", "три"])
|
||||
self.assertEqual(rest["items"][-1], created)
|
||||
|
||||
|
||||
class ChatPaginationTest(unittest.TestCase):
|
||||
def test_walk_chat_list(self):
|
||||
user = new_user()
|
||||
created = [new_chat(user, title="Чат %d" % number) for number in range(5)]
|
||||
items, cursor = [], None
|
||||
while True:
|
||||
path = "/api/v1/chats?limit=2"
|
||||
if cursor:
|
||||
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
|
||||
status, page, _ = call("GET", path, user=user)
|
||||
self.assertEqual(status, 200)
|
||||
self.assertLessEqual(len(page["items"]), 2)
|
||||
items += page["items"]
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
self.assertEqual(items, created)
|
||||
|
||||
def test_chat_cursor_belongs_to_user(self):
|
||||
alice, bob = new_user("alice"), new_user("bob")
|
||||
for number in range(2):
|
||||
new_chat(alice, bob, title="Общий %d" % number)
|
||||
_, page, _ = call("GET", "/api/v1/chats?limit=1", user=alice)
|
||||
cursor = urllib.parse.quote(page["next_cursor"], safe="")
|
||||
self.assertEqual(call("GET", "/api/v1/chats?cursor=" + cursor, user=bob)[0], 400)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,122 @@
|
||||
import unittest
|
||||
|
||||
from api import call, login, new_chat, new_user, send, user_body
|
||||
|
||||
|
||||
class ErrorFormatTest(unittest.TestCase):
|
||||
def assert_error(self, result, status, code):
|
||||
got_status, body, headers = result
|
||||
self.assertEqual(got_status, status)
|
||||
self.assertEqual(set(body), {"error"})
|
||||
self.assertEqual(set(body["error"]), {"code", "message", "request_id"})
|
||||
self.assertEqual(body["error"]["code"], code)
|
||||
self.assertTrue(body["error"]["message"])
|
||||
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
|
||||
|
||||
|
||||
class InvalidJsonTest(ErrorFormatTest):
|
||||
def test_malformed_json(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=b'{"username": "abc", '), 400, "invalid_request")
|
||||
|
||||
def test_not_an_object(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=b'["abc"]'), 400, "invalid_request")
|
||||
|
||||
def test_extra_field(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(is_admin=True)), 400, "invalid_request")
|
||||
|
||||
def test_wrong_type(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(username=12345)), 400, "invalid_request")
|
||||
|
||||
def test_missing_field(self):
|
||||
body = user_body()
|
||||
del body["password"]
|
||||
self.assert_error(call("POST", "/api/v1/users", body), 400, "invalid_request")
|
||||
|
||||
def test_malformed_json_in_message(self):
|
||||
user = new_user()
|
||||
chat = new_chat(user)
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
self.assert_error(call("POST", path, raw=b"{text: no quotes}", user=user), 400, "invalid_request")
|
||||
|
||||
|
||||
class UserValidationTest(ErrorFormatTest):
|
||||
def test_bad_usernames(self):
|
||||
for username in ("ab", "a" * 33, "Alice", "with space", "имя", "abc\n", ""):
|
||||
with self.subTest(username=username):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(username=username)), 400, "invalid_request")
|
||||
|
||||
def test_bad_display_names(self):
|
||||
for display_name in ("", " ", "\t\n", "я" * 101, "имя\u0000"):
|
||||
with self.subTest(display_name=display_name):
|
||||
result = call("POST", "/api/v1/users", user_body(display_name=display_name))
|
||||
self.assert_error(result, 400, "invalid_request")
|
||||
|
||||
def test_display_name_length_is_counted_in_code_points(self):
|
||||
# 100 эмодзи это 400 байт в UTF-8, но ровно 100 code points
|
||||
status, user, _ = call("POST", "/api/v1/users", user_body(display_name="🙂" * 100))
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(user["display_name"], "🙂" * 100)
|
||||
|
||||
def test_bad_passwords(self):
|
||||
for password in ("short-11-ch", "x" * 129, " " * 12, "", 123456789012, None):
|
||||
with self.subTest(password=password):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(password=password)), 400, "invalid_request")
|
||||
|
||||
def test_password_length_limits(self):
|
||||
for password in ("exactly-12-c", "x" * 128, "пароль🙂пароль"):
|
||||
with self.subTest(length=len(password)):
|
||||
body = user_body(password=password)
|
||||
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
|
||||
self.assertEqual(login(body["username"], password)[0], 201)
|
||||
|
||||
def test_password_is_never_returned(self):
|
||||
body = user_body()
|
||||
status, user, _ = call("POST", "/api/v1/users", body)
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(set(user), {"id", "username", "display_name", "created_at"})
|
||||
_, session, _ = login(body["username"], body["password"])
|
||||
self.assertNotIn(body["password"], str(session))
|
||||
|
||||
def test_duplicate_username(self):
|
||||
body = user_body(display_name="Первый")
|
||||
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
|
||||
body["display_name"] = "Второй"
|
||||
self.assert_error(call("POST", "/api/v1/users", body), 409, "conflict")
|
||||
|
||||
|
||||
class MessageValidationTest(ErrorFormatTest):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.user = new_user()
|
||||
cls.chat = new_chat(cls.user)
|
||||
|
||||
def test_empty_message(self):
|
||||
self.assert_error(send(self.user, self.chat, ""), 400, "invalid_request")
|
||||
|
||||
def test_whitespace_message(self):
|
||||
for text in (" ", " \n\t ", " "):
|
||||
with self.subTest(text=repr(text)):
|
||||
self.assert_error(send(self.user, self.chat, text), 400, "invalid_request")
|
||||
|
||||
def test_nul_character(self):
|
||||
self.assert_error(send(self.user, self.chat, "до\u0000после"), 400, "invalid_request")
|
||||
|
||||
def test_text_limit(self):
|
||||
self.assertEqual(send(self.user, self.chat, "ы" * 4000)[0], 201)
|
||||
self.assert_error(send(self.user, self.chat, "ы" * 4001), 400, "invalid_request")
|
||||
|
||||
def test_sender_id_is_not_accepted(self):
|
||||
path = "/api/v1/chats/" + self.chat["id"] + "/messages"
|
||||
body = {"text": "привет", "sender_id": self.user["id"]}
|
||||
self.assert_error(call("POST", path, body, user=self.user), 400, "invalid_request")
|
||||
|
||||
def test_unicode_is_kept(self):
|
||||
text = "Привет 👋 你好 مرحبا\nвторая строка"
|
||||
status, message, _ = send(self.user, self.chat, text)
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(message["text"], text)
|
||||
self.assertEqual(message["sender_id"], self.user["id"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user