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>
571 lines
33 KiB
Python
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()
|