squad-manager/werkzeuge/server_test.py
danny a5da53d373 1.7.0: Mitmachen im Squad ohne Konto
Der Squad-Reiter braucht kein Konto mehr: Spielername eingeben, der PC
bekommt einen Schluessel (Token ohne Ablauf), die Akten werden fuer alle
sichtbar. E-Mail und Passwort sind optional ("Konto sichern") und machen
die Charaktere reset- und mehr-PC-fest. Ohne gesichertes Konto bietet das
Menue kein Abmelden, weil das den Schluessel loeschte.

Server: Aktionen mitmachen und konto_sichern, Konten ohne E-Mail
(Datenbank-Stand 2, eingespielt von DB::migrieren() bei der ersten
Anfrage), Loeschen ohne Passwort fuer reine Schluessel-Konten, Verwaltung
zeigt sie als "nur Schluessel". Deinstallationsfrage nennt den Schluessel.

Tests: Server 108, Zwei-PC 34, Oberflaeche 24 - auch gegen das Paket.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 06:35:54 +02:00

571 lines
33 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())
import sqlite3
datenbank = sqlite3.connect(s.ordner / "sva-privat" / "test.sqlite")
datenbank.execute("UPDATE sm_meta SET wert = '1' WHERE schluessel = 'schema'")
datenbank.commit()
(s.daten / "schema-2.ok").unlink()
s.api("status")
stand = datenbank.execute("SELECT wert FROM sm_meta WHERE schluessel = 'schema'").fetchone()[0]
pruefe("Datenbank-Update läuft bei der ersten Anfrage", stand == "2" and (s.daten / "schema-2.ok").exists(), stand)
datenbank.close()
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("Mitmachen ohne Konto")
code, antwort = s.api("mitmachen", spielername="x")
pruefe("Spielername zu kurz", antwort.get("fehler") == "benutzername_ungueltig", antwort)
code, antwort = s.api("mitmachen", spielername="Kiwi", geraet="PC-Kiwi")
kiwi, kiwi_nutzer = antwort.get("token"), antwort.get("nutzer", {})
pruefe("mitgemacht: Schlüssel ohne E-Mail",
kiwi and kiwi_nutzer.get("gesichert") is False and kiwi_nutzer.get("email") is None, antwort)
code, antwort = s.api("mitmachen", spielername="kiwi")
pruefe("Spielername doppelt (Groß/klein egal)", antwort.get("fehler") == "benutzername_vergeben", antwort)
code, antwort = s.api("mitmachen", spielername="Alice")
pruefe("Name eines E-Mail-Kontos ist auch vergeben", antwort.get("fehler") == "benutzername_vergeben", antwort)
kiwi_akte = "f" * 32
code, antwort = s.api("charakter_speichern", token=kiwi, lokale_id=kiwi_akte,
daten=akte(kiwi_akte, "Kiwi-1", "Tane"))
pruefe("mit Schlüssel Akte speichern", code == 200, antwort)
code, antwort = s.api("charaktere_alle", token=alice)
pruefe("andere sehen den Charakter mit Spielernamen",
any(c["callsign"] == "Kiwi-1" and c["spieler"] == "Kiwi" for c in antwort.get("charaktere", [])), antwort)
code, antwort = s.api("anmelden", login="Kiwi", passwort="irgendwas123")
pruefe("ohne gesichertes Konto keine Passwort-Anmeldung", antwort.get("fehler") == "anmeldung_falsch", antwort)
code, antwort = s.api("konto_sichern", token=kiwi, email="alice@example.org", passwort="kiwipasswort1")
pruefe("Sichern mit vergebener E-Mail abgewiesen", antwort.get("fehler") == "email_vergeben", antwort)
code, antwort = s.api("konto_sichern", token=kiwi, email="Kiwi@Example.org", passwort="kiwipasswort1")
pruefe("Konto gesichert, noch unbestätigt",
antwort.get("nutzer", {}).get("gesichert") is True and antwort["nutzer"]["bestaetigt"] is False, antwort)
code, antwort = s.api("konto_sichern", token=kiwi, email="kiwi2@example.org", passwort="kiwipasswort1")
pruefe("zweimal sichern geht nicht", antwort.get("fehler") == "schon_gesichert", antwort)
code, antwort = s.api("ich", token=kiwi)
pruefe("Schlüssel gilt nach dem Sichern weiter", code == 200, antwort)
teile = urllib.parse.urlparse(s.link_aus_mail("kiwi@example.org"))
s.roh(teile.path + "?" + teile.query)
code, antwort = s.api("anmelden", login="kiwi@example.org", passwort="kiwipasswort1")
zweiter_pc = antwort.get("token")
pruefe("zweiter PC: Anmeldung mit E-Mail, gleiches Konto",
zweiter_pc and antwort["nutzer"]["id"] == kiwi_nutzer.get("id"), antwort)
code, antwort = s.api("charaktere_eigene", token=zweiter_pc)
pruefe("zweiter PC sieht die Akte", [c["lokale_id"] for c in antwort.get("charaktere", [])] == [kiwi_akte], antwort)
code, antwort = s.api("mitmachen", spielername="Einweg")
einweg = antwort.get("token")
code, antwort = s.api("konto_loeschen", token=einweg, passwort="")
pruefe("Konto nur mit Schlüssel ohne Passwort löschbar", code == 200, antwort)
code, antwort = s.api("ich", token=einweg)
pruefe("Schlüssel danach ungültig", code == 401, antwort)
code, antwort = s.api("mitmachen", spielername="Stumm")
pruefe("weiteres Mitmachen", bool(antwort.get("token")), 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", "nur Schlüssel"), ("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()