Files
mtusi2026lab2/student-tests/api/test_operability.py
T
ArtyomandClaude Opus 5.5 7bf28fc6ed Make message posts idempotent with Idempotency-Key
POST /api/v1/chats/{chat_id}/messages now requires the header, checked
at the HTTP boundary (1-128 of [A-Za-z0-9._:-], else 400). The handler
keeps the lab 2 order under the chat row lock: membership, then text,
then the receipt for (chat, sender, key) younger than
IDEMPOTENCY_TTL_SECONDS. A receipt with the same fingerprint replays
the stored message, a different one is 409 conflict; without a
receipt one statement inserts the message, the key row and the chat
mark, so both commit or neither does. Concurrent retries wait on the
same row lock and then read the committed receipt. The fingerprint is
SHA-256 of the canonical JSON of the parsed body, so layout does not
matter, and only 201 answers are ever stored.

A lock timeout now counts as a dependency failure and answers 503
instead of 500, so a retry with the same key is safe.

Own tests cover replay, a different layout of the same JSON, conflict,
missing and malformed keys, rejected attempts that leave the key free,
scope by user and chat, revalidation after logout and for outsiders,
expiry, and eight concurrent retries through two app instances
sharing one PostgreSQL. Every earlier message post sends a fresh key.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 11:36:15 +03:00

145 lines
5.7 KiB
Python

import json
import time
from uuid import uuid4
from httpx import ASGITransport, AsyncClient
from conftest import PASSWORD, actor, keyed, make_chat, 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_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