server-up/tests/test_app_templates.py

"""Alle app-sjablonen doorlopen op fouten die pas bij het installeren opvallen.

Deze controles zijn ontstaan uit echte fouten: een Homepage die met
"Host validation failed" weigerde omdat de standaardwaarde een andere poort
noemde dan het poortveld, en velden die in het formulier stonden maar nergens
in het compose-bestand terechtkwamen.
"""
import json
import os
import re
import sys
from pathlib import Path

import pytest
import yaml

WORTEL = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(WORTEL / "server-up"))
os.environ.setdefault("SU_CONFIG", "/tmp/su-templates-test.json")

from core import boilerplates                                    # noqa: E402

APPS = WORTEL / "apps"
VAR_RE = re.compile(r"<<\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\|[^>]*?)?>>")
BLOK_RE = re.compile(r"<%-?\s*(?:if|elif)\s+([^%]+?)\s*-?%>")
SLEUTELWOORDEN = {"and", "or", "not", "in", "is", "if", "elif",
                  "true", "false", "none", "defined"}


def _apps():
    return sorted(d for d in APPS.iterdir()
                  if d.is_dir() and (d / "template.json").is_file())


def _compose_bestanden(d):
    f = d / "files"
    return sorted(p for p in f.iterdir()
                  if f.is_dir() and p.suffix in (".yaml", ".yml")
                  and "compose" in p.name.lower())


def _gerenderd(d):
    """Render elk compose-bestand met de standaardwaarden en geef de YAML."""
    velden = boilerplates.fields(d)
    waarden = {f["name"]: (f["default"] if f["default"] is not None else "")
               for f in velden}
    uit = []
    for p in _compose_bestanden(d):
        tekst = boilerplates.render_text(p.read_text(encoding="utf-8"), waarden)
        uit.append((p, yaml.safe_load(tekst)))
    return uit


IDS = [d.name for d in _apps()]


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_template_is_geldige_json(app):
    json.loads((app / "template.json").read_text(encoding="utf-8"))


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_rendert_naar_geldige_compose(app):
    for pad, doc in _gerenderd(app):
        assert isinstance(doc, dict), f"{pad.name} levert geen mapping op"
        assert doc.get("services"), f"{pad.name} heeft geen services"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_alle_variabelen_zijn_gedefinieerd(app):
    """Een variabele zonder veld rendert leeg; dat levert stilzwijgend een
    kapotte instelling op in plaats van een foutmelding."""
    namen = {f["name"] for f in boilerplates.fields(app)}
    for p in _compose_bestanden(app):
        ruw = p.read_text(encoding="utf-8")
        gebruikt = set(VAR_RE.findall(ruw))
        for blok in BLOK_RE.findall(ruw):
            gebruikt |= (set(re.findall(r"[a-zA-Z_][a-zA-Z0-9_]*", blok))
                         - SLEUTELWOORDEN)
        onbekend = sorted(gebruikt - namen)
        assert not onbekend, f"{p.name}: niet gedefinieerd: {onbekend}"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_geen_velden_die_nergens_gebruikt_worden(app):
    """Een veld dat nergens terechtkomt, liegt tegen de gebruiker: je vult een
    datamap in en je gegevens staan ergens anders."""
    velden = [f for f in boilerplates.fields(app) if not f.get("is_group_toggle")]
    gebruikt = set()
    for p in _compose_bestanden(app):
        ruw = p.read_text(encoding="utf-8")
        gebruikt |= set(VAR_RE.findall(ruw))
        for blok in BLOK_RE.findall(ruw):
            gebruikt |= set(re.findall(r"[a-zA-Z_][a-zA-Z0-9_]*", blok))
    # Ook andere bestanden in files/ mogen variabelen gebruiken — inclusief
    # YAML dat geen compose is, zoals de config.yaml die Headscale en Gatus
    # meekrijgen. Die vielen eerder tussen wal en schip: niet gescand als
    # compose, en overgeslagen omdat ze op .yaml eindigen.
    composes = set(_compose_bestanden(app))
    for p in (app / "files").rglob("*"):
        if p.is_file() and p not in composes:
            try:
                gebruikt |= set(VAR_RE.findall(p.read_text(encoding="utf-8")))
            except (UnicodeDecodeError, OSError):
                pass
    ongebruikt = sorted(f["name"] for f in velden if f["name"] not in gebruikt)
    assert not ongebruikt, f"velden zonder werking: {ongebruikt}"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_named_volumes_staan_bovenaan(app):
    """Compose weigert een volume dat niet in het top-level blok staat."""
    for pad, doc in _gerenderd(app):
        top = set(doc.get("volumes") or {})
        for snaam, svc in (doc.get("services") or {}).items():
            for v in (svc or {}).get("volumes") or []:
                if not isinstance(v, str):
                    continue
                bron = v.split(":")[0]
                if bron and not bron.startswith(("/", ".", "~", "$")):
                    assert bron in top, f"{pad.name}: {snaam} gebruikt '{bron}'"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_depends_on_verwijst_naar_bestaande_services(app):
    for pad, doc in _gerenderd(app):
        services = doc.get("services") or {}
        for snaam, svc in services.items():
            dep = (svc or {}).get("depends_on")
            for d in (list(dep) if isinstance(dep, (list, dict)) else []):
                assert d in services, f"{pad.name}: {snaam} → onbekend '{d}'"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_geen_dubbele_containernamen(app):
    for pad, doc in _gerenderd(app):
        namen = [svc.get("container_name") for svc in (doc.get("services") or {}).values()
                 if isinstance(svc, dict) and svc.get("container_name")]
        assert len(namen) == len(set(namen)), f"{pad.name}: dubbel in {namen}"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_geen_poortconflict_binnen_een_stack(app):
    """Twee services die dezelfde hostpoort claimen levert een stack op die
    half start. TCP en UDP op hetzelfde nummer mag wel."""
    for pad, doc in _gerenderd(app):
        bezet = {}
        for snaam, svc in (doc.get("services") or {}).items():
            for pr in (svc or {}).get("ports") or []:
                s = str(pr)
                proto = "udp" if s.endswith("/udp") else "tcp"
                deel = s.replace("/udp", "").replace("/tcp", "").split(":")
                if len(deel) >= 2 and deel[-2].strip('"').isdigit():
                    bezet.setdefault((deel[-2].strip('"'), proto), []).append(snaam)
        dubbel = {k: v for k, v in bezet.items() if len(v) > 1}
        assert not dubbel, f"{pad.name}: {dubbel}"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_poort_in_een_standaardwaarde_klopt_met_het_poortveld(app):
    """Homepage weigerde met 'Host validation failed' omdat allowed_hosts
    poort 3001 noemde terwijl het poortveld op 3002 stond. Dezelfde fout zat in
    baserow, hedgedoc en ntfy."""
    velden = boilerplates.fields(app)
    poorten = {f["default"] for f in velden
               if f["type"] == "int" and "port" in f["name"]
               and isinstance(f["default"], int)}
    if not poorten:
        return
    for f in velden:
        d = f.get("default")
        if not isinstance(d, str):
            continue
        # Een koppelveld wijst juist naar een ándere app; dat die op zijn eigen
        # poort staat is geen fout maar de bedoeling.
        if f.get("connect"):
            continue
        for m in re.finditer(r"[a-zA-Z0-9_.-]+:(\d{2,5})\b", d):
            genoemd = int(m.group(1))
            # Alleen poorten die duidelijk bij deze app horen; een willekeurig
            # ander nummer (een SMTP-poort bijvoorbeeld) valt hier buiten.
            if any(abs(genoemd - p) < 1000 for p in poorten):
                assert genoemd in poorten, (
                    f"{f['name']}={d!r} noemt poort {genoemd}, "
                    f"maar de poortvelden staan op {sorted(poorten)}")


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_wachtwoordvelden_zijn_als_geheim_gemarkeerd(app):
    """Anders staat het wachtwoord leesbaar in beeld en ontbreekt de knop om er
    een te laten maken."""
    for f in boilerplates.fields(app):
        naam = f["name"].lower()
        if any(w in naam for w in ("password", "secret", "token", "_key")):
            assert f["secret"] is True, f"{f['name']} is niet als geheim gemarkeerd"


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_geen_vast_wachtwoord_in_het_sjabloon(app):
    """Acht apps hadden er een: 'immich_db_pass' voor iedereen die het
    installeert, en 'admin' als beheerderswachtwoord van Grafana en Gotify.
    Een standaardwaarde die overal hetzelfde is, is geen wachtwoord."""
    for f in boilerplates.fields(app):
        if not f.get("secret"):
            continue
        waarde = str(f.get("default") or "").strip()
        assert not waarde, (
            f"{f['name']} heeft een vaste waarde ({waarde!r}); maak het veld "
            f"leeg en zet 'generate' aan, of laat de gebruiker het invullen")


@pytest.mark.parametrize("app", _apps(), ids=IDS)
def test_verplichte_geheimen_zijn_invulbaar_of_worden_gegenereerd(app):
    """Een verplicht geheim zonder standaardwaarde moet óf automatisch gevuld
    worden, óf iets zijn dat de gebruiker zelf aanlevert. Wat overblijft is een
    veld waar niemand een geldige waarde voor kan verzinnen."""
    # Wachtwoorden waarmee je zelf inlogt en tokens die je elders ophaalt vult
    # de gebruiker bewust zelf in. Nieuwe sjablonen zeggen dat met
    # `"eigen_invoer": true`; de namen hieronder zijn van vóór die vlag.
    eigen_invoer = ("admin_password", "web_password", "ui_password",
                    "superuser_password", "password_hash", "hass_token",
                    "forgejo_token", "adminpass")
    for f in boilerplates.fields(app):
        if not (f.get("required") and f.get("secret")):
            continue
        if str(f.get("default") or "").strip():
            continue
        if f.get("eigen_invoer"):
            continue
        # Een API-sleutel komt per definitie uit de app waar je naartoe wijst;
        # die kun je hier niet verzinnen, alleen overtypen.
        if f["name"].endswith(("_apikey", "_api_key")):
            continue
        if f.get("generate") or f["name"] in eigen_invoer:
            continue
        pytest.fail(f"{f['name']}: verplicht geheim zonder waarde, zonder "
                    f"generator en niet als eigen invoer aangemerkt")