forked from mtusi2026/mtusi2026lab3
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
172 lines
6.5 KiB
Python
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
|