Files
ArtyomandClaude Opus 5.5 a59e3a39a8 Carry over the lab 2 fixes made after 8cddb09
Brings the system changes of lab 2 from 8cddb09..102579e onto the lab 3
code, resolving each conflict by meaning:

- the request pipeline counts the body bytes actually received, so a
  chunked body over the limit gets 413 instead of reaching the app;
- logout revokes through a SessionRevocations port and withdraws the
  mark when PostgreSQL rejects the delete, so 503 means the session
  still works; PostgresSessionDirectory loses its no-op invalidate;
- an empty cursor is 400 on history and on the chat list;
- EventBus.project and the test that allowed importing an event across
  zones are gone, the config rules speak of the schema foreign key;
- the worker waits one second less than the rest of the shutdown
  budget, so it cancels a stuck request with 500 and exits 0 instead
  of being killed by the gunicorn master. Lab 3 keeps 3 s after the
  drain window for the database timeouts, so SHUTDOWN_TIMEOUT_SECONDS
  becomes 6 s and the stop hooks wait 7 s, still under the 8 s grace;
- the lab 3 single statement post already locks the chat only for a
  member, so lab 2's LOCK_CHAT edit is not needed; its test is kept;
- lab 2 tests come along with Idempotency-Key where lab 3 needs it;
  the short TTL after restart runs without api-shortttl by shortening
  the session in the database; test_drain adds a stuck request;
- make validate uses .venv with openapi-spec-validator, PYTEST_ARGS,
  faults-evidence, down with the bench profile, the image is tagged by
  the compose project, start probes every 200 ms, cache evidence fails
  without a tombstone and checks the key expiry, kdf.txt shows the
  seed stub apart.

The track 2 tooling of lab 2 (track.py, postgres-restore and the
database argument of migrate) and its evidence scripts stay out.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
2026-10-30 02:32:49 +03:00

172 lines
6.5 KiB
Python

import json
import time
from collections.abc import AsyncIterator
from uuid import uuid4
from httpx import ASGITransport, AsyncClient
from conftest import (
PASSWORD,
actor,
keyed,
make_chat,
new_user,
register,
running_app,
split_settings,
)
from messenger.main import create_app
MARKER_TEXT = "маркер-который-не-должен-попасть-в-логи-9f3a"
async def test_health_needs_no_identity(client: AsyncClient) -> None:
for path in ("/health/live", "/health/ready"):
response = await client.get(path)
assert response.status_code == 200
assert response.json() == {"status": "ok"}
assert response.headers["X-Request-Id"]
async def test_every_response_carries_request_id(client: AsyncClient) -> None:
alice = await register(client, "alice")
probes = [
await client.get("/health/live"),
await client.get("/api/v1/users/me", headers=actor(alice)),
await client.get("/api/v1/users/me"),
await client.get(f"/api/v1/chats/{uuid4()}", headers=actor(alice)),
await client.get("/api/v1/unknown-path"),
]
assert all(probe.headers.get("X-Request-Id") for probe in probes)
async def test_client_request_id_is_preserved(client: AsyncClient) -> None:
response = await client.get("/health/live", headers={"X-Request-Id": "trace-42"})
assert response.headers["X-Request-Id"] == "trace-42"
async def test_unknown_public_route_is_404(client: AsyncClient) -> None:
response = await client.get("/nothing-here")
assert response.status_code == 404
assert response.json()["error"]["code"] == "not_found"
async def test_unknown_protected_route_needs_identity(client: AsyncClient) -> None:
anonymous = await client.get("/api/v1/unknown-path")
assert anonymous.status_code == 401
assert set(anonymous.json()["error"]) == {"code", "message", "request_id"}
alice = await register(client, "alice")
identified = await client.get("/api/v1/unknown-path", headers=actor(alice))
assert identified.status_code == 404
async def test_method_not_allowed_is_hidden(client: AsyncClient) -> None:
response = await client.delete("/health/live")
assert response.status_code == 404
assert response.json()["error"]["code"] == "not_found"
async def test_logs_do_not_contain_message_text(capsys) -> None:
app = create_app(**split_settings(log_level="INFO"))
async with (
app.router.lifespan_context(app),
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
):
alice = await register(http, "alice")
chat = await make_chat(http, alice)
response = await http.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": MARKER_TEXT},
headers=keyed(alice),
)
assert response.status_code == 201
captured = capsys.readouterr()
assert MARKER_TEXT not in captured.out
assert MARKER_TEXT not in captured.err
assert alice["display_name"] not in captured.out
assert any("request.handled" in line for line in captured.out.splitlines())
async def test_log_lines_are_json(capsys) -> None:
app = create_app(**split_settings(log_level="INFO"))
async with (
app.router.lifespan_context(app),
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
):
await http.get("/health/live")
for line in capsys.readouterr().out.splitlines():
record = json.loads(line)
assert {"ts", "level", "event"} <= set(record)
async def test_body_limit_returns_413() -> None:
app = create_app(**split_settings(max_body_bytes=4096))
async with (
app.router.lifespan_context(app),
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
):
response = await http.post("/api/v1/users", content=b"x" * 5000)
assert response.status_code == 413
assert response.json()["error"]["code"] == "payload_too_large"
async def test_chunked_body_is_limited_too() -> None:
async def chunks(body: bytes) -> AsyncIterator[bytes]:
for start in range(0, len(body), 1000):
yield body[start : start + 1000]
user = json.dumps(new_user("chunked")).encode()
async with running_app(max_body_bytes=4096) as http:
large = await http.post("/api/v1/users", content=chunks(b"x" * 5000))
small = await http.post(
"/api/v1/users", content=chunks(user), headers={"Content-Type": "application/json"}
)
assert "content-length" not in large.request.headers
assert large.status_code == 413
assert large.json()["error"]["code"] == "payload_too_large"
assert small.status_code == 201
async def test_ready_turns_unavailable_without_database() -> None:
async with running_app(database_url="postgresql://u:p@127.0.0.1:1/none") as http:
started = time.perf_counter()
ready = await http.get("/health/ready")
live = await http.get("/health/live")
elapsed = time.perf_counter() - started
assert ready.status_code == 503
assert ready.json()["error"]["code"] == "unavailable"
assert live.status_code == 200
assert elapsed < 2
async def test_protected_request_is_503_not_401_without_database() -> None:
async with running_app(database_url="postgresql://u:p@127.0.0.1:1/none") as http:
response = await http.get(
"/api/v1/users/me", headers={"Authorization": "Bearer " + "x" * 43}
)
assert response.status_code == 503
assert response.json()["error"]["code"] == "unavailable"
assert response.json()["error"]["request_id"] == response.headers["X-Request-Id"]
async def test_state_survives_new_process() -> None:
async with running_app() as http:
alice = await register(http, "alice")
chat = await make_chat(http, alice)
async with running_app() as http:
me = await http.get("/api/v1/users/me", headers=actor(alice))
listed = await http.get("/api/v1/chats?limit=100", headers=actor(alice))
assert me.json() == alice
assert [item["id"] for item in listed.json()["items"]] == [chat["id"]]
async def test_logs_do_not_contain_credentials(capsys) -> None:
async with running_app(log_level="INFO") as http:
alice = await register(http, "secret")
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200
output = capsys.readouterr()
captured = output.out + output.err
assert PASSWORD not in captured
assert actor(alice)["Authorization"].split()[1] not in captured
assert "audit.session_opened" in captured