squad-manager/werkzeuge/abgleich_test.py
danny 4d9e30bc90 1.6.0: Squad-Reiter, Anmeldung und Abgleich im Programm
- Neuer Hauptreiter SQUAD: Anmeldung und Registrierung; angemeldet alle
  Charaktere mit Zustand (KIA/MIA/WIA), Suche und Fraktionsfilter,
  fremde Akten als Dokument, Squads gruenden und verwalten, Einladungen
  annehmen, ablehnen, zurueckziehen; Konto abmelden oder loeschen
- Akten werden nach dem Anmelden, kurz nach jeder Aenderung und alle
  5 Minuten mit dem Server abgeglichen; Zustand unter der Aktenliste
- Dokumentansicht als dokument_zeichnen() fuer eigene und fremde Akten;
  ohne Portraet scheint "KEIN PORTRAET" nicht mehr durch den Stempel
- Release-Bau: Bezeichner wie "konto_loeschen" bekommen keine Umlaute
  mehr - sonst waeren vier Serveraktionen im Paket kaputt gewesen
- Tests koennen mit SM_PROGRAMM gegen das gebaute Paket laufen
- Datenschutz-Baustein fuer tyrveil.com, Anleitung und Doku auf 1.6.0

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

245 lines
11 KiB
Python

"""
Test des Akten-Abgleichs mit zwei simulierten Rechnern.
Startet den lokalen Testserver aus server_test.py. Jeder "Rechner" ist ein
eigener Python-Prozess mit eigenem %APPDATA% - so wie zwei echte PCs mit
demselben Konto. Beruehrt weder echte Akten noch den echten Server.
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\abgleich_test.py
"""
import json
import os
import re
import subprocess
import sys
import tempfile
import urllib.parse
from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
# SM_PROGRAMM=dist\paket\Programm prueft das gebaute Paket statt der Quelle
PROGRAMM = Path(os.environ.get("SM_PROGRAMM") or WURZEL)
sys.path.insert(0, str(Path(__file__).resolve().parent))
# -- Ein Rechner: wird als eigener Prozess mit "pc" aufgerufen ----------------
def rechner_befehl(aktion, parameter):
sys.path.insert(0, str(PROGRAMM))
import hashlib
from PIL import Image
import abgleich
import akte_modell as modell
import konto
def portraet_setzen(akte_id, farbe):
pfad = Path(tempfile.gettempdir()) / f"sm_test_{akte_id}.jpg"
Image.new("RGB", (400, 500), tuple(farbe)).save(pfad, "JPEG")
modell.portraet_setzen(akte_id, pfad)
pfad.unlink()
if aktion == "anmelden":
return konto.anmelden(parameter["login"], parameter["passwort"])
if aktion == "akte_anlegen":
akte = modell.neu_anlegen()
akte["personalien"]["callsign"] = parameter["callsign"]
akte["dienst"].update({"fraktion": "Bundeswehr", "teilstreitkraft": "Heer", "rang": "Feldwebel"})
modell.speichern(akte)
if parameter.get("farbe"):
portraet_setzen(akte["id"], parameter["farbe"])
return akte["id"]
if aktion == "rang":
akte = modell.laden(parameter["id"])
akte["dienst"]["rang"] = parameter["rang"]
modell.speichern(akte)
return True
if aktion == "portraet":
portraet_setzen(parameter["id"], parameter["farbe"])
return True
if aktion == "papierkorb":
abgleich.loeschen_vormerken(parameter["id"])
modell.in_papierkorb(parameter["id"])
return True
if aktion == "abgleichen":
ergebnis = abgleich.abgleichen()
return {**ergebnis, "geaendert": sorted(ergebnis["geaendert"])}
if aktion == "ausstehend":
return abgleich.ausstehend()
if aktion == "akten":
liste = []
for akte in modell.alle_akten():
pfad = modell.portraet_pfad(akte["id"])
ordner = modell.ordner_von(akte["id"])
liste.append({
"id": akte["id"], "aktennummer": akte["aktennummer"],
"callsign": akte["personalien"]["callsign"], "rang": akte["dienst"]["rang"],
"portraet": hashlib.sha256(pfad.read_bytes()).hexdigest() if pfad else "",
"konflikte": len(list(ordner.glob("konflikt-*.json"))),
"meta": abgleich.meta_laden(akte["id"]),
})
return liste
if aktion == "konto_datei":
return konto.KONTO_DATEI.read_text(encoding="utf-8")
raise ValueError(aktion)
class Rechner:
server = None
def __init__(self, name, basis):
self.name = name
self.appdata = tempfile.mkdtemp(prefix=f"sm_pc_{name}_")
self.basis = basis
def __call__(self, aktion, **parameter):
umgebung = dict(os.environ, APPDATA=self.appdata, SM_SERVER=self.basis, PYTHONIOENCODING="utf-8")
lauf = subprocess.run([sys.executable, __file__, "pc", aktion, json.dumps(parameter)],
capture_output=True, text=True, encoding="utf-8", env=umgebung, timeout=120)
zeilen = [z for z in lauf.stdout.splitlines() if z.startswith("ERGEBNIS ")]
if not zeilen:
raise RuntimeError(f"{self.name}.{aktion} gescheitert:\n{lauf.stdout}\n{lauf.stderr}")
antwort = json.loads(zeilen[-1][len("ERGEBNIS "):])
if "fehler" in antwort:
print(f" ({self.name}.{aktion}: {antwort['fehler']} - {antwort.get('meldung')})")
if antwort["fehler"] == "offline" and Rechner.server is not None and "127.0.0.1:9" not in self.basis:
print(f" (Testserver läuft noch: {Rechner.server.laeuft()})")
import time
print(f" (Zeit jetzt {time.strftime('%H:%M:%S')}, letzte Zeilen des PHP-Servers:)\n"
+ Rechner.server.php_protokoll(40))
return antwort
return antwort["wert"]
# -- Ablauf -------------------------------------------------------------------
def main():
import server_test as st
from server_test import pruefe
server = st.Server()
try:
ablauf(server, pruefe)
finally:
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[-600:])
server.beenden()
print(f"\nERGEBNIS: {st.ergebnisse['ok']} bestanden, {st.ergebnisse['fehl']} fehlgeschlagen")
sys.exit(1 if st.ergebnisse["fehl"] else 0)
def ablauf(server, pruefe):
import server_test as st
print("Vorbereitung")
code, html, _ = server.roh("/einrichten.php", {"schluessel": st.SCHLUESSEL})
pruefe("Testserver eingerichtet", "Tabellen vorhanden" in html.decode(), html[-300:])
code, antwort = server.api("registrieren", benutzername="danny", email="danny@example.org",
passwort="dannypasswort1")
pruefe("Konto registriert", antwort.get("ok"), antwort)
link = server.link_aus_mail("danny@example.org")
teile = urllib.parse.urlparse(link)
code, html, _ = server.roh(teile.path + "?" + teile.query)
pruefe("E-Mail bestätigt", "bestätigt" in html.decode())
Rechner.server = server
a = Rechner("A", server.basis)
b = Rechner("B", server.basis)
print("Erstes Hochladen (Rechner A)")
nordlicht = a("akte_anlegen", callsign="Nordlicht", farbe=[60, 80, 50])
frost = a("akte_anlegen", callsign="Frost")
pruefe("ohne Anmeldung nichts ausstehend", a("ausstehend") is False)
pruefe("Anmeldung", a("anmelden", login="danny", passwort="dannypasswort1").get("benutzername") == "danny")
datei = a("konto_datei")
pruefe("Token nicht im Klartext gespeichert", not re.search(r"[0-9a-f]{64}", datei), datei[:120])
pruefe("vor dem Abgleich ausstehend", a("ausstehend") is True)
erg = a("abgleichen")
pruefe("zwei Akten hochgeladen", erg["hochgeladen"] == 2, erg)
akten_a = {x["callsign"]: x for x in a("akten")}
pruefe("Server-Nummern übernommen, Meta geschrieben",
all(x["meta"] and x["meta"]["server_id"] and re.fullmatch(r"SM-\d{4}-\d{4}", x["aktennummer"])
for x in akten_a.values()), akten_a)
pruefe("Porträt-Kennung gemerkt", akten_a["Nordlicht"]["meta"]["portraet_kennung"], akten_a["Nordlicht"]["meta"])
pruefe("danach nichts ausstehend", a("ausstehend") is False)
erg = a("abgleichen")
pruefe("zweiter Abgleich tut nichts", erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0, erg)
print("Zweiter Rechner (B)")
b("anmelden", login="danny@example.org", passwort="dannypasswort1")
erg = b("abgleichen")
pruefe("zwei Akten heruntergeladen", erg["heruntergeladen"] == 2 and len(erg["geaendert"]) == 2, erg)
akten_b = {x["callsign"]: x for x in b("akten")}
pruefe("gleiche IDs und Nummern wie auf A",
{k: (v["id"], v["aktennummer"]) for k, v in akten_b.items()}
== {k: (v["id"], v["aktennummer"]) for k, v in akten_a.items()}, akten_b)
pruefe("Porträt mit heruntergeladen", akten_b["Nordlicht"]["portraet"] != "" and akten_b["Frost"]["portraet"] == "")
erg = b("abgleichen")
pruefe("B: zweiter Abgleich tut nichts",
erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0 and not erg["geaendert"], erg)
print("Änderung wandert von B nach A")
b("rang", id=nordlicht, rang="Hauptfeldwebel")
erg = b("abgleichen")
pruefe("B hochgeladen", erg.get("hochgeladen") == 1, erg)
erg = a("abgleichen")
pruefe("A heruntergeladen", erg["heruntergeladen"] == 1 and nordlicht in erg["geaendert"], erg)
pruefe("A hat den neuen Rang", {x["id"]: x["rang"] for x in a("akten")}[nordlicht] == "Hauptfeldwebel")
print("Konflikt: beide ändern dieselbe Akte")
a("rang", id=frost, rang="Stabsfeldwebel")
b("rang", id=frost, rang="Oberstabsfeldwebel")
erg = a("abgleichen")
pruefe("A lädt zuerst hoch", erg.get("hochgeladen") == 1, erg)
erg = b("abgleichen")
pruefe("B erkennt Konflikt", erg["konflikte"] == 1 and erg["hochgeladen"] == 1, erg)
frost_b = {x["id"]: x for x in b("akten")}[frost]
pruefe("B behält eigene Fassung, Serverfassung gesichert",
frost_b["rang"] == "Oberstabsfeldwebel" and frost_b["konflikte"] == 1, frost_b)
a("abgleichen")
pruefe("A übernimmt Bs Fassung", {x["id"]: x["rang"] for x in a("akten")}[frost] == "Oberstabsfeldwebel")
print("Porträt geändert")
b("portraet", id=frost, farbe=[150, 40, 40])
pruefe("B lädt Porträt hoch", b("abgleichen") is not None)
erg = a("abgleichen")
pruefe("A lädt neues Porträt", frost in erg.get("geaendert", []) and {x["id"]: x["portraet"] for x in a("akten")}[frost], erg)
erg = a("abgleichen")
pruefe("A: Porträt nicht erneut hochgeladen", erg["hochgeladen"] == 0 and not erg["geaendert"], erg)
erg = b("abgleichen")
pruefe("B: nichts mehr zu tun", erg["hochgeladen"] == 0 and erg["heruntergeladen"] == 0 and not erg["geaendert"], erg)
print("Löschen")
a("papierkorb", id=nordlicht)
pruefe("A: Löschung ausstehend", a("ausstehend") is True)
a("abgleichen")
pruefe("A: danach nichts ausstehend", a("ausstehend") is False)
code, antwort = server.api("anmelden", login="danny", passwort="dannypasswort1")
code, antwort = server.api("charaktere_eigene", token=antwort["token"])
pruefe("auf dem Server gelöscht", [c["lokale_id"] for c in antwort["charaktere"]] == [frost], antwort)
erg = b("abgleichen")
pruefe("B verschiebt sie in den Papierkorb", erg["entfernt"] == 1, erg)
pruefe("B hat nur noch Frost", [x["id"] for x in b("akten")] == [frost])
print("Ohne Server")
offline = Rechner("C", "http://127.0.0.1:9")
antwort = offline("anmelden", login="danny", passwort="dannypasswort1")
pruefe("keine Verbindung: verständlicher Fehler", antwort.get("fehler") == "offline", antwort)
if __name__ == "__main__":
if len(sys.argv) >= 2 and sys.argv[1] == "pc":
sys.path.insert(0, str(PROGRAMM))
import konto
try:
wert = rechner_befehl(sys.argv[2], json.loads(sys.argv[3]))
print("ERGEBNIS " + json.dumps({"wert": wert}, ensure_ascii=False, default=str))
except konto.ServerFehler as fehler:
ursache = f" [{type(fehler.__cause__).__name__}: {fehler.__cause__}]" if fehler.__cause__ else ""
print("ERGEBNIS " + json.dumps({"fehler": fehler.code, "meldung": fehler.meldung + ursache},
ensure_ascii=False))
else:
main()