Files
phelex 231490bb7c Make admin and API errors visible and traceable
Return structured JSON errors with request IDs, log unexpected exceptions with tracebacks, and show HTTP and network failures in the admin UI without losing unsaved source.

Preserve publication errors when release listing also fails, handle cancelled preview promises, and add regression tests, browser failure scenarios, and updated API documentation.
2026-11-13 09:55:55 +03:00

450 lines
21 KiB
Python

"""Real FastAPI contract and HTML -> ASGI client -> API integration."""
import os
from unittest.mock import patch
from fastapi.testclient import TestClient
from helpers import SiteTestCase
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
class ApiTests(SiteTestCase):
@classmethod
def setUpClass(cls):
cls.password = "temporary test password"
cls.password_hash = hash_password(cls.password, n=2**10)
def setUp(self):
super().setUp()
self.env = patch.dict(
os.environ,
{
"SITE_ROOT": str(self.site),
"SITE_DIST": str(self.out),
"SITE_STATE_DIR": str(self.tmp / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": self.password_hash,
"SITE_SECRET_KEY": "test-api-secret-" * 4,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
},
)
self.env.start()
self.addCleanup(self.env.stop)
self.app = create_app()
self.client = TestClient(self.app)
self.addCleanup(self.client.close)
self.cookie = self.app.state.auth.login("admin", self.password, "testclient")
self.client.cookies.set("se_session", self.cookie)
self.principal = self.app.state.auth.authenticate(self.cookie)
self.csrf = self.app.state.auth.csrf_token(self.principal)
self.app.state.api_credentials["test-credential"] = (self.cookie, "testclient")
self.headers = {"Authorization": "Bearer test-credential"}
def api(self, method, path, data=None, headers=None):
return self.client.request(
method, "/admin/api/v1" + path, json=data, headers=headers or self.headers
)
def source(self):
return self.api("GET", "/pages/index/source").json()
def test_unexpected_publish_error_has_json_code_request_id_and_traceback(self):
with (
patch("site_engine.web.api.routes.publish", side_effect=RuntimeError("publish probe")),
self.assertLogs("uvicorn.error", level="ERROR") as captured,
):
response = self.api("POST", "/publish")
self.assertEqual(response.status_code, 500)
detail = response.json()["error"]
self.assertEqual(detail["code"], "internal_error")
self.assertTrue(detail["message"])
self.assertRegex(detail["request_id"], r"^[a-f0-9]{32}$")
self.assertEqual(response.headers["x-request-id"], detail["request_id"])
self.assertIn("no-store", response.headers["cache-control"])
self.assertNotIn("publish probe", response.text)
output = "\n".join(captured.output)
self.assertIn(detail["request_id"], output)
self.assertIn("POST", output)
self.assertIn("/admin/api/v1/publish", output)
self.assertIn("RuntimeError: publish probe", output)
self.assertTrue(any(record.exc_info for record in captured.records))
self.assertNotIn(self.password, output)
self.assertNotIn("test-credential", output)
def test_real_publish_storage_failure_reaches_html_and_logs(self):
# A file instead of the release directory causes a real filesystem failure on every OS.
self.out.write_text("occupied by a file")
with self.assertLogs("uvicorn.error", level="ERROR") as captured:
response = self.client.post(
"/admin/publish",
data={"csrf": self.csrf},
headers={"Origin": "http://testserver", "HX-Request": "true", "HX-Boosted": "true"},
)
self.assertEqual(response.status_code, 500)
self.assertEqual(response.headers["x-error-code"], "storage_error")
self.assertEqual(response.headers["x-admin-error"], "1")
self.assertIn("Ошибка доступа к файлам", response.text)
self.assertIn(response.headers["x-request-id"], response.text)
self.assertIn(response.headers["x-request-id"], "\n".join(captured.output))
self.assertIn("FileExistsError", "\n".join(captured.output))
self.assertEqual(self.out.read_text(), "occupied by a file")
def test_publish_error_keeps_original_error_if_release_listing_also_fails(self):
from site_engine.web.admin.api_client import AdminApi, ApiError
original = AdminApi.call
async def failing(api, method, path, data=None):
if path == "/publish":
raise ApiError(
500, {"error": {"code": "publish_failed", "message": "Publish failure"}}
)
if path == "/releases" and getattr(api, "listed", False):
raise ApiError(
500, {"error": {"code": "list_failed", "message": "Listing failure"}}
)
if path == "/releases":
api.listed = True
return await original(api, method, path, data)
with patch.object(AdminApi, "call", failing):
response = self.client.post(
"/admin/publish", data={"csrf": self.csrf}, headers={"Origin": "http://testserver"}
)
self.assertEqual(response.status_code, 500)
self.assertIn("Publish failure", response.text)
self.assertNotIn("Listing failure", response.text)
self.assertIn("Список релизов недоступен", response.text)
self.assertEqual(response.headers["x-error-code"], "publish_failed")
def test_validation_and_http_errors_include_correlation(self):
for response in (
self.api("POST", "/pages", {}),
self.api("DELETE", "/publish"),
self.api("GET", "/preview/" + "a" * 32 + "/html"),
self.client.get("/admin/api/v1/site"),
):
self.assertGreaterEqual(response.status_code, 400)
detail = response.json()["error"]
self.assertTrue(detail["code"])
self.assertTrue(detail["message"])
self.assertEqual(response.headers["x-request-id"], detail["request_id"])
def test_unexpected_login_error_is_visible_and_logged(self):
with (
patch.object(self.app.state.auth, "login", side_effect=RuntimeError("login probe")),
self.assertLogs("uvicorn.error", level="ERROR") as captured,
):
response = self.client.post(
"/admin/login",
data={"login": "admin", "password": self.password},
headers={"Origin": "http://testserver"},
)
self.assertEqual(response.status_code, 500)
self.assertIn("internal_error", response.text)
self.assertIn(response.headers["x-request-id"], response.text)
self.assertIn("RuntimeError: login probe", "\n".join(captured.output))
self.assertNotIn(self.password, "\n".join(captured.output))
def test_fragment_names_and_descriptions_reach_catalog_through_api(self):
fragments = self.source()["schema"]["fragments"]
expected = {
"collection_list": ("Список коллекций", "Карточки, получаемые из collection"),
"section": ("Текстовая секция", "Заголовок и содержимое секции"),
"richtext": ("Markdown body", "Выводит Markdown из файла страницы"),
"card_grid": ("Карточки", "Сетка преимуществ"),
}
html = self.client.get("/admin/pages/index").text
from html.parser import HTMLParser
class Catalog(HTMLParser):
def __init__(self):
super().__init__()
self.items, self.current = {}, None
def handle_starttag(self, tag, attrs):
attrs = dict(attrs)
if tag == "button" and "data-fragment" in attrs:
self.current = attrs["data-fragment"]
self.items[self.current] = []
def handle_data(self, data):
if self.current:
self.items[self.current].append(data)
def handle_endtag(self, tag):
if tag == "button":
self.current = None
catalog = Catalog()
catalog.feed(html)
for fid, (name, description) in expected.items():
self.assertEqual(fragments[fid]["name"], name)
self.assertEqual(fragments[fid]["description"], description)
text = " ".join(catalog.items[fid])
self.assertIn(name, text)
self.assertIn(description, text)
def test_json_html_and_openapi_separate(self):
self.assertEqual(self.client.get("/admin/api/v1/site").status_code, 401)
data = self.api("GET", "/site")
self.assertEqual(data.status_code, 200)
self.assertIn("pages", data.json())
self.assertEqual(data.headers["cache-control"], "no-store")
schema = self.client.get("/admin/api/openapi.json")
self.assertEqual(schema.status_code, 200)
self.assertIn("/admin/api/v1/pages/{identity}/save", schema.json()["paths"])
self.assertIn("Transform", schema.json()["components"]["schemas"])
self.assertIn("InternalUiSession", schema.json()["components"]["securitySchemes"])
self.client.cookies.clear()
self.assertEqual(self.client.get("/admin/api/openapi.json").status_code, 401)
self.assertEqual(self.client.get("/admin/api/docs").status_code, 401)
def test_html_uses_client_and_removes_request_credentials(self):
before = self.app.state.api_calls
response = self.client.get("/admin/pages/index")
self.assertEqual(response.status_code, 200)
self.assertIn("document-editor", response.text)
self.assertGreater(self.app.state.api_calls, before)
self.assertEqual(set(self.app.state.api_credentials), {"test-credential"})
self.assertNotIn("test-credential", response.text)
self.assertNotIn("Bearer ", response.text)
with patch(
"site_engine.web.admin.api_client.AdminApi.call",
side_effect=__import__(
"site_engine.web.admin.api_client", fromlist=["ApiError"]
).ApiError(503, {"error": {"message": "Unavailable"}}),
):
response = self.client.get("/admin/pages")
self.assertEqual(response.status_code, 503)
self.assertIn("Unavailable", response.text)
def test_buffer_validate_transform_save_and_conflict(self):
s = self.source()
payload = {"source": s["source"], "etag": s["etag"], "revision": 7}
transformed = self.api(
"POST",
"/pages/index/transform",
dict(payload, action={"type": "metadata", "values": {"title": "API buffer"}}),
)
self.assertEqual(transformed.status_code, 200, transformed.text)
t = transformed.json()
self.assertEqual(t["etag"], s["etag"])
self.assertEqual(self.source()["source"], s["source"])
saved = self.api("POST", "/pages/index/save", dict(payload, source=t["source"]))
self.assertEqual(saved.status_code, 200, saved.text)
conflict = self.api("POST", "/pages/index/save", payload)
self.assertEqual(conflict.status_code, 409)
e = conflict.json()["error"]
self.assertEqual(e["current"]["source"], t["source"])
self.assertEqual(e["submitted"]["source"], s["source"])
self.assertEqual(e["submitted"]["etag"], s["etag"])
def test_typed_actions_and_error_envelopes(self):
s = self.source()
payload = {"source": s["source"], "etag": s["etag"]}
for action in (
{"type": "unimplemented"},
{"type": "move", "block_id": "b_hero", "direction": "up", "before": "b_hero"},
):
response = self.api("POST", "/pages/index/transform", dict(payload, action=action))
self.assertEqual(response.status_code, 422)
self.assertIn("error", response.json())
bad = self.api(
"POST", "/pages/index/validate", dict(payload, source="---\na: 1\na: 2\n---\n")
)
self.assertEqual(bad.status_code, 422)
self.assertIsNone(bad.json()["error"]["buffer"]["model"])
self.assertEqual(self.api("GET", "/pages/missing/source").status_code, 404)
self.assertEqual(self.api("GET", "/assets/..%2f..%2fsite.yaml").status_code, 403)
def test_builder_catalog_duplicate_and_metadata_use_the_same_contract(self):
s = self.source()
payload = {"source": s["source"], "etag": s["etag"], "revision": 4}
added = self.api(
"POST",
"/pages/index/transform",
dict(
payload,
action={
"type": "add",
"fragment": "hero",
"region": "main",
"props": {"title": "Catalog"},
},
),
)
self.assertEqual(added.status_code, 200, added.text)
block = added.json()["model"]["meta"]["regions"]["main"][-1]
self.assertRegex(block["id"], r"^hero_[a-z0-9]{5}$")
duplicate = self.api(
"POST",
"/pages/index/transform",
dict(
payload,
source=added.json()["source"],
action={"type": "duplicate", "block_id": block["id"]},
),
)
self.assertEqual(duplicate.status_code, 200, duplicate.text)
blocks = duplicate.json()["model"]["meta"]["regions"]["main"]
self.assertNotEqual(blocks[-1]["id"], block["id"])
self.assertRegex(blocks[-1]["id"], r"^hero_[a-z0-9]{5}$")
self.assertEqual(blocks[-1]["props"], block["props"])
response = self.client.post(
"/admin/editor/pages/index/transform",
data={
**payload,
"csrf": self.csrf,
"operation": "metadata",
"title": "Changed title",
"status": "published",
"seo_title": "Real SEO title",
"seo_description": "Description",
},
headers={"Origin": "http://testserver", "HX-Request": "true"},
)
self.assertEqual(response.status_code, 200, response.text[:1000])
self.assertIn("Real SEO title", response.text)
self.assertEqual(self.source()["source"], s["source"])
def test_nested_create_entry_and_publish_rollback(self):
result = self.api("POST", "/pages", {"id": "nested/api", "title": "Nested API"})
self.assertEqual(result.status_code, 201, result.text)
self.assertEqual(self.api("GET", "/pages/nested/api/source").status_code, 200)
self.assertEqual(
self.api("POST", "/collections/services/entries", {"id": "api-draft"}).status_code, 201
)
e = self.api("GET", "/collections/services/entries/bots/source").json()
self.assertEqual(e["kind"], "entry")
result = self.api("POST", "/publish")
self.assertEqual(result.status_code, 200, result.text)
build = result.json()["current"]
self.assertEqual(self.api("POST", "/rollback/" + build).status_code, 200)
def test_epoch_revokes_api_credentials(self):
self.app.state.auth.logout(self.principal)
self.assertEqual(self.api("GET", "/site").status_code, 401)
def test_pages_comparison_and_html_creation_preserve_list_selection(self):
self.assertEqual(len(self.api("GET", "/pages?changed=true").json()), 5)
self.assertEqual(self.api("POST", "/publish").status_code, 200)
rows = self.api("GET", "/pages?changed=true").json()
self.assertEqual([p["id"] for p in rows], ["drafts/next"])
self.assertEqual(self.client.get("/admin/pages?selected=missing").status_code, 404)
payload = {
"csrf": self.csrf,
"title": "Nested draft",
"page_id": "nested/ui",
"layout": "default",
}
response = self.client.post(
"/admin/pages/new",
data=payload,
headers={"Origin": "http://testserver"},
follow_redirects=False,
)
self.assertEqual(response.status_code, 303, response.text)
self.assertEqual(
response.headers["location"], "/admin/pages?selected=nested%2Fui&msg=created"
)
response = self.client.post(
"/admin/pages/new", data=payload, headers={"Origin": "http://testserver"}
)
self.assertEqual(response.status_code, 409, response.text[:500])
self.assertIn("open data-auto-open", response.text)
self.assertIn("value='Nested draft'", response.text)
def test_html_csrf_and_full_form_save(self):
s = self.source()
response = self.client.post(
"/admin/editor/pages/index/save",
data={"source": s["source"], "etag": s["etag"], "csrf": self.csrf},
)
self.assertEqual(response.status_code, 403)
source = s["source"].replace("title:", "# preserved\ntitle:", 1)
response = self.client.post(
"/admin/editor/pages/index/save",
data={"source": source, "etag": s["etag"], "csrf": self.csrf},
headers={"Origin": "http://testserver"},
)
self.assertEqual(response.status_code, 200, response.text[:1000])
self.assertEqual(self.source()["source"], source)
response = self.client.post(
"/admin/editor/pages/index/save",
data={"source": s["source"], "etag": s["etag"], "csrf": self.csrf},
headers={"Origin": "http://testserver", "HX-Request": "true"},
)
self.assertEqual(response.status_code, 409)
self.assertIn("data-rebase", response.text)
self.assertIn("Серверный исходник", response.text)
def test_ui_assets_are_binary_and_protected(self):
self.write("assets/new.svg", '<svg xmlns="http://www.w3.org/2000/svg"/>')
response = self.client.get("/admin/preview/assets/new.svg")
self.assertEqual(response.status_code, 200)
self.assertIn("image/svg+xml", response.headers["content-type"])
self.client.cookies.clear()
self.assertEqual(
self.client.get("/admin/preview/assets/new.svg", follow_redirects=False).status_code,
303,
)
def test_planned_routes_filters_and_readonly_inspector(self):
self.assertEqual(self.api("GET", "/collections").status_code, 200)
self.assertEqual(self.api("GET", "/pages?q=no-such-document").json(), [])
self.assertEqual(self.api("GET", "/pages?status=unknown").status_code, 422)
self.assertEqual(self.api("GET", "/entries/services").status_code, 200)
s = self.api("GET", "/editor/pages/index/source").json()
self.assertEqual(s["kind"], "page")
response = self.api(
"POST",
"/editor/pages/index/validate",
{"source": s["source"], "etag": s["etag"], "revision": 2},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.client.get("/admin/api/v1/openapi.json").status_code, 200)
self.assertEqual(self.client.get("/admin/api/v1/docs").status_code, 200)
import json
response = self.client.post(
"/admin/editor/pages/index/select",
data={
"source": s["source"],
"etag": s["etag"],
"csrf": self.csrf,
"readonly": json.dumps({"scope": "layout", "owner": "default", "id": "lh_header"}),
},
headers={"Origin": "http://testserver", "HX-Request": "true"},
)
self.assertEqual(response.status_code, 200)
self.assertIn("data-readonly-inspector", response.text)
self.assertIn("site_header", response.text)
def test_incomplete_preview_configuration_keeps_editor_available(self):
with patch.dict(
os.environ, {"SITE_ADMIN_ORIGIN": "http://127.0.0.1:8000", "SITE_PREVIEW_ORIGIN": ""}
):
app = create_app()
self.assertIsNone(app.state.previews.config)
self.assertTrue(app.state.previews.unavailable_reason)
def test_limits_and_forged_credentials_keep_error_contract(self):
response = self.api("GET", "/site", headers={"Authorization": "Bearer forged"})
self.assertEqual(response.status_code, 401)
self.assertIn("error", response.json())
response = self.client.post(
"/admin/api/v1/pages/index/validate", content=b"x" * 1048577, headers=self.headers
)
self.assertEqual(response.status_code, 413)
self.assertEqual(response.json()["error"]["code"], "body_too_large")
response = self.api("GET", "/site", headers={**self.headers, "HX-Request": "true"})
self.assertIn("application/json", response.headers["content-type"])
response = self.client.get("/admin/pages/index?mode=expert")
self.assertEqual(response.status_code, 200)
self.assertIn("name='mode' value='expert'", response.text)