- 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>
245 lines
11 KiB
Python
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()
|