deklarix/internal/rules/loader_test.go

package rules_test

import (
	"io/fs"
	"os"
	"testing"
	"testing/fstest"

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

func realRulesFS(t *testing.T) fs.FS {
	t.Helper()
	return os.DirFS("../../rules")
}

func TestLoadDatenklasseRealFile(t *testing.T) {
	rw, err := rules.LoadDatenklasse(realRulesFS(t), "datenklasse.yaml")
	if err != nil {
		t.Fatalf("LoadDatenklasse: %v", err)
	}
	if rw.Version != 1 {
		t.Fatalf("Version = %d, want 1", rw.Version)
	}
	if len(rw.Stufen) != 6 {
		t.Fatalf("expected 6 Stufen, got %d", len(rw.Stufen))
	}
	byID := map[string]rules.DatenklasseStufe{}
	for _, st := range rw.Stufen {
		byID[st.ID] = st
	}
	for _, id := range []string{"oeffentlich", "intern", "auftragsdaten", "personenbezogen", "berufsgeheimnis", "besondere_kategorie"} {
		if _, ok := byID[id]; !ok {
			t.Errorf("expected Stufe %q to be defined", id)
		}
	}
	if byID["besondere_kategorie"].Rang <= byID["personenbezogen"].Rang {
		t.Error("expected besondere_kategorie to outrank personenbezogen")
	}
}

func TestLoadDatenklasseRejectsDuplicateRang(t *testing.T) {
	fsys := fstest.MapFS{
		"datenklasse.yaml": &fstest.MapFile{Data: []byte(`
version: 1
stufen:
  - {id: a, rang: 1, ausloeser: [b1]}
  - {id: b, rang: 1, ausloeser: [b2]}
`)},
	}
	if _, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml"); err == nil {
		t.Fatal("expected an error for duplicate rang values")
	}
}

func TestLoadDatenklasseRejectsMissingVersion(t *testing.T) {
	fsys := fstest.MapFS{
		"datenklasse.yaml": &fstest.MapFile{Data: []byte(`
stufen:
  - {id: a, rang: 1, ausloeser: [b1]}
`)},
	}
	if _, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml"); err == nil {
		t.Fatal("expected an error for a missing version")
	}
}

func TestLoadEinstufungRealFile(t *testing.T) {
	rw, err := rules.LoadEinstufung(realRulesFS(t), "kivo_einstufung.yaml")
	if err != nil {
		t.Fatalf("LoadEinstufung: %v", err)
	}
	if len(rw.Stufen) != 4 {
		t.Fatalf("expected 4 Stufen, got %d", len(rw.Stufen))
	}
	if rw.Stufen[0].ID != "verboten" {
		t.Fatalf("expected 'verboten' to be checked first (K.-o.-Prüfung), got %q", rw.Stufen[0].ID)
	}
	if rw.Stufen[len(rw.Stufen)-1].ID != "minimal" {
		t.Fatalf("expected 'minimal' as the last (catch-all) Stufe, got %q", rw.Stufen[len(rw.Stufen)-1].ID)
	}
}

func TestLoadEinstufungRejectsNonLastStufeWithoutVarianten(t *testing.T) {
	fsys := fstest.MapFS{
		"kivo_einstufung.yaml": &fstest.MapFile{Data: []byte(`
version: 1
stufen:
  - {id: verboten, varianten: []}
  - {id: minimal, varianten: []}
`)},
	}
	if _, err := rules.LoadEinstufung(fsys, "kivo_einstufung.yaml"); err == nil {
		t.Fatal("expected an error when a non-last Stufe has no Varianten")
	}
}

func TestLoadAnforderungenRealFile(t *testing.T) {
	rw, err := rules.LoadAnforderungen(realRulesFS(t), "anforderungen.yaml")
	if err != nil {
		t.Fatalf("LoadAnforderungen: %v", err)
	}
	wantIDs := []string{
		"avv_erforderlich", "eu_verarbeitung", "kein_training_auf_eingabe",
		"loeschfrist_max_tage", "menschliche_aufsicht", "kennzeichnungspflicht", "dsfa_erforderlich",
	}
	if len(rw.Anforderungen) != len(wantIDs) {
		t.Fatalf("expected %d Anforderungen, got %d", len(wantIDs), len(rw.Anforderungen))
	}
	byID := map[string]bool{}
	for _, a := range rw.Anforderungen {
		byID[a.ID] = true
	}
	for _, id := range wantIDs {
		if !byID[id] {
			t.Errorf("expected Anforderung %q to be defined", id)
		}
	}
}

func TestLoadAnforderungenRejectsAnforderungWithoutTrigger(t *testing.T) {
	fsys := fstest.MapFS{
		"anforderungen.yaml": &fstest.MapFile{Data: []byte(`
version: 1
anforderungen:
  - {id: x}
`)},
	}
	if _, err := rules.LoadAnforderungen(fsys, "anforderungen.yaml"); err == nil {
		t.Fatal("expected an error for an Anforderung without any trigger")
	}
}