Files

186 lines
9.0 KiB
Python

"""Exercise server failures and network errors in a real browser on a temporary site."""
import json
import logging
import os
import shutil
import tempfile
from pathlib import Path
from unittest.mock import patch
from playwright.sync_api import expect, sync_playwright
from qa_001 import PASSWORD, ROOT, serve
from site_engine.build.pipeline import build_site
from site_engine.services.auth import hash_password
from site_engine.web.app import create_app
class CapturedLogs(logging.Handler):
def __init__(self):
super().__init__()
self.records = []
def emit(self, record):
self.records.append(record)
def main():
out = Path(os.environ.get("QA_ERRORS_OUT", "/tmp/cms-errors-qa"))
out.mkdir(parents=True, exist_ok=True)
checks, errors, dialogs = [], [], []
captured = CapturedLogs()
logger = logging.getLogger("uvicorn.error")
try:
with tempfile.TemporaryDirectory(prefix="cms-errors-") as temp:
work = Path(temp)
site, dist = work / "site", work / "dist"
shutil.copytree(
ROOT / "examples/site-studio", site, ignore=shutil.ignore_patterns(".engine")
)
build_site(site, dist)
live = (dist / "current").resolve()
env = {
"SITE_ROOT": str(site),
"SITE_DIST": str(dist),
"SITE_STATE_DIR": str(work / "state"),
"SITE_ADMIN_LOGIN": "admin",
"SITE_ADMIN_PASSWORD_HASH": hash_password(PASSWORD, n=2**10),
"SITE_SECRET_KEY": "temporary-error-qa-secret-" * 3,
"SITE_COOKIE_SECURE": "0",
"SITE_ADMIN_ORIGIN": "",
"SITE_PREVIEW_ORIGIN": "",
}
with (
patch.dict(os.environ, env),
serve(create_app()) as origin,
sync_playwright() as pw,
):
logger.addHandler(captured) # Uvicorn replaces its handlers on startup.
kind = getattr(pw, os.environ.get("QA_BROWSER", "chromium"))
options = {"headless": True}
if kind.name == "chromium":
options["args"] = ["--no-sandbox", "--no-proxy-server"]
options["channel"] = "chromium"
if kind.name == "firefox":
options["firefox_user_prefs"] = {"network.proxy.type": 0}
if os.environ.get("QA_BROWSER_EXECUTABLE"):
options["executable_path"] = os.environ["QA_BROWSER_EXECUTABLE"]
browser = kind.launch(**options)
page = browser.new_page(viewport={"width": 1440, "height": 960})
page.on(
"pageerror",
lambda e: errors.append({"message": str(e), "stack": e.stack, "url": page.url}),
)
def native(dialog):
dialogs.append(dialog.message)
dialog.dismiss()
page.on("dialog", native)
page.goto(origin + "/admin/login")
page.locator('[name="login"]').fill("admin")
page.locator('[name="password"]').fill(PASSWORD)
page.get_by_role("button", name="Войти", exact=True).click()
page.wait_for_url(origin + "/admin/")
page.goto(origin + "/admin/publish")
with patch(
"site_engine.services.publication.build_site",
side_effect=PermissionError("QA publish denied"),
):
with page.expect_response(
lambda r: r.url.endswith("/admin/publication/build") and r.request.method == "POST"
) as failed:
page.locator('[data-pub-action=candidate]').first.click()
response = failed.value
assert response.status == 500
correlation = response.headers["x-request-id"]
expect(page.locator("#workspace")).to_contain_text("storage_error")
expect(page.locator("#workspace")).to_contain_text(correlation)
toast = page.locator("#request-error")
expect(toast).to_be_visible()
expect(toast).to_contain_text(correlation)
expect(toast).to_contain_text("Ошибка доступа к файлам")
assert (dist / "current").resolve() == live
assert any(
correlation in r.getMessage() and r.exc_info for r in captured.records
)
checks.append(
"publish_500_visible_in_page_and_notification_with_traceback_and_same_request_id"
)
page.screenshot(path=str(out / "publish-error-1440.png"))
page.set_viewport_size({"width": 390, "height": 844})
expect(toast).to_be_visible()
assert toast.bounding_box()["x"] >= 0
page.screenshot(path=str(out / "publish-error-390.png"))
checks.append("persistent_error_notification_at_desktop_and_mobile_widths")
page.set_viewport_size({"width": 1440, "height": 960})
page.goto(origin + "/admin/pages/index")
expect(page.locator("#preview-result iframe")).to_be_visible()
page.locator("[data-editor-mode=expert]").click()
source = page.locator("#document-source")
original = (site / "pages/index.md").read_text()
edited = original + "\nQA unsaved error check\n"
source.fill(edited)
with patch(
"site_engine.services.pages.PageService.save_source",
side_effect=RuntimeError("QA save failure"),
):
with page.expect_response(
lambda r: r.url.endswith("/admin/editor/pages/index/save")
) as failed:
page.get_by_role("button", name="Сохранить документ", exact=True).click()
assert failed.value.status == 500
expect(page.locator("#request-error")).to_contain_text("internal_error")
expect(source).to_have_value(edited)
expect(source).to_be_editable()
assert (site / "pages/index.md").read_text() == original
checks.append("save_500_preserves_exact_unsaved_source_and_releases_editor")
page.route("**/admin/editor/pages/index/save", lambda route: route.abort())
page.get_by_role("button", name="Сохранить документ", exact=True).click()
expect(page.locator("#request-error")).to_contain_text("network_error")
expect(source).to_have_value(edited)
expect(source).to_be_editable()
page.unroute("**/admin/editor/pages/index/save")
checks.append("network_failure_is_visible_and_preserves_unsaved_source")
page.get_by_role("button", name="Сохранить документ", exact=True).click()
page.wait_for_function(
"expected => window.siteDocument?.state?.saved === expected && !window.siteDocument.state.dirty",
arg=edited,
)
assert (site / "pages/index.md").read_text() == edited
assert (dist / "current").resolve() == live
checks.append("save_recovers_after_failure_without_publishing")
page.goto(origin + "/admin/publish")
page.locator('[data-pub-action=candidate]').first.click()
page.locator('[data-publication-root][aria-busy=false]').wait_for()
page.locator('[data-pub-action=publish]').click()
page.locator('#release-comment').fill('Error recovery QA release')
with page.expect_response(
lambda r: r.url.endswith("/admin/publication/activate") and r.request.method == "POST"
) as published:
page.locator('[data-pub-action=confirm-publish]').click()
assert published.value.status == 200
assert (dist / "current").resolve() != live
expect(page.locator("#request-error")).to_be_hidden()
checks.append("publish_recovers_after_failure")
assert not errors, errors
assert not dialogs, dialogs
report = {
"browser": kind.name,
"checks": checks,
"browser_errors": errors,
"native_dialogs": dialogs,
}
(out / "report.json").write_text(
json.dumps(report, ensure_ascii=False, indent=2) + "\n"
)
print(json.dumps(report, ensure_ascii=False))
browser.close()
finally:
logger.removeHandler(captured)
if __name__ == "__main__":
main()