squad-manager/werkzeuge/oberflaeche_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

302 lines
14 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
Test des Squad-Reiters im laufenden Programm gegen den lokalen Testserver.
Legt zwei Konten an, startet das Programm mit eigenem %APPDATA%, meldet
sich ueber die Eingabefelder an, wartet den Abgleich ab, nimmt eine
Einladung an und oeffnet eine fremde Akte. Bildschirmfotos landen im
Ordner, der als erstes Argument uebergeben wird (Standard: Temp).
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\oberflaeche_test.py [bildordner]
"""
import ctypes
import ctypes.wintypes as wintypes
import os
import subprocess
import sys
import tempfile
import time
import urllib.parse
from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(Path(__file__).resolve().parent))
import server_test as st # noqa: E402
BILDER = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(tempfile.gettempdir())
server = st.Server()
os.environ["SM_SERVER"] = server.basis
os.environ["APPDATA"] = tempfile.mkdtemp(prefix="sm_ui_")
# SM_PROGRAMM=dist\paket\Programm prueft das gebaute Paket statt der Quelle
sys.path.insert(0, os.environ.get("SM_PROGRAMM") or str(WURZEL))
import tkinter as tk # noqa: E402
from PIL import Image # noqa: E402
import akte_modell as modell # noqa: E402
import konto # noqa: E402
import squad_manager as sm # noqa: E402
pruefe = st.pruefe
def konto_anlegen(name, email, passwort):
server.api("registrieren", benutzername=name, email=email, passwort=passwort)
teile = urllib.parse.urlparse(server.link_aus_mail(email))
server.roh(teile.path + "?" + teile.query)
return server.api("anmelden", login=name, passwort=passwort)[1]["token"]
# -- Vorbereitung auf dem Server und lokal ---------------------------------------
server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL})
kamerad = konto_anlegen("kamerad", "kamerad@example.org", "kameradpasswort1")
rook_akte = {"schema": 1, "id": "ab" * 16, "personalien": {"vorname": "Dale", "nachname": "Hutchins", "callsign": "Rook"},
"dienst": {"fraktion": "US Marine Corps", "teilstreitkraft": "Marineinfanterie",
"rang": "Corporal (Cpl)", "verwendung": "Automatic Rifleman", "status": "gefallen"},
"beschreibung": "Gefallen bei der Verteidigung von Point Alpha.", "auszeichnungen": [],
"einsaetze": [], "vermerke": ""}
rook = server.api("charakter_speichern", token=kamerad, lokale_id=rook_akte["id"], daten=rook_akte)[1]["charakter"]
hawk_akte = dict(rook_akte, id="cd" * 16, personalien={"vorname": "Mia", "nachname": "Lindqvist", "callsign": "Hawk"},
dienst={"fraktion": "Schweden – Försvarsmakten", "teilstreitkraft": "Amphibienkorps (Amfibiekåren)",
"rang": "Sergeant", "verwendung": "Squad Leader", "status": "aktiv"})
hawk = server.api("charakter_speichern", token=kamerad, lokale_id=hawk_akte["id"], daten=hawk_akte)[1]["charakter"]
squad = server.api("squad_gruenden", token=kamerad, charakter_id=hawk["id"], name="Nordwind",
beschreibung="Amphibische Aufklärung, Schären vor Stockholm.")[1]["squad"]
server.api("squad_einladen", token=kamerad, squad_id=squad["id"], charakter_id=rook["id"])
server.api("einladung_beantworten", token=kamerad,
einladung_id=server.api("einladungen", token=kamerad)[1]["eingang"][0]["id"], annehmen=True)
nordlicht = modell.neu_anlegen()
nordlicht["personalien"].update({"vorname": "Erik", "nachname": "Brandt", "callsign": "Nordlicht"})
nordlicht["dienst"].update({"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": "Oberfeldwebel",
"verwendung": "Squad Leader"})
modell.speichern(nordlicht)
bild = Path(os.environ["APPDATA"]) / "portraet.jpg"
Image.new("RGB", (400, 500), (58, 70, 46)).save(bild, "JPEG")
modell.portraet_setzen(nordlicht["id"], bild)
lokale_nummer = nordlicht["aktennummer"]
# -- Programm ---------------------------------------------------------------------
class RECT(ctypes.Structure):
_fields_ = [("l", wintypes.LONG), ("t", wintypes.LONG), ("r", wintypes.LONG), ("b", wintypes.LONG)]
def foto(fenster, name):
fenster.update_idletasks()
fenster.update()
hwnd = ctypes.windll.user32.GetParent(fenster.winfo_id()) or fenster.winfo_id()
r = RECT()
ctypes.windll.user32.GetWindowRect(wintypes.HWND(hwnd), ctypes.byref(r))
ziel = BILDER / name
ps = ("Add-Type -AssemblyName System.Drawing;"
f"$b = New-Object System.Drawing.Bitmap {r.r - r.l},{r.b - r.t};"
"$g = [System.Drawing.Graphics]::FromImage($b);"
f"$g.CopyFromScreen({r.l},{r.t},0,0,$b.Size);$b.Save('{ziel}')")
subprocess.run(["powershell", "-NoProfile", "-Command", ps], capture_output=True)
fehler = []
root = tk.Tk()
sm.apply_tactical_theme(root)
app = sm.VoiceActivationApp(root)
root.report_callback_exception = lambda *a: fehler.append(a)
root.attributes("-topmost", True)
seite = app.squad
def warte(bedingung, dann, grenze=60.0, name=""):
start = time.time()
def pruefen():
if bedingung():
dann()
elif time.time() - start > grenze:
pruefe(f"Zeitlimit: {name}", False)
ende()
else:
root.after(150, pruefen)
root.after(150, pruefen)
def schritt_anmeldung():
app.haupt_nb.select(2)
root.update()
pruefe("ohne Mitmachen: Einstiegsseite", seite.anmeldung.winfo_ismapped())
pruefe("vor dem Mitmachen nichts hochgeladen", "Nur auf diesem PC" in app.akte.abgleich_var.get(),
app.akte.abgleich_var.get())
foto(root, "ui_1_mitmachen.png")
seite.anmeldung.spielername_var.set("danny")
seite.anmeldung.mitmachen()
warte(lambda: konto.angemeldet() and seite.inhalt.winfo_ismapped(), schritt_abgleich, name="Mitmachen")
def schritt_abgleich():
root.update()
pruefe("mitgemacht ohne Konto", seite.nutzer_var.get() == "Spieler: danny"
and not konto.gesichert(), seite.nutzer_var.get())
pruefe("Hinweis 'Konto sichern' sichtbar", seite.sichern_zeile.winfo_ismapped()
and "Konto sichern" in seite.sichern_text.cget("text"))
seite._konto_menue_fuellen()
eintraege = [seite.konto_menue.entrycget(i, "label") for i in range(seite.konto_menue.index("end") + 1)
if seite.konto_menue.type(i) == "command"]
pruefe("Menü: Konto sichern statt Abmelden", "Konto sichern …" in eintraege and "Abmelden" not in eintraege,
eintraege)
warte(lambda: "abgeglichen" in app.akte.abgleich_var.get(), schritt_liste, name="Abgleich")
def schritt_liste():
geladen = modell.laden(nordlicht["id"])
pruefe("Aktennummer vom Server übernommen", geladen["aktennummer"] != lokale_nummer
or geladen["aktennummer"].startswith("SM-"), (lokale_nummer, geladen["aktennummer"]))
pruefe("AKTE-Reiter zeigt Abgleich", "abgeglichen" in app.akte.abgleich_var.get(), app.akte.abgleich_var.get())
seite._zuletzt_geladen = 0
seite._laedt = False
seite.aktualisieren()
warte(lambda: len(seite.charaktere) == 3 and len(seite.einladungen["eingang"]) == 0, schritt_einladung,
name="Liste laden")
def schritt_einladung():
namen = {c["callsign"]: c for c in seite.charaktere}
pruefe("drei Charaktere, eigener markiert", set(namen) == {"Nordlicht", "Rook", "Hawk"} and namen["Nordlicht"]["eigener"])
pruefe("Zustand KIA in der Liste", seite.liste.item(str(namen["Rook"]["id"]))["values"][2] == "KIA · gefallen",
seite.liste.item(str(namen["Rook"]["id"]))["values"])
seite.liste.selection_set(str(namen["Rook"]["id"]))
root.update()
pruefe("Einladen gesperrt ohne eigenes Squad", str(seite.knopf_einladen["state"]) == "disabled",
seite.einladen_hinweis.cget("text"))
# Das Portraet hat nur Nordlicht - hochgeladen vom Abgleich
seite.liste.selection_set(str(namen["Nordlicht"]["id"]))
root.update()
def konto_menue_foto():
foto(root, "ui_2_charaktere.png")
knopf = next(w for w in seite.inhalt.winfo_children()[0].winfo_children() if isinstance(w, tk.Menubutton)
or w.winfo_class() == "TMenubutton")
pruefe("Konto-Knopf vorhanden", knopf.cget("text") == "Konto")
schritt_einladen()
warte(lambda: seite.bild.cget("text") == "", konto_menue_foto, grenze=15, name="Porträt laden")
def schritt_einladen():
server.api("squad_einladen", token=kamerad, squad_id=squad["id"],
charakter_id=next(c["id"] for c in seite.charaktere if c["callsign"] == "Nordlicht"))
seite.aktualisieren()
warte(lambda: len(seite.einladungen["eingang"]) == 1, schritt_annehmen, name="Einladung laden")
def schritt_annehmen():
seite.nb.select(2)
pruefe("Reiter zeigt Anzahl", seite.nb.tab(seite.einladungen_seite, "text") == "Einladungen (1)")
seite.eingang.selection_set(seite.eingang.get_children()[0])
root.update()
foto(root, "ui_3_einladungen.png")
seite.einladung_beantworten(True)
warte(lambda: any(c["callsign"] == "Nordlicht" and c.get("squad") for c in seite.charaktere)
and not seite.einladungen["eingang"], schritt_squad, name="Annehmen")
def schritt_squad():
pruefe("Nordlicht ist jetzt in Nordwind", next(c for c in seite.charaktere
if c["callsign"] == "Nordlicht")["squad"]["name"] == "Nordwind")
seite.nb.select(1)
seite.squad_liste.selection_set(seite.squad_liste.get_children()[0])
root.update()
pruefe("drei Mitglieder, Führer mit Stern", len(seite.mitglieder.get_children()) == 3
and str(seite.mitglieder.item(seite.mitglieder.get_children()[0])["values"][0]).startswith("★"))
pruefe("Nicht-Führer: Auflösen gesperrt, Verlassen möglich",
str(seite.knopf_aufloesen["state"]) == "disabled" and str(seite.knopf_verlassen["state"]) == "normal")
foto(root, "ui_4_squads.png")
seite.nb.select(0)
seite.liste.selection_set(str(next(c["id"] for c in seite.charaktere if c["callsign"] == "Rook")))
root.update()
vorher = set(fenster_alle(root))
seite.akte_ansehen()
warte(lambda: set(fenster_alle(root)) - vorher, lambda: schritt_fenster(vorher), name="Akte ansehen")
def fenster_alle(widget):
"""Alle Toplevel-Fenster im Baum - das Aktenfenster haengt am Squad-Reiter, nicht an root."""
for kind in widget.winfo_children():
if isinstance(kind, tk.Toplevel):
yield kind
yield from fenster_alle(kind)
def schritt_fenster(vorher):
fenster = next(iter(set(fenster_alle(root)) - vorher))
fenster.attributes("-topmost", True)
root.after(600, lambda: (foto(fenster, "ui_5_fremde_akte.png"), fenster.destroy(), schritt_akte()))
def schritt_akte():
app.haupt_nb.select(1)
root.after(500, lambda: (foto(root, "ui_6_akte_status.png"), schritt_sichern()))
def schritt_sichern():
app.haupt_nb.select(2)
seite.hintergrund.starten(lambda: konto.konto_sichern("danny@example.org", "dannypasswort1"),
lambda _: seite._kopf_aktualisieren(), lambda f: fehler.append((type(f), f, None)))
warte(lambda: konto.gesichert(), schritt_bestaetigen, name="Konto sichern")
def schritt_bestaetigen():
root.update()
pruefe("nach dem Sichern: Hinweis auf Bestätigung", "nicht bestätigt" in seite.sichern_text.cget("text"),
seite.sichern_text.cget("text"))
teile = urllib.parse.urlparse(server.link_aus_mail("danny@example.org"))
server.roh(teile.path + "?" + teile.query)
seite._laedt = False
seite.aktualisieren()
warte(lambda: (konto.nutzer() or {}).get("bestaetigt") and not seite.sichern_zeile.winfo_ismapped(),
schritt_nach_bestaetigung, name="Bestätigung übernehmen")
def schritt_nach_bestaetigung():
seite._konto_menue_fuellen()
eintraege = [seite.konto_menue.entrycget(i, "label") for i in range(seite.konto_menue.index("end") + 1)
if seite.konto_menue.type(i) == "command"]
pruefe("gesichert und bestätigt: Hinweis weg, Menü mit Abmelden", "Abmelden" in eintraege, eintraege)
code, antwort = server.api("anmelden", login="danny@example.org", passwort="dannypasswort1")
pruefe("zweiter PC könnte sich jetzt anmelden", antwort.get("nutzer", {}).get("benutzername") == "danny", antwort)
schritt_konto_loeschen()
def schritt_konto_loeschen():
app.haupt_nb.select(2)
seite.nb.select(0)
root.update()
seite.konto_loeschen_ausfuehren("dannypasswort1", bestaetigen=False)
warte(lambda: not konto.angemeldet() and seite.anmeldung.winfo_ismapped(), schritt_nach_loeschen,
name="Konto löschen")
def schritt_nach_loeschen():
code, antwort = server.api("anmelden", login="danny", passwort="dannypasswort1")
pruefe("Konto auf dem Server gelöscht", antwort.get("fehler") == "anmeldung_falsch", antwort)
pruefe("lokale Akte bleibt erhalten", modell.laden(nordlicht["id"])["personalien"]["callsign"] == "Nordlicht")
pruefe("Abgleichstand der Akte entfernt", not (modell.ordner_von(nordlicht["id"]) / "server.json").exists())
squad_nachher = server.api("squad_ansehen", token=kamerad, squad_id=squad["id"])[1]["squad"]
pruefe("Nordlicht aus dem Squad verschwunden",
[m["callsign"] for m in squad_nachher["mitglieder"]] == ["Rook", "Hawk"]
or sorted(m["callsign"] for m in squad_nachher["mitglieder"]) == ["Hawk", "Rook"], squad_nachher)
ende()
def ende():
pruefe("keine Fehler in Tk-Rückrufen", not fehler, [str(f[1]) for f in fehler][:3])
app.stop()
root.destroy()
root.after(1500, schritt_anmeldung)
root.mainloop()
log = server.daten / "fehler.log"
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
pruefe("fehler.log des Servers leer", not inhalt.strip(), inhalt[-500:])
server.beenden()
print(f"\nERGEBNIS: {st.ergebnisse['ok']} bestanden, {st.ergebnisse['fehl']} fehlgeschlagen")