"""Database-level guarantees, checked over HTTP and verified directly in PostgreSQL / Valkey.""" from __future__ import annotations import threading import time import uuid import pytest from conftest import PASSWORD, Api, compose, psql pytestmark = pytest.mark.stack def run_concurrently(workers: int, target) -> list: barrier = threading.Barrier(workers) results: list = [None] * workers def body(index: int) -> None: local = Api() # one HTTP client (connection) per worker barrier.wait() # all workers fire at the same moment try: results[index] = target(local, index) except BaseException as exc: # noqa: BLE001 - reported by the test results[index] = exc threads = [threading.Thread(target=body, args=(i,)) for i in range(workers)] for t in threads: t.start() for t in threads: t.join() return results def test_registration_race_exactly_one_201_and_seven_409(): username = "race_" + uuid.uuid4().hex[:10] def register(client: Api, _index: int) -> int: body = {"username": username, "display_name": "Гонка", "password": PASSWORD} response = client.client.post("/api/v1/users", json=body) return response.status_code statuses = run_concurrently(8, register) # Real HTTP codes are compared: a timeout, 500 or exception fails the test instead of counting as 409. assert sorted(statuses, key=str) == [201] + [409] * 7, statuses assert psql(f"SELECT count(*) FROM users WHERE username = '{username}'") == "1" def _ins_counter() -> int: return int(psql("SELECT n_tup_ins FROM pg_stat_user_tables WHERE relname = 'chats'")) def test_create_chat_rolls_back_after_the_chat_row_was_inserted(api): """The chat INSERT runs first; the unknown member then breaks the membership INSERT (FK). Proof that the first INSERT really happened and was rolled back: PostgreSQL counts attempted inserts in pg_stat_user_tables.n_tup_ins even for aborted transactions, while the table contains no such chat and no new membership rows. """ alice = api.user("rollback") title = "rollback-" + uuid.uuid4().hex members_before = int(psql("SELECT count(*) FROM chat_members")) attempts_before = _ins_counter() error = api.call("POST", "/api/v1/chats", 400, token=alice["token"], json_body={"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]}).json() assert "несуществующих" in error["error"]["message"] deadline = time.monotonic() + 20 # statistics are flushed by the API backend asynchronously while _ins_counter() == attempts_before and time.monotonic() < deadline: time.sleep(0.5) assert _ins_counter() > attempts_before, "the chat INSERT was never attempted" assert psql(f"SELECT count(*) FROM chats WHERE title = convert_to('{title}', 'UTF8')") == "0" assert int(psql("SELECT count(*) FROM chat_members")) == members_before def test_migrations_rerun_is_a_noop(): users_before = psql("SELECT count(*) FROM users") result = compose("run", "--rm", "--no-deps", "migrate") assert "0001_init: already applied, skipped" in result.stdout assert "0002_idempotency_keys: already applied, skipped" in result.stdout assert "0003_post_message_function: already applied, skipped" in result.stdout assert "0004_attachments: already applied, skipped" in result.stdout assert psql("SELECT count(*) FROM schema_migrations") == "4" assert psql("SELECT count(*) FROM users") == users_before def test_100_messages_from_10_clients_keep_order_and_cursor_walk(api): clients = [api.user(f"w{i}") for i in range(10)] chat = api.chat(clients[0], *clients[1:]) def writer(client: Api, index: int) -> list[dict]: return [client.send(clients[index], chat, f"c{index}-m{j}") for j in range(10)] results = run_concurrently(10, writer) assert all(isinstance(r, list) for r in results), results confirmed = [m for batch in results for m in batch] history, pages = api.history(clients[5], chat, 7) ids = [m["id"] for m in history] assert len(confirmed) == 100 and len(history) == 100 and len(set(ids)) == 100 and pages == 15 assert set(ids) == {m["id"] for m in confirmed} keys = [(m["created_at"], uuid.UUID(m["id"]).int) for m in history] assert all(a < b for a, b in zip(keys, keys[1:])), "history is not strictly ordered" stamps = [m["created_at"] for m in history] assert len(set(stamps)) == 100, "per-chat clock must give unique timestamps" for i, client in enumerate(clients): own = [m["text"] for m in history if m["sender_id"] == client["id"]] assert own == [f"c{i}-m{j}" for j in range(10)] def test_secrets_are_not_stored_in_plain_text(api): actor = api.user("store") stored = psql(f"SELECT password_hash FROM users WHERE id = '{actor['id']}'") assert stored.startswith("$argon2id$v=19$m=19456,t=2,p=1$") and PASSWORD not in stored token_hex = actor["token"].encode().hex() keys = compose("exec", "-T", "valkey", "sh", "-c", 'REDISCLI_AUTH="$(cat /run/secrets/valkey_password)" valkey-cli --scan --pattern "session:*"').stdout.split() assert keys and all(len(k) == len("session:") + 64 for k in keys) assert not any(actor["token"] in k or token_hex in k for k in keys)