adminandClaude Opus 5.5
85fcadae54
Windows-Build / windows-exe (push) Failing after 3m13s
Auf dem langsameren Build-Runner schlug der Alt+F4-Test fehl: Kam der Tastendruck an, bevor der Dialog gezeichnet und gesperrt war, übersah die Ausweichsuche das Popup (winfo_ismapped = 0) und Alt+F4 galt dem Hauptfenster. Die Suche nutzt jetzt den Fensterstatus. Neuer Test erzwingt genau diesen Zustand plattformunabhängig. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
581 lines
24 KiB
Python
581 lines
24 KiB
Python
"""GUI-Tests: bedienen die echte Oberfläche (unter Xvfb bzw. Wine+Xvfb im Build).
|
||
|
||
Jede Ausnahme in einem Tk-Callback, jeder Absturz des Fehler-Handlers und jeder Eintrag in
|
||
fehler.log lässt den Test fehlschlagen. Modale Dialoge blockieren eine eigene Ereignisschleife –
|
||
deshalb laufen die Testschritte als Tk-Callbacks (Schrittplan) und ein Watchdog bricht hängende
|
||
Tests nach einer Zeitgrenze ab, statt den Build zu blockieren.
|
||
|
||
Ohne Bildschirm werden die Tests übersprungen – außer PROVTOOL_GUI_TESTS=1 ist gesetzt (Build).
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import time
|
||
import tkinter as tk
|
||
import traceback
|
||
|
||
import pytest
|
||
|
||
from provtool import config
|
||
from provtool.db import Datenbank, Haendler
|
||
|
||
PFLICHT = os.environ.get("PROVTOOL_GUI_TESTS") == "1"
|
||
IMMER = lambda: True # noqa: E731
|
||
|
||
|
||
class Lauf:
|
||
"""Startet die App in einem eigenen Profil, führt Schrittpläne aus und sammelt alle Fehler."""
|
||
|
||
def __init__(self, home, einstellungen: dict | None = None):
|
||
self.home = home
|
||
if einstellungen is not None:
|
||
(home / "einstellungen.json").write_text(json.dumps(einstellungen), encoding="utf-8")
|
||
self.root = None
|
||
for versuch in range(3):
|
||
try:
|
||
self.root = tk.Tk()
|
||
break
|
||
except tk.TclError as exc:
|
||
# Unter Wine scheitert das Anlegen vieler Tk-Instanzen in einem Prozess gelegentlich
|
||
# mit „couldn't read file init.tcl: Success“ – das betrifft nur die Tests (die App
|
||
# legt genau eine Instanz an). Daher kurz warten und erneut versuchen.
|
||
if "init.tcl" in str(exc) and versuch < 2:
|
||
time.sleep(0.5)
|
||
continue
|
||
if PFLICHT:
|
||
raise
|
||
pytest.skip(f"kein Bildschirm: {exc}")
|
||
self.fehler: list[str] = []
|
||
from provtool.gui import app as A
|
||
self.app = A.App(self.root)
|
||
echt = self.root.report_callback_exception
|
||
|
||
def melden(exc, val, tb):
|
||
self.fehler.append("".join(traceback.format_exception(exc, val, tb)))
|
||
try:
|
||
echt(exc, val, tb) # der echte Fehler-Handler darf dabei selbst nicht abstürzen
|
||
except Exception:
|
||
self.fehler.append("Fehler-Handler ist abgestürzt:\n" + traceback.format_exc())
|
||
# eine evtl. geöffnete Fehlermeldung schließen, damit der Test nicht hängt
|
||
self.root.after(100, self._meldungen_zu)
|
||
self.root.report_callback_exception = melden
|
||
|
||
# ---------------------------------------------------------------- Zustand
|
||
@property
|
||
def lebt(self) -> bool:
|
||
try:
|
||
return bool(self.root.winfo_exists())
|
||
except tk.TclError:
|
||
return False
|
||
|
||
def dialoge(self) -> list[tk.Toplevel]:
|
||
from provtool.gui import win95 as w
|
||
out = []
|
||
|
||
def suche(widget):
|
||
try:
|
||
kinder = widget.winfo_children()
|
||
except tk.TclError:
|
||
return
|
||
for kind in kinder:
|
||
if isinstance(kind, w.Dialog) and kind.winfo_exists():
|
||
out.append(kind)
|
||
suche(kind)
|
||
if self.lebt:
|
||
suche(self.root)
|
||
return out
|
||
|
||
def dialog(self, typ):
|
||
return next((d for d in self.dialoge() if isinstance(d, typ)), None)
|
||
|
||
def _meldungen_zu(self):
|
||
for d in reversed(self.dialoge()):
|
||
if d.winfo_exists() and d.title() == "Allgemeine Schutzverletzung":
|
||
d.destroy()
|
||
|
||
def _notaus(self):
|
||
for d in reversed(self.dialoge()):
|
||
try:
|
||
d.destroy()
|
||
except tk.TclError:
|
||
pass
|
||
try:
|
||
self.root.destroy()
|
||
except tk.TclError:
|
||
pass
|
||
|
||
# ---------------------------------------------------------------- Ablauf
|
||
def ablauf(self, schritte: list[tuple], sekunden: float = 20.0, nachlauf: float = 0.3):
|
||
"""schritte: [(bedingung, aktion, beschreibung), ...] – jede Aktion läuft als eigener
|
||
Tk-Callback, sobald ihre Bedingung erfüllt ist (auch während ein modaler Dialog offen ist)."""
|
||
offen = list(schritte)
|
||
start = time.time()
|
||
zustand = {"fertig_seit": None}
|
||
|
||
def poll():
|
||
if not self.lebt:
|
||
return
|
||
if time.time() - start > sekunden:
|
||
text = offen[0][2] if offen else "(nach dem letzten Schritt hängt ein Dialog)"
|
||
self.fehler.append(f"Zeitüberschreitung – hängt bei: {text}")
|
||
self._notaus()
|
||
return
|
||
if offen:
|
||
bed, akt, _ = offen[0]
|
||
try:
|
||
bereit = bed()
|
||
except Exception:
|
||
bereit = False
|
||
if bereit:
|
||
offen.pop(0)
|
||
self.root.after(0, akt)
|
||
elif zustand["fertig_seit"] is None:
|
||
zustand["fertig_seit"] = time.time()
|
||
self.root.after(20, poll)
|
||
|
||
self.root.after(20, poll)
|
||
while self.lebt:
|
||
try:
|
||
self.root.update()
|
||
except tk.TclError:
|
||
break
|
||
f = zustand["fertig_seit"]
|
||
if f is not None and time.time() - f >= nachlauf:
|
||
break
|
||
time.sleep(0.01)
|
||
self.uebrig = [s[2] for s in offen]
|
||
|
||
def schliessen_ueber_fenster(self):
|
||
"""Wie Klick auf × / Taskleiste ▸ Fenster schließen (WM_DELETE_WINDOW)."""
|
||
cmd = self.root.tk.call("wm", "protocol", self.root._w, "WM_DELETE_WINDOW")
|
||
self.root.tk.call(cmd)
|
||
|
||
def pruefen(self):
|
||
log = self.home / "fehler.log"
|
||
inhalt = log.read_text(encoding="utf-8") if log.exists() else ""
|
||
assert not self.fehler, "Fehler in der Oberfläche:\n\n" + "\n".join(self.fehler)
|
||
assert not inhalt, "fehler.log wurde geschrieben:\n" + inhalt
|
||
|
||
def ende(self):
|
||
if self.lebt:
|
||
self.ablauf([(IMMER, self.app.beenden, "beenden")], sekunden=10)
|
||
|
||
|
||
@pytest.fixture
|
||
def home(tmp_path, monkeypatch):
|
||
monkeypatch.setenv("PROVTOOL_HOME", str(tmp_path))
|
||
return tmp_path
|
||
|
||
|
||
@pytest.fixture
|
||
def lauf_mit_daten(home):
|
||
"""App mit einem Händler und einer Abrechnung (erfundene Daten)."""
|
||
from tests.test_kern import FREENET_KOPF, freenet_zeile
|
||
csv = home / "freenet.csv"
|
||
csv.write_bytes(("\r\n".join([
|
||
FREENET_KOPF,
|
||
freenet_zeile("SIM-Karten", "111", "05.10.2026", "1601111111", "Muster GmbH", "Allnet", "8"),
|
||
freenet_zeile("Sonderbonus Aktion", "111", "06.10.2026", "1602222222", "Beispiel KG", "Classic", "170"),
|
||
freenet_zeile("SIM-Karten", "999", "07.10.2026", "1603333333", "Eigener Kunde", "Flex", "8"),
|
||
]) + "\r\n").encode("cp1252"))
|
||
db = Datenbank(config.db_path())
|
||
db.haendler_speichern(Haendler(0, "Händler A"), [("freenet", "111")])
|
||
from provtool.importer import lies_datei
|
||
db.importieren(db.abrechnung_neu("Oktober 2026"), lies_datei(csv))
|
||
db.close()
|
||
lauf = Lauf(home, {"assistent_erledigt": True, "tipps_beim_start": False})
|
||
yield lauf
|
||
lauf.ende()
|
||
|
||
|
||
def _assistent_offen(lauf):
|
||
from provtool.gui.assistent import Einrichtungsassistent
|
||
return lambda: lauf.dialog(Einrichtungsassistent) is not None
|
||
|
||
|
||
# =========================================================================== Schließen bei offenem Dialog
|
||
|
||
@pytest.mark.parametrize("weg", ["fenster", "beenden"])
|
||
def test_schliessen_waehrend_assistent(home, weg):
|
||
"""Reproduziert den gemeldeten Absturz: Programm schließen, während der Assistent offen ist."""
|
||
lauf = Lauf(home) # frisches Profil → Assistent startet automatisch
|
||
zu = {"fenster": lauf.schliessen_ueber_fenster, "beenden": lauf.app.beenden}[weg]
|
||
lauf.ablauf([(_assistent_offen(lauf), lambda: None, "Assistent erscheint"),
|
||
(IMMER, zu, f"schließen über {weg}")])
|
||
assert not lauf.lebt, "Programm wurde nicht beendet"
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_alt_f4_im_assistent_fragt_und_schliesst_nur_assistent(home):
|
||
"""Alt+F4 bei offenem Assistenten = „Abbrechen“ mit Rückfrage; das Programm bleibt offen."""
|
||
from provtool.gui.assistent import Einrichtungsassistent
|
||
lauf = Lauf(home)
|
||
rueckfrage = lambda: next((d for d in lauf.dialoge() if d.title() == "Einrichtung abbrechen"), None) # noqa: E731
|
||
|
||
def ja_klicken():
|
||
d = rueckfrage()
|
||
d.result = True
|
||
d.destroy()
|
||
|
||
lauf.ablauf([
|
||
(_assistent_offen(lauf), lambda: lauf.dialog(Einrichtungsassistent).event_generate("<Alt-F4>"), "Alt+F4"),
|
||
(lambda: rueckfrage() is not None, ja_klicken, "Rückfrage mit Ja beantworten"),
|
||
(lambda: lauf.dialog(Einrichtungsassistent) is None, lambda: None, "Assistent ist zu"),
|
||
])
|
||
assert lauf.lebt, "Programm darf nicht beendet werden"
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
assert lauf.app.settings.get("assistent_erledigt") is True
|
||
lauf.pruefen()
|
||
lauf.ende()
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_alt_f4_im_dialog_schliesst_nur_den_dialog(lauf_mit_daten):
|
||
from provtool.gui.dialogs import InfoDialog
|
||
lauf = lauf_mit_daten
|
||
lauf.ablauf([
|
||
(IMMER, lambda: InfoDialog(lauf.root).zeigen(), "Info öffnen"),
|
||
(lambda: lauf.dialog(InfoDialog) is not None,
|
||
lambda: lauf.dialog(InfoDialog).event_generate("<Alt-F4>"), "Alt+F4 im Dialog"),
|
||
(lambda: lauf.dialog(InfoDialog) is None, lambda: None, "Dialog geschlossen"),
|
||
], sekunden=8)
|
||
assert lauf.lebt, "Alt+F4 im Dialog darf nicht das ganze Programm beenden"
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
lauf.pruefen()
|
||
|
||
|
||
def _dialog_oeffner():
|
||
from provtool.gui import dialogs as dlg
|
||
return {
|
||
"haendler": lambda a: a.haendler(),
|
||
"abrechnungen": lambda a: a.abrechnung_waehlen(),
|
||
"export": lambda a: a.exportieren(),
|
||
"einstellungen": lambda a: a.einstellungen(),
|
||
"neu": lambda a: a.neu(),
|
||
"info": lambda a: dlg.InfoDialog(a.root).zeigen(),
|
||
"tipp": lambda a: a.tipp_des_tages(),
|
||
"dateien": lambda a: a.dateien(),
|
||
"hilfe": lambda a: a.hilfe(),
|
||
"assistent": lambda a: a.assistent(),
|
||
"prozent": lambda a: (a.ptree.selection_set(a.ptree.get_children()[0]), a.prozent()),
|
||
"neu_berechnen": lambda a: (a.db.betrag_setzen(a.positionen[0]["id"], 1), a._aktualisieren(),
|
||
a.neu_berechnen()),
|
||
}
|
||
|
||
|
||
@pytest.mark.parametrize("name", ["haendler", "abrechnungen", "export", "einstellungen", "neu", "info", "tipp",
|
||
"dateien", "hilfe", "assistent", "prozent", "neu_berechnen"])
|
||
def test_schliessen_waehrend_dialog_offen(lauf_mit_daten, name):
|
||
lauf = lauf_mit_daten
|
||
oeffnen = _dialog_oeffner()[name]
|
||
lauf.ablauf([(IMMER, lambda: oeffnen(lauf.app), f"{name} öffnen"),
|
||
(lambda: bool(lauf.dialoge()), lauf.schliessen_ueber_fenster, "Programm schließen")])
|
||
assert not lauf.lebt, f"Programm wurde nicht beendet (offen: {lauf.uebrig})"
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_schliessen_waehrend_rueckfrage_im_assistent(home):
|
||
"""Assistent offen → „Abbrechen“ → Rückfrage offen → Programm schließen."""
|
||
from provtool.gui.assistent import Einrichtungsassistent
|
||
lauf = Lauf(home)
|
||
lauf.ablauf([
|
||
(_assistent_offen(lauf), lambda: lauf.dialog(Einrichtungsassistent).abbrechen(), "Abbrechen klicken"),
|
||
(lambda: len(lauf.dialoge()) >= 2, lauf.schliessen_ueber_fenster, "Programm schließen"),
|
||
])
|
||
assert not lauf.lebt
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_schliessen_waehrend_rundgang(lauf_mit_daten):
|
||
lauf = lauf_mit_daten
|
||
lauf.ablauf([
|
||
(IMMER, lauf.app.rundgang, "Rundgang starten"),
|
||
(lambda: getattr(lauf.app, "_rundgang", None) and lauf.app._rundgang.blase, lauf.schliessen_ueber_fenster,
|
||
"Programm schließen"),
|
||
])
|
||
assert not lauf.lebt
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_alt_f4_bevor_die_sperre_steht(lauf_mit_daten, monkeypatch):
|
||
"""Erzwingt den Zustand vom langsamen Build-Rechner: Dialog ist offen, aber Tk-Sperre und
|
||
Zeichnen sind noch nicht fertig. Alt+F4 muss trotzdem nur den Dialog schließen."""
|
||
from provtool.gui import win95 as w
|
||
from provtool.gui.dialogs import InfoDialog
|
||
monkeypatch.setattr(w.Dialog, "_sperre_setzen", lambda self, versuch=0: None) # keine Sperre
|
||
monkeypatch.setattr(w.Dialog, "winfo_ismapped", lambda self: 0) # „noch nicht gezeichnet“
|
||
lauf = lauf_mit_daten
|
||
lauf.ablauf([
|
||
(IMMER, lambda: InfoDialog(lauf.root).zeigen(), "Info öffnen"),
|
||
# wie unter Windows: Tk liefert den Tastendruck an das Fenster mit Fokus – hier noch das Hauptfenster
|
||
(lambda: lauf.dialog(InfoDialog) is not None, lambda: lauf.app.rahmen.alt_f4(lauf.root),
|
||
"Alt+F4 (Fokus noch beim Hauptfenster)"),
|
||
(lambda: lauf.dialog(InfoDialog) is None, lambda: None, "Dialog geschlossen"),
|
||
], sekunden=8)
|
||
assert lauf.lebt, "Alt+F4 darf bei offenem Dialog nicht das ganze Programm beenden"
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_alt_f4_im_rundgang_beendet_nur_den_rundgang(lauf_mit_daten):
|
||
lauf = lauf_mit_daten
|
||
rg = lambda: getattr(lauf.app, "_rundgang", None) # noqa: E731
|
||
lauf.ablauf([
|
||
(IMMER, lauf.app.rundgang, "Rundgang starten"),
|
||
(lambda: rg() is not None and rg().blase is not None,
|
||
lambda: rg().blase.event_generate("<Alt-F4>"), "Alt+F4"),
|
||
(lambda: rg().blase is None and not rg().rahmen, lambda: None, "Rundgang samt Rahmen weg"),
|
||
], sekunden=8)
|
||
assert lauf.lebt, "Alt+F4 im Rundgang darf nicht das Programm beenden"
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_betrag_dialog_wenn_zelle_unsichtbar(lauf_mit_daten):
|
||
"""Ist die Betragszelle nicht sichtbar, öffnet sich ein Dialog statt still nichts zu tun."""
|
||
lauf = lauf_mit_daten
|
||
app = lauf.app
|
||
hid = next(h.id for h in app.db.haendler_liste())
|
||
eingabe = lambda: next((d for d in lauf.dialoge() if d.title() == "Betrag ändern"), None) # noqa: E731
|
||
|
||
def tippen():
|
||
d = eingabe()
|
||
entry = next(k for k in d.winfo_children() if isinstance(k, tk.Entry))
|
||
entry.delete(0, "end")
|
||
entry.insert(0, "7,77")
|
||
d.result = entry.get()
|
||
d.destroy()
|
||
|
||
def oeffnen():
|
||
pos = app.ptree.get_children(app.ptree.get_children()[0])[0]
|
||
app.ptree.bbox = lambda *a, **k: "" # Zelle „unsichtbar“
|
||
app.betrag_bearbeiten(pos)
|
||
|
||
lauf.ablauf([
|
||
(IMMER, lambda: app.htree.selection_set(str(hid)), "Händler wählen"),
|
||
(lambda: bool(app.ptree.get_children()), oeffnen, "Betrag ändern bei unsichtbarer Zelle"),
|
||
(lambda: eingabe() is not None, tippen, "Betrag im Dialog eingeben"),
|
||
])
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
assert any(p["betrag"] == 777 and p["manuell"] for p in app.positionen)
|
||
del app.ptree.bbox
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_fehler_handler_nach_zerstoertem_fenster(home):
|
||
"""Der Fehler-Handler darf nicht abstürzen, wenn das Fenster schon weg ist – nur protokollieren."""
|
||
lauf = Lauf(home, {"assistent_erledigt": True, "tipps_beim_start": False})
|
||
app = lauf.app
|
||
lauf.root.destroy()
|
||
try:
|
||
raise RuntimeError("Testfehler")
|
||
except RuntimeError as exc:
|
||
app._fehler_handler(type(exc), exc, exc.__traceback__) # darf nicht werfen
|
||
assert "RuntimeError: Testfehler" in (home / "fehler.log").read_text(encoding="utf-8")
|
||
|
||
|
||
def test_zweimal_beenden(lauf_mit_daten):
|
||
lauf = lauf_mit_daten
|
||
lauf.ablauf([(IMMER, lambda: (lauf.app.beenden(), lauf.app.beenden()), "zweimal beenden")])
|
||
assert not lauf.lebt
|
||
lauf.pruefen()
|
||
|
||
|
||
# =========================================================================== Rauchtests der Abläufe
|
||
|
||
def test_assistent_komplett_durchklicken(home):
|
||
from provtool.gui.assistent import Einrichtungsassistent
|
||
lauf = Lauf(home)
|
||
wiz = lambda: lauf.dialog(Einrichtungsassistent) # noqa: E731
|
||
|
||
def haendler_eintragen():
|
||
wiz().v_name.set("Testhändler")
|
||
wiz().v_fn.set("111 (3 Pos., 10,00 €)")
|
||
wiz().v_caps.set(True)
|
||
assert wiz()._haendler_dazu()
|
||
|
||
seite = lambda n: (lambda: wiz() is not None and wiz().nr == n) # noqa: E731
|
||
lauf.ablauf([
|
||
(seite(0), lambda: wiz()._weiter(), "Willkommen → Speicherort"),
|
||
(seite(1), lambda: wiz()._weiter(), "Speicherort → Händler"),
|
||
(seite(2), haendler_eintragen, "Händler eintragen"),
|
||
(lambda: len(lauf.app.db.haendler_liste()) == 1, lambda: wiz()._zurueck(), "zurück"),
|
||
(seite(1), lambda: wiz()._weiter(), "wieder vor"),
|
||
(seite(2), lambda: wiz()._weiter(), "Händler → Abrechnung"),
|
||
(seite(3), lambda: wiz()._weiter(), "Abrechnung → Fertig"),
|
||
(seite(4), lambda: wiz()._weiter(), "Fertig stellen"),
|
||
(lambda: getattr(lauf.app, "_rundgang", None) is not None and lauf.app._rundgang.blase is not None,
|
||
lambda: [lauf.app._rundgang._weiter() for _ in range(len(lauf.app._rundgang.schritte))],
|
||
"Rundgang komplett durchklicken"),
|
||
])
|
||
assert not lauf.uebrig, f"nicht ausgeführt: {lauf.uebrig}"
|
||
db = lauf.app.db
|
||
h = db.haendler_liste()
|
||
assert [x.name for x in h] == ["Testhändler"]
|
||
assert ("vodafone_caps", "*") in db.kennungen(h[0].id)
|
||
assert [a["titel"] for a in db.abrechnungen()]
|
||
assert lauf.app._rundgang.blase is None
|
||
lauf.pruefen()
|
||
lauf.ende()
|
||
lauf.pruefen()
|
||
|
||
|
||
def test_hauptfenster_ablaeufe(lauf_mit_daten):
|
||
from provtool.gui.dialogs import ProzentDialog
|
||
lauf = lauf_mit_daten
|
||
app = lauf.app
|
||
hid = next(h.id for h in app.db.haendler_liste())
|
||
|
||
def betrag_aendern():
|
||
# Feld öffnen und sofort tippen: ohne Fenstermanager (Xvfb/Wine) verliert das Feld sonst
|
||
# gleich den Fokus und speichert unverändert – genau wie beim Wegklicken.
|
||
pos = app.ptree.get_children(app.ptree.get_children()[0])[0]
|
||
app.betrag_bearbeiten(pos)
|
||
lauf.root.update_idletasks()
|
||
e = app._edit
|
||
e.focus_force()
|
||
e.delete(0, "end")
|
||
e.insert(0, "5,55")
|
||
e.event_generate("<Return>")
|
||
if app._edit is e:
|
||
# Unter Windows gehen erzeugte Tastendrücke an das Fenster mit Fokus – ohne Fenster-
|
||
# manager hat das Feld ihn evtl. nicht. Dann wie „wegklicken“ speichern (FocusOut).
|
||
e.event_generate("<FocusOut>")
|
||
|
||
def prozent_ok():
|
||
d = lauf.dialog(ProzentDialog)
|
||
d.v.set("80")
|
||
d._ok()
|
||
|
||
def fenster():
|
||
if app.rahmen.klassisch:
|
||
app.rahmen.maximieren()
|
||
app.rahmen.wiederherstellen()
|
||
|
||
lauf.ablauf([
|
||
(IMMER, lambda: app.htree.selection_set(str(hid)), "Händler wählen"),
|
||
(lambda: bool(app.ptree.get_children())
|
||
and bool(app.ptree.bbox(app.ptree.get_children(app.ptree.get_children()[0])[0], "ausz")),
|
||
betrag_aendern, "Betrag inline ändern (sobald die Zeile sichtbar ist)"),
|
||
(lambda: any(p["betrag"] == 555 and p["manuell"] for p in app.positionen),
|
||
lambda: (app.ptree.selection_set(app.ptree.get_children()[-1]), app.prozent()), "Prozent-Dialog"),
|
||
(lambda: lauf.dialog(ProzentDialog) is not None, prozent_ok, "80 % setzen"),
|
||
(lambda: lauf.dialog(ProzentDialog) is None, lambda: app.v_suche.set("Beispiel"), "suchen"),
|
||
(IMMER, lambda: app.v_suche.set(""), "Suche leeren"),
|
||
(IMMER, fenster, "maximieren/wiederherstellen"),
|
||
])
|
||
assert not lauf.uebrig, f"nicht ausgeführt: {lauf.uebrig}"
|
||
assert any(p["prozent"] == 80 for p in app.positionen)
|
||
lauf.pruefen()
|
||
|
||
|
||
# =========================================================================== Windows: Popups bleiben erreichbar
|
||
|
||
import sys # noqa: E402
|
||
|
||
nur_windows = pytest.mark.skipif(not sys.platform.startswith("win"),
|
||
reason="Win32-Fensterbesitz gibt es nur unter Windows (im Build: Wine)")
|
||
|
||
|
||
@nur_windows
|
||
def test_windows_popup_kommt_nach_alt_tab_wieder_nach_vorn(lauf_mit_daten):
|
||
"""Gemeldet: Popup offen, woanders hingeklickt – danach kam das Popup nicht mehr nach vorn
|
||
(auch nicht per Alt+Tab). Geprüft wird: Popup gehört dem Hauptfenster, das Hauptfenster ist
|
||
gesperrt, und holt man das Hauptfenster zurück, liegt das Popup darüber."""
|
||
from provtool.gui import win32
|
||
from provtool.gui.dialogs import InfoDialog
|
||
lauf = lauf_mit_daten
|
||
m = {}
|
||
|
||
def messen():
|
||
d = lauf.dialog(InfoDialog)
|
||
fremd = tk.Toplevel(lauf.root) # steht für ein anderes Programm
|
||
fremd.geometry("400x300+50+50")
|
||
fremd.update()
|
||
m.update(besitzer=win32.besitzer_von(d), haupt=win32.hwnd(lauf.root),
|
||
haupt_bedienbar=win32.ist_bedienbar(lauf.root))
|
||
win32.nach_vorn(fremd) # „woanders hingeklickt“
|
||
lauf.root.update()
|
||
m["woanders"] = win32.stapel(d, lauf.root, fremd)
|
||
win32.nach_vorn(lauf.root) # Alt+Tab / Taskleiste zurück zu uns
|
||
lauf.root.update()
|
||
m["zurueck"] = win32.stapel(d, lauf.root, fremd)
|
||
fremd.destroy()
|
||
d.abbrechen()
|
||
|
||
lauf.ablauf([
|
||
(IMMER, lambda: InfoDialog(lauf.root).zeigen(), "Info öffnen"),
|
||
(lambda: lauf.dialog(InfoDialog) is not None, lambda: lauf.root.after(150, messen), "messen"),
|
||
(lambda: "zurueck" in m and lauf.dialog(InfoDialog) is None, lambda: None, "geschlossen"),
|
||
], sekunden=10)
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
assert m["besitzer"] == m["haupt"], "Popup gehört nicht dem Hauptfenster"
|
||
assert m["haupt_bedienbar"] is False, "Hauptfenster muss gesperrt sein, solange das Popup offen ist"
|
||
assert m["woanders"][0] == 2, f"Testaufbau: das fremde Fenster sollte oben liegen ({m['woanders']})"
|
||
assert m["zurueck"][:2] == [0, 1], f"Popup liegt nach dem Zurückholen nicht über dem Hauptfenster: {m['zurueck']}"
|
||
assert win32.ist_bedienbar(lauf.root), "Hauptfenster nach dem Schließen nicht wieder freigegeben"
|
||
lauf.pruefen()
|
||
|
||
|
||
@nur_windows
|
||
def test_windows_verschachtelte_rueckfrage(lauf_mit_daten):
|
||
"""Händler-Dialog → Rückfrage: Rückfrage gehört dem Händler-Dialog; beim Schließen der Reihe nach frei."""
|
||
from provtool.gui import win32
|
||
from provtool.gui import win95 as w
|
||
from provtool.gui.dialogs import HaendlerDialog
|
||
lauf = lauf_mit_daten
|
||
m = {}
|
||
rueckfrage = lambda: next((d for d in lauf.dialoge() if d.title() == "Test-Rückfrage"), None) # noqa: E731
|
||
|
||
def messen_innen():
|
||
h, r = lauf.dialog(HaendlerDialog), rueckfrage()
|
||
m.update(r_besitzer=win32.besitzer_von(r), h=win32.hwnd(h), h_an=win32.ist_bedienbar(h),
|
||
haupt_an=win32.ist_bedienbar(lauf.root))
|
||
r.destroy()
|
||
|
||
def messen_aussen():
|
||
h = lauf.dialog(HaendlerDialog)
|
||
m.update(h_an_danach=win32.ist_bedienbar(h), haupt_an_danach=win32.ist_bedienbar(lauf.root))
|
||
h.abbrechen()
|
||
|
||
lauf.ablauf([
|
||
(IMMER, lauf.app.haendler, "Händler-Dialog öffnen"),
|
||
(lambda: lauf.dialog(HaendlerDialog) is not None,
|
||
lambda: w.info(lauf.dialog(HaendlerDialog), "Test-Rückfrage", "?"), "Rückfrage öffnen"),
|
||
(lambda: rueckfrage() is not None, lambda: lauf.root.after(100, messen_innen), "innen messen"),
|
||
(lambda: "h" in m and rueckfrage() is None, messen_aussen, "außen messen"),
|
||
(lambda: lauf.dialog(HaendlerDialog) is None, lambda: None, "alles zu"),
|
||
], sekunden=12)
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
assert m["r_besitzer"] == m["h"], "Rückfrage gehört nicht dem Händler-Dialog"
|
||
assert m["h_an"] is False and m["haupt_an"] is False
|
||
assert m["h_an_danach"] is True and m["haupt_an_danach"] is False
|
||
assert win32.ist_bedienbar(lauf.root)
|
||
lauf.pruefen()
|
||
|
||
|
||
@nur_windows
|
||
def test_windows_rundgang_sperrt_und_gibt_frei(lauf_mit_daten):
|
||
from provtool.gui import win32
|
||
lauf = lauf_mit_daten
|
||
rg = lambda: getattr(lauf.app, "_rundgang", None) # noqa: E731
|
||
m = {}
|
||
|
||
def messen_und_weiter():
|
||
m.setdefault("gesperrt", []).append(not win32.ist_bedienbar(lauf.root))
|
||
m.setdefault("besitzer", []).append(win32.besitzer_von(rg().blase) == win32.hwnd(lauf.root))
|
||
rg()._weiter()
|
||
|
||
schritte = [(IMMER, lauf.app.rundgang, "Rundgang starten")]
|
||
for i in range(3):
|
||
schritte.append((lambda i=i: rg() is not None and rg().blase is not None and rg().nr == i,
|
||
messen_und_weiter, f"Schritt {i + 1}"))
|
||
schritte.append((IMMER, lambda: rg().beenden(), "Rundgang beenden"))
|
||
lauf.ablauf(schritte, sekunden=12)
|
||
assert not lauf.uebrig, lauf.uebrig
|
||
assert all(m["gesperrt"]), "Hauptfenster während des Rundgangs nicht gesperrt"
|
||
assert all(m["besitzer"]), "Sprechblase gehört nicht dem Hauptfenster"
|
||
assert win32.ist_bedienbar(lauf.root), "Hauptfenster nach dem Rundgang nicht freigegeben"
|
||
lauf.pruefen()
|