squad-manager/werkzeuge/server_test.py
danny 6e4d4afc1d Server fuer Konten, Akten und Squads
PHP 8 ohne Framework unter server/: oeffentliche Einstiege fuer
sva.tyrveil.com (Schnittstelle, Konto-Links, Verwaltung, Einrichtung) und
die Logik in sva-privat neben dem Dokumentenstamm.

- Konten mit E-Mail-Bestaetigung, Anmeldung per Token, Passwort
  vergessen, Konto loeschen
- Akten auf dem Server mit serververgebener Aktennummer und
  Versionspruefung; Portraets werden neu als PNG gespeichert
- Squads mit Einladungen, Fuehrung uebergeben, Aufloesen
- Verwaltung fuer info@tyrveil.com: Nutzer, Charaktere, Squads
- Bremsen gegen Durchprobieren, Token nur als Hash, CSRF-Schutz

werkzeuge/server_test.py prueft alles lokal mit SQLite (91 Faelle).
Der Release-Bau legt dist/server und dist/sva-privat an, ohne config.php.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 17:50:33 +02:00

433 lines
25 KiB
Python

"""
Gesamttest des Servers (server/) auf dem eigenen Rechner.
Kopiert server/ in einen temporaeren Ordner mit derselben Aufteilung wie auf
Plesk (sva.tyrveil.com neben sva-privat), schreibt eine Test-config.php mit
SQLite und Mails als Dateien, startet den PHP-Entwicklungsserver und spielt
alle Ablaeufe durch. Beruehrt weder den echten Server noch die echte
Datenbank.
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\server_test.py
Braucht: php (8.1+) mit pdo_sqlite, gd, mbstring im Suchpfad.
"""
import base64
import http.cookiejar
import io
import json
import quopri
import re
import shutil
import socket
import subprocess
import sys
import tempfile
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
from PIL import Image
WURZEL = Path(__file__).resolve().parent.parent
SCHLUESSEL = "test-einrichtung-0123456789abcdef"
ergebnisse = {"ok": 0, "fehl": 0}
def pruefe(name, bedingung, info=""):
if bedingung:
ergebnisse["ok"] += 1
print(f" OK {name}")
else:
ergebnisse["fehl"] += 1
print(f" FEHL {name}" + (f" [{info}]" if info else ""))
def freier_port():
with socket.socket() as s:
s.bind(("127.0.0.1", 0))
return s.getsockname()[1]
class Server:
def __init__(self):
self.ordner = Path(tempfile.mkdtemp(prefix="sm_servertest_"))
shutil.copytree(WURZEL / "server", self.ordner, dirs_exist_ok=True)
(self.ordner / "sva-privat" / "config.php").unlink(missing_ok=True)
shutil.rmtree(self.ordner / "sva-privat" / "daten", ignore_errors=True)
shutil.copy2(WURZEL / "icon.png", self.ordner / "sva.tyrveil.com" / "icon.png")
self.port = freier_port()
self.basis = f"http://127.0.0.1:{self.port}"
privat = self.ordner / "sva-privat"
dsn = "sqlite:" + (privat / "test.sqlite").as_posix()
(privat / "config.php").write_text(f"""<?php
return [
'datenbank' => ['dsn' => '{dsn}', 'benutzer' => '', 'passwort' => ''],
'basis_url' => '{self.basis}',
'rechtliches_url' => 'https://tyrveil.com/rechtliches#impressum',
'admin_email' => 'info@tyrveil.com',
'mail' => ['art' => 'datei', 'absender' => 'info@tyrveil.com', 'absender_name' => 'Squad Manager'],
'einrichtungs_schluessel' => '{SCHLUESSEL}',
'daten_ordner' => __DIR__ . '/daten',
'fehler_anzeigen' => false,
];
""", encoding="utf-8")
self.prozess = subprocess.Popen(
["php", "-S", f"127.0.0.1:{self.port}", "-t", str(self.ordner / "sva.tyrveil.com")],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
for _ in range(50):
try:
socket.create_connection(("127.0.0.1", self.port), timeout=0.2).close()
break
except OSError:
time.sleep(0.1)
def beenden(self):
self.prozess.terminate()
self.prozess.wait(timeout=10)
shutil.rmtree(self.ordner, ignore_errors=True)
@property
def daten(self):
return self.ordner / "sva-privat" / "daten"
def letzte_mail(self, an):
mails = sorted((self.daten / "mails").glob("*.eml"), key=lambda p: p.stat().st_mtime_ns)
for pfad in reversed(mails):
roh = pfad.read_bytes()
kopf, _, inhalt = roh.partition(b"\r\n\r\n")
if f"To: {an}".encode() in kopf:
return quopri.decodestring(inhalt).decode("utf-8")
return ""
def link_aus_mail(self, an):
treffer = re.search(r"http://127\.0\.0\.1:\d+/\S+", self.letzte_mail(an))
return treffer.group(0) if treffer else ""
# -- HTTP ---------------------------------------------------------------
def api(self, aktion, token=None, **felder):
anfrage = urllib.request.Request(
self.basis + "/api/", data=json.dumps({"aktion": aktion, **felder}).encode(),
headers={"Content-Type": "application/json", **({"X-SM-Token": token} if token else {})},
method="POST")
try:
with urllib.request.urlopen(anfrage, timeout=30) as antwort:
return antwort.status, json.loads(antwort.read())
except urllib.error.HTTPError as fehler:
text = fehler.read()
try:
return fehler.code, json.loads(text)
except ValueError:
return fehler.code, {"roh": text[:300]}
def roh(self, pfad, daten=None, token=None, oeffner=None, methode=None):
kodiert = urllib.parse.urlencode(daten).encode() if daten is not None else None
anfrage = urllib.request.Request(self.basis + pfad, data=kodiert, method=methode,
headers={"X-SM-Token": token} if token else {})
try:
with (oeffner or urllib.request.build_opener()).open(anfrage, timeout=30) as antwort:
return antwort.status, antwort.read(), dict(antwort.headers)
except urllib.error.HTTPError as fehler:
return fehler.code, fehler.read(), dict(fehler.headers)
def akte(lokale_id, callsign, nachname, rang="", status="aktiv"):
return {"schema": 1, "id": lokale_id, "aktennummer": "SM-2026-0001",
"personalien": {"vorname": "Test", "nachname": nachname, "callsign": callsign},
"dienst": {"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": rang,
"verwendung": "Medic", "status": status},
"beschreibung": "", "auszeichnungen": [], "einsaetze": [], "vermerke": ""}
def png_base64(breite=900, hoehe=1200):
puffer = io.BytesIO()
Image.new("RGB", (breite, hoehe), (80, 90, 60)).save(puffer, "JPEG")
return base64.b64encode(puffer.getvalue()).decode()
def main():
s = Server()
try:
ablauf(s)
finally:
log = s.daten / "fehler.log"
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-600:])
s.beenden()
print(f"\nERGEBNIS: {ergebnisse['ok']} bestanden, {ergebnisse['fehl']} fehlgeschlagen")
sys.exit(1 if ergebnisse["fehl"] else 0)
def ablauf(s):
print("Einrichtung")
code, html, kopf = s.roh("/einrichten.php")
pruefe("Formular erreichbar", code == 200 and b"Einrichtungsschl" in html, code)
pruefe("Sicherheitskopf Referrer-Policy", kopf.get("Referrer-Policy") == "no-referrer", kopf)
code, html, _ = s.roh("/einrichten.php", {"schluessel": "falsch"})
pruefe("falscher Schlüssel abgewiesen", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL})
text = html.decode()
pruefe("Tabellen angelegt", "7 Tabellen vorhanden" in text, text[-500:])
admin_link = s.link_aus_mail("info@tyrveil.com")
pruefe("Passwort-Mail an info@tyrveil.com", "/konto/passwort.php?t=" in admin_link, admin_link)
code, html, _ = s.roh("/einrichten.php", {"schluessel": SCHLUESSEL})
pruefe("zweiter Aufruf schadet nicht", "vorhanden" in html.decode())
erster_link, admin_link = admin_link, s.link_aus_mail("info@tyrveil.com")
pruefe("zweiter Aufruf schickt neuen Link", admin_link and admin_link != erster_link)
code, html, _ = s.roh(urllib.parse.urlparse(erster_link).path + "?" + urllib.parse.urlparse(erster_link).query)
pruefe("erster Link damit ungültig", "ungültig" in html.decode())
print("Schnittstelle allgemein")
code, antwort = s.api("status")
pruefe("status", code == 200 and antwort.get("api") == 1, antwort)
code, _, _ = s.roh("/api/", methode="GET")
pruefe("GET wird abgewiesen (405)", code == 405, code)
code, antwort = s.api("charaktere_alle")
pruefe("ohne Token: nicht_angemeldet (401)", code == 401 and antwort["fehler"] == "nicht_angemeldet", antwort)
code, antwort = s.api("gibtsnicht", token="0" * 64)
pruefe("falsches Token: 401", code == 401, antwort)
print("Registrierung")
for name, email, pw, erwartet in (
("al", "al@example.org", "langespasswort1", "benutzername_ungueltig"),
("alice", "keine-mail", "langespasswort1", "email_ungueltig"),
("alice", "alice@example.org", "kurz", "passwort_zu_schwach")):
code, antwort = s.api("registrieren", benutzername=name, email=email, passwort=pw)
pruefe(f"abgewiesen: {erwartet}", antwort.get("fehler") == erwartet, antwort)
code, antwort = s.api("registrieren", benutzername="Alice", email="Alice@Example.org", passwort="alicepasswort1")
pruefe("Alice registriert", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("registrieren", benutzername="bob", email="bob@example.org", passwort="bobpasswort12")
pruefe("Bob registriert", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("registrieren", benutzername="ALICE", email="neu@example.org", passwort="alicepasswort1")
pruefe("Benutzername doppelt (Groß/klein egal)", antwort.get("fehler") == "benutzername_vergeben", antwort)
code, antwort = s.api("anmelden", login="alice", passwort="alicepasswort1")
pruefe("vor Bestätigung: nicht_bestaetigt", antwort.get("fehler") == "nicht_bestaetigt", antwort)
for wer in ("alice@example.org", "bob@example.org"):
link = s.link_aus_mail(wer)
code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query)
pruefe(f"Bestätigungslink {wer.split('@')[0]}", code == 200 and "bestätigt" in html.decode(), link)
code, html, _ = s.roh(urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query)
pruefe("Link nur einmal gültig", "ungültig" in html.decode())
print("Anmeldung")
code, antwort = s.api("anmelden", login="alice", passwort="falsch-falsch")
pruefe("falsches Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("anmelden", login="ALICE@example.org", passwort="alicepasswort1", geraet="Test-PC")
alice = antwort.get("token")
pruefe("Alice per E-Mail angemeldet", code == 200 and alice and antwort["nutzer"]["benutzername"] == "Alice", antwort)
code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12")
bob = antwort.get("token")
pruefe("Bob angemeldet", bool(bob), antwort)
code, antwort = s.api("ich", token=alice)
pruefe("ich", antwort.get("nutzer", {}).get("email") == "alice@example.org", antwort)
print("Charaktere")
ids = {n: f"{i:032x}" for i, n in enumerate(("nordlicht", "rook", "frost"), start=11)}
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"],
daten=akte(ids["nordlicht"], "Nordlicht", "Brandt", "Oberfeldwebel"))
nordlicht = antwort.get("charakter", {})
pruefe("Akte gespeichert, Server vergibt Nummer",
code == 200 and re.fullmatch(r"SM-\d{4}-\d{4}", nordlicht.get("aktennummer") or "")
and nordlicht["daten"]["aktennummer"] == nordlicht["aktennummer"], antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["frost"],
daten=akte(ids["frost"], "Frost", "Sigurdsson"))
frost = antwort.get("charakter", {})
code, antwort = s.api("charakter_speichern", token=bob, lokale_id=ids["rook"],
daten=akte(ids["rook"], "Rook", "Hutchins", status="gefallen"))
rook = antwort.get("charakter", {})
nummern = {nordlicht.get("aktennummer"), frost.get("aktennummer"), rook.get("aktennummer")}
pruefe("Aktennummern eindeutig", len(nummern) == 3 and None not in nummern, nummern)
geaendert = akte(ids["nordlicht"], "Nordlicht", "Brandt", "Hauptfeldwebel")
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1)
pruefe("Änderung mit passender Version", antwort.get("charakter", {}).get("version") == 2, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1)
pruefe("veraltete Version: konflikt (409) mit Serverstand",
code == 409 and antwort.get("charakter", {}).get("version") == 2, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id=ids["nordlicht"], daten=geaendert,
basis_version=1, erzwingen=True)
pruefe("erzwingen überschreibt", antwort.get("charakter", {}).get("version") == 3, antwort)
code, antwort = s.api("charakter_speichern", token=alice, lokale_id="kaputt", daten={})
pruefe("ungültige Akten-ID", antwort.get("fehler") == "lokale_id_ungueltig", antwort)
code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"], bild=png_base64())
pruefe("Porträt hochgeladen", antwort.get("charakter", {}).get("portraet") is True, antwort)
code, bild, kopf = s.roh(f"/api/bild.php?id={nordlicht['id']}", token=bob)
groesse = Image.open(io.BytesIO(bild)).size if code == 200 else None
pruefe("Porträt für andere abrufbar, neu als PNG ≤ 512",
code == 200 and kopf.get("Content-Type") == "image/png" and max(groesse) == 512, (code, groesse))
code, _, _ = s.roh(f"/api/bild.php?id={nordlicht['id']}")
pruefe("Porträt ohne Token: 401", code == 401, code)
code, antwort = s.api("portraet_hochladen", token=alice, lokale_id=ids["nordlicht"],
bild=base64.b64encode(b"<?php echo 1; ?>").decode())
pruefe("keine Bilddatei: abgewiesen", antwort.get("fehler") == "bild_ungueltig", antwort)
code, antwort = s.api("portraet_hochladen", token=bob, lokale_id=ids["nordlicht"], bild=png_base64(10, 10))
pruefe("fremde Akte: nicht gefunden", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("charaktere_alle", token=bob)
liste = antwort.get("charaktere", [])
pruefe("Bob sieht alle 3 Charaktere mit Status",
len(liste) == 3 and {c["callsign"]: c["status"] for c in liste}.get("Rook") == "gefallen", liste)
pruefe("'eigener' richtig gesetzt", [c["callsign"] for c in liste if c["eigener"]] == ["Rook"], liste)
code, antwort = s.api("charaktere_alle", token=bob, suche="nord")
pruefe("Suche", [c["callsign"] for c in antwort.get("charaktere", [])] == ["Nordlicht"], antwort)
code, antwort = s.api("charaktere_alle", token=bob, suche="100%_")
pruefe("Suche mit Sonderzeichen", code == 200 and antwort.get("charaktere") == [], antwort)
code, antwort = s.api("charakter_ansehen", token=bob, id=nordlicht["id"])
pruefe("fremde Akte ansehen", antwort.get("charakter", {}).get("daten", {}).get("dienst", {}).get("rang")
== "Hauptfeldwebel", antwort)
print("Squads")
code, antwort = s.api("squad_gruenden", token=alice, charakter_id=nordlicht["id"], name=" Nordwind ")
squad = antwort.get("squad", {})
pruefe("Squad gegründet", squad.get("name") == "Nordwind" and squad.get("fuehrer_id") == nordlicht["id"], antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="nordwind")
pruefe("Name doppelt", antwort.get("fehler") == "name_vergeben", antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=nordlicht["id"], name="Fremd")
pruefe("fremder Charakter kann nicht gründen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Nicht-Führer kann nicht einladen", antwort.get("fehler") == "kein_fuehrer", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
einladung = antwort.get("einladung", {})
pruefe("Alice lädt Rook ein", einladung.get("status") == "offen", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("doppelte Einladung", antwort.get("fehler") == "schon_eingeladen", antwort)
code, antwort = s.api("einladungen", token=bob)
pruefe("Bob sieht Einladung im Eingang", [e["squad"]["name"] for e in antwort.get("eingang", [])] == ["Nordwind"], antwort)
code, antwort = s.api("einladungen", token=alice)
pruefe("Alice sieht sie im Ausgang", len(antwort.get("ausgang", [])) == 1, antwort)
code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=einladung["id"], annehmen=True)
pruefe("Alice kann Bobs Einladung nicht annehmen", antwort.get("fehler") == "charakter_nicht_gefunden", antwort)
code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True)
pruefe("Bob nimmt an", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("einladung_beantworten", token=bob, einladung_id=einladung["id"], annehmen=True)
pruefe("zweimal annehmen geht nicht", antwort.get("fehler") == "einladung_nicht_offen", antwort)
code, antwort = s.api("squad_gruenden", token=bob, charakter_id=rook["id"], name="Zweites")
pruefe("im Squad kein zweites gründen", antwort.get("fehler") == "bereits_im_squad", antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"])
frost_einladung = antwort.get("einladung", {})
code, antwort = s.api("einladung_zurueckziehen", token=alice, einladung_id=frost_einladung.get("id"))
pruefe("Einladung zurückgezogen", code == 200, antwort)
code, antwort = s.api("squad_einladen", token=alice, squad_id=squad["id"], charakter_id=frost["id"])
code, antwort = s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=False)
pruefe("Einladung abgelehnt", code == 200, antwort)
code, antwort = s.api("squad_ansehen", token=bob, squad_id=squad["id"])
pruefe("Squad hat 2 Mitglieder", [m["callsign"] for m in antwort.get("squad", {}).get("mitglieder", [])]
== ["Nordlicht", "Rook"], antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
pruefe("Führer mit Mitgliedern muss übergeben", antwort.get("fehler") == "fuehrer_muss_uebergeben", antwort)
code, antwort = s.api("squad_fuehrung_uebergeben", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Führung an Rook übergeben", code == 200, antwort)
code, antwort = s.api("squad_entfernen", token=alice, squad_id=squad["id"], charakter_id=rook["id"])
pruefe("Ex-Führer kann nicht mehr entfernen", antwort.get("fehler") == "kein_fuehrer", antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
pruefe("Nordlicht verlässt das Squad", code == 200, antwort)
code, antwort = s.api("squad_einladen", token=bob, squad_id=squad["id"], charakter_id=nordlicht["id"])
s.api("einladung_beantworten", token=alice, einladung_id=antwort["einladung"]["id"], annehmen=True)
code, antwort = s.api("charakter_loeschen", token=bob, lokale_id=ids["rook"])
pruefe("Führer gelöscht", code == 200, antwort)
code, antwort = s.api("squad_ansehen", token=alice, squad_id=squad["id"])
pruefe("dienstältestes Mitglied übernimmt", antwort.get("squad", {}).get("fuehrer_id") == nordlicht["id"], antwort)
code, antwort = s.api("squad_verlassen", token=alice, charakter_id=nordlicht["id"])
code, antwort = s.api("squads", token=alice)
pruefe("letztes Mitglied geht: Squad aufgelöst", antwort.get("squads") == [], antwort)
print("Passwort vergessen")
code, antwort = s.api("passwort_vergessen", email="gibtsnicht@example.org")
pruefe("unbekannte Adresse: gleiche Antwort", code == 200 and antwort["ok"], antwort)
code, antwort = s.api("passwort_vergessen", email="alice@example.org")
link = s.link_aus_mail("alice@example.org")
pfad = urllib.parse.urlparse(link).path + "?" + urllib.parse.urlparse(link).query
code, html, _ = s.roh(pfad)
pruefe("Formular per GET, Link noch nicht verbraucht", code == 200 and "Neues Passwort" in html.decode(), link)
token = urllib.parse.parse_qs(urllib.parse.urlparse(link).query)["t"][0]
code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "anders"})
pruefe("Wiederholung falsch", "stimmen nicht" in html.decode())
code, html, _ = s.roh("/konto/passwort.php", {"t": token, "passwort": "neuespasswort1", "wiederholung": "neuespasswort1"})
pruefe("neues Passwort gespeichert", "Passwort gespeichert" in html.decode())
code, antwort = s.api("ich", token=alice)
pruefe("alte Sitzung abgemeldet", code == 401, antwort)
code, antwort = s.api("anmelden", login="alice", passwort="neuespasswort1")
alice = antwort.get("token")
pruefe("Anmeldung mit neuem Passwort", bool(alice), antwort)
print("Verwaltung")
jar = http.cookiejar.CookieJar()
oeffner = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
def csrf(html):
treffer = re.search(rb'name="csrf" value="([0-9a-f]+)"', html)
return treffer.group(1).decode() if treffer else ""
admin_token = urllib.parse.parse_qs(urllib.parse.urlparse(admin_link).query)["t"][0]
code, html, _ = s.roh("/konto/passwort.php", {"t": admin_token, "passwort": "adminpasswort99",
"wiederholung": "adminpasswort99"})
pruefe("Admin-Passwort über Einrichtungslink gesetzt", "Zur Verwaltung" in html.decode())
code, html, _ = s.roh("/verwaltung/", oeffner=oeffner)
pruefe("Verwaltung fordert Anmeldung", "Anmelden" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com", "passwort": "falsch",
"csrf": csrf(html)}, oeffner=oeffner)
pruefe("falsches Admin-Passwort", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "alice@example.org",
"passwort": "neuespasswort1", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("normaler Nutzer kommt nicht in die Verwaltung", "stimmt nicht" in html.decode())
code, html, _ = s.roh("/verwaltung/", {"aktion": "anmelden", "email": "info@tyrveil.com",
"passwort": "adminpasswort99", "csrf": csrf(html)}, oeffner=oeffner)
pruefe("Admin angemeldet, Übersicht", code == 200 and "Offene Einladungen" in html.decode(), html[-300:])
for seite, erwartet in (("nutzer", "alice@example.org"), ("charaktere", "Nordlicht"), ("squads", "Squads"),
(f"charakter&id={nordlicht['id']}", "ROHDATEN")):
code, html, _ = s.roh(f"/verwaltung/?seite={seite}", oeffner=oeffner)
pruefe(f"Seite {seite.split('&')[0]}", code == 200 and erwartet in html.decode(), code)
code, bild, kopf = s.roh(f"/verwaltung/?seite=bild&id={nordlicht['id']}", oeffner=oeffner)
pruefe("Porträt in der Verwaltung", code == 200 and kopf.get("Content-Type") == "image/png", code)
code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner)
bob_id = s_nutzer_id(html, "bob@example.org")
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id}, oeffner=oeffner)
pruefe("ohne CSRF-Token abgewiesen", "abgelaufen" in html.decode())
code, html, _ = s.roh("/verwaltung/?seite=nutzer", oeffner=oeffner)
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_sperren", "id": bob_id, "csrf": csrf(html)},
oeffner=oeffner)
pruefe("Bob gesperrt", "gesperrt und abgemeldet" in html.decode())
code, antwort = s.api("ich", token=bob)
pruefe("Bobs Sitzung ungültig", code == 401, antwort)
code, antwort = s.api("anmelden", login="bob", passwort="bobpasswort12")
pruefe("Bob kann sich nicht anmelden", antwort.get("fehler") == "gesperrt", antwort)
code, html, _ = s.roh(f"/verwaltung/?seite=bestaetigen&aktion=nutzer_loeschen&id={bob_id}", oeffner=oeffner)
pruefe("Löschen zeigt Bestätigungsseite", "Ja, ausführen" in html.decode() and "bob" in html.decode())
code, html, _ = s.roh("/verwaltung/?seite=nutzer", {"aktion": "nutzer_loeschen", "id": bob_id, "csrf": csrf(html)},
oeffner=oeffner)
pruefe("Bob gelöscht", "gelöscht" in html.decode() and "bob@example.org" not in html.decode())
print("Konto und Bremse")
code, antwort = s.api("konto_loeschen", token=alice, passwort="falsch")
pruefe("Konto löschen braucht Passwort", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("konto_loeschen", token=alice, passwort="neuespasswort1")
pruefe("Alice löscht ihr Konto", code == 200, antwort)
portraets = list((s.daten / "portraets").glob("*.png"))
pruefe("Porträtdateien mitgelöscht", portraets == [], portraets)
antworten = [s.api("anmelden", login="niemand", passwort="falsch-falsch")[1].get("fehler") for _ in range(11)]
pruefe("nach 10 Fehlversuchen: zu_viele_versuche", antworten[-1] == "zu_viele_versuche", antworten)
def s_nutzer_id(html, email):
zeilen = html.decode().split("<tr>")
for zeile in zeilen:
if email in zeile:
treffer = re.search(r'name="id" value="(\d+)"', zeile)
if treffer:
return treffer.group(1)
return "0"
if __name__ == "__main__":
main()