"""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 @pytest.mark.parametrize("blank", [" ", "  ", "  \t "]) def test_unicode_whitespace_only_strings_are_400(api, blank): alice = api.user("blank") chat = api.chat(alice) api.call("POST", "/api/v1/users", 400, json_body={"username": "bl_" + uuid.uuid4().hex[:10], "display_name": blank, "password": PASSWORD}) api.call("POST", "/api/v1/chats", 400, token=alice["token"], json_body={"title": blank, "member_ids": [alice["id"]]}) api.post_message(alice, chat, {"text": blank}, 400) assert api.history(alice, chat, 100)[0] == [] @pytest.mark.parametrize("raw", [b'{"username":"num_probe","display_name":"x","password":1e1000}', '{"username":"ff_probe","display_name":"x","password":"12345678901'.encode() + b'\xff"}', b'{"username":"num_probe","display_name":1,"password":"Twelve-chars-ok"}']) def test_odd_registration_bodies_are_400_and_the_api_survives(api, raw): api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"}) api.call("GET", "/health/ready", 200) def test_more_than_100_members_is_400(api): owner = api.user("big") others = [api.register(f"m{i}")["id"] for i in range(100)] api.call("POST", "/api/v1/chats", 400, token=owner["token"], json_body={"title": "x", "member_ids": [owner["id"], *others]}) chat = api.call("POST", "/api/v1/chats", 201, token=owner["token"], json_body={"title": "x", "member_ids": [owner["id"], *others[:99]]}, schema="Chat").json() assert len(chat["member_ids"]) == 100 def test_cursor_of_one_list_is_rejected_by_the_other(api): alice = api.user("cross") chats = [api.chat(alice, title=f"c{i}") for i in range(2)] for _ in range(2): api.send(alice, chats[0], "m") message_cursor = api.call("GET", f"/api/v1/chats/{chats[0]['id']}/messages?limit=1", 200, token=alice["token"]).json()["next_cursor"] chat_cursor = api.call("GET", "/api/v1/chats?limit=1", 200, token=alice["token"]).json()["next_cursor"] api.call("GET", f"/api/v1/chats?cursor={message_cursor}", 400, token=alice["token"]) api.call("GET", f"/api/v1/chats/{chats[0]['id']}/messages?cursor={chat_cursor}", 400, token=alice["token"])