deklarix/internal/store/werkzeug_test.go

package store_test

import (
	"context"
	"errors"
	"testing"
	"time"

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

func intPtr(v int) *int { return &v }

func testWerkzeugInput(accountID *string, name string) store.WerkzeugInput {
	return store.WerkzeugInput{
		AccountID:        accountID,
		Name:             name,
		Anbieter:         "Beispiel-Anbieter GmbH",
		Verarbeitungsort: "EU",
		AVVVerfuegbar:    true,
		AVVURL:           "https://beispiel.example/avv",
		TrainingOptOut:   true,
		TrainingStandard: true,
		AufbewahrungTage: intPtr(30),
		Zertifizierungen: []string{"ISO 27001"},
		Subprozessoren:   []string{"Beispiel-Subprozessor Inc."},
		GeeigneteZwecke:  []string{"Textgenerierung"},
		Einschraenkungen: nil,
		LetztePruefung:   time.Now().Add(-24 * time.Hour).Truncate(time.Millisecond),
		Quelle:           "https://beispiel.example/beleg",
	}
}

func TestWerkzeugCRUD(t *testing.T) {
	s := openTestStore(t)
	ctx := context.Background()

	w, err := s.CreateWerkzeug(ctx, testWerkzeugInput(nil, "Zentrales Werkzeug"))
	if err != nil {
		t.Fatalf("CreateWerkzeug: %v", err)
	}
	if w.AccountID != nil {
		t.Fatalf("expected AccountID nil fuer zentralen Katalogeintrag, got %v", w.AccountID)
	}
	if len(w.Zertifizierungen) != 1 || w.Zertifizierungen[0] != "ISO 27001" {
		t.Fatalf("Zertifizierungen = %v, want [ISO 27001]", w.Zertifizierungen)
	}
	if len(w.Subprozessoren) != 1 || w.Subprozessoren[0] != "Beispiel-Subprozessor Inc." {
		t.Fatalf("Subprozessoren = %v, want [Beispiel-Subprozessor Inc.]", w.Subprozessoren)
	}
	if w.AufbewahrungTage == nil || *w.AufbewahrungTage != 30 {
		t.Fatalf("AufbewahrungTage = %v, want 30", w.AufbewahrungTage)
	}

	unbekannt, err := s.CreateWerkzeug(ctx, func() store.WerkzeugInput {
		in := testWerkzeugInput(nil, "Werkzeug ohne Aufbewahrungsangabe")
		in.AufbewahrungTage = nil
		return in
	}())
	if err != nil {
		t.Fatalf("CreateWerkzeug (ohne Aufbewahrungsangabe): %v", err)
	}
	if unbekannt.AufbewahrungTage != nil {
		t.Fatalf("AufbewahrungTage = %v, want nil (unbekannt)", *unbekannt.AufbewahrungTage)
	}

	got, err := s.GetWerkzeug(ctx, w.ID)
	if err != nil {
		t.Fatalf("GetWerkzeug: %v", err)
	}
	if got.Name != "Zentrales Werkzeug" {
		t.Fatalf("Name = %q, want Zentrales Werkzeug", got.Name)
	}

	updateInput := testWerkzeugInput(nil, "Zentrales Werkzeug (aktualisiert)")
	updateInput.AufbewahrungTage = intPtr(14)
	updated, err := s.UpdateWerkzeug(ctx, w.ID, updateInput)
	if err != nil {
		t.Fatalf("UpdateWerkzeug: %v", err)
	}
	if updated.Name != "Zentrales Werkzeug (aktualisiert)" || updated.AufbewahrungTage == nil || *updated.AufbewahrungTage != 14 {
		t.Fatalf("UpdateWerkzeug = %+v, unerwartete Werte", updated)
	}

	if err := s.DeleteWerkzeug(ctx, w.ID); err != nil {
		t.Fatalf("DeleteWerkzeug: %v", err)
	}
	if _, err := s.GetWerkzeug(ctx, w.ID); !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("err nach Delete = %v, want store.ErrNotFound", err)
	}
}

func TestUpdateWerkzeugNotFound(t *testing.T) {
	s := openTestStore(t)
	_, err := s.UpdateWerkzeug(context.Background(), "00000000-0000-0000-0000-000000000000", testWerkzeugInput(nil, "x"))
	if !errors.Is(err, store.ErrNotFound) {
		t.Fatalf("err = %v, want store.ErrNotFound", err)
	}
}

func TestListWerkzeugeForAccountIncludesCentralAndOwnEntries(t *testing.T) {
	s := openTestStore(t)
	ctx := context.Background()
	accID := testAccountID(t, s)

	zentral, err := s.CreateWerkzeug(ctx, testWerkzeugInput(nil, "Zentral A"))
	if err != nil {
		t.Fatalf("CreateWerkzeug (zentral): %v", err)
	}
	eigenes, err := s.CreateWerkzeug(ctx, testWerkzeugInput(&accID, "Mandanten-eigenes Werkzeug"))
	if err != nil {
		t.Fatalf("CreateWerkzeug (eigenes): %v", err)
	}

	// Anderer Mandant darf das eigene Werkzeug nicht sehen.
	otherAcc := testAccountID(t, s)
	otherList, err := s.ListWerkzeugeForAccount(ctx, otherAcc)
	if err != nil {
		t.Fatalf("ListWerkzeugeForAccount (other): %v", err)
	}
	for _, w := range otherList {
		if w.ID == eigenes.ID {
			t.Fatal("expected the other account's own werkzeug to stay isolated")
		}
	}

	list, err := s.ListWerkzeugeForAccount(ctx, accID)
	if err != nil {
		t.Fatalf("ListWerkzeugeForAccount: %v", err)
	}
	byID := map[string]bool{}
	for _, w := range list {
		byID[w.ID] = true
	}
	if !byID[zentral.ID] || !byID[eigenes.ID] {
		t.Fatalf("expected both the central and the own werkzeug, got %+v", list)
	}
}

func TestWerkzeugSperreHidesCentralEntry(t *testing.T) {
	s := openTestStore(t)
	ctx := context.Background()
	accID := testAccountID(t, s)

	zentral, err := s.CreateWerkzeug(ctx, testWerkzeugInput(nil, "Zu sperrendes Werkzeug"))
	if err != nil {
		t.Fatalf("CreateWerkzeug: %v", err)
	}

	if _, err := s.CreateWerkzeugSperre(ctx, accID, zentral.ID, "vom Mandanten intern verboten"); err != nil {
		t.Fatalf("CreateWerkzeugSperre: %v", err)
	}

	list, err := s.ListWerkzeugeForAccount(ctx, accID)
	if err != nil {
		t.Fatalf("ListWerkzeugeForAccount: %v", err)
	}
	for _, w := range list {
		if w.ID == zentral.ID {
			t.Fatal("expected the sperred central werkzeug to be hidden for this account")
		}
	}

	// Der zentrale Katalog selbst bleibt fuer andere Mandanten sichtbar.
	otherAcc := testAccountID(t, s)
	otherList, err := s.ListWerkzeugeForAccount(ctx, otherAcc)
	if err != nil {
		t.Fatalf("ListWerkzeugeForAccount (other): %v", err)
	}
	found := false
	for _, w := range otherList {
		if w.ID == zentral.ID {
			found = true
		}
	}
	if !found {
		t.Fatal("expected the central werkzeug to remain visible for a different account")
	}

	if err := s.DeleteWerkzeugSperre(ctx, accID, zentral.ID); err != nil {
		t.Fatalf("DeleteWerkzeugSperre: %v", err)
	}
	listAfter, err := s.ListWerkzeugeForAccount(ctx, accID)
	if err != nil {
		t.Fatalf("ListWerkzeugeForAccount nach Entsperren: %v", err)
	}
	found = false
	for _, w := range listAfter {
		if w.ID == zentral.ID {
			found = true
		}
	}
	if !found {
		t.Fatal("expected the werkzeug to be visible again after DeleteWerkzeugSperre")
	}
}

func TestCurrentKatalogVersionChangesOnCreate(t *testing.T) {
	s := openTestStore(t)
	ctx := context.Background()

	before, err := s.CurrentKatalogVersion(ctx)
	if err != nil {
		t.Fatalf("CurrentKatalogVersion: %v", err)
	}
	if _, err := s.CreateWerkzeug(ctx, testWerkzeugInput(nil, "Version-Test-Werkzeug")); err != nil {
		t.Fatalf("CreateWerkzeug: %v", err)
	}
	after, err := s.CurrentKatalogVersion(ctx)
	if err != nil {
		t.Fatalf("CurrentKatalogVersion (2): %v", err)
	}
	if before == after {
		t.Fatalf("expected CurrentKatalogVersion to change after adding a werkzeug, got %q both times", before)
	}
}

func TestListZentraleWerkzeugeExcludesMandantenEigene(t *testing.T) {
	s := openTestStore(t)
	ctx := context.Background()
	accID := testAccountID(t, s)

	if _, err := s.CreateWerkzeug(ctx, testWerkzeugInput(nil, "Zentral B")); err != nil {
		t.Fatalf("CreateWerkzeug (zentral): %v", err)
	}
	eigenes, err := s.CreateWerkzeug(ctx, testWerkzeugInput(&accID, "Mandanten-eigenes B"))
	if err != nil {
		t.Fatalf("CreateWerkzeug (eigenes): %v", err)
	}

	list, err := s.ListZentraleWerkzeuge(ctx)
	if err != nil {
		t.Fatalf("ListZentraleWerkzeuge: %v", err)
	}
	for _, w := range list {
		if w.ID == eigenes.ID {
			t.Fatal("expected ListZentraleWerkzeuge to exclude mandantenspezifische Eintraege")
		}
	}
}