squad-manager/werkzeuge/server_test.py
danny 0c7aae5b93 Abgleich der Akten mit dem Server (ohne Oberflaeche)
- konto.py: Aufrufe der Schnittstelle, Anmeldung; das Token liegt per
  DPAPI an das Windows-Konto gebunden in konto.json
- abgleich.py: gleicht lokale Akten und Server ab. server.json neben
  jeder Akte haelt den Stand des letzten Abgleichs (Pruefwert des Inhalts
  statt Zeitstempel, der nur sekundengenau ist). Konflikte sichern die
  Serverfassung als konflikt-<Zeit>.json; auf dem Server geloeschte Akten
  wandern lokal in den Papierkorb
- hintergrund.py: Netzwerkarbeit im Thread, Ergebnis im tkinter-Hauptthread
- akte_modell.speichern(zeit_setzen=False) fuer uebernommene Serverdaten
- Server liefert portraet_kennung, damit ein zweiter Rechner neue Bilder erkennt
- Tests: werkzeuge/abgleich_test.py mit zwei simulierten Rechnern (34
  Faelle); der Testserver nutzt php-cgi statt "php -S", das unter Windows
  nach vielen Verbindungen haengen bleibt

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

515 lines
29 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 http.server
import io
import json
import os
import quopri
import re
import shutil
import socket
import subprocess
import sys
import tempfile
import threading
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 ""))
class _CgiServer(http.server.ThreadingHTTPServer):
daemon_threads = True
class _CgiAnfrage(http.server.BaseHTTPRequestHandler):
"""Liefert statische Dateien selbst und reicht .php an php-cgi weiter."""
def log_message(self, format, *args):
with open(self.server.protokoll, "a", encoding="utf-8") as datei:
datei.write(time.strftime("[%H:%M:%S] ") + (format % args) + "\n")
def do_GET(self):
self._behandeln()
def do_POST(self):
self._behandeln()
def _antwort(self, status, kopf, inhalt):
self.send_response(status)
for name, wert in kopf:
self.send_header(name, wert)
self.send_header("Content-Length", str(len(inhalt)))
self.send_header("Connection", "close")
self.end_headers()
self.wfile.write(inhalt)
def _behandeln(self):
wurzel = self.server.dokumentenstamm
pfad, _, abfrage = self.path.partition("?")
ziel = (wurzel / urllib.parse.unquote(pfad).lstrip("/")).resolve()
if wurzel not in ziel.parents and ziel != wurzel:
return self._antwort(403, [], b"")
if ziel.is_dir():
ziel = ziel / "index.php"
if not ziel.is_file():
return self._antwort(404, [("Content-Type", "text/plain")], b"File not found.")
laenge = int(self.headers.get("Content-Length") or 0)
koerper = self.rfile.read(laenge) if laenge else b""
if ziel.suffix != ".php":
art = {".png": "image/png", ".html": "text/html", ".json": "application/json"}.get(ziel.suffix, "application/octet-stream")
return self._antwort(200, [("Content-Type", art)], ziel.read_bytes())
umgebung = {k: v for k, v in os.environ.items() if k.upper() in ("SYSTEMROOT", "PATH", "TEMP", "TMP", "WINDIR")}
umgebung.update({
"REDIRECT_STATUS": "200", "GATEWAY_INTERFACE": "CGI/1.1", "SERVER_PROTOCOL": "HTTP/1.1",
"SCRIPT_FILENAME": str(ziel), "SCRIPT_NAME": "/" + ziel.relative_to(wurzel).as_posix(),
"REQUEST_METHOD": self.command, "QUERY_STRING": abfrage, "REQUEST_URI": self.path,
"CONTENT_LENGTH": str(laenge), "CONTENT_TYPE": self.headers.get("Content-Type", ""),
"SERVER_NAME": "127.0.0.1", "SERVER_PORT": str(self.server.server_port),
"REMOTE_ADDR": self.client_address[0], "DOCUMENT_ROOT": str(wurzel),
})
for name, wert in self.headers.items():
if name.lower() not in ("content-length", "content-type"):
umgebung["HTTP_" + name.upper().replace("-", "_")] = wert
lauf = subprocess.run([self.server.php_cgi], input=koerper, capture_output=True, env=umgebung, timeout=60)
if lauf.stderr:
self.log_message("php-cgi: %s", lauf.stderr.decode("utf-8", "replace")[:500])
kopftext, _, inhalt = lauf.stdout.partition(b"\r\n\r\n")
status, kopf = 200, []
for zeile in kopftext.decode("latin-1").split("\r\n"):
name, _, wert = zeile.partition(":")
if name.lower() == "status":
status = int(wert.strip().split()[0])
elif name:
kopf.append((name, wert.strip()))
if status == 200 and any(n.lower() == "location" for n, _ in kopf):
status = 302
self._antwort(status, kopf, inhalt)
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")
# Nicht "php -S": Der Entwicklungsserver nimmt unter Windows nach
# einigen hundert schnellen Verbindungen keine mehr an. Stattdessen
# startet ein Python-Server fuer jede Anfrage ein eigenes php-cgi -
# naeher an Plesk, wo PHP ebenfalls in eigenen Prozessen laeuft.
self.protokoll = self.ordner / "php-server.log"
self.webserver = _CgiServer(("127.0.0.1", self.port), _CgiAnfrage)
self.webserver.dokumentenstamm = (self.ordner / "sva.tyrveil.com").resolve()
self.webserver.protokoll = self.protokoll
self.webserver.php_cgi = str(Path(shutil.which("php")).with_name("php-cgi.exe"))
threading.Thread(target=self.webserver.serve_forever, daemon=True).start()
def laeuft(self):
return self.webserver is not None
def php_protokoll(self, zeilen=15):
text = self.protokoll.read_text(encoding="utf-8", errors="replace") if self.protokoll.exists() else ""
return "\n".join(text.splitlines()[-zeilen:])
def beenden(self):
self.webserver.shutdown()
self.webserver.server_close()
self.webserver = None
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()