Projektwissen/tests/test_referenzmodelle.py

"""Strukturtests für die Modelle unter .agents/skills/sn-bpmn/beispiele/ – reines Python/pytest.

Die Referenzmodelle (referenz_*.md) sind echte, größere Prozesse, die Syntaxbeispiele (beispiel_*.md) zeigen gezielt
einzelne Elemente. Der Byte-Vergleich in test_pruefe_prozesse.py meldet jede Änderung an der Ausgabe von
md_to_bpmn.py; diese Tests prüfen zusätzlich, ob das Ergebnis danach noch den Modellierregeln und den Grenzen von
PICTURE genügt – auch wenn die .bpmn bewusst neu erzeugt wurde.
"""
import math
import sys
from pathlib import Path

import pytest

ROOT = Path(__file__).resolve().parents[1]
SKILL = ROOT / ".agents" / "skills" / "sn-bpmn"
sys.path.insert(0, str(SKILL))

import md_to_bpmn as m  # noqa: E402
from test_md_to_bpmn import _liegt_in_rautenflaeche  # noqa: E402  (dieselbe Rautengeometrie wie dort)

MODELLE = sorted((SKILL / "beispiele").glob("*.md"))
REFERENZEN = [md for md in MODELLE if md.stem.startswith("referenz_")]
GATEWAYS = ("exclusiveGateway", "inclusiveGateway", "parallelGateway", "eventBasedGateway")
EREIGNISSE = ("startEvent", "endEvent", "intermediateCatchEvent", "intermediateThrowEvent", "boundaryEvent")
# Formen, durch die keine Kante laufen darf; Pools, Lanes, Gruppen und Hinweise zählen nicht als Hindernis
HINDERNISSE = GATEWAYS + EREIGNISSE + (
    "task", "manualTask", "userTask", "serviceTask", "scriptTask", "businessRuleTask", "sendTask", "receiveTask",
    "subProcess", "callActivity", "dataObjectReference", "dataStoreReference",
)
KANTEN = ("sequenceFlow", "messageFlow")

# Bekannte, per Issue erfasste Konverterfehler: (Modell, Kante, Element) -> Grund mit Issue-Nummer.
# Jedes Paar bekommt einen eigenen xfail(strict=True)-Test; sobald der Fehler behoben ist, schlägt dieser als XPASS
# fehl – dann den Eintrag hier entfernen. Nie verwenden, um neue Fehler zu verstecken (AGENTS.md).
BEKANNTE_KREUZUNGEN = {}


def baue(md):
    meta, steps, order, externals = m.parse_markdown(md.read_text(encoding="utf-8"))
    return m.build_bpmn(meta, steps, order, externals)


def _liegt_innen(px, py, art, x, y, w, h, abstand=1.0):
    """True, wenn der Punkt im Inneren der sichtbaren Form liegt (Kontur und Umgebung zählen nicht)."""
    if art in GATEWAYS:
        return _liegt_in_rautenflaeche(px, py, x, y, w, h)
    if art in EREIGNISSE:
        r = min(w, h) / 2
        return math.hypot(px - x - w / 2, py - y - h / 2) < r - abstand
    return x + abstand < px < x + w - abstand and y + abstand < py < y + h - abstand


def kreuzungen(defs):
    """Alle Paare (Kante, Element), bei denen ein Sequenz- oder Nachrichtenfluss durchs Innere eines Elements läuft.

    Die Kante wird in Schritten von höchstens 4 Einheiten abgetastet, damit auch kleine Ereignisse nicht zwischen
    zwei Stichproben fallen."""
    art = {el.get("id"): el.tag.rpartition("}")[2] for el in defs.iter() if el.get("id")}
    formen = {}
    for shape in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape"):
        eid = shape.get("bpmnElement")
        if art.get(eid) in HINDERNISSE:
            b = shape.find(f"{{{m.NS['dc']}}}Bounds")
            formen[eid] = tuple(float(b.get(a)) for a in ("x", "y", "width", "height"))

    funde = set()
    for edge in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNEdge"):
        kante = edge.get("bpmnElement")
        if art.get(kante) not in KANTEN:
            continue
        punkte = [(float(wp.get("x")), float(wp.get("y"))) for wp in edge.findall(f"{{{m.NS['di']}}}waypoint")]
        for eid, (x, y, w, h) in formen.items():
            for (x1, y1), (x2, y2) in zip(punkte, punkte[1:]):
                schritte = max(8, int(math.hypot(x2 - x1, y2 - y1) / 4))
                if any(_liegt_innen(x1 + (x2 - x1) * s / schritte, y1 + (y2 - y1) * s / schritte, art[eid], x, y, w, h)
                       for s in range(1, schritte)):
                    funde.add((kante, eid))
                    break
    return sorted(funde)


def test_es_gibt_mindestens_ein_referenzmodell():
    """Prüft, dass die Strukturtests tatsächlich an einem Referenzmodell laufen."""
    assert REFERENZEN


@pytest.mark.parametrize("md", REFERENZEN, ids=lambda p: p.stem)
def test_jedes_element_hat_eine_zustaendigkeit(md):
    """Prüft, dass im Referenzmodell kein Element in der Lane 'Nicht zugeordnet' landet."""
    lanes = [lane.get("name") for lane in baue(md).iter(f"{{{m.NS['bpmn']}}}lane")]
    assert lanes, "Referenzmodell ohne Lanes"
    assert m.UNASSIGNED_LANE not in lanes


@pytest.mark.parametrize("md", REFERENZEN, ids=lambda p: p.stem)
def test_kein_gateway_hat_mehr_als_vier_kanten(md):
    """Prüft Modellierregel 4: kein Gateway im Referenzmodell braucht mehr als die vier Anschlusspunkte von PICTURE."""
    defs = baue(md)
    for tag in GATEWAYS:
        for gateway in defs.iter(f"{{{m.NS['bpmn']}}}{tag}"):
            kanten = gateway.findall(f"{{{m.NS['bpmn']}}}incoming") + gateway.findall(f"{{{m.NS['bpmn']}}}outgoing")
            assert len(kanten) <= 4, f"{gateway.get('id')} hat {len(kanten)} Kanten"


@pytest.mark.parametrize("md", MODELLE, ids=lambda p: p.stem)
def test_keine_unbekannte_kante_fuehrt_durch_ein_element(md):
    """Prüft, dass in keinem Modell ein Sequenz- oder Nachrichtenfluss durchs Innere einer Aufgabe, eines Ereignisses,
    eines Gateways oder eines Datenelements läuft – außer den per Issue erfassten Fällen. Meldet alle Funde auf einmal."""
    bekannt = {(k, e) for (modell, k, e) in BEKANNTE_KREUZUNGEN if modell == md.stem}
    neu = [paar for paar in kreuzungen(baue(md)) if paar not in bekannt]
    assert neu == [], "Kante durch Element (Kante, Element): " + ", ".join(f"{k} → {e}" for k, e in neu)


@pytest.mark.parametrize("modell, kante, element", [
    pytest.param(*schluessel, id="-".join(schluessel), marks=pytest.mark.xfail(reason=grund, strict=True))
    for schluessel, grund in BEKANNTE_KREUZUNGEN.items()
])
def test_bekannte_kreuzung_ist_behoben(modell, kante, element):
    """Prüft je per Issue erfasster Kreuzung, ob sie noch besteht; als xfail(strict=True) markiert, damit ein Fix
    auffällt und der Eintrag in BEKANNTE_KREUZUNGEN entfernt wird."""
    assert (kante, element) not in kreuzungen(baue(SKILL / "beispiele" / f"{modell}.md"))


def _box(el):
    b = el.find(f"{{{m.NS['dc']}}}Bounds")
    return tuple(float(b.get(a)) for a in ("x", "y", "width", "height"))


def _ueberlappen(a, b, rand=0.5):
    """True, wenn sich die Rechtecke a und b (x, y, w, h) echt überschneiden (Berührung zählt nicht)."""
    return (a[0] + rand < b[0] + b[2] and b[0] + rand < a[0] + a[2]
            and a[1] + rand < b[1] + b[3] and b[1] + rand < a[1] + a[3])


def beschriftungskonflikte(defs):
    """Alle Konflikte einer Gateway-Beschriftung mit Kanten, Kantenbeschriftungen oder anderen Elementen."""
    art = {el.get("id"): el.tag.rpartition("}")[2] for el in defs.iter() if el.get("id")}
    gw_labels, formen = {}, {}
    for shape in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape"):
        eid = shape.get("bpmnElement")
        if art.get(eid) in HINDERNISSE or art.get(eid) == "textAnnotation":
            formen[eid] = _box(shape)
        label = shape.find(f"{{{m.NS['bpmndi']}}}BPMNLabel")
        if art.get(eid) in GATEWAYS and label is not None:
            gw_labels[eid] = _box(label)
    konflikte = []
    for edge in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNEdge"):
        kante = edge.get("bpmnElement")
        punkte = [(float(wp.get("x")), float(wp.get("y"))) for wp in edge.findall(f"{{{m.NS['di']}}}waypoint")]
        label = edge.find(f"{{{m.NS['bpmndi']}}}BPMNLabel")
        for gid, (x, y, w, h) in gw_labels.items():
            if label is not None and _ueberlappen(_box(label), (x, y, w, h)):
                konflikte.append((gid, f"Beschriftung von {kante}"))
            for (x1, y1), (x2, y2) in zip(punkte, punkte[1:]):
                schritte = max(8, int(math.hypot(x2 - x1, y2 - y1) / 4))
                if any(x < x1 + (x2 - x1) * s / schritte < x + w and y < y1 + (y2 - y1) * s / schritte < y + h
                       for s in range(1, schritte)):
                    konflikte.append((gid, kante))
                    break
    for gid, box in gw_labels.items():
        konflikte += [(gid, eid) for eid, form in formen.items() if eid != gid and _ueberlappen(box, form)]
    return sorted(konflikte)


@pytest.mark.parametrize("md", MODELLE, ids=lambda p: p.stem)
def test_gateway_beschriftung_wird_von_nichts_geschnitten(md):
    """Prüft, dass jede Gateway-Beschriftung eine feste Position hat und weder von einer Kante noch von einer
    Kantenbeschriftung oder einem anderen Element geschnitten wird (Issue #14; PICTURE übernimmt die Position)."""
    defs = baue(md)
    art = {el.get("id"): el.tag.rpartition("}")[2] for el in defs.iter() if el.get("id")}
    ohne = [s.get("bpmnElement") for s in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape")
            if art.get(s.get("bpmnElement")) in GATEWAYS and s.find(f"{{{m.NS['bpmndi']}}}BPMNLabel") is None
            and next(el for el in defs.iter() if el.get("id") == s.get("bpmnElement")).get("name")]
    assert ohne == [], "Gateway mit Namen, aber ohne Beschriftungsposition: " + ", ".join(ohne)
    konflikte = beschriftungskonflikte(defs)
    assert konflikte == [], "Gateway-Beschriftung geschnitten: " + ", ".join(f"{g} ← {k}" for g, k in konflikte)


@pytest.mark.parametrize("md", [md for md in MODELLE if md.stem != "beispiel_prozess"], ids=lambda p: p.stem)
def test_gateway_beschriftung_bleibt_in_der_eigenen_lane(md):
    """Prüft, dass jede Gateway-Beschriftung vollständig in der Lane ihres Gateways liegt und nicht in den Lane-Kopf
    mit den Lane-Namen oder in eine Nachbar-Lane ragt (Issue #14)."""
    defs = baue(md)
    lanes = [_box(s) for s in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape") if s.get("bpmnElement").startswith("Lane_")]
    assert lanes, "Modell ohne Lanes"
    for shape in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape"):
        label = shape.find(f"{{{m.NS['bpmndi']}}}BPMNLabel")
        if label is None:
            continue
        x, y, w, h = _box(shape)
        lx, ly, lw, lh = _box(label)
        lane = next(b for b in lanes if b[1] <= y + h / 2 <= b[1] + b[3])
        assert lane[1] <= ly and ly + lh <= lane[1] + lane[3], f"{shape.get('bpmnElement')}: ragt aus der Lane"
        assert lx >= lane[0] + m.LANE_HEADER_WIDTH, f"{shape.get('bpmnElement')}: ragt in den Lane-Kopf"


MIT_ANMERKUNGEN = [md for md in MODELLE if " Hinweis:" in md.read_text(encoding="utf-8")]


def test_es_gibt_ein_modell_mit_anmerkungen():
    """Prüft, dass die Anmerkungs-Tests tatsächlich an einem Modell laufen."""
    assert MIT_ANMERKUNGEN


@pytest.mark.parametrize("md", MIT_ANMERKUNGEN, ids=lambda p: p.stem)
def test_anmerkungen_ueberlappen_nichts_und_stehen_neben_dem_pool(md):
    """Prüft, dass Anmerkungen (Hinweise) sich nicht gegenseitig überlappen, kein anderes Element überdecken und –
    wenn es einen Prozess-Pool gibt – rechts daneben stehen, also keine Lane-Grenze kreuzen (Issue #14)."""
    defs = baue(md)
    art = {el.get("id"): el.tag.rpartition("}")[2] for el in defs.iter() if el.get("id")}
    formen = {s.get("bpmnElement"): _box(s) for s in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape")}
    anmerkungen = {eid: box for eid, box in formen.items() if art.get(eid) == "textAnnotation"}
    ids = sorted(anmerkungen)
    for i, a in enumerate(ids):
        for b in ids[i + 1:]:
            assert not _ueberlappen(anmerkungen[a], anmerkungen[b]), f"{a} überlappt {b}"
        for eid, form in formen.items():
            if art.get(eid) in HINDERNISSE:
                assert not _ueberlappen(anmerkungen[a], form), f"{a} überdeckt {eid}"
    if "Participant_1" in formen:
        px, _, pw, _ = formen["Participant_1"]
        for eid, (x, _, _, _) in anmerkungen.items():
            assert x >= px + pw, f"{eid} steht im Pool (x {x:g} < {px + pw:g})"


@pytest.mark.parametrize("md", MIT_ANMERKUNGEN, ids=lambda p: p.stem)
def test_anmerkung_ist_gross_genug_fuer_ihren_text(md):
    """Prüft, dass jedes Anmerkungs-Kästchen seinen Text fassen kann (grob: 7 Einheiten je Zeichen, 16 je Zeile).
    Sonst vergrößert PICTURE das Kästchen beim Import, und es überlappt Nachbarn und Lane-Grenzen (Issue #14)."""
    defs = baue(md)
    formen = {s.get("bpmnElement"): _box(s) for s in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape")}
    for anm in defs.iter(f"{{{m.NS['bpmn']}}}textAnnotation"):
        text = anm.find(f"{{{m.NS['bpmn']}}}text").text or ""
        _, _, w, h = formen[anm.get("id")]
        zeilen = math.ceil(len(text) * 7 / (w - 10))
        assert h >= zeilen * 16, f"{anm.get('id')}: {len(text)} Zeichen brauchen etwa {zeilen} Zeilen, Höhe nur {h:g}"


def test_kreuzungspruefung_findet_eine_kante_durch_eine_aufgabe():
    """Prüft die Prüfung selbst: eine absichtlich durch eine Aufgabe gelegte Kante wird gefunden, eine daneben nicht."""
    defs = baue(SKILL / "beispiele" / "beispiel_prozess.md")
    task_shape = next(s for s in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNShape") if s.get("bpmnElement").startswith("Task_"))
    b = task_shape.find(f"{{{m.NS['dc']}}}Bounds")
    x, y, w, h = (float(b.get(a)) for a in ("x", "y", "width", "height"))
    edge = next(e for e in defs.iter(f"{{{m.NS['bpmndi']}}}BPMNEdge") if e.get("bpmnElement").startswith("Flow_"))
    wp = edge.findall(f"{{{m.NS['di']}}}waypoint")
    wp[0].set("x", str(x - 20)); wp[0].set("y", str(y + h / 2))
    wp[-1].set("x", str(x + w + 20)); wp[-1].set("y", str(y + h / 2))
    for mitte in wp[1:-1]:
        edge.remove(mitte)
    assert (edge.get("bpmnElement"), task_shape.get("bpmnElement")) in kreuzungen(defs)
    wp[0].set("y", str(y - 30)); wp[-1].set("y", str(y - 30))
    assert (edge.get("bpmnElement"), task_shape.get("bpmnElement")) not in kreuzungen(defs)