nexarch/dms/internal/folderapi/handler_test.go

package folderapi

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"

	"gitea.perlbach24.de/scripte/nexarch/common/testdb"
	"gitea.perlbach24.de/scripte/nexarch/dms/internal/folder"
	"gitea.perlbach24.de/scripte/nexarch/dms/internal/policyclient"
)

func requireTestPool(t *testing.T) (*pgxpool.Pool, string) {
	t.Helper()
	dsn := os.Getenv("TEST_TENANT_DSN")
	if dsn == "" {
		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
	}
	ctx := context.Background()
	pool := testdb.Pool(t, dsn)
	t.Cleanup(func() { pool.Close() })

	if _, err := pool.Exec(ctx, `
		CREATE EXTENSION IF NOT EXISTS pgcrypto;
		CREATE TABLE IF NOT EXISTS users (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
			status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE TABLE IF NOT EXISTS folders (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), parent_folder_id UUID REFERENCES folders(id) ON DELETE CASCADE,
			name TEXT NOT NULL, path TEXT NOT NULL, created_by UUID NOT NULL REFERENCES users(id),
			trashed_at TIMESTAMPTZ, trashed_via_folder_id UUID,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
		CREATE INDEX IF NOT EXISTS idx_folders_path ON folders (path text_pattern_ops);
		CREATE TABLE IF NOT EXISTS documents (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), folder_id UUID REFERENCES folders(id) ON DELETE SET NULL,
			title TEXT NOT NULL, current_revision_id UUID, created_by UUID NOT NULL REFERENCES users(id),
			trashed_at TIMESTAMPTZ, trashed_via_folder_id UUID,
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), deleted_at TIMESTAMPTZ
		);
		CREATE TABLE IF NOT EXISTS file_revisions (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
			revision_number INT NOT NULL, storage_key TEXT NOT NULL, checksum_sha256 TEXT NOT NULL,
			size_bytes BIGINT NOT NULL, mime_type TEXT NOT NULL, created_by UUID NOT NULL REFERENCES users(id),
			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), wrapped_dek BYTEA,
			UNIQUE (document_id, revision_number)
		);
		CREATE TABLE IF NOT EXISTS revision_scans (
			revision_id UUID PRIMARY KEY REFERENCES file_revisions(id) ON DELETE CASCADE,
			status TEXT NOT NULL CHECK (status IN ('pending', 'processing', 'clean', 'infected')),
			finding TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
		);
	`); err != nil {
		t.Fatalf("schema: %v", err)
	}
	t.Cleanup(func() {
		_, _ = pool.Exec(context.Background(), `TRUNCATE revision_scans, file_revisions, documents, folders, users CASCADE`)
	})

	var userID string
	if err := pool.QueryRow(ctx, `
		INSERT INTO users (email, name) VALUES ($1, 'Test-Benutzer') RETURNING id
	`, fmt.Sprintf("folderapi-test-%d@example.test", time.Now().UnixNano())).Scan(&userID); err != nil {
		t.Fatalf("testbenutzer anlegen: %v", err)
	}
	return pool, userID
}

func createDocument(t *testing.T, pool *pgxpool.Pool, userID string, folderID *string, title string, sizeBytes int64) string {
	t.Helper()
	ctx := context.Background()
	var documentID string
	if err := pool.QueryRow(ctx, `
		INSERT INTO documents (folder_id, title, created_by) VALUES ($1, $2, $3) RETURNING id
	`, folderID, title, userID).Scan(&documentID); err != nil {
		t.Fatalf("dokument anlegen: %v", err)
	}
	var revisionID string
	if err := pool.QueryRow(ctx, `
		INSERT INTO file_revisions (document_id, revision_number, storage_key, checksum_sha256, size_bytes, mime_type, created_by)
		VALUES ($1, 1, 'k', 'x', $2, 'application/pdf', $3) RETURNING id
	`, documentID, sizeBytes, userID).Scan(&revisionID); err != nil {
		t.Fatalf("revision anlegen: %v", err)
	}
	if _, err := pool.Exec(ctx, `UPDATE documents SET current_revision_id = $2 WHERE id = $1`, documentID, revisionID); err != nil {
		t.Fatalf("aktuelle revision setzen: %v", err)
	}
	return documentID
}

// Akzeptanzkriterium 1: Baum und Liste bleiben synchron - beide fragen
// denselben Ordner-/Dokumentenbestand ab.
func TestHandleChildrenAndDocuments_ReflectSameFolderState(t *testing.T) {
	pool, userID := requireTestPool(t)
	root, err := folder.Create(context.Background(), pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}
	child, err := folder.Create(context.Background(), pool, "kind", &root.ID, userID)
	if err != nil {
		t.Fatalf("child: %v", err)
	}
	createDocument(t, pool, userID, &root.ID, "dok-a.pdf", 1000)
	createDocument(t, pool, userID, &child.ID, "dok-b.pdf", 2000)

	mux := http.NewServeMux()
	NewServer(pool).RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID + "/children")
	if err != nil {
		t.Fatalf("get children: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	var children []folderDTO
	_ = json.NewDecoder(resp.Body).Decode(&children)
	if len(children) != 1 || children[0].ID != child.ID {
		t.Fatalf("erwartet genau 1 kind (%q), habe: %+v", child.ID, children)
	}

	respDocs, err := http.Get(server.URL + "/folders/" + root.ID + "/documents?caller=" + userID)
	if err != nil {
		t.Fatalf("get documents: %v", err)
	}
	defer func() { _ = respDocs.Body.Close() }()
	var docs []documentDTO
	_ = json.NewDecoder(respDocs.Body).Decode(&docs)
	if len(docs) != 1 || docs[0].Title != "dok-a.pdf" {
		t.Fatalf("erwartet genau 1 dokument in root (dok-a.pdf), habe: %+v", docs)
	}
}

// Brotkrumenpfad liefert die Kette von der Wurzel bis zum Ordner.
func TestHandleBreadcrumb_ReturnsFullTrail(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}
	child, err := folder.Create(ctx, pool, "kind", &root.ID, userID)
	if err != nil {
		t.Fatalf("child: %v", err)
	}
	grandchild, err := folder.Create(ctx, pool, "enkel", &child.ID, userID)
	if err != nil {
		t.Fatalf("grandchild: %v", err)
	}

	mux := http.NewServeMux()
	NewServer(pool).RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + grandchild.ID + "/breadcrumb")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	var trail []folderDTO
	_ = json.NewDecoder(resp.Body).Decode(&trail)
	if len(trail) != 3 {
		t.Fatalf("erwartet 3 brotkrumen-eintraege, habe %d: %+v", len(trail), trail)
	}
	if trail[0].Name != "wurzel" || trail[1].Name != "kind" || trail[2].Name != "enkel" {
		t.Fatalf("brotkrumen-reihenfolge falsch: %+v", trail)
	}
}

// Dokumentenliste unterstuetzt Sortierung.
func TestHandleDocuments_SortsByRequestedColumn(t *testing.T) {
	pool, userID := requireTestPool(t)
	root, err := folder.Create(context.Background(), pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}
	createDocument(t, pool, userID, &root.ID, "b.pdf", 500)
	createDocument(t, pool, userID, &root.ID, "a.pdf", 9000)

	mux := http.NewServeMux()
	NewServer(pool).RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID + "/documents?sort=title&order=asc&caller=" + userID)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	var docs []documentDTO
	_ = json.NewDecoder(resp.Body).Decode(&docs)
	if len(docs) != 2 || docs[0].Title != "a.pdf" || docs[1].Title != "b.pdf" {
		t.Fatalf("erwartet nach titel aufsteigend sortiert, habe: %+v", docs)
	}
}

// fakeObjectACL ist ein einstellbarer ObjectACLClient-Stub fuer die
// Objektrechte-Tests (DOC-23). Er prueft zusaetzlich, dass tenant und der
// letzte Pfadknoten (das tatsaechlich angefragte Objekt) korrekt
// durchgereicht werden.
type fakeObjectACL struct {
	// perFolder steuert je Ordner-ID (letzter Pfadknoten) das Ergebnis;
	// fehlt ein Eintrag, gilt hasEntries=false (kein Objektrecht gesetzt).
	perFolder map[string]struct {
		allowed    bool
		hasEntries bool
	}
	wantTenant string
	err        error
	calls      []policyclient.ObjectPathNode // letzter Knoten je Aufruf
}

func (f *fakeObjectACL) ObjectAllowed(_ context.Context, tenant string, path []policyclient.ObjectPathNode, right, userID string, _ []string) (bool, bool, error) {
	if f.wantTenant != "" && tenant != f.wantTenant {
		return false, false, fmt.Errorf("fakeObjectACL: unerwarteter mandant %q", tenant)
	}
	if right != "read" {
		return false, false, fmt.Errorf("fakeObjectACL: unerwartetes recht %q", right)
	}
	if userID == "" {
		return false, false, fmt.Errorf("fakeObjectACL: leere user-id")
	}
	last := path[len(path)-1]
	f.calls = append(f.calls, last)
	if f.err != nil {
		return false, false, f.err
	}
	e, ok := f.perFolder[last.ID]
	if !ok {
		return false, false, nil // keine ACL fuer dieses Objekt
	}
	return e.allowed, e.hasEntries, nil
}

// Akzeptanzkriterium 2: Ein Ordner ohne Objekt-ACL verhaelt sich unveraendert
// - ein fremder Nutzer (nicht Ersteller) sieht trotzdem die Kindliste und
// den Ordner selbst, weil handleChildren/handleFolder/handleBreadcrumb nie
// nach Eigentuemer gefiltert haben und der ACL-Client keinen Eintrag kennt.
func TestFolderACL_NoEntries_UnchangedBehaviour(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}
	child, err := folder.Create(ctx, pool, "kind", &root.ID, userID)
	if err != nil {
		t.Fatalf("child: %v", err)
	}

	fake := &fakeObjectACL{wantTenant: "acme", perFolder: map[string]struct {
		allowed    bool
		hasEntries bool
	}{}}
	srv := NewServer(pool)
	srv.SetObjectACL(fake, "acme")
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID + "/children?caller=" + "fremder-nutzer")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("erwartet 200 ohne ACL, habe %d", resp.StatusCode)
	}
	var children []folderDTO
	_ = json.NewDecoder(resp.Body).Decode(&children)
	if len(children) != 1 || children[0].ID != child.ID {
		t.Fatalf("erwartet weiterhin sichtbares kind, habe: %+v", children)
	}
}

// Akzeptanzkriterium 1: Ein Ordner MIT gesetzter Objekt-ACL, die dem
// aufrufenden Nutzer kein Recht gibt, ist fuer ihn nicht mehr sichtbar
// (403); ein Rechteentzug (naechster Test) wirkt sofort beim naechsten
// Aufruf, weil hier kein Ergebnis-Cache existiert.
func TestFolderACL_DeniesWithoutRight(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "geschuetzt", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}

	fake := &fakeObjectACL{wantTenant: "acme", perFolder: map[string]struct {
		allowed    bool
		hasEntries bool
	}{root.ID: {allowed: false, hasEntries: true}}}
	srv := NewServer(pool)
	srv.SetObjectACL(fake, "acme")
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID + "?caller=fremder-nutzer")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusForbidden {
		t.Fatalf("erwartet 403, habe %d", resp.StatusCode)
	}

	// Rechteentzug wirkt sofort: kein Cache haelt eine fruehere
	// Entscheidung fest, auch nicht innerhalb desselben Tests.
	fake.perFolder[root.ID] = struct {
		allowed    bool
		hasEntries bool
	}{allowed: true, hasEntries: true}
	resp2, err := http.Get(server.URL + "/folders/" + root.ID + "?caller=fremder-nutzer")
	if err != nil {
		t.Fatalf("get 2: %v", err)
	}
	defer func() { _ = resp2.Body.Close() }()
	if resp2.StatusCode != http.StatusOK {
		t.Fatalf("erwartet 200 nach gewaehrtem recht, habe %d", resp2.StatusCode)
	}
}

// Vererbung: Ein Unterordner ohne eigenen ACL-Eintrag erbt die Entscheidung
// des Elternordners, weil handleBreadcrumb den vollen Pfad an den ACL-Client
// uebergibt und fakeObjectACL nur den LETZTEN Pfadknoten auswertet — hier
// simuliert dadurch, dass fuer den Kindordner selbst kein Eintrag existiert,
// aber der Aufruf trotzdem denselben Pfad (inkl. Elternteil) sieht. Der
// eigentliche Vererbungsalgorithmus (naechster unterbrochener Vorfahre bis
// Wurzel) liegt in Core (RBAC-11) und ist dort bereits getestet; dieser Test
// belegt nur, dass das DMS den VOLLEN Pfad (nicht nur die ID) mitgibt.
func TestFolderACL_PassesFullPathForInheritance(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}
	child, err := folder.Create(ctx, pool, "kind", &root.ID, userID)
	if err != nil {
		t.Fatalf("child: %v", err)
	}

	fake := &fakeObjectACL{wantTenant: "acme", perFolder: map[string]struct {
		allowed    bool
		hasEntries bool
	}{child.ID: {allowed: true, hasEntries: true}}}
	srv := NewServer(pool)
	srv.SetObjectACL(fake, "acme")
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + child.ID + "/breadcrumb?caller=nutzer-x")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("erwartet 200, habe %d", resp.StatusCode)
	}
	if len(fake.calls) != 1 {
		t.Fatalf("erwartet genau 1 aufruf des acl-clients, habe %d", len(fake.calls))
	}
}

// Mandantentrennung: der konfigurierte Mandant wird bei jedem Aufruf an
// Core mitgegeben; ein Client, der einen anderen Mandanten erwartet (bzw.
// hier: ablehnt), zeigt dass keine mandantenuebergreifende Pruefung
// stattfinden kann.
func TestFolderACL_PassesConfiguredTenant(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}

	fake := &fakeObjectACL{wantTenant: "globex", perFolder: map[string]struct {
		allowed    bool
		hasEntries bool
	}{root.ID: {allowed: true, hasEntries: true}}}
	srv := NewServer(pool)
	srv.SetObjectACL(fake, "acme") // konfigurierter Mandant weicht ab
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID + "?caller=nutzer-x")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusServiceUnavailable {
		t.Fatalf("erwartet 503 bei mandanten-mismatch (fakeObjectACL lehnt ab), habe %d", resp.StatusCode)
	}
}

// Akzeptanzkriterium 3: Ausfall der Core-Policy-Pruefung verweigert den
// Zugriff (fail closed), auch wenn der Ordner ohne Pruefung sichtbar waere.
func TestFolderACL_CoreUnavailable_FailsClosed(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}

	fake := &fakeObjectACL{wantTenant: "acme", err: fmt.Errorf("core nicht erreichbar")}
	srv := NewServer(pool)
	srv.SetObjectACL(fake, "acme")
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID + "?caller=nutzer-x")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusServiceUnavailable {
		t.Fatalf("erwartet 503 bei core-ausfall, habe %d", resp.StatusCode)
	}
}

// Ohne konfigurierte Objekt-ACL verlangen /children und /breadcrumb weiterhin
// KEINE Identitaet - das war vor diesem Ticket schon so (Akzeptanzkriterium
// 2 gilt auch fuer den Authentifizierungs-Aspekt, nicht nur die Sichtbarkeit).
func TestFolderACL_Disabled_NoIdentityRequired(t *testing.T) {
	pool, userID := requireTestPool(t)
	ctx := context.Background()
	root, err := folder.Create(ctx, pool, "wurzel", nil, userID)
	if err != nil {
		t.Fatalf("root: %v", err)
	}

	mux := http.NewServeMux()
	NewServer(pool).RegisterRoutes(mux) // kein SetObjectACL
	server := httptest.NewServer(mux)
	defer server.Close()

	resp, err := http.Get(server.URL + "/folders/" + root.ID) // ohne ?caller=
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("erwartet 200 ohne identitaet bei deaktivierter acl, habe %d", resp.StatusCode)
	}
}