forked from mtusi2026/mtusi2026lab3
- test_idempotency: точные коды и тела повторов через разные реплики, 24
одновременных запроса с одним ключом -> ровно одно сообщение и одна строка
ключа в БД, 409 при другом body, scope user+chat+key, 404 постороннему,
откат после сбоя на втором INSERT (триггер, n_tup_ins), неопределённый
POST (клиентский timeout) и lock_timeout с повтором тем же ключом.
- test_balancing: X-Instance-Id = реальные контейнеры, нет sticky,
LB исключает живую, но неготовую реплику (pg_hba reject), graceful stop
каждой реплики под нагрузкой без единой ошибки, SIGKILL — ограниченные
ошибки и восстановление, полный restart и scale up/down без рестарта LB,
политика compose (лимиты, порты, secrets, digest), миграции один раз.
- Входы из замечаний к чужим PR: курсоры с []/{}/числами/пустые/пробел,
байт FF, TEXT/text, дубли ключей, Bearer é, UUID в разном регистре, тело
при входе, пароль "я:"*64. Тесты lab2 переведены на Idempotency-Key и LB;
все отказы восстанавливаются в finally и ждут UP всех реплик в HAProxy.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
305 lines
16 KiB
Python
305 lines
16 KiB
Python
"""Contract behaviour over real HTTP (stand must be running). Lab 1 checks moved to Bearer + new lab 2 auth."""
|
||
from __future__ import annotations
|
||
|
||
import base64
|
||
import uuid
|
||
|
||
import pytest
|
||
|
||
from conftest import PASSWORD, basic
|
||
|
||
pytestmark = pytest.mark.stack
|
||
|
||
|
||
def key(item: dict) -> tuple[str, int]:
|
||
return item["created_at"], uuid.UUID(item["id"]).int
|
||
|
||
|
||
# ================================================================== registration & login
|
||
def test_register_never_returns_password_and_login_returns_bearer(api):
|
||
actor = api.register("alice", display_name="Алиса 👩💻")
|
||
assert set(actor["user"]) == {"id", "username", "display_name", "created_at"}
|
||
session = api.call("POST", "/api/v1/auth/sessions", 201,
|
||
headers={"Authorization": basic(actor["username"], PASSWORD)}, schema="Session").json()
|
||
assert session["token_type"] == "Bearer" and len(session["token"]) >= 43
|
||
assert actor["username"] not in session["token"] and actor["id"] not in session["token"]
|
||
assert api.call("GET", "/api/v1/users/me", 200, token=session["token"], schema="User").json() == actor["user"]
|
||
|
||
|
||
def test_duplicate_username_is_409(api):
|
||
actor = api.register("dup")
|
||
body = {"username": actor["username"], "display_name": "Другой", "password": PASSWORD}
|
||
assert api.call("POST", "/api/v1/users", 409, json_body=body).json()["error"]["code"] == "conflict"
|
||
|
||
|
||
@pytest.mark.parametrize("password", ["short-11ch", " " * 12, " \t \n " * 3, "я" * 129])
|
||
def test_bad_password_on_registration_is_400(api, password):
|
||
body = {"username": "pw_" + uuid.uuid4().hex[:10], "display_name": "x", "password": password}
|
||
api.call("POST", "/api/v1/users", 400, json_body=body)
|
||
|
||
|
||
@pytest.mark.parametrize("password", ["я" * 128, "with:colons:inside", "Twelve chars"])
|
||
def test_edge_passwords_register_and_login(api, password):
|
||
actor = api.user("edge", password=password)
|
||
api.call("GET", "/api/v1/users/me", 200, token=actor["token"])
|
||
|
||
|
||
def test_wrong_password_and_unknown_user_give_the_same_401(api):
|
||
actor = api.register("victim")
|
||
wrong = api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": basic(actor["username"], "Wrong-password-1")})
|
||
unknown = api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": basic("nobody_" + uuid.uuid4().hex[:8], PASSWORD)})
|
||
assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"]
|
||
assert wrong.headers["www-authenticate"] == 'Basic realm="messenger", charset="UTF-8"'
|
||
|
||
|
||
@pytest.mark.parametrize("header", ["Basic é", "Basic !!!", "Basic " + base64.b64encode(b"no_colon").decode(),
|
||
"Basic " + base64.b64encode(b"\xff\xfe:x").decode(), "Bearer " + "a" * 43, ""])
|
||
def test_malformed_basic_is_401_not_500(api, header):
|
||
# Raw UTF-8 bytes, as curl would send them (httpx refuses non-ASCII str headers).
|
||
api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": header.encode("utf-8")} if header else {})
|
||
|
||
|
||
def test_logout_revokes_only_this_token(api):
|
||
actor = api.user("logout")
|
||
second = api.login(actor)
|
||
api.call("DELETE", "/api/v1/auth/sessions/current", 204, token=actor["token"])
|
||
api.call("GET", "/api/v1/users/me", 401, token=actor["token"])
|
||
api.call("DELETE", "/api/v1/auth/sessions/current", 401, token=actor["token"])
|
||
api.call("GET", "/api/v1/users/me", 200, token=second) # other session of the same user survives
|
||
|
||
|
||
def test_x_user_id_basic_and_garbage_do_not_authenticate(api):
|
||
actor = api.user("hdr")
|
||
for headers in ({"X-User-Id": actor["id"]},
|
||
{"Authorization": basic(actor["username"], PASSWORD)},
|
||
{"Authorization": "Bearer " + "A" * 43},
|
||
{"Authorization": "Bearer"}):
|
||
api.call("GET", "/api/v1/users/me", 401, headers=headers)
|
||
me = api.call("GET", "/api/v1/users/me", 200, token=actor["token"], headers={"X-User-Id": str(uuid.uuid4())})
|
||
assert me.json()["id"] == actor["id"]
|
||
|
||
|
||
# ================================================================== validation / errors (from lab 1)
|
||
@pytest.mark.parametrize("raw", [b"{", b"", b"[]", b"null", b'{"username": "abc_def", "display_name": NaN, "password": "Twelve-chars"}',
|
||
b'{"username": "abc_def", "display_name": "x", "password": "Twelve-chars"}{"a": 1}',
|
||
b'{"username": "abc_def", "display_name": "\\ud800", "password": "Twelve-chars"}'])
|
||
def test_malformed_json_is_400(api, raw):
|
||
api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"})
|
||
|
||
|
||
@pytest.mark.parametrize("body", [
|
||
{"username": "abc_def", "display_name": "x"}, # no password
|
||
{"username": "abc_def", "display_name": "x", "password": "Twelve-chars", "extra": 1},
|
||
{"username": "Abc_def", "display_name": "x", "password": "Twelve-chars"},
|
||
{"username": "abc_def", "display_name": " ", "password": "Twelve-chars"},
|
||
{"username": "abc_def", "display_name": "x" * 101, "password": "Twelve-chars"},
|
||
{"username": 5, "display_name": "x", "password": "Twelve-chars"},
|
||
])
|
||
def test_invalid_registration_fields_are_400(api, body):
|
||
api.call("POST", "/api/v1/users", 400, json_body=body)
|
||
|
||
|
||
def test_unicode_limits_are_code_points_and_nul_is_stored(api):
|
||
actor = api.user("uni", display_name="😀" * 100)
|
||
assert actor["user"]["display_name"] == "😀" * 100
|
||
nul = api.user("nul", display_name="A\u0000B")
|
||
assert api.call("GET", "/api/v1/users/me", 200, token=nul["token"]).json()["display_name"] == "A\u0000B"
|
||
chat = api.chat(actor, title="T\u0000itle")
|
||
assert chat["title"] == "T\u0000itle"
|
||
assert api.send(actor, chat, "hello\u0000world")["text"] == "hello\u0000world"
|
||
assert api.send(actor, chat, "🙂" * 4000)["text"] == "🙂" * 4000
|
||
api.post_message(actor, chat, {"text": "я" * 4001}, 400)
|
||
texts = [m["text"] for m in api.history(actor, chat, 100)[0]]
|
||
assert texts == ["hello\u0000world", "🙂" * 4000]
|
||
|
||
|
||
def test_oversized_body_and_wrong_content_type(api):
|
||
api.call("POST", "/api/v1/users", 413, json_body={"username": "big_body", "display_name": "x" * 70_000, "password": PASSWORD})
|
||
api.call("POST", "/api/v1/users", 400, raw=b'{"username":"abc_def"}', headers={"Content-Type": "text/plain"})
|
||
|
||
|
||
# ================================================================== chats & membership
|
||
def test_chat_validation(api):
|
||
alice, bob = api.user("alice"), api.user("bob")
|
||
for body in ({"title": "x", "member_ids": [alice["id"], bob["id"], bob["id"]]},
|
||
{"title": "x", "member_ids": [alice["id"], str(uuid.uuid4())]},
|
||
{"title": "x", "member_ids": [bob["id"]]},
|
||
{"title": " ", "member_ids": [alice["id"]]},
|
||
{"title": "x", "member_ids": [alice["id"], "bob"]}):
|
||
api.call("POST", "/api/v1/chats", 400, token=alice["token"], json_body=body)
|
||
|
||
|
||
def test_foreign_chat_is_indistinguishable_from_missing(api):
|
||
alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve")
|
||
chat = api.chat(alice, bob)
|
||
for chat_id in (chat["id"], str(uuid.uuid4())):
|
||
base = f"/api/v1/chats/{chat_id}"
|
||
errors = [api.call("GET", base, 404, token=eve["token"]).json(),
|
||
api.call("GET", base + "/messages", 404, token=eve["token"]).json(),
|
||
api.call("POST", base + "/messages", 404, token=eve["token"], json_body={"text": "чужое"}, headers={"Idempotency-Key": "k1"}).json(),
|
||
api.call("GET", base + "/messages?cursor=garbage", 404, token=eve["token"]).json()]
|
||
assert len({e["error"]["message"] for e in errors}) == 1
|
||
api.call("GET", "/api/v1/chats/not-a-uuid", 401)
|
||
api.call("GET", "/api/v1/chats/not-a-uuid", 400, token=alice["token"])
|
||
api.call("GET", "/api/v1/chats/NOT-A-UUID/messages", 400, token=alice["token"])
|
||
|
||
|
||
def test_chat_list_order_pagination_and_isolation(api):
|
||
alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve")
|
||
created = [api.chat(alice, bob, title=f"Чат {i}") for i in range(5)]
|
||
api.chat(eve, title="Чат Евы")
|
||
walked, cursor = [], None
|
||
while True:
|
||
query = "?limit=2" + (f"&cursor={cursor}" if cursor else "")
|
||
page = api.call("GET", "/api/v1/chats" + query, 200, token=bob["token"], schema="ChatPage").json()
|
||
walked += page["items"]
|
||
cursor = page["next_cursor"]
|
||
if not cursor:
|
||
break
|
||
assert walked == created
|
||
first = api.call("GET", "/api/v1/chats?limit=1", 200, token=alice["token"]).json()["next_cursor"]
|
||
api.call("GET", f"/api/v1/chats?limit=1&cursor={first}", 400, token=bob["token"]) # cursor of another user
|
||
api.call("GET", "/api/v1/chats?limit=0", 400, token=bob["token"])
|
||
|
||
|
||
# ================================================================== messages & keyset pagination
|
||
def test_history_pages_without_loss_or_duplicates(api):
|
||
alice, bob = api.user("alice"), api.user("bob")
|
||
chat = api.chat(alice, bob)
|
||
sent = [api.send(alice if i % 2 else bob, chat, f"сообщение {i}") for i in range(25)]
|
||
items, pages = api.history(bob, chat, 7)
|
||
assert pages == 4 and items == sent and items == sorted(items, key=key)
|
||
assert sent[0]["sender_id"] == bob["id"] and sent[1]["sender_id"] == alice["id"]
|
||
|
||
|
||
@pytest.mark.parametrize("query", ["limit=0", "limit=101", "limit=abc", "limit=1&limit=2", "cursor=", "cursor=garbage",
|
||
"cursor=djF8bXx4fDF8Mg", "cursor=" + base64.urlsafe_b64encode(b"v1|m|x|99999999999999999999|y").decode()])
|
||
def test_bad_limit_or_cursor_is_400(api, query):
|
||
alice = api.user("alice")
|
||
chat = api.chat(alice)
|
||
api.call("GET", f"/api/v1/chats/{chat['id']}/messages?{query}", 400, token=alice["token"])
|
||
|
||
|
||
def test_cursor_bound_to_chat(api):
|
||
alice = api.user("alice")
|
||
a, b = api.chat(alice, title="A"), api.chat(alice, title="B")
|
||
for chat in (a, b):
|
||
api.send(alice, chat, "1")
|
||
api.send(alice, chat, "2")
|
||
cursor = api.call("GET", f"/api/v1/chats/{a['id']}/messages?limit=1", 200, token=alice["token"]).json()["next_cursor"]
|
||
api.call("GET", f"/api/v1/chats/{b['id']}/messages?cursor={cursor}", 400, token=alice["token"])
|
||
empty = api.chat(alice, title="Empty")
|
||
api.call("GET", f"/api/v1/chats/{empty['id']}/messages?cursor=garbage", 400, token=alice["token"])
|
||
|
||
|
||
def test_read_after_write(api):
|
||
alice, bob = api.user("alice"), api.user("bob")
|
||
chat = api.chat(alice, bob)
|
||
for i in range(5):
|
||
message = api.send(alice, chat, f"m{i}")
|
||
last = api.call("GET", f"/api/v1/chats/{chat['id']}/messages?limit=100", 200, token=bob["token"]).json()["items"][-1]
|
||
assert last == message
|
||
|
||
|
||
# ================================================================== lab 3: inputs found by the reviewer in other PRs
|
||
def b64(raw: bytes) -> str:
|
||
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
|
||
|
||
|
||
def bad_cursors(owner_id: str) -> list[str]:
|
||
"""Wrong types/values inside the cursor, empty and whitespace cursors, out-of-range time."""
|
||
good_uuid = str(uuid.uuid4())
|
||
return ["", " ", "%20", "garbage", b64(b"[]"), b64(b"{}"), b64(b"123"), b64(b"false"), b64(b"null"),
|
||
b64(b'{"created_at":1,"id":1}'), b64(b'{"created_at":null,"id":"x"}'),
|
||
b64(f"v1|m|{owner_id}|1|1".encode()), b64(f"v1|c|{owner_id}|1|1".encode()),
|
||
b64(f"v1|m|{owner_id}|abc|{good_uuid}".encode()), b64(f"v1|m|{owner_id}|-1|{good_uuid}".encode()),
|
||
b64(f"v1|m|{owner_id}|9223372036854775807|{good_uuid}".encode()),
|
||
b64(f"v1|c|{owner_id}|9223372036854775807|{good_uuid}".encode()),
|
||
b64(f"v1|m|{owner_id}|1|{good_uuid.upper()}".encode()), b64(f"v2|m|{owner_id}|1|{good_uuid}".encode())]
|
||
|
||
|
||
def test_malformed_cursor_values_are_400_on_both_lists(api):
|
||
alice = api.user("cur")
|
||
chat = api.chat(alice)
|
||
for cursor in bad_cursors(chat["id"]) + bad_cursors(alice["id"]):
|
||
quoted = cursor if cursor in ("", "%20") else cursor.replace(" ", "%20")
|
||
for path in (f"/api/v1/chats/{chat['id']}/messages", "/api/v1/chats"):
|
||
error = api.call("GET", f"{path}?cursor={quoted}", 400, token=alice["token"]).json()
|
||
assert error["error"]["code"] == "invalid_request", (path, cursor)
|
||
|
||
|
||
@pytest.mark.parametrize("raw", [b"\xff", b'{"text":"first","TEXT":"second"}', b'{"text":"a","text":"b"}',
|
||
b'{"text":123}', b'{"text":"valid"}}', b'{"text":"valid"}]', b'{"text":"x"} {}',
|
||
b'{"text":"x","sender_id":"11111111-1111-4111-8111-111111111111"}',
|
||
b'{"text":"x","attachment_ids":null}', b'{"text":"x","attachment_ids":["nope"]}',
|
||
b'{"text":" \n\t "}'])
|
||
def test_bad_message_body_is_400_and_nothing_is_stored(api, raw):
|
||
alice = api.user("body")
|
||
chat = api.chat(alice)
|
||
error = api.post_message(alice, chat, None, 400, raw=raw).json()
|
||
assert error["error"]["code"] == "invalid_request"
|
||
assert api.history(alice, chat, 100)[0] == []
|
||
|
||
|
||
def test_ff_byte_body_on_registration_is_contract_error(api):
|
||
response = api.call("POST", "/api/v1/users", 400, raw=b"\xff", headers={"Content-Type": "application/json"})
|
||
assert response.json()["error"]["request_id"] == response.headers["x-request-id"]
|
||
|
||
|
||
def test_text_is_stored_verbatim_and_length_counts_raw_text(api):
|
||
alice = api.user("verbatim")
|
||
chat = api.chat(alice)
|
||
padded = " строка\nс пробелами "
|
||
assert api.send(alice, chat, padded)["text"] == padded
|
||
api.post_message(alice, chat, {"text": " " + "a" * 4000}, 400) # 4001 code points before any trimming
|
||
assert [m["text"] for m in api.history(alice, chat, 100)[0]] == [padded]
|
||
|
||
|
||
def test_unknown_attachment_ids_are_404(api):
|
||
alice = api.user("att")
|
||
chat = api.chat(alice)
|
||
api.post_message(alice, chat, {"text": "x", "attachment_ids": [str(uuid.uuid4())]}, 404)
|
||
api.post_message(alice, chat, {"text": "x", "attachment_ids": [str(uuid.uuid4())] * 2}, 400) # duplicates
|
||
assert api.history(alice, chat, 100)[0] == []
|
||
|
||
|
||
def test_member_ids_are_compared_as_uuids_not_strings(api):
|
||
alice, bob = api.user("case"), api.user("case")
|
||
api.call("POST", "/api/v1/chats", 400, token=alice["token"],
|
||
json_body={"title": "x", "member_ids": [alice["id"], alice["id"].upper()]})
|
||
api.call("POST", "/api/v1/chats", 400, token=alice["token"],
|
||
json_body={"title": "x", "member_ids": [alice["id"], bob["id"]], "id": str(uuid.uuid4())})
|
||
chat = api.call("POST", "/api/v1/chats", 201, token=alice["token"],
|
||
json_body={"title": "x", "member_ids": [alice["id"].upper(), bob["id"]]}, schema="Chat").json()
|
||
assert chat["member_ids"] == [alice["id"], bob["id"]]
|
||
|
||
|
||
@pytest.mark.parametrize("header", ["Bearer é", "Bearer .", "Bearer a b", "Bearer " + "é" * 43, "bearer\t" + "a" * 43])
|
||
def test_non_ascii_or_garbage_bearer_is_401_not_500(api, header):
|
||
api.call("GET", "/api/v1/users/me", 401, headers={"Authorization": header.encode("utf-8")})
|
||
|
||
|
||
def test_login_with_a_body_is_rejected(api):
|
||
actor = api.register("login_body")
|
||
auth = {"Authorization": basic(actor["username"], actor["password"])}
|
||
api.call("POST", "/api/v1/auth/sessions", 400, raw=b'{"extra":1}', headers={**auth, "Content-Type": "application/json"})
|
||
api.call("POST", "/api/v1/auth/sessions", 400, raw=b"x", headers=auth)
|
||
api.call("POST", "/api/v1/auth/sessions", 201, headers=auth, schema="Session")
|
||
|
||
|
||
def test_password_range_is_12_to_128_code_points(api):
|
||
api.call("POST", "/api/v1/users", 400, json_body={"username": "pw_" + uuid.uuid4().hex[:10], "display_name": "x", "password": "a"})
|
||
actor = api.user("pw128", password="я:" * 64)
|
||
api.call("GET", "/api/v1/users/me", 200, token=actor["token"])
|
||
|
||
|
||
def test_every_api_response_carries_instance_and_request_id(api):
|
||
"""X-Instance-Id also on 404 of unknown routes, 405, 401, 400 and health (Api.call asserts it)."""
|
||
api.call("GET", "/health/live", 200)
|
||
api.call("GET", "/health/ready", 200)
|
||
api.call("GET", "/no/such/route", 404)
|
||
api.call("PUT", "/api/v1/users", 405)
|
||
api.call("GET", "/api/v1/users/me", 401)
|
||
response = api.call("GET", "/api/v1/users/me", 401, headers={"X-Request-Id": "client-supplied.id-1"})
|
||
assert response.headers["x-request-id"] == "client-supplied.id-1" # one id from LB log to API log
|