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

243 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
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(WURZEL))
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(WURZEL))
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()