From 58cc8090a9030f65ad5440ee52f640e1596ac6bf Mon Sep 17 00:00:00 2001 From: Alexey Dudin Date: Wed, 11 Nov 2026 18:43:40 +0300 Subject: [PATCH] Update with last fixes --- .dockerignore | 12 + .env.example | 18 ++ .gitignore | 5 +- Dockerfile | 9 +- README.md | 51 +++- pyproject.toml | 2 +- src/.env.example | 11 - src/site_engine/build/__init__.py | 1 + src/site_engine/build/pipeline.py | 252 ++++++++++++++++++ src/site_engine/core/registry.py | 2 +- src/site_engine/services/auth.py | 39 ++- src/site_engine/web/admin/handlers.py | 8 +- src/site_engine/web/admin/routes.py | 13 +- .../web/admin/templates/dashboard.html.j2 | 1 + src/site_engine/web/app.py | 44 ++- src/site_engine/web/config.py | 59 ++++ src/site_engine/web/static_site.py | 45 ++++ tests/test_admin_handlers.py | 11 +- tests/test_admin_routes_wiring.py | 17 ++ tests/test_auth.py | 16 ++ tests/test_config.py | 50 ++++ tests/test_packaging.py | 54 ++++ tests/test_repo_hygiene.py | 113 ++++++++ tests/test_static_site.py | 49 ++++ 24 files changed, 832 insertions(+), 50 deletions(-) create mode 100644 .dockerignore create mode 100644 .env.example delete mode 100644 src/.env.example create mode 100644 src/site_engine/build/__init__.py create mode 100644 src/site_engine/build/pipeline.py create mode 100644 src/site_engine/web/config.py create mode 100644 src/site_engine/web/static_site.py create mode 100644 tests/test_config.py create mode 100644 tests/test_packaging.py create mode 100644 tests/test_repo_hygiene.py create mode 100644 tests/test_static_site.py diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..dafd84e --- /dev/null +++ b/.dockerignore @@ -0,0 +1,12 @@ +# секреты и мусор не должны попадать в контекст сборки образа +.env +.env.* +!.env.example +/build/ +/dist/ +*.egg-info/ +__pycache__/ +.engine/ +.pytest_cache/ +/tests/ +/docs/ diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..c709a23 --- /dev/null +++ b/.env.example @@ -0,0 +1,18 @@ +# Формат: одна переменная на строку, БЕЗ кавычек и БЕЗ комментариев в конце строки. +# `docker run --env-file` не снимает кавычки и не вырезает «# …» после значения: они станут частью значения. +# Знаки `$` в хеше пароля экранировать не нужно. +# +# Хеш пароля: docker run --rm -it site-engine site-engine hash-password +# Ключ сессий: docker run --rm site-engine site-engine gen-secret (не короче 32 символов) +SITE_ADMIN_LOGIN=admin +SITE_ADMIN_PASSWORD_HASH= +SITE_SECRET_KEY= + +# Cookie с флагом Secure браузер примет только по https и на http://localhost. +# Если открываете админку по http с другого адреса (http://192.168.1.10:8181), поставьте 0. +SITE_COOKIE_SECURE=1 +SITE_SESSION_HOURS=8 + +# Пути НЕ задавайте при запуске в Docker: в образе они уже указывают внутрь тома /data +# (SITE_ROOT=/data/site, SITE_DIST=/data/dist, SITE_STATE_DIR=/data/state). +# Для запуска без Docker: SITE_ROOT=examples/studio-site SITE_DIST=dist diff --git a/.gitignore b/.gitignore index e9fa106..3df0a97 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,9 @@ __pycache__/ *.pyc +.env .venv/ -dist/ -build/ +/dist/ +/build/ *.egg-info/ .engine/ *.sqlite3 diff --git a/Dockerfile b/Dockerfile index deb7a0a..461b534 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,10 +1,11 @@ -# M2+: образ для админки, форм и MCP. Статику в production отдаёт nginx из тома dist/. +# Один том /data: data/site (контент), data/dist (опубликованное), data/state (вход и аудит). +# Статику в production лучше отдавать nginx из data/dist/current. FROM python:3.12-slim WORKDIR /app COPY pyproject.toml README.md ./ COPY src ./src -RUN pip install --no-cache-dir ".[server,mcp]" -ENV SITE_ROOT=/data/site SITE_DIST=/data/dist SITE_DB=/data/db/engine.sqlite3 -VOLUME ["/data/site", "/data/dist", "/data/db"] +RUN pip install --no-cache-dir ".[server,mcp]" && mkdir -p /data/site /data/dist /data/state +ENV SITE_ROOT=/data/site SITE_DIST=/data/dist SITE_STATE_DIR=/data/state +VOLUME ["/data"] EXPOSE 8000 CMD ["uvicorn", "site_engine.web.app:create_app", "--factory", "--host", "0.0.0.0", "--port", "8000"] diff --git a/README.md b/README.md index 3c17f86..5c41c49 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ site-engine/ ├── docs/ # ТЗ, ревью, журнал решений ├── examples/studio-site/ # сайт-пример из SiteMap.md (услуги, формы, коллекция, редирект) ├── .env.example # переменные окружения для админки -├── tests/ # 178 тестов: ядро, сборка, безопасность, запись, вход и редактор +├── tests/ # 206 тестов: ядро, сборка, безопасность, запись, вход и редактор └── src/site_engine/ ├── cli.py # validate · build · preview · fragments ├── errors.py # Issue/Report: код, путь к полю, серьёзность, подсказка @@ -50,6 +50,53 @@ site-engine/ └── mcp/ # перечень инструментов MVP (M3) ``` +## Запуск в Docker + +Один том `/data`, в нём три каталога. Всё, что важно сохранить, лежит на хосте в `./data`. + +| На хосте | В контейнере | Что это | +|---|---|---| +| `data/site` | `/data/site` | Ваш сайт: `site.yaml`, `pages/`, `content/`, фрагменты. Его правит редактор | +| `data/dist` | `/data/dist` | Опубликованные релизы и симлинк `current` | +| `data/state` | `/data/state` | Состояние входа и журнал `audit.jsonl` | + +```bash +docker build -t site-engine . +docker run --rm -it site-engine site-engine hash-password # спросит пароль, напечатает хеш +docker run --rm site-engine site-engine gen-secret # ключ подписи сессий +cp .env.example .env # впишите хеш и ключ + +mkdir -p data && cp -r examples/studio-site data/site # или положите свой сайт в data/site +docker run -d --name site-engine -p 8181:8000 --env-file .env -v "$PWD/data:/data" site-engine +``` + +Админка: `http://localhost:8181/admin/` (на обзоре сверху показаны абсолютные пути, которыми пользуется приложение), опубликованный сайт: `http://localhost:8181/`. Проверка того, что видит контейнер: + +```bash +docker logs site-engine # строка «site-engine: site=/data/site, dist=/data/dist, state=/data/state, admin=on» +docker exec site-engine env | grep '^SITE_' # SITE_ROOT, SITE_DIST, SITE_STATE_DIR должны начинаться с /data/ +``` + +Если вместо `/data/...` там относительные пути (`examples/studio-site`, `dist`), эти строки остались в вашем `.env` от старой версии: удалите `SITE_ROOT`, `SITE_DIST`, `SITE_STATE_DIR` из `.env`, так как значения из `--env-file` перекрывают значения из образа. При старте приложение само пишет об этом предупреждение. + +Правила для `.env` при `docker run --env-file`: + +- **Без кавычек.** Docker не снимает их, они станут частью значения. +- **Без комментариев в конце строки.** `KEY=value # текст` даёт значение «value # текст». +- **Знак `$` в хеше экранировать не нужно.** (Для `docker compose` и его `.env` его нужно удваивать: `$$`.) + +Приложение проверяет эти значения строго: хеш, ключ, логин, флаг Secure и host с лишними символами не принимаются молча, `/admin/` не включается, а в `docker logs` пишется причина. + +| Симптом | Причина | +|---|---| +| `/admin/` даёт 404 | Не заданы `SITE_ADMIN_PASSWORD_HASH` и `SITE_SECRET_KEY`, ключ короче 32 символов или в значении кавычки или комментарий; причина в `docker logs`: «админка отключена: …» | +| «Сайт не загружен» на обзоре | В `data/site` нет `site.yaml` или том не смонтирован; на обзоре виден абсолютный путь, который проверял движок | +| Опубликованного сайта нет на хосте | Том не смонтирован (`-v "$PWD/data:/data"`): релизы лежат внутри контейнера и пропадут вместе с ним | +| После ввода пароля снова страница входа | Cookie с флагом Secure не принимается по `http://` с адреса не `localhost`: поставьте `SITE_COOKIE_SECURE=0` | +| Ответ 422 с `"loc": ["query","request"]` | Образ собран из версии до исправления: пересоберите `docker build` | + +Контейнер работает от root, поэтому файлы в `data/` на Linux будут принадлежать root. Чтобы этого избежать, добавьте `--user "$(id -u):$(id -g)"`. + ## Вход в админку Самый простой вариант: **один администратор, без ролей**, логин и хеш пароля задаются переменными окружения, БД для входа не нужна. @@ -120,7 +167,7 @@ SITE_COOKIE_SECURE=0 uvicorn site_engine.web.app:create_app --factory --env-file ## Что проверено, а что нет -Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, `editor.py`, `forms.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 178 тестами, включая сквозные через HTML-формы. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp). +Тесты и сборка примера выполнялись в окружении без сети: ядро (`core/`, `build/`, `parsing/`, `storage/`, `services/`) и вся логика админки (`web/admin/handlers.py`, `editor.py`, `forms.py`, шаблоны, вход, CSRF, заголовки) запущены и покрыты 206 тестами, включая сквозные через HTML-формы. Тонкий FastAPI-адаптер `web/admin/routes.py` проверен на подставном модуле `fastapi`, а `web/app.py`, `db/`, `mcp/` и `Dockerfile` только компиляцией и чтением: FastAPI, SQLAlchemy и MCP SDK в окружении не было. Ядро намеренно не зависит от pydantic: ошибки должны нести путь к полю (`pages/index.md:regions.main[b_hero].props.title`), а валидация задаётся манифестами фрагментов. Pydantic нужен на границах API (web, mcp). ## Соответствие журналу решений diff --git a/pyproject.toml b/pyproject.toml index 13d6786..e4e1080 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,7 +36,7 @@ site-engine = "site_engine.cli:main" where = ["src"] [tool.setuptools.package-data] -site_engine = ["builtin/**/*"] +site_engine = ["builtin/**/*", "web/admin/templates/*", "web/admin/static/*"] [tool.pytest.ini_options] testpaths = ["tests"] diff --git a/src/.env.example b/src/.env.example deleted file mode 100644 index 8e4d219..0000000 --- a/src/.env.example +++ /dev/null @@ -1,11 +0,0 @@ -# Каталоги -SITE_ROOT=examples/studio-site -SITE_DIST=dist - -# Вход в админку (без этих переменных /admin/ отключена) -SITE_ADMIN_LOGIN=admin -SITE_ADMIN_PASSWORD_HASH= # site-engine hash-password -SITE_SECRET_KEY= # site-engine gen-secret (не короче 32 символов) -SITE_COOKIE_SECURE=1 # 0 только для локальной разработки по http -SITE_SESSION_HOURS=8 -# SITE_PUBLIC_HOST=admin.example.com # если Host подменяется прокси diff --git a/src/site_engine/build/__init__.py b/src/site_engine/build/__init__.py new file mode 100644 index 0000000..f926e96 --- /dev/null +++ b/src/site_engine/build/__init__.py @@ -0,0 +1 @@ +"""Сборка: реестр → проверка → рендер → релиз `dist/` → атомарный `current`.""" diff --git a/src/site_engine/build/pipeline.py b/src/site_engine/build/pipeline.py new file mode 100644 index 0000000..f238c7a --- /dev/null +++ b/src/site_engine/build/pipeline.py @@ -0,0 +1,252 @@ +"""Конвейер сборки (ТЗ 6.1, ADR-003): сборка — чистая функция от каталога сайта. + +Порядок: load → validate → render → postprocess → publish. Неудачная сборка не трогает +`dist/current`; релиз пишется в staging и переименовывается целиком. +""" + +from __future__ import annotations + +import datetime as dt +import hashlib +import json +import os +import re +import shutil +from dataclasses import dataclass +from pathlib import Path + +from markupsafe import escape + +from ..core.models import Block, Page +from ..core.registry import BUILTIN_DIR, Registry, load_site +from ..core.render import ASSETS_BODY, ASSETS_HEAD, PageView, Renderer +from ..core.routes import RouteRef, build_route_table, route_to_output +from ..core.validate import validate_release, validate_workspace +from ..errors import EngineError, Report + +BUILD_ID_RE = re.compile(r"^\d{8}T\d{6}-[0-9a-f]{8}$") +_TOKEN_VALUE_RE = re.compile(r"^[A-Za-z0-9#%.,()\s'\"/_+-]+$") +_SKIP_DIRS = {"dist", ".engine", ".git", "__pycache__", "node_modules"} + + +@dataclass +class BuildResult: + build_id: str + output_dir: Path + pages: int + source_hash: str + report: Report + + +def hash_tree(root: Path) -> str: + """Хеш всех исходных файлов сайта: основа build_id и проверки детерминизма.""" + digest = hashlib.sha256() + for path in sorted(p for p in root.rglob("*") if p.is_file()): + rel = path.relative_to(root) + if _SKIP_DIRS & set(rel.parts): + continue + digest.update(rel.as_posix().encode("utf-8")) + digest.update(b"\0") + digest.update(path.read_bytes()) + digest.update(b"\0") + return digest.hexdigest() + + +def merge_regions(base: dict[str, list[Block]], extra: dict[str, list[Block]], mode: str) -> dict[str, list[Block]]: + out = {name: list(blocks) for name, blocks in base.items()} + for name, blocks in extra.items(): + if mode == "replace" or name not in out: + out[name] = list(blocks) + elif mode == "prepend": + out[name] = list(blocks) + out[name] + else: + out[name] = out[name] + list(blocks) + return out + + +def make_views(reg: Registry, table: dict[str, RouteRef], report: Report, published_only: bool = True) -> list[PageView]: + views: list[PageView] = [] + for ref in table.values(): + if published_only and not ref.published: + continue + if ref.kind == "page" and ref.page is not None: + page: Page = ref.page + layout_id = reg.effective_layout(page) + if not layout_id: + report.add("E_LAYOUT_MISSING", "у страницы нет layout (ни своего, ни из раздела, ни из site.yaml)", page.file) + continue + views.append(PageView( + id=page.id, title=page.title, route=ref.route, layout_id=layout_id, seo=page.seo, + regions=page.regions, body=page.body, source=page.file, + )) + elif ref.kind == "entry" and ref.entry is not None and ref.collection is not None: + entry, coll = ref.entry, ref.collection + display = reg.displays.get(coll.display or coll.id) + if display is None or not display.layout: + report.add("E_DISPLAY_MISSING", f"нет display для коллекции «{coll.id}»", entry.file) + continue + views.append(PageView( + id=f"{coll.id}/{entry.slug}", title=str(entry.data.get("title", entry.slug)), route=ref.route, + layout_id=display.layout, seo=display.seo, + regions=merge_regions(display.regions, entry.regions, entry.regions_mode), + body=entry.body, entry=entry, collection=coll, source=entry.file, + )) + views.sort(key=lambda v: v.route) + return views + + +def _token_css(tokens: dict, report: Report) -> str: + lines = [] + for key, value in tokens.items(): + name = "--" + str(key).replace(".", "-") + if not re.match(r"^--[a-z0-9-]+$", name) or not _TOKEN_VALUE_RE.match(str(value)): + report.add("E_THEME_TOKEN", f"недопустимый токен темы «{key}: {value}»", "site.yaml:theme.tokens") + continue + lines.append(f" {name}: {value};") + return ":root {\n" + "\n".join(lines) + "\n}\n" if lines else "" + + +def _bundle(reg: Registry, used: set[str], report: Report) -> tuple[str, str]: + base_css = (BUILTIN_DIR / "base.css").read_text(encoding="utf-8") + css = [_token_css(reg.site.theme_tokens, report), base_css] + js: list[str] = [] + for fid in sorted(used): + fragment = reg.fragments[fid] + if fragment.style: + css.append(f"/* fragment: {fid} */\n{fragment.style}") + if fragment.script: + js.append(f"/* fragment: {fid} */\n{fragment.script}") + return "\n".join(css), "\n".join(js) + + +def _redirect_html(target: str) -> str: + t = escape(target) + return (f"Перенаправление" + f"" + f"

Перейти

\n") + + +def _sitemap(reg: Registry, routes: list[str]) -> str: + base = reg.site.base_url + items = "".join(f" {escape(base + r)}\n" for r in routes) + return ("\n" + "\n" + items + "\n") + + +def switch_current(dist: Path, build_id: str) -> None: + """Атомарное переключение: новый симлинк рядом, затем rename поверх `current`.""" + tmp = dist / f".current-{os.getpid()}" + if tmp.is_symlink() or tmp.exists(): + tmp.unlink() + os.symlink(build_id, tmp) + os.replace(tmp, dist / "current") + + +def prune_releases(dist: Path, keep: int) -> list[str]: + current = (dist / "current").resolve().name if (dist / "current").exists() else None + builds = sorted((p.name for p in dist.iterdir() if p.is_dir() and BUILD_ID_RE.match(p.name)), reverse=True) + removed = [] + for name in builds[keep:]: + if name != current: + shutil.rmtree(dist / name) + removed.append(name) + return removed + + +def build_site(root: Path, out: Path, *, keep: int = 5, now: dt.datetime | None = None) -> BuildResult: + root, out = Path(root), Path(out) + now = now or dt.datetime.now(dt.timezone.utc) + reg = load_site(root) + report = Report() + table_report = Report() + table = build_route_table(reg, table_report) + report.extend(validate_workspace(reg, table)) + report.extend(table_report) + report.extend(validate_release(reg, table)) + + source_hash = hash_tree(root) + build_id = f"{now.strftime('%Y%m%dT%H%M%S')}-{source_hash[:8]}" + + views = make_views(reg, table, report) + renderer = Renderer(reg, table, report, strict=True, now=now, build_id=build_id) + rendered: dict[str, str] = {} + used: set[str] = set() + for view in views: + html, fragments = renderer.render(view) + rendered[view.route] = html + used |= fragments + css, js = _bundle(reg, used, report) + if report.errors: + raise EngineError(f"сборка остановлена: ошибок {len(report.errors)}", report) + + css_name = f"site.{hashlib.sha256(css.encode()).hexdigest()[:8]}.css" + head = f"" + body = "" + js_name = None + if js: + js_name = f"site.{hashlib.sha256(js.encode()).hexdigest()[:8]}.js" + body = f"" + + out.mkdir(parents=True, exist_ok=True) + staging = out / f".staging-{build_id}" + if staging.exists(): + shutil.rmtree(staging) + try: + staging.mkdir() + for route, html in rendered.items(): + target = staging / route_to_output(route) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text(html.replace(ASSETS_HEAD, head).replace(ASSETS_BODY, body), encoding="utf-8") + assets = staging / "assets" + assets.mkdir(exist_ok=True) + if (root / "assets").is_dir(): + shutil.copytree(root / "assets", assets, dirs_exist_ok=True) + (assets / css_name).write_text(css, encoding="utf-8") + if js_name: + (assets / js_name).write_text(js, encoding="utf-8") + forms_dir = staging / "_forms" + forms_dir.mkdir() + for form in reg.forms.values(): + (forms_dir / f"{form.id}@{form.version}.json").write_text( + json.dumps(form.raw, ensure_ascii=False, sort_keys=True, indent=2, default=str), encoding="utf-8") + for ref in table.values(): + if ref.kind == "redirect" and ref.target: + dest = ref.target if ref.target.startswith("http") else reg.site.base_url + ref.target + target = staging / route_to_output(ref.route) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text(_redirect_html(dest), encoding="utf-8") + (staging / "redirects.map").write_text( + "".join(f"{r.route} {r.target};\n" for r in table.values() if r.kind == "redirect" and r.target), + encoding="utf-8") + public = [r for r in rendered if r != "/404.html"] + (staging / "sitemap.xml").write_text(_sitemap(reg, public), encoding="utf-8") + (staging / "robots.txt").write_text(f"User-agent: *\nAllow: /\nSitemap: {reg.site.base_url}/sitemap.xml\n", encoding="utf-8") + (staging / "manifest.json").write_text(json.dumps({ + "build_id": build_id, "source_hash": source_hash, "built_at": now.isoformat(), + "routes": sorted(rendered), "fragments": sorted(used), + }, ensure_ascii=False, indent=2), encoding="utf-8") + final = out / build_id + if final.exists(): + shutil.rmtree(final) + os.rename(staging, final) + except BaseException: + shutil.rmtree(staging, ignore_errors=True) + raise + switch_current(out, build_id) + prune_releases(out, keep) + return BuildResult(build_id, out / build_id, len(rendered), source_hash, report) + + +def preview_page(root: Path, page_id: str, *, now: dt.datetime | None = None) -> tuple[str, Report]: + """Рендер одной страницы из рабочего каталога, включая черновики (нестрогий режим).""" + reg = load_site(root) + report = Report() + table = build_route_table(reg, report) + views = [v for v in make_views(reg, table, report, published_only=False) if v.id == page_id] + if not views: + raise EngineError(f"нет страницы «{page_id}»", report) + renderer = Renderer(reg, table, report, strict=False, now=now, build_id="preview") + html, used = renderer.render(views[0]) + css, _ = _bundle(reg, used, report) + html = html.replace(ASSETS_HEAD, f"").replace(ASSETS_BODY, "") + return html, report diff --git a/src/site_engine/core/registry.py b/src/site_engine/core/registry.py index f850897..c31adee 100644 --- a/src/site_engine/core/registry.py +++ b/src/site_engine/core/registry.py @@ -94,7 +94,7 @@ def load_site(root: Path, builtin_dir: Path | None = BUILTIN_DIR) -> Registry: report = Report() site_file = root / "site.yaml" if not site_file.is_file(): - raise EngineError(f"нет site.yaml в {root}") + raise EngineError(f"нет site.yaml в {root.resolve()}") raw_site = _read_yaml(site_file, "site.yaml", report) site = parse_site(raw_site, "site.yaml", report) if raw_site is not None else None if site is None: diff --git a/src/site_engine/services/auth.py b/src/site_engine/services/auth.py index b1e45a1..861071b 100644 --- a/src/site_engine/services/auth.py +++ b/src/site_engine/services/auth.py @@ -17,6 +17,7 @@ import hashlib import hmac import json import os +import re import secrets import time from collections import defaultdict, deque @@ -84,6 +85,15 @@ def verify_password(password: str, stored: str) -> bool: # ── конфигурация ────────────────────────────────────────────────────────────── +_HASH_RE = re.compile(r"^scrypt\$\d+\$\d+\$\d+\$[A-Za-z0-9_-]+\$[A-Za-z0-9_-]+$") +_SECRET_RE = re.compile(r"^[^\s#'\"]+$") +_LOGIN_RE = re.compile(r"^[A-Za-z0-9._@-]{1,64}$") +_HOST_RE = re.compile(r"^[A-Za-z0-9.-]+(:\d+)?$") +_TRUE, _FALSE = ("1", "true", "yes", "on"), ("0", "false", "no", "off") +_ENV_HINT = ("похоже на кавычки или комментарий в строке .env: для `docker run --env-file` значения пишутся " + "без кавычек и без «# …» после значения") + + @dataclass(frozen=True) class AuthConfig: login: str @@ -102,21 +112,30 @@ class AuthConfig: login = env.get("SITE_ADMIN_LOGIN", "admin").strip() password_hash = env.get("SITE_ADMIN_PASSWORD_HASH", "").strip() secret = env.get("SITE_SECRET_KEY", "") - if not login: - raise ConfigError("SITE_ADMIN_LOGIN пуст") - if not password_hash.startswith("scrypt$"): - raise ConfigError("SITE_ADMIN_PASSWORD_HASH не задан или не в формате scrypt (site-engine hash-password)") + if not _LOGIN_RE.match(login): + raise ConfigError(f"SITE_ADMIN_LOGIN «{login}»: допустимы латиница, цифры, . _ @ - ({_ENV_HINT})") + if not password_hash: + raise ConfigError("SITE_ADMIN_PASSWORD_HASH не задан (site-engine hash-password)") + if not _HASH_RE.match(password_hash): + raise ConfigError(f"SITE_ADMIN_PASSWORD_HASH: неверный формат, {_ENV_HINT}") if len(secret) < MIN_SECRET_LENGTH: - raise ConfigError(f"SITE_SECRET_KEY короче {MIN_SECRET_LENGTH} символов (site-engine gen-secret)") + raise ConfigError(f"SITE_SECRET_KEY не задан или короче {MIN_SECRET_LENGTH} символов (site-engine gen-secret)") + if not _SECRET_RE.match(secret): + raise ConfigError(f"SITE_SECRET_KEY содержит пробелы, # или кавычки: {_ENV_HINT}") try: - hours = float(env.get("SITE_SESSION_HOURS", "8")) + hours = float(env.get("SITE_SESSION_HOURS", "8").strip()) except ValueError as exc: - raise ConfigError("SITE_SESSION_HOURS: ожидается число") from exc + raise ConfigError(f"SITE_SESSION_HOURS: ожидается число ({_ENV_HINT})") from exc if not 0 < hours <= 24 * 30: raise ConfigError("SITE_SESSION_HOURS: от 0 до 720") - secure = env.get("SITE_COOKIE_SECURE", "1").strip().lower() not in ("0", "false", "no", "off") - return cls(login, password_hash, secret.encode("utf-8"), hours, secure, - env.get("SITE_PUBLIC_HOST") or None) + flag = env.get("SITE_COOKIE_SECURE", "1").strip().lower() + if flag not in _TRUE + _FALSE: + raise ConfigError(f"SITE_COOKIE_SECURE «{flag}»: ожидается 0 или 1 ({_ENV_HINT})") + secure = flag in _TRUE + public_host = (env.get("SITE_PUBLIC_HOST") or "").strip() or None + if public_host and not _HOST_RE.match(public_host): + raise ConfigError(f"SITE_PUBLIC_HOST «{public_host}»: ожидается host или host:port ({_ENV_HINT})") + return cls(login, password_hash, secret.encode("utf-8"), hours, secure, public_host) # ── ограничение попыток и аудит ─────────────────────────────────────────────── diff --git a/src/site_engine/web/admin/handlers.py b/src/site_engine/web/admin/handlers.py index fdfb606..7f47b34 100644 --- a/src/site_engine/web/admin/handlers.py +++ b/src/site_engine/web/admin/handlers.py @@ -62,9 +62,10 @@ def htmx_available() -> bool: class AdminHandlers: - def __init__(self, auth: AuthService, site_root: Path): + def __init__(self, auth: AuthService, site_root: Path, dist: Path | None = None): self.auth = auth self.site_root = Path(site_root) + self.dist = Path(dist) if dist is not None else None def _clear_cookie(self) -> str: return build_set_cookie("", max_age=0, secure=self.auth.cfg.cookie_secure) @@ -110,7 +111,10 @@ class AdminHandlers: ctx: dict = {"login": principal.login, "csrf": self.auth.csrf_token(principal), "section": "dashboard", "flash": "", "htmx": htmx_available(), "site_error": "", "site_name": "", "pages": [], "collections": [], - "errors": 0, "warnings": 0} + "errors": 0, "warnings": 0, + "paths": {"site": str(self.site_root.resolve()), + "dist": str(self.dist.resolve()) if self.dist else "не задан", + "state": str(self.auth.state_dir.resolve())}} try: reg = load_site(self.site_root) report = Report() diff --git a/src/site_engine/web/admin/routes.py b/src/site_engine/web/admin/routes.py index 3d16cda..c489923 100644 --- a/src/site_engine/web/admin/routes.py +++ b/src/site_engine/web/admin/routes.py @@ -1,12 +1,15 @@ -"""FastAPI-адаптер для `AdminHandlers`. Не запускался в песочнице без сети: только компиляция. +"""FastAPI-адаптер для `AdminHandlers` и `EditorHandlers`. + +ВАЖНО: в этом модуле нельзя ставить `from __future__ import annotations`. `Request` и `Form` импортируются +внутри `create_admin_router`, поэтому FastAPI не сможет разрешить аннотации-строки: параметр `request` станет +query-параметром, и любой запрос упадёт с 422 `loc: ["query", "request"]`. Это ловит тест +`test_annotations_are_real_types`. Обработчики синхронные (`def`): хеш scrypt считается около 100 мс, и FastAPI вынесет их в пул потоков. -За обратным прокси `request.client.host` — адрес прокси, тогда ограничение попыток по IP -работает как общее; доверие к X-Forwarded-For нужно включать явно (задача M2). +За обратным прокси `request.client.host` — адрес прокси, тогда ограничение попыток по IP работает как +общее; доверие к X-Forwarded-For нужно включать явно (задача M2). """ -from __future__ import annotations - from ...services.auth import COOKIE_NAME from .editor import EditorHandlers from .forms import FormData diff --git a/src/site_engine/web/admin/templates/dashboard.html.j2 b/src/site_engine/web/admin/templates/dashboard.html.j2 index d33bdb8..39c0e02 100644 --- a/src/site_engine/web/admin/templates/dashboard.html.j2 +++ b/src/site_engine/web/admin/templates/dashboard.html.j2 @@ -1,6 +1,7 @@ {% extends 'shell.html.j2' %} {% block title %}Обзор — админка{% endblock %} {% block content %} +

Каталог сайта: {{ paths.site }} · публикация: {{ paths.dist }} · состояние: {{ paths.state }}

{% if site_error %} {% else %} diff --git a/src/site_engine/web/app.py b/src/site_engine/web/app.py index 67954ce..c59bf14 100644 --- a/src/site_engine/web/app.py +++ b/src/site_engine/web/app.py @@ -1,13 +1,12 @@ """Фабрика приложения. Админка подключается, только если задана конфигурация входа. -Переменные окружения: SITE_ROOT, SITE_DIST, SITE_STATE_DIR (по умолчанию SITE_ROOT/.engine), +Сайт раздаётся из `SITE_DIST/current` (удобно для разработки; в production лучше nginx). +Переменные окружения: SITE_ROOT, SITE_DIST, SITE_STATE_DIR (по умолчанию SITE_ROOT/.engine; в образе /data/state), SITE_ADMIN_LOGIN, SITE_ADMIN_PASSWORD_HASH, SITE_SECRET_KEY, SITE_COOKIE_SECURE, SITE_SESSION_HOURS, SITE_PUBLIC_HOST. Без них `/admin/` отдаёт 404, и это сознательно: нет пароля — нет входа. Не запускалось в песочнице без сети (нужен `pip install site-engine[server]`). """ -from __future__ import annotations - import logging import os from pathlib import Path @@ -20,13 +19,15 @@ def create_app(): from fastapi.staticfiles import StaticFiles from ..services.auth import AuthConfig, AuthService, ConfigError + from .config import SitePaths from .admin.editor import EditorHandlers from .admin.handlers import AdminHandlers from .admin.routes import create_admin_router app = FastAPI(title="Site Engine", docs_url=None, redoc_url=None, openapi_url=None) - root = Path(os.environ.get("SITE_ROOT", "site")) - dist = Path(os.environ.get("SITE_DIST", "dist")) + paths = SitePaths.from_env() + root, dist = paths.root, paths.dist + uvicorn_log = logging.getLogger("uvicorn.error") # его уровень и вывод настраивает uvicorn @app.get("/healthz") def healthz() -> dict: @@ -36,15 +37,36 @@ def create_app(): def submit_form(form_id: str) -> None: raise HTTPException(status_code=501, detail="приём заявок появится в M2 (ADR-003)") + admin = "off" try: cfg = AuthConfig.from_env() except ConfigError as exc: - log.warning("админка отключена: %s", exc) + uvicorn_log.warning("админка отключена: %s", exc) else: - state_dir = Path(os.environ.get("SITE_STATE_DIR", root / ".engine")) - auth = AuthService(cfg, state_dir) - app.include_router(create_admin_router(AdminHandlers(auth, root), EditorHandlers(auth, root, dist))) + auth = AuthService(cfg, paths.state) + app.include_router(create_admin_router(AdminHandlers(auth, root, dist), EditorHandlers(auth, root, dist))) + admin = "on" + uvicorn_log.info("site-engine: %s, admin=%s", paths.describe(), admin) + for problem in paths.problems(): + uvicorn_log.warning("site-engine: %s", problem) + + # Раздача сайта: путь к `dist/current` разрешается на каждый запрос, поэтому публикация и откат + # из админки видны сразу, без перезапуска. Маршрут объявлен последним: админка и /healthz важнее. + from fastapi.responses import FileResponse, PlainTextResponse, RedirectResponse + + from .static_site import resolve_site_file + + @app.get("/{path:path}", include_in_schema=False) + def serve_site(path: str): + kind, target = resolve_site_file(dist, "/" + path) + if kind == "file": + return FileResponse(target) + if kind == "redirect": + return RedirectResponse(target, status_code=308) + if kind == "unpublished": + return PlainTextResponse("Сайт ещё не опубликован. Войдите в /admin/ и откройте «Публикация».", status_code=404) + if target is not None: + return FileResponse(target, status_code=404) + return PlainTextResponse("Не найдено", status_code=404) - if (dist / "current").exists(): # маршруты выше имеют приоритет над раздачей статики - app.mount("/", StaticFiles(directory=dist / "current", html=True), name="site") return app diff --git a/src/site_engine/web/config.py b/src/site_engine/web/config.py new file mode 100644 index 0000000..1b241fd --- /dev/null +++ b/src/site_engine/web/config.py @@ -0,0 +1,59 @@ +"""Пути сайта из окружения и понятная диагностика при старте. + +Три каталога: `SITE_ROOT` (контент и код сайта), `SITE_DIST` (опубликованные релизы), +`SITE_STATE_DIR` (состояние входа и аудит; по умолчанию `SITE_ROOT/.engine`). В Docker-образе все три +заданы внутри единственного тома `/data`. Относительные пути разрешаются от рабочего каталога процесса +(в образе это `/app`), и при старте о них пишется предупреждение: чаще всего это строки из старого `.env`. +""" + +from __future__ import annotations + +import os +from collections.abc import Mapping +from dataclasses import dataclass +from pathlib import Path + + +def _abs(value: str, base: Path) -> Path: + path = Path(value) + return Path(os.path.abspath(path if path.is_absolute() else base / path)) + + +@dataclass(frozen=True) +class SitePaths: + root: Path + dist: Path + state: Path + relative: tuple[str, ...] = () # имена переменных, заданных относительным путём + + @classmethod + def from_env(cls, env: Mapping[str, str] | None = None, cwd: Path | None = None) -> "SitePaths": + env = os.environ if env is None else env + base = Path(cwd) if cwd else Path.cwd() + values = {"SITE_ROOT": env.get("SITE_ROOT", "site"), "SITE_DIST": env.get("SITE_DIST", "dist")} + explicit_state = env.get("SITE_STATE_DIR", "").strip() + root = _abs(values["SITE_ROOT"], base) + state = _abs(explicit_state, base) if explicit_state else root / ".engine" + relative = tuple(k for k, v in {**values, **({"SITE_STATE_DIR": explicit_state} if explicit_state else {})}.items() + if v and not Path(v).is_absolute() and k in env) + return cls(root=root, dist=_abs(values["SITE_DIST"], base), state=state, relative=relative) + + def describe(self) -> str: + return f"site={self.root}, dist={self.dist}, state={self.state}" + + def problems(self, env: Mapping[str, str] | None = None) -> list[str]: + env = os.environ if env is None else env + found = [] + if not self.root.is_dir(): + found.append(f"каталога сайта нет: {self.root}. Смонтируйте его (docker run -v \"$PWD/data:/data\" ..., " + "сайт в data/site) или поправьте SITE_ROOT") + elif not (self.root / "site.yaml").is_file(): + found.append(f"в каталоге сайта нет site.yaml: {self.root}") + for name in self.relative: + found.append(f"{name}={env.get(name)} задан относительным путём и разрешён как " + f"{ {'SITE_ROOT': self.root, 'SITE_DIST': self.dist, 'SITE_STATE_DIR': self.state}[name] }: " + "в контейнере это путь внутри образа, а не примонтированный том. Удалите строку из .env: " + "в образе пути уже заданы (/data/site, /data/dist, /data/state)") + if self.dist == self.root or self.root in self.dist.parents: + found.append(f"SITE_DIST находится внутри SITE_ROOT ({self.dist}): релизы попадут в исходники сайта") + return found diff --git a/src/site_engine/web/static_site.py b/src/site_engine/web/static_site.py new file mode 100644 index 0000000..dfe7e71 --- /dev/null +++ b/src/site_engine/web/static_site.py @@ -0,0 +1,45 @@ +"""Раздача собранного сайта из `dist/current` для разработки и небольших установок. + +Каталог `current` — симлинк, который переключается при публикации и откате, поэтому путь +разрешается на каждый запрос (StaticFiles при старте зафиксировал бы каталог навсегда). +В production статику лучше отдавать nginx. Служебные файлы релиза наружу не отдаются. +""" + +from __future__ import annotations + +from pathlib import Path + +from ..errors import UnsafePathError +from ..storage.fs import safe_join + +_PRIVATE_NAMES = {"manifest.json", "redirects.map"} +_PRIVATE_DIRS = {"_forms"} + + +def resolve_site_file(dist: Path, url_path: str) -> tuple[str, Path | str | None]: + """(`file`, путь) | (`redirect`, url) | (`not_found`, путь к 404.html или None) | (`unpublished`, None).""" + current = Path(dist) / "current" + if not current.exists(): + return "unpublished", None + rel = url_path.lstrip("/") + parts = [p for p in rel.split("/") if p] + if (parts and parts[0] in _PRIVATE_DIRS) or (parts and parts[-1] in _PRIVATE_NAMES and len(parts) == 1): + return "not_found", _page_404(current) + try: + target = safe_join(current, rel) if rel else current.resolve() + except UnsafePathError: + return "not_found", _page_404(current) + if target.is_dir(): + if rel and not url_path.endswith("/"): + return "redirect", "/" + rel + "/" + index = target / "index.html" + if index.is_file(): + return "file", index + elif target.is_file(): + return "file", target + return "not_found", _page_404(current) + + +def _page_404(current: Path) -> Path | None: + page = current.resolve() / "404.html" + return page if page.is_file() else None diff --git a/tests/test_admin_handlers.py b/tests/test_admin_handlers.py index 6b256f3..9431cde 100644 --- a/tests/test_admin_handlers.py +++ b/tests/test_admin_handlers.py @@ -16,7 +16,7 @@ class AdminHandlersTest(SiteTestCase): super().setUp() self.clock = Clock() self.auth = AuthService(make_cfg(), self.tmp / "state", clock=self.clock) - self.h = AdminHandlers(self.auth, self.site) + self.h = AdminHandlers(self.auth, self.site, self.tmp / "dist") def cookie_value(self, result): header = result.cookies[0] @@ -91,6 +91,15 @@ class AdminHandlersTest(SiteTestCase): self.assertIn("name='csrf'", result.body) self.assertIn("no-store", result.headers["Cache-Control"]) + def test_dashboard_shows_the_absolute_paths_in_use(self): + body = self.h.dashboard(self.login()).body + for path in (self.site.resolve(), (self.tmp / "dist").resolve(), (self.tmp / "state").resolve()): + self.assertIn(str(path), body) + + def test_missing_site_error_names_the_absolute_path(self): + (self.site / "site.yaml").unlink() + self.assertIn(str(self.site.resolve()), self.h.dashboard(self.login()).body) + def test_dashboard_shows_broken_site_instead_of_crashing(self): (self.site / "site.yaml").unlink() result = self.h.dashboard(self.login()) diff --git a/tests/test_admin_routes_wiring.py b/tests/test_admin_routes_wiring.py index d34b82f..a151139 100644 --- a/tests/test_admin_routes_wiring.py +++ b/tests/test_admin_routes_wiring.py @@ -134,6 +134,23 @@ class RoutesWiringTest(SiteTestCase): self.assertEqual((out.status_code, out.headers["Location"]), (303, "/admin/login")) self.assertIn("Max-Age=0", out.headers.appended[0][1]) + def test_annotations_are_real_types(self): + """Регрессия: с `from __future__ import annotations` и локальным импортом Request FastAPI не разрешает + аннотацию, считает `request` query-параметром и отвечает 422 {"loc": ["query", "request"]}.""" + import typing + + from pathlib import Path + + source = (Path(__file__).resolve().parent.parent / "src/site_engine/web/admin/routes.py").read_text(encoding="utf-8") + import re + + self.assertIsNone(re.search(r"^from __future__ import annotations", source, re.M)) + for key, fn in self.router.routes.items(): + hints = typing.get_type_hints(fn) # как это делает FastAPI: имена берутся из globals модуля + if "request" in hints: + self.assertIs(hints["request"], FakeRequest, key) + self.assertFalse(any(isinstance(v, str) for v in fn.__annotations__.values()), key) + def test_static_and_login_page_routes(self): css = self.route("GET", "/admin/static/{name}")("admin.css") self.assertTrue(css.media_type.startswith("text/css")) diff --git a/tests/test_auth.py b/tests/test_auth.py index db900cb..0f6b627 100644 --- a/tests/test_auth.py +++ b/tests/test_auth.py @@ -64,6 +64,22 @@ class ConfigTest(unittest.TestCase): with self.assertRaises(ConfigError, msg=str(patch)): AuthConfig.from_env({**self.ENV, **patch}) + def test_trailing_comment_or_quotes_in_env_are_rejected_not_silently_accepted(self): + h, s = self.ENV["SITE_ADMIN_PASSWORD_HASH"], self.ENV["SITE_SECRET_KEY"] + for patch in ({"SITE_ADMIN_PASSWORD_HASH": h + " # site-engine hash-password"}, + {"SITE_ADMIN_PASSWORD_HASH": f'"{h}"'}, {"SITE_ADMIN_PASSWORD_HASH": f"'{h}'"}, + {"SITE_SECRET_KEY": s + " # gen-secret"}, {"SITE_SECRET_KEY": f'"{s}"'}, + {"SITE_COOKIE_SECURE": "1 # только http"}, {"SITE_COOKIE_SECURE": "maybe"}, + {"SITE_SESSION_HOURS": "8 # часов"}, {"SITE_ADMIN_LOGIN": "admin # мой"}, + {"SITE_PUBLIC_HOST": "admin.example.com # прокси"}): + with self.assertRaises(ConfigError, msg=str(patch)) as ctx: + AuthConfig.from_env({**self.ENV, **patch}) + self.assertIn("кавычки или комментарий", str(ctx.exception)) + + def test_valid_host_and_flags(self): + cfg = AuthConfig.from_env({**self.ENV, "SITE_PUBLIC_HOST": "admin.example.com:8443", "SITE_COOKIE_SECURE": "false"}) + self.assertEqual((cfg.public_host, cfg.cookie_secure), ("admin.example.com:8443", False)) + def test_cookie_secure_can_be_disabled_for_local_dev(self): self.assertFalse(AuthConfig.from_env({**self.ENV, "SITE_COOKIE_SECURE": "0"}).cookie_secure) diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 0000000..9620c4d --- /dev/null +++ b/tests/test_config.py @@ -0,0 +1,50 @@ +import tempfile +import unittest +from pathlib import Path + +from site_engine.web.config import SitePaths + +DOCKER_ENV = {"SITE_ROOT": "/data/site", "SITE_DIST": "/data/dist", "SITE_STATE_DIR": "/data/state"} +OLD_ENV_EXAMPLE = {"SITE_ROOT": "examples/studio-site", "SITE_DIST": "dist"} # строки, которые когда-то были включены в .env.example + + +class SitePathsTest(unittest.TestCase): + def test_docker_defaults_resolve_inside_the_data_volume(self): + p = SitePaths.from_env(DOCKER_ENV, cwd=Path("/app")) + self.assertEqual((p.root, p.dist, p.state), (Path("/data/site"), Path("/data/dist"), Path("/data/state"))) + self.assertEqual(p.relative, ()) + + def test_leftover_relative_paths_from_old_env_are_called_out(self): + env = {**DOCKER_ENV, **OLD_ENV_EXAMPLE} + p = SitePaths.from_env(env, cwd=Path("/app")) + self.assertEqual((p.root, p.dist), (Path("/app/examples/studio-site"), Path("/app/dist"))) + text = "\n".join(p.problems(env)) + for needle in ("SITE_ROOT=examples/studio-site", "/app/examples/studio-site", "SITE_DIST=dist", "/app/dist", + "Удалите строку из .env", "каталога сайта нет"): + self.assertIn(needle, text) + + def test_state_defaults_to_dot_engine_inside_site(self): + p = SitePaths.from_env({"SITE_ROOT": "/srv/site", "SITE_DIST": "/srv/dist"}, cwd=Path("/app")) + self.assertEqual(p.state, Path("/srv/site/.engine")) + + def test_no_problems_for_a_healthy_layout(self): + with tempfile.TemporaryDirectory() as tmp: + (Path(tmp) / "site").mkdir() + (Path(tmp) / "site" / "site.yaml").write_text("name: x\n", encoding="utf-8") + env = {"SITE_ROOT": f"{tmp}/site", "SITE_DIST": f"{tmp}/dist", "SITE_STATE_DIR": f"{tmp}/state"} + self.assertEqual(SitePaths.from_env(env).problems(env), []) + + def test_missing_site_yaml_and_dist_inside_root(self): + with tempfile.TemporaryDirectory() as tmp: + env = {"SITE_ROOT": tmp, "SITE_DIST": f"{tmp}/dist"} + text = "\n".join(SitePaths.from_env(env).problems(env)) + self.assertIn("нет site.yaml", text) + self.assertIn("внутри SITE_ROOT", text) + + def test_relative_paths_resolve_against_cwd_for_local_runs(self): + p = SitePaths.from_env({"SITE_ROOT": "examples/studio-site", "SITE_DIST": "dist"}, cwd=Path("/work/project")) + self.assertEqual((p.root, p.dist), (Path("/work/project/examples/studio-site"), Path("/work/project/dist"))) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_packaging.py b/tests/test_packaging.py new file mode 100644 index 0000000..3250601 --- /dev/null +++ b/tests/test_packaging.py @@ -0,0 +1,54 @@ +"""Регрессия: в установленный пакет (Docker-образ, wheel) должны попасть шаблоны и статика админки, +встроенные фрагменты и стили. Раньше package-data включал только builtin/.""" + +import fnmatch +import glob +import shutil +import subprocess +import sys +import tempfile +import tomllib +import unittest +import zipfile +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +PKG = ROOT / "src" / "site_engine" + + +class PackagingTest(unittest.TestCase): + def test_package_data_patterns_cover_every_runtime_file(self): + patterns = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))["tool"]["setuptools"]["package-data"]["site_engine"] + runtime = [p for sub in ("builtin", "web/admin/templates", "web/admin/static") for p in (PKG / sub).rglob("*") + if p.is_file() and p.suffix != ".pyc" and "__pycache__" not in p.parts] + self.assertGreater(len(runtime), 50) + uncovered = [str(p.relative_to(PKG)) for p in runtime + if not any(fnmatch.fnmatch(p.relative_to(PKG).as_posix(), pat.replace("**/*", "*")) for pat in patterns)] + self.assertEqual(uncovered, []) + + def test_built_wheel_contains_templates_static_and_fragments(self): + try: + import setuptools # noqa: F401 + except ImportError: + self.skipTest("нет setuptools") + before = {name: (ROOT / name).exists() for name in ("build", "src/site_engine.egg-info")} + with tempfile.TemporaryDirectory() as tmp: + project = Path(tmp) / "project" + shutil.copytree(ROOT, project, ignore=shutil.ignore_patterns( + "build", "*.egg-info", "__pycache__", ".git", "tests", "docs", "examples", "dist", ".engine")) + result = subprocess.run([sys.executable, "-m", "pip", "wheel", str(project), "--no-deps", "--no-build-isolation", + "-q", "-w", str(Path(tmp) / "out")], capture_output=True, text=True, timeout=180) + wheels = glob.glob(f"{tmp}/out/*.whl") + if result.returncode != 0 or not wheels: + self.skipTest(f"wheel не собрался в этом окружении: {result.stderr[-200:]}") + names = zipfile.ZipFile(wheels[0]).namelist() + after = {name: (ROOT / name).exists() for name in before} + self.assertEqual(after, before, "сборка wheel не должна оставлять мусор в рабочем каталоге") + for needed in ("site_engine/web/admin/templates/login.html.j2", "site_engine/web/admin/templates/page_edit.html.j2", + "site_engine/web/admin/static/admin.css", "site_engine/builtin/base.css", + "site_engine/builtin/fragments/hero/template.html.j2"): + self.assertIn(needed, names) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_repo_hygiene.py b/tests/test_repo_hygiene.py new file mode 100644 index 0000000..770ea24 --- /dev/null +++ b/tests/test_repo_hygiene.py @@ -0,0 +1,113 @@ +"""Страховка от ошибок упаковки, из-за которых пользователь получал неверные пути в Docker.""" + +import re +import shutil +import subprocess +import tempfile +import unittest +from pathlib import Path + +from site_engine.services.auth import AuthConfig, ConfigError +from site_engine.web.config import SitePaths + +ROOT = Path(__file__).resolve().parent.parent +GOOD_HASH = "scrypt$32768$8$1$aGVsbG8$d29ybGQ" +OLD_ENV_EXAMPLE = """# Каталоги +SITE_ROOT=examples/studio-site +SITE_DIST=dist +SITE_ADMIN_LOGIN=admin +SITE_ADMIN_PASSWORD_HASH= # site-engine hash-password +SITE_SECRET_KEY= # site-engine gen-secret (не короче 32 символов) +SITE_COOKIE_SECURE=1 # 0 только для локальной разработки по http +""" + + +def parse_docker_env_file(text: str) -> dict[str, str]: + """Как `docker run --env-file`: строки с # в начале пропускаются, значение — всё после первого «=», + кавычки и комментарии в конце строки не обрабатываются.""" + env = {} + for line in text.splitlines(): + if line.strip() and not line.lstrip().startswith("#") and "=" in line: + key, value = line.split("=", 1) + env[key] = value + return env + + +class EnvExampleTest(unittest.TestCase): + def test_env_example_lives_in_the_project_root_only(self): + self.assertTrue((ROOT / ".env.example").is_file()) + self.assertFalse((ROOT / "src" / ".env.example").exists()) + + def test_env_example_has_no_path_overrides(self): + env = parse_docker_env_file((ROOT / ".env.example").read_text(encoding="utf-8")) + for name in ("SITE_ROOT", "SITE_DIST", "SITE_STATE_DIR", "SITE_DB"): + self.assertNotIn(name, env) + + def test_filled_env_example_works_exactly_as_docker_reads_it(self): + text = (ROOT / ".env.example").read_text(encoding="utf-8") + text = text.replace("SITE_ADMIN_PASSWORD_HASH=", f"SITE_ADMIN_PASSWORD_HASH={GOOD_HASH}") + text = text.replace("SITE_SECRET_KEY=", "SITE_SECRET_KEY=" + "k" * 43) + env = parse_docker_env_file(text) + cfg = AuthConfig.from_env(env) + self.assertEqual((cfg.login, cfg.cookie_secure, cfg.session_hours), ("admin", True, 8.0)) + self.assertEqual(SitePaths.from_env({**{"SITE_ROOT": "/data/site", "SITE_DIST": "/data/dist"}, **env}).relative, ()) + + def test_old_env_example_would_have_failed_loudly_instead_of_silently(self): + text = OLD_ENV_EXAMPLE.replace("SITE_ADMIN_PASSWORD_HASH= #", f"SITE_ADMIN_PASSWORD_HASH={GOOD_HASH} #") + text = text.replace("SITE_SECRET_KEY= #", "SITE_SECRET_KEY=" + "k" * 43 + " #") + with self.assertRaises(ConfigError): + AuthConfig.from_env(parse_docker_env_file(text)) + + +class IgnoreRulesTest(unittest.TestCase): + """Пакет `site_engine.build` (конвейер сборки) раньше мог попасть под правило `build/` без привязки к корню.""" + + PACKAGE_FILES = ("src/site_engine/build/pipeline.py", "src/site_engine/build/__init__.py", + "src/site_engine/web/admin/templates/login.html.j2", "src/site_engine/builtin/base.css") + + def test_source_package_exists(self): + for rel in self.PACKAGE_FILES: + self.assertTrue((ROOT / rel).is_file(), rel) + + def test_gitignore_patterns_for_build_and_dist_are_anchored_to_the_root(self): + lines = [l.strip() for l in (ROOT / ".gitignore").read_text(encoding="utf-8").splitlines()] + for bad in ("build/", "dist/", "build", "dist"): + self.assertNotIn(bad, lines) + for good in ("/build/", "/dist/"): + self.assertIn(good, lines) + + @unittest.skipUnless(shutil.which("git"), "git недоступен") + def test_git_does_not_ignore_the_source_package(self): + with tempfile.TemporaryDirectory() as tmp: + subprocess.run(["git", "init", "-q", tmp], check=True) + shutil.copy(ROOT / ".gitignore", Path(tmp) / ".gitignore") + for rel in self.PACKAGE_FILES: + result = subprocess.run(["git", "-C", tmp, "check-ignore", "-q", rel]) + self.assertEqual(result.returncode, 1, f"{rel} игнорируется git") + for rel in ("build/lib/x.py", "dist/current/index.html"): + self.assertEqual(subprocess.run(["git", "-C", tmp, "check-ignore", "-q", rel]).returncode, 0, rel) + + +class DockerfileTest(unittest.TestCase): + def setUp(self): + self.text = (ROOT / "Dockerfile").read_text(encoding="utf-8") + + def test_all_paths_point_inside_one_data_volume(self): + for pair in ("SITE_ROOT=/data/site", "SITE_DIST=/data/dist", "SITE_STATE_DIR=/data/state"): + self.assertIn(pair, self.text) + self.assertEqual(re.findall(r"^VOLUME .*$", self.text, re.M), ['VOLUME ["/data"]']) + + def test_env_file_is_never_copied_into_the_image(self): + self.assertIn(".env", (ROOT / ".dockerignore").read_text(encoding="utf-8").splitlines()) + self.assertNotRegex(self.text, r"COPY\s+.*\.env") + + +class ReadmeTest(unittest.TestCase): + def test_readme_docker_command_matches_the_dockerfile(self): + readme = (ROOT / "README.md").read_text(encoding="utf-8") + self.assertIn('-v "$PWD/data:/data"', readme) + self.assertNotIn("/data/dist\" site-engine", readme) # прежняя схема с двумя томами + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_static_site.py b/tests/test_static_site.py new file mode 100644 index 0000000..46d8314 --- /dev/null +++ b/tests/test_static_site.py @@ -0,0 +1,49 @@ +import unittest + +from helpers import NOW, SiteTestCase + +from site_engine.build.pipeline import build_site +from site_engine.services.publish import rollback +from site_engine.web.static_site import resolve_site_file + + +class StaticSiteTest(SiteTestCase): + def test_unpublished(self): + self.assertEqual(resolve_site_file(self.out, "/"), ("unpublished", None)) + + def test_pages_assets_redirects_and_404(self): + build_site(self.site, self.out, now=NOW) + cur = (self.out / "current").resolve() + self.assertEqual(resolve_site_file(self.out, "/"), ("file", cur / "index.html")) + self.assertEqual(resolve_site_file(self.out, "/services/"), ("file", cur / "services" / "index.html")) + self.assertEqual(resolve_site_file(self.out, "/services"), ("redirect", "/services/")) + self.assertEqual(resolve_site_file(self.out, "/assets/hero.svg")[0], "file") + self.assertEqual(resolve_site_file(self.out, "/nope/"), ("not_found", None)) + self.assertEqual(resolve_site_file(self.out, "/drafts/next/"), ("not_found", None)) + + def test_custom_404_page_is_used(self): + self.write("pages/404.md", "---\ntitle: Не найдено\nstatus: published\nregions:\n main:\n - {id: b_h, fragment: page_header, props: {title: Нет такой страницы}}\n---\n") + build_site(self.site, self.out, now=NOW) + kind, target = resolve_site_file(self.out, "/missing/") + self.assertEqual((kind, target.name), ("not_found", "404.html")) + + def test_traversal_and_service_files_are_not_served(self): + build_site(self.site, self.out, now=NOW) + for path in ("/../../etc/passwd", "/..%2f..%2fetc/passwd", "/assets/../../x", "/_forms/consultation@d409cada0967.json", + "/_forms/", "/manifest.json", "/redirects.map", "//etc/passwd", "/\x00"): + self.assertEqual(resolve_site_file(self.out, path)[0], "not_found", path) + + def test_publish_and_rollback_are_visible_without_restart(self): + first = build_site(self.site, self.out, now=NOW) + self.edit("pages/privacy.md", "Текст политики", "Версия два") + second = build_site(self.site, self.out, now=NOW.replace(minute=30)) + page = lambda: resolve_site_file(self.out, "/privacy/")[1].read_text(encoding="utf-8") + self.assertIn("Версия два", page()) + rollback(self.out, first.build_id) + self.assertNotIn("Версия два", page()) + rollback(self.out, second.build_id) + self.assertIn("Версия два", page()) + + +if __name__ == "__main__": + unittest.main()