diff --git a/Makefile b/Makefile index 80ed53f..72a20f3 100644 --- a/Makefile +++ b/Makefile @@ -11,11 +11,11 @@ export BASE_URL export BASE_URL_TTL .PHONY: help check validate test load test-persistence \ - secrets up down ps logs student-test race expiry failure-valkey failure-postgres db-test explain demo cache-stats + secrets up down ps logs student-test race expiry failure-valkey failure-postgres failure-valkey-pause db-test explain demo cache-stats help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" - @echo "secrets/up/down/ps/logs: stand; student-test, race, expiry, failure-valkey, failure-postgres, db-test, explain, demo, cache-stats: own checks" + @echo "secrets/up/down/ps/logs: stand; student-test, race, expiry, failure-valkey, failure-postgres, failure-valkey-pause, db-test, explain, demo, cache-stats: own checks" check: $(PYTHON) scripts/check_contract.py @@ -70,6 +70,10 @@ failure-valkey: failure-postgres: $(PYTHON) student-tests/dependency_failure.py postgres +# Valkey на паузе (данные в нём сохраняются), logout, снова в строю: токен должен остаться отозванным. +failure-valkey-pause: + $(PYTHON) student-tests/cache_revocation.py + db-test: docker compose --profile tools run --rm db-test diff --git a/REPORT.md b/REPORT.md index d643100..2f1b365 100644 --- a/REPORT.md +++ b/REPORT.md @@ -27,6 +27,7 @@ make db-test make expiry PYTHON=python make failure-valkey PYTHON=python make failure-postgres PYTHON=python +make failure-valkey-pause PYTHON=python make explain > evidence/explain-history.txt ``` @@ -75,7 +76,8 @@ PostgreSQL и Valkey наружу не опубликованы, доступн - источник истины — таблица `sessions` в PostgreSQL. Она переживает рестарт, срок `expires_at` абсолютный, рестарт его не продлевает; - Valkey — кэш, чтобы не делать SQL-запрос при каждой проверке токена. Ключ `sess:`, значение — пользователь и expires_at; - expiry в кэше: TTL ключа = min(30 с, остаток жизни сессии); кроме того, expires_at проверяется при чтении, поэтому кэш никогда не продлевает сессию; -- инвалидация: logout сначала ставит revoked_at в PostgreSQL, затем удаляет ключ из кэша. Если Valkey в момент logout недоступен, запись в кэше может прожить не дольше 30 с — это осознанная граница; +- инвалидация: logout сначала ставит revoked_at в PostgreSQL, затем кладёт в кэш вместо записи о сессии отметку «отозвано» (на 30 с). Запись о сессии кладётся в кэш только если ключа нет (`SET NX`), поэтому запрос, прочитавший сессию из базы за мгновение до logout, не может вернуть её в кэш после logout; +- поколение кэша: каждая запись о сессии помечена поколением процесса (случайное значение при старте). При любой ошибке Valkey процесс начинает новое поколение и записям старого больше не доверяет. Если Valkey был недоступен в момент logout (например, `docker compose pause`), запись о сессии осталась в кэше, но после возвращения Valkey она старого поколения: проверка идёт в PostgreSQL, там сессия отозвана — 401. Отметки «отозвано» действуют в любом поколении: они только запрещают; - persistence у Valkey выключена: кэш после рестарта пустой, данные снова берутся из PostgreSQL; - если Valkey недоступен, API его обходит и работает напрямую с PostgreSQL. После первой ошибки запросы перестают обращаться к кэшу, а фоновый поток раз в 5 с делает PING и, когда Valkey вернулся, снова включает кэш. Так ожидание подключения к пропавшему Valkey не попадает в запросы пользователей; - у Valkey ACL: пользователь `default` выключен, `messenger` (пароль из secrets) может только get/set/del/ping и только по ключам `sess:*`, `health` (без пароля) — только ping/info/dbsize. @@ -106,6 +108,8 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on ( | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | | Публичный smoke | make test | PASS: lab2 public API scenario | evidence/test.txt | +| Замечание к MR: отозванный токен после возвращения Valkey | make failure-valkey-pause (pause valkey → logout → unpause) | во время паузы logout 204 → 401; после unpause 24 проверки за 12 с, GET и POST — всегда 401; другие токены работают | evidence/failure-valkey-pause.txt | +| Замечание к MR: граничная дата в cursor | make student-test (test_bad_cursor_returns_400) | 0001-01-01T00:00:00+14:00 и 9999-12-31T23:59:59-14:00 в курсоре → 400, не 500 | evidence/student-test.txt | | Строки с U+0000 сохраняются (нашёл сам по замечанию к похожей работе) | make student-test (test_nul_character_is_stored) | display_name, title и text с U+0000 → 201, читаются без изменений; вход с таким логином → 401, не 500 | evidence/student-test.txt | | Структура skeleton и контракт не изменены | make check | PASS: offline skeleton structure | evidence/check.txt | | 3: минимум lab1 сохранён, переход на новую аутентификацию | make test, make student-test (тесты lab1 переведены на пароль и Bearer) | smoke PASS; Ran 22 tests, OK | evidence/test.txt, evidence/student-test.txt | @@ -141,6 +145,7 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on ( | --- | --- | --- | --- | | restart hook: stop api, restart postgres и valkey, start api (volumes на месте) | данные и токен живы | тот же токен читает то же сообщение; ID контейнеров те же, Up сбросился у api, postgres, valkey; кэш пустой и заполняется из PostgreSQL | весь make test-persistence (создание данных, hook, ожидание готовности, проверка) — 12,5 с; потерь нет | | docker compose stop valkey | API работает без кэша | ready 200, вход, сообщения, logout работают; первый запрос после остановки ждал около 4 с (на нём обнаружился сбой: подключение к остановленному контейнеру), дальше запросы десятки мс, в том числе через 6 с | после start valkey кэш включается сам в течение 5 с; потерь нет | +| docker compose pause valkey, logout, unpause (данные в кэше сохранились) | отозванный токен не оживает | во время паузы 401; после unpause кэш снова включился, но запись до сбоя старого поколения — 401 при каждой из 24 проверок | кэш снова работает через ≤5 с; отзыв не теряется | | docker compose stop postgres | ограниченная ошибка, никого не пускаем без проверки | ready 503 за ~1 с, бизнес-запросы 503, без токена 401 | после start postgres прежний токен и сообщения на месте; запросы во время отказа не сохранены (получили 503) | | 20 одновременных регистраций одного username | один победитель | 201 x1, 409 x19 | дублей нет | | 10 клиентов x 10 сообщений одновременно | ровно 100 сообщений | 100, все id уникальны | потерь нет | @@ -150,7 +155,7 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on ( - PostgreSQL одна: если упала она или весь Docker-host, API отвечает 503. Отказоустойчивости к потере хоста нет, бэкапов нет. - Конкурентные вставки: created_at = время начала транзакции. Сообщение, которое закоммитилось позже, может получить более раннее время, и клиент, уже пролиставший дальше по курсору, его не увидит. Повторов нет, но такую запись можно пропустить; это ограничение keyset-пагинации по времени. - Первый запрос после пропадания Valkey ждёт обнаружения сбоя (на Windows/Docker Desktop около 4 с), следующие идут без кэша сразу. -- Если Valkey недоступен ровно в момент logout, отозванная сессия может ещё до 30 с проходить по старой записи в кэше (если сам Valkey при этом не перезапускался). +- Поколение кэша своё у каждого процесса API. Если logout во время сбоя Valkey прошёл через один экземпляр (например, api-short-ttl), а другой экземпляр сбоя не заметил, второй может до 30 с доверять своей старой записи. В lab2 основной API один; для нескольких реплик (lab3) поколение нужно хранить общим. - Приложение подключается к PostgreSQL пользователем-владельцем базы. Отдельная роль с минимальными правами — в lab7. - Basic по HTTP передаёт пароль открыто (base64 — это не шифрование). Допустимо только на локальном стенде, TLS — в lab7. - Старые сессии чистятся только при входе того же пользователя; периодической очистки нет. diff --git a/evidence/expiry.txt b/evidence/expiry.txt index 1939194..e58137d 100644 --- a/evidence/expiry.txt +++ b/evidence/expiry.txt @@ -1,8 +1,8 @@ docker compose --profile ttl up -d --wait api-short-ttl Container mtusi-lab2-valkey-1 Running Container mtusi-lab2-postgres-1 Running - Container mtusi-lab2-api-short-ttl-1 Creating - Container mtusi-lab2-api-short-ttl-1 Created + Container mtusi-lab2-api-short-ttl-1 Recreate + Container mtusi-lab2-api-short-ttl-1 Recreated Container mtusi-lab2-postgres-1 Waiting Container mtusi-lab2-valkey-1 Waiting Container mtusi-lab2-valkey-1 Healthy diff --git a/evidence/failure-valkey-pause.txt b/evidence/failure-valkey-pause.txt new file mode 100644 index 0000000..9390c92 --- /dev/null +++ b/evidence/failure-valkey-pause.txt @@ -0,0 +1,7 @@ +python student-tests/cache_revocation.py +pausing valkey (docker compose pause valkey): данные в кэше сохраняются +во время паузы: logout -> 204, тот же токен -> 401 +unpausing valkey +после unpause: 23 проверок за 12 с, отозванный токен всегда 401 (и GET, и POST) +действующие токены других пользователей работают +PASS: revoked session stays revoked after Valkey comes back with stale data diff --git a/evidence/failure-valkey.txt b/evidence/failure-valkey.txt index 05e4b6b..3858617 100644 --- a/evidence/failure-valkey.txt +++ b/evidence/failure-valkey.txt @@ -5,7 +5,7 @@ existing token: GET /users/me -> 200 (4015 ms), сессия проверена POST message -> 201, история читается register + login new user -> 201 logout -> 204, затем тот же токен -> 401 (отзыв записан в PostgreSQL) -10 x GET /users/me без кэша: max 16 ms (кэш не ждём на каждом запросе) +10 x GET /users/me без кэша: max 32 ms (кэш не ждём на каждом запросе) через 6 с, ещё 10 x GET /users/me: max 31 ms (повторные попытки — в фоне) starting valkey again after recovery: прежний токен работает, подтверждённые сообщения на месте diff --git a/evidence/persistence.txt b/evidence/persistence.txt index e4a07a5..178612f 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -1,21 +1,21 @@ docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}" SERVICE CONTAINER ID STATUS -api 719af7c38c2d Up 41 seconds (healthy) -api-short-ttl 047512285fe6 Up 8 hours (healthy) -postgres 094d2f567e2e Up 8 hours (healthy) -valkey 195f4a7b30f1 Up 7 hours (healthy) +api 5d506a14e681 Up About a minute (healthy) +api-short-ttl 6e433cfb380a Up 9 seconds (healthy) +postgres 094d2f567e2e Up 22 seconds (healthy) +valkey 195f4a7b30f1 Up 44 seconds (healthy) python tests/resilience.py --mode persistence --action-script "scripts/restart.cmd" --base-url "http://127.0.0.1:8080" Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. -real 0m12.535s -user 0m0.015s -sys 0m0.015s +real 0m10.093s +user 0m0.031s +sys 0m0.000s docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}" SERVICE CONTAINER ID STATUS -api 719af7c38c2d Up 3 seconds (health: starting) -api-short-ttl 047512285fe6 Up 8 hours (healthy) -postgres 094d2f567e2e Up 9 seconds (healthy) -valkey 195f4a7b30f1 Up 9 seconds (healthy) -api-1 | 2026-10-09 17:57:26,685 INFO messenger.db: Миграции применены: 003_text_as_bytes -api-1 | 2026-10-09 17:58:17,783 INFO messenger.db: Миграции: новых нет, схема актуальна +api 5d506a14e681 Up 2 seconds (health: starting) +api-short-ttl 6e433cfb380a Up 20 seconds (healthy) +postgres 094d2f567e2e Up 7 seconds (healthy) +valkey 195f4a7b30f1 Up 7 seconds (healthy) +api-1 | 2026-10-09 21:17:33,062 INFO messenger.db: Миграции: новых нет, схема актуальна +api-1 | 2026-10-09 21:19:16,340 INFO messenger.db: Миграции: новых нет, схема актуальна diff --git a/evidence/student-test.txt b/evidence/student-test.txt index 768b1b4..cf11a15 100644 --- a/evidence/student-test.txt +++ b/evidence/student-test.txt @@ -23,6 +23,6 @@ test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTest.test_wron test_x_user_id_does_not_change_identity (test_auth.AuthTest.test_x_user_id_does_not_change_identity) ... ok ---------------------------------------------------------------------- -Ran 22 tests in 3.300s +Ran 22 tests in 2.609s OK diff --git a/evidence/valkey.txt b/evidence/valkey.txt index 2939161..1480bec 100644 --- a/evidence/valkey.txt +++ b/evidence/valkey.txt @@ -1,7 +1,7 @@ docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning dbsize -2 +5 docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning info stats | grep -E "keyspace_(hits|misses)" -keyspace_hits:14 +keyspace_hits:16 keyspace_misses:2 docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning get sess:anything NOPERM User health has no permissions to run the 'get' command diff --git a/src/messenger/cursor.py b/src/messenger/cursor.py index cff454c..b183fab 100644 --- a/src/messenger/cursor.py +++ b/src/messenger/cursor.py @@ -26,7 +26,7 @@ def decode_cursor(scope: str, cursor: str | None) -> tuple[datetime, uuid.UUID] return None try: data = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii"))) - except ValueError: # не ASCII, не base64 или не JSON + except (ValueError, RecursionError): # не ASCII, не base64, не JSON или слишком глубокая вложенность raise InvalidRequest("Неверный cursor") from None well_formed = isinstance(data, list) and len(data) == 3 and all(isinstance(x, str) for x in data) if not well_formed or data[0] != scope: @@ -34,8 +34,11 @@ def decode_cursor(scope: str, cursor: str | None) -> tuple[datetime, uuid.UUID] try: created_at = datetime.fromisoformat(data[1].replace("Z", "+00:00")) item_id = uuid.UUID(data[2]) - except ValueError: + if created_at.tzinfo is None: + raise ValueError("время без часового пояса") + # Перевод в UTC может выйти за пределы годов 1–9999 (например, 0001-01-01T00:00+14:00): + # Python бросает OverflowError. Это тоже испорченный курсор -> 400, а не 500. + created_at = created_at.astimezone(timezone.utc) + except (ValueError, OverflowError): raise InvalidRequest("Неверный cursor") from None - if created_at.tzinfo is None: - raise InvalidRequest("Неверный cursor") - return created_at.astimezone(timezone.utc), item_id + return created_at, item_id diff --git a/src/messenger/sessions.py b/src/messenger/sessions.py index d9de66c..3f4ba60 100644 --- a/src/messenger/sessions.py +++ b/src/messenger/sessions.py @@ -10,7 +10,16 @@ Политика кэша: - запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии): кэш никогда не продлевает сессию, а истёкшая запись к тому же отбрасывается по expires_at; -- logout: сначала отметка revoked_at в PostgreSQL, затем удаление ключа из кэша; +- logout: сначала отметка revoked_at в PostgreSQL, затем в кэш вместо записи о сессии + кладётся отметка «отозвано» (tombstone). Новая запись о сессии кладётся только если ключа + нет (SET NX), поэтому запрос, который прочитал сессию из базы до logout, не сможет + «воскресить» её в кэше после logout; +- поколение кэша: каждая запись о сессии помечена поколением процесса. При любом сбое + Valkey процесс начинает новое поколение и больше не доверяет записям старого. Пока Valkey + был недоступен, logout не мог убрать запись из кэша; после возвращения Valkey эта старая + запись всё ещё лежит там, но она старого поколения, поэтому проверка идёт в PostgreSQL, + а там сессия отозвана -> 401. Отметки «отозвано» действуют в любом поколении: они только + запрещают, а не разрешают; - если Valkey недоступен, его обходят: всё работает напрямую через PostgreSQL. После первого сбоя запросы вообще перестают обращаться к кэшу, а фоновый поток раз в CACHE_RETRY_AFTER_SECONDS проверяет (PING), вернулся ли Valkey. Так ожидание подключения @@ -19,6 +28,7 @@ """ import json import logging +import secrets import threading import time from dataclasses import asdict, dataclass @@ -46,6 +56,8 @@ class SessionCache: self._client = None self._down = False # True = кэш считается недоступным, запросы его не трогают self._lock = threading.Lock() + # Поколение: случайное при старте процесса и новое после каждого сбоя Valkey. + self.generation = secrets.token_hex(8) if url: timeout = config.CACHE_TIMEOUT_MS / 1000 pool = valkey.BlockingConnectionPool.from_url( @@ -67,6 +79,8 @@ class SessionCache: def _failed(self, operation: str, exc: Exception) -> None: with self._lock: + # Новое поколение при КАЖДОЙ ошибке: всё, что лежит в кэше сейчас, больше не доверенное. + self.generation = secrets.token_hex(8) if self._down: # уже знаем о сбое, фоновая проверка уже запущена return self._down = True @@ -81,7 +95,7 @@ class SessionCache: if self.ping(): with self._lock: self._down = False - log.info("Valkey снова доступен: кэш сессий включён") + log.info("Valkey снова доступен: кэш сессий включён (записи до сбоя не используются)") return def get(self, key: bytes) -> dict | None: @@ -94,21 +108,24 @@ class SessionCache: return None return None if raw is None else json.loads(raw) - def set(self, key: bytes, value: dict, ttl_ms: int) -> None: + def add(self, key: bytes, value: dict, ttl_ms: int) -> None: + """Положить запись, только если ключа ещё нет (SET NX): отметку «отозвано» не затираем.""" if not self._available() or ttl_ms < 100: return try: - self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms) + self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms, nx=True) except valkey.ValkeyError as exc: self._failed("set", exc) - def delete(self, key: bytes) -> None: + def mark_revoked(self, key: bytes) -> None: + """Заменить запись о сессии отметкой «отозвано» на SESSION_CACHE_TTL_SECONDS.""" if not self._available(): - return + return # запись в кэше осталась, но после сбоя она старого поколения и не доверенная try: - self._client.delete(self.PREFIX + key.hex()) + self._client.set(self.PREFIX + key.hex(), json.dumps({"revoked": True}), + px=config.SESSION_CACHE_TTL_SECONDS * 1000) except valkey.ValkeyError as exc: - self._failed("delete", exc) + self._failed("set", exc) def ping(self) -> bool: try: @@ -137,30 +154,37 @@ class Sessions: return None token = security.new_token() key = security.token_hash(token) + generation = self.cache.generation expires_at = self.store.create_session(key, user.id, self.ttl_seconds) - self._remember(key, user, expires_at) # write-through: следующий запрос сразу попадёт в кэш + self._remember(key, user, expires_at, generation) # следующий запрос сразу попадёт в кэш return token, ts(expires_at), user def authenticate(self, token: str) -> AuthContext | None: key = security.token_hash(token) + # Поколение запоминаем ДО чтения: если во время запроса случится сбой Valkey, + # то, что мы положим в кэш, окажется старого поколения и доверенным не будет. + generation = self.cache.generation cached = self.cache.get(key) if cached is not None: + if cached.get("revoked"): + return None # logout уже был expires_at = datetime.fromisoformat(cached["expires_at"]) - if expires_at > datetime.now(timezone.utc): + if cached.get("gen") == generation and expires_at > datetime.now(timezone.utc): return AuthContext(User(**cached["user"]), key) - found = self.store.get_session(key) # промах кэша или кэш недоступен -> PostgreSQL + # запись старого поколения или истёкшая -> проверяем по источнику истины + found = self.store.get_session(key) # промах кэша, недоверенная запись или кэш недоступен if found is None: return None user, expires_at = found - self._remember(key, user, expires_at) + self._remember(key, user, expires_at, generation) return AuthContext(user, key) def logout(self, auth: AuthContext) -> None: - self.store.revoke_session(auth.token_hash) # сначала источник истины - self.cache.delete(auth.token_hash) # затем инвалидация кэша + self.store.revoke_session(auth.token_hash) # сначала источник истины + self.cache.mark_revoked(auth.token_hash) # затем инвалидация кэша - def _remember(self, key: bytes, user: User, expires_at: datetime) -> None: + def _remember(self, key: bytes, user: User, expires_at: datetime, generation: str) -> None: left = expires_at - datetime.now(timezone.utc) ttl = min(timedelta(seconds=config.SESSION_CACHE_TTL_SECONDS), left) - self.cache.set(key, {"user": asdict(user), "expires_at": expires_at.isoformat()}, + self.cache.add(key, {"user": asdict(user), "expires_at": expires_at.isoformat(), "gen": generation}, int(ttl.total_seconds() * 1000)) diff --git a/student-tests/cache_revocation.py b/student-tests/cache_revocation.py new file mode 100644 index 0000000..e284e6b --- /dev/null +++ b/student-tests/cache_revocation.py @@ -0,0 +1,51 @@ +"""Отозванный токен не «воскресает» из кэша после возвращения Valkey (замечание к MR). + +Запуск: make failure-valkey-pause + +Сценарий преподавателя: Valkey ставится на паузу (docker compose pause) — процесс жив, +данные в его памяти сохраняются, но он не отвечает. В это время делается logout: PostgreSQL +отзывает сессию, а убрать запись из кэша нельзя. После unpause в кэше всё ещё лежит старая +запись «токен -> пользователь». Она не должна снова пропускать этот токен. +""" +import time + +from helpers import Client, check, compose, run, wait_ready + + +def main(): + api = Client() + alice, bob, _eve, chat = api.bootstrap() + dave = api.user("dave") + for _ in range(2): # запись о сессии dave точно лежит в кэше + api.call("GET", "/api/v1/users/me", actor=dave, schema="User") + + print("pausing valkey (docker compose pause valkey): данные в кэше сохраняются") + compose("pause", "valkey") + try: + api.call("GET", "/api/v1/users/me", actor=dave, schema="User") # этот запрос обнаруживает сбой кэша + api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=dave) + api.call("GET", "/api/v1/users/me", 401, actor=dave) + print("во время паузы: logout -> 204, тот же токен -> 401") + finally: + print("unpausing valkey") + compose("unpause", "valkey") + + wait_ready(api) + # Фоновая проверка возвращает кэш в работу в течение 5 с. Смотрим 12 с — дольше, чем она. + deadline = time.monotonic() + 12 + checks = 0 + while time.monotonic() < deadline: + api.call("GET", "/api/v1/users/me", 401, actor=dave) + api.call("POST", "/api/v1/chats", 401, actor=dave, body={"title": "x", "member_ids": [dave["id"]]}) + checks += 1 + time.sleep(0.5) + print(f"после unpause: {checks} проверок за 12 с, отозванный токен всегда 401 (и GET, и POST)") + + api.call("GET", "/api/v1/users/me", actor=alice, schema="User") + api.message(bob, chat, "после возвращения Valkey") + print("действующие токены других пользователей работают") + print("PASS: revoked session stays revoked after Valkey comes back with stale data") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/test_api.py b/student-tests/test_api.py index 422f20a..834ab5b 100644 --- a/student-tests/test_api.py +++ b/student-tests/test_api.py @@ -140,8 +140,12 @@ class MessengerApiTest(unittest.TestCase): # Курсор правильной формы, но с испорченным временем/UUID: 400, а не ошибка БД (500). import base64 import json - for bad in (["messages:" + chat_a["id"], "not-a-time", str(uuid.uuid4())], - ["messages:" + chat_a["id"], "2026-01-01T00:00:00.000000Z", "not-a-uuid"]): + scope = "messages:" + chat_a["id"] + for bad in ([scope, "not-a-time", str(uuid.uuid4())], + [scope, "2026-01-01T00:00:00.000000Z", "not-a-uuid"], + [scope, "2026-01-01T00:00:00", str(uuid.uuid4())], # без часового пояса + [scope, "0001-01-01T00:00:00+14:00", str(uuid.uuid4())], # в UTC это год 0 + [scope, "9999-12-31T23:59:59-14:00", str(uuid.uuid4())]): # в UTC это год 10000 forged = base64.urlsafe_b64encode(json.dumps(bad).encode()).decode() self.api.call("GET", self.messages_path(chat_a["id"]) + "?cursor=" + forged, 400, actor=self.alice) for limit in ("0", "101", "abc"):