deklarix/internal/rules/evaluate_test.go

package rules_test

import (
	"testing"

	"github.com/netcell-it/deklarix/internal/rules"
)

func loadRealRegelwerke(t *testing.T) (rules.DatenklasseRegelwerk, rules.EinstufungRegelwerk, rules.AnforderungsRegelwerk) {
	t.Helper()
	fsys := realRulesFS(t)
	dk, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml")
	if err != nil {
		t.Fatalf("LoadDatenklasse: %v", err)
	}
	ei, err := rules.LoadEinstufung(fsys, "kivo_einstufung.yaml")
	if err != nil {
		t.Fatalf("LoadEinstufung: %v", err)
	}
	an, err := rules.LoadAnforderungen(fsys, "anforderungen.yaml")
	if err != nil {
		t.Fatalf("LoadAnforderungen: %v", err)
	}
	return dk, ei, an
}

func TestEvaluateDatenklasseOnlyOeffentlich(t *testing.T) {
	dk, _, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"b1": "nein", "b2": "nein", "b3": "nein", "b4": "nein", "b5": "nein", "b6": "nein", "b7": "ja"}
	got := rules.EvaluateDatenklasse(dk, antworten)
	if got.ID != "oeffentlich" {
		t.Fatalf("EvaluateDatenklasse.ID = %q, want oeffentlich", got.ID)
	}
}

func TestEvaluateDatenklasseHighestWins(t *testing.T) {
	dk, _, _ := loadRealRegelwerke(t)
	// b1 (personenbezogen) UND b2 (besondere_kategorie) beide ja ->
	// besondere_kategorie hat den hoeheren Rang und muss gewinnen.
	antworten := rules.Antworten{"b1": "ja", "b2": "ja", "b7": "nein"}
	got := rules.EvaluateDatenklasse(dk, antworten)
	if got.ID != "besondere_kategorie" {
		t.Fatalf("EvaluateDatenklasse.ID = %q, want besondere_kategorie", got.ID)
	}
}

func TestEvaluateDatenklasseUnsicherZaehltWieJa(t *testing.T) {
	dk, _, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"b3": "unsicher"}
	got := rules.EvaluateDatenklasse(dk, antworten)
	if got.ID != "berufsgeheimnis" {
		t.Fatalf("EvaluateDatenklasse.ID = %q, want berufsgeheimnis (unsicher zaehlt wie ja)", got.ID)
	}
}

func TestEvaluateDatenklasseFallsBackToInternWhenNothingMatches(t *testing.T) {
	dk, _, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"b1": "nein", "b2": "nein", "b3": "nein", "b4": "nein", "b5": "nein", "b6": "nein", "b7": "nein"}
	got := rules.EvaluateDatenklasse(dk, antworten)
	if got.ID != "intern" {
		t.Fatalf("EvaluateDatenklasse.ID = %q, want intern (konservativer Fallback)", got.ID)
	}
}

func TestEvaluateEinstufungVerboten(t *testing.T) {
	_, ei, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"c3": true, "c3_art": "social_scoring"}
	got, err := rules.EvaluateEinstufung(ei, antworten)
	if err != nil {
		t.Fatalf("EvaluateEinstufung: %v", err)
	}
	if got.ID != "verboten" {
		t.Fatalf("EvaluateEinstufung.ID = %q, want verboten", got.ID)
	}
	if !rules.IstVerboten(got.ID) {
		t.Error("IstVerboten sollte true liefern")
	}
}

func TestEvaluateEinstufungHochrisiko(t *testing.T) {
	_, ei, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"c2": true, "c2_folge": "kreditwuerdigkeit", "c3": false}
	got, err := rules.EvaluateEinstufung(ei, antworten)
	if err != nil {
		t.Fatalf("EvaluateEinstufung: %v", err)
	}
	if got.ID != "hochrisiko" {
		t.Fatalf("EvaluateEinstufung.ID = %q, want hochrisiko", got.ID)
	}
}

func TestEvaluateEinstufungTransparenzpflicht(t *testing.T) {
	_, ei, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"c1": true, "c2": false, "c3": false, "c5": false}
	got, err := rules.EvaluateEinstufung(ei, antworten)
	if err != nil {
		t.Fatalf("EvaluateEinstufung: %v", err)
	}
	if got.ID != "transparenzpflicht" {
		t.Fatalf("EvaluateEinstufung.ID = %q, want transparenzpflicht", got.ID)
	}
}

func TestEvaluateEinstufungMinimalFallback(t *testing.T) {
	_, ei, _ := loadRealRegelwerke(t)
	antworten := rules.Antworten{"c1": false, "c2": false, "c3": false, "c4": false, "c5": true}
	got, err := rules.EvaluateEinstufung(ei, antworten)
	if err != nil {
		t.Fatalf("EvaluateEinstufung: %v", err)
	}
	if got.ID != "minimal" {
		t.Fatalf("EvaluateEinstufung.ID = %q, want minimal", got.ID)
	}
	if rules.IstVerboten(got.ID) {
		t.Error("IstVerboten sollte fuer minimal false liefern")
	}
}

func TestDeriveAnforderungenPersonenbezogen(t *testing.T) {
	_, _, an := loadRealRegelwerke(t)
	got := rules.DeriveAnforderungen(an, "personenbezogen", "minimal")
	want := map[string]bool{"avv_erforderlich": true, "kein_training_auf_eingabe": true, "loeschfrist_max_tage": true}
	gotSet := map[string]bool{}
	for _, a := range got {
		gotSet[a.ID] = true
		if a.Herleitung == "" {
			t.Errorf("Anforderung %q hat keine Herleitung", a.ID)
		}
	}
	for id := range want {
		if !gotSet[id] {
			t.Errorf("expected Anforderung %q for personenbezogen/minimal, got %v", id, got)
		}
	}
	if gotSet["eu_verarbeitung"] {
		t.Error("eu_verarbeitung sollte fuer personenbezogen (ohne berufsgeheimnis/besondere_kategorie) nicht ausgeloest werden")
	}
}

func TestDeriveAnforderungenHochrisikoAddsAufsichtUndDsfa(t *testing.T) {
	_, _, an := loadRealRegelwerke(t)
	got := rules.DeriveAnforderungen(an, "oeffentlich", "hochrisiko")
	gotSet := map[string]bool{}
	for _, a := range got {
		gotSet[a.ID] = true
	}
	if !gotSet["menschliche_aufsicht"] || !gotSet["dsfa_erforderlich"] {
		t.Errorf("expected menschliche_aufsicht und dsfa_erforderlich fuer hochrisiko, got %v", got)
	}
}

func TestErfuelltAnforderungAVV(t *testing.T) {
	if rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: false}, nil) {
		t.Error("erwartet: nicht erfuellt ohne AVV")
	}
	if !rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: true}, nil) {
		t.Error("erwartet: erfuellt mit AVV")
	}
}

func TestErfuelltAnforderungEUVerarbeitung(t *testing.T) {
	if !rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland"}}, nil) {
		t.Error("erwartet: erfuellt bei einem einzelnen EU/EWR-Land")
	}
	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"USA"}}, nil) {
		t.Error("erwartet: nicht erfuellt bei USA - die USA sind ein Drittland wie jedes andere")
	}
	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland", "USA"}}, nil) {
		t.Error("erwartet: nicht erfuellt, sobald auch nur ein Land nicht EU/EWR ist")
	}
	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{}, nil) {
		t.Error("erwartet: nicht erfuellt ohne benanntes Land - 'wissen wir nicht' darf nicht als 'ist okay' durchgehen")
	}
}

func TestErfuelltAnforderungLoeschfrist(t *testing.T) {
	dreissig := 30
	neunzig := 90
	// Keine Frist konfiguriert -> nicht hart gefiltert (Rückwärtskompatibilität).
	if !rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{}, nil) {
		t.Error("erwartet: erfuellt ohne konfigurierte Frist")
	}
	// Frist gesetzt, Werkzeug bleibt innerhalb -> erfuellt.
	if !rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{AufbewahrungTage: &dreissig}, &neunzig) {
		t.Error("erwartet: erfuellt, wenn Aufbewahrung <= Frist")
	}
	// Frist gesetzt, Werkzeug überschreitet -> nicht erfuellt.
	if rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{AufbewahrungTage: &neunzig}, &dreissig) {
		t.Error("erwartet: nicht erfuellt, wenn Aufbewahrung > Frist")
	}
	// Frist gesetzt, Werkzeug beziffert Aufbewahrung nicht -> fail closed.
	if rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{}, &dreissig) {
		t.Error("erwartet: nicht erfuellt, wenn Aufbewahrungsdauer unbekannt ist ('wissen wir nicht' darf nicht als 'ist okay' durchgehen)")
	}
}

func TestErfuelltAnforderungUnbekannteAnforderungIstUnkritisch(t *testing.T) {
	if !rules.ErfuelltAnforderung("menschliche_aufsicht", rules.WerkzeugEigenschaften{}, nil) {
		t.Error("Prozess-Anforderungen duerfen ein Werkzeug nicht hart aussortieren")
	}
}

func TestFilterWerkzeugeSortsOutMissingAVV(t *testing.T) {
	kandidaten := []rules.WerkzeugKandidat{
		{ID: "mit-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: true, Verarbeitungslaender: []string{"Deutschland"}, TrainingStandard: true}},
		{ID: "ohne-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: false, Verarbeitungslaender: []string{"Deutschland"}, TrainingStandard: true}},
	}
	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, []string{"avv_erforderlich"}, nil)
	if len(zulaessig) != 1 || zulaessig[0] != "mit-avv" {
		t.Fatalf("zulaessig = %v, want [mit-avv]", zulaessig)
	}
	if len(ausgeschlossen) != 1 || ausgeschlossen[0].WerkzeugID != "ohne-avv" {
		t.Fatalf("ausgeschlossen = %v, want genau ohne-avv", ausgeschlossen)
	}
	if len(ausgeschlossen[0].NichtErfuellt) != 1 || ausgeschlossen[0].NichtErfuellt[0] != "avv_erforderlich" {
		t.Fatalf("NichtErfuellt = %v, want [avv_erforderlich]", ausgeschlossen[0].NichtErfuellt)
	}
}

func TestFilterWerkzeugeNoRequirementsAllowsEverything(t *testing.T) {
	kandidaten := []rules.WerkzeugKandidat{{ID: "x"}, {ID: "y"}}
	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, nil, nil)
	if len(zulaessig) != 2 || len(ausgeschlossen) != 0 {
		t.Fatalf("zulaessig=%v ausgeschlossen=%v, want beide zulaessig", zulaessig, ausgeschlossen)
	}
}

func TestParseAntwortenRoundTrip(t *testing.T) {
	raw := []byte(`{"b1":"ja","c2":true,"c2_folge":"bildung"}`)
	a, err := rules.ParseAntworten(raw)
	if err != nil {
		t.Fatalf("ParseAntworten: %v", err)
	}
	if a["b1"] != "ja" || a["c2_folge"] != "bildung" {
		t.Fatalf("ParseAntworten = %+v, unerwartete Werte", a)
	}
}

func TestParseAntwortenEmpty(t *testing.T) {
	a, err := rules.ParseAntworten(nil)
	if err != nil {
		t.Fatalf("ParseAntworten: %v", err)
	}
	if len(a) != 0 {
		t.Fatalf("ParseAntworten(nil) = %+v, want empty", a)
	}
}