nexarch/dms/internal/documentapi/handler_test.go

package documentapi

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

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

	dmscrypto "gitea.perlbach24.de/scripte/nexarch/dms/internal/crypto"
	"gitea.perlbach24.de/scripte/nexarch/dms/internal/storage"
)

type fakeKEKProvider struct{ kek []byte }

func (f *fakeKEKProvider) TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error) {
	return f.kek, nil
}

type noopUsageReporter struct{}

func (noopUsageReporter) Report(ctx context.Context, tenantSlug, metric string, delta int64) error {
	return nil
}

func setupTest(t *testing.T) (*httptest.Server, *pgxpool.Pool, *storage.Service, *dmscrypto.Service, string) {
	t.Helper()
	dsn := os.Getenv("TEST_TENANT_DSN")
	if dsn == "" {
		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
	}
	ctx := context.Background()
	pool, err := pgxpool.New(ctx, dsn)
	if err != nil {
		t.Fatalf("pool: %v", err)
	}
	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 documents (
			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), folder_id UUID,
			title TEXT NOT NULL, current_revision_id UUID, created_by UUID NOT NULL REFERENCES users(id),
			trashed_at TIMESTAMPTZ,
			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, users CASCADE`)
	})

	storageSvc := storage.NewService(storage.NewLocalDriver(t.TempDir(), []byte("secret"), "https://files.example.test"), noopUsageReporter{}, "acme")
	cryptoSvc := dmscrypto.NewService(&fakeKEKProvider{kek: bytes.Repeat([]byte{0x33}, dmscrypto.KEKSize)})

	server := NewServer(pool, storageSvc, cryptoSvc, "acme")
	mux := http.NewServeMux()
	server.RegisterRoutes(mux)
	httpServer := httptest.NewServer(mux)
	t.Cleanup(httpServer.Close)

	return httpServer, pool, storageSvc, cryptoSvc, "acme"
}

func createDocument(t *testing.T, pool *pgxpool.Pool, storageSvc *storage.Service, cryptoSvc *dmscrypto.Service, tenantSlug string, content []byte) string {
	t.Helper()
	ctx := context.Background()

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

	var documentID string
	if err := pool.QueryRow(ctx, `
		INSERT INTO documents (title, created_by) VALUES ('Testdokument', $1) RETURNING id
	`, userID).Scan(&documentID); err != nil {
		t.Fatalf("dokument anlegen: %v", err)
	}

	env, err := cryptoSvc.Seal(ctx, tenantSlug, bytes.NewReader(content))
	if err != nil {
		t.Fatalf("seal: %v", err)
	}
	var buf bytes.Buffer
	if _, err := buf.ReadFrom(env.Ciphertext); err != nil {
		t.Fatalf("chiffretext lesen: %v", err)
	}

	storageKey := storage.ObjectKey(documentID, "1")
	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, wrapped_dek)
		VALUES ($1, 1, $2, 'x', $3, 'application/octet-stream', $4, $5)
		RETURNING id
	`, documentID, storageKey, len(content), userID, env.WrappedDEK).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)
	}
	if _, err := storageSvc.Put(ctx, storageKey, bytes.NewReader(buf.Bytes()), int64(buf.Len()), "application/octet-stream"); err != nil {
		t.Fatalf("objekt ablegen: %v", err)
	}
	return documentID
}

const minimalPDF = "%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 200 200]>>endobj\nxref\n0 4\n0000000000 65535 f \ntrailer<</Size 4/Root 1 0 R>>\nstartxref\n0\n%%EOF"

// Akzeptanzkriterium 1 + Pruefung: PDF wird ohne Download-Zwang
// ausgeliefert - korrekter, ueber Magic-Bytes bestimmter Content-Type und
// "inline" statt "attachment".
func TestHandleContent_ServesPDFInlineWithCorrectContentType(t *testing.T) {
	server, pool, storageSvc, cryptoSvc, tenant := setupTest(t)
	documentID := createDocument(t, pool, storageSvc, cryptoSvc, tenant, []byte(minimalPDF))

	resp, err := http.Get(server.URL + "/documents/" + documentID + "/content")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()

	if resp.StatusCode != http.StatusOK {
		t.Fatalf("status = %d, want 200", resp.StatusCode)
	}
	if ct := resp.Header.Get("Content-Type"); ct != "application/pdf" {
		t.Errorf("content-type = %q, want application/pdf", ct)
	}
	disposition := resp.Header.Get("Content-Disposition")
	if disposition != "inline" {
		t.Errorf("content-disposition = %q, want \"inline\" (kein download-zwang)", disposition)
	}

	var buf bytes.Buffer
	_, _ = buf.ReadFrom(resp.Body)
	if buf.String() != minimalPDF {
		t.Error("ausgelieferter inhalt stimmt nicht mit dem original ueberein")
	}
}

// Akzeptanzkriterium 3 + Pruefung: grosse Dokumente werden seitenweise
// nachgeladen - echter HTTP-Range-Request liefert einen Teilbereich mit
// Status 206, nicht das gesamte Dokument.
func TestHandleContent_SupportsRangeRequestsForPartialLoading(t *testing.T) {
	server, pool, storageSvc, cryptoSvc, tenant := setupTest(t)
	// Groesserer, deterministischer Inhalt, damit ein Range-Request
	// tatsaechlich nur einen Teil zurueckliefert.
	content := bytes.Repeat([]byte("0123456789"), 10000) // 100.000 bytes
	documentID := createDocument(t, pool, storageSvc, cryptoSvc, tenant, content)

	req, _ := http.NewRequest(http.MethodGet, server.URL+"/documents/"+documentID+"/content", nil)
	req.Header.Set("Range", "bytes=100-199")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()

	if resp.StatusCode != http.StatusPartialContent {
		t.Fatalf("status = %d, want 206 (Partial Content)", resp.StatusCode)
	}
	var buf bytes.Buffer
	_, _ = buf.ReadFrom(resp.Body)
	if buf.Len() != 100 {
		t.Fatalf("erwartet 100 bytes teilinhalt, hatte %d", buf.Len())
	}
	if !bytes.Equal(buf.Bytes(), content[100:200]) {
		t.Error("teilinhalt stimmt nicht mit dem erwarteten byte-bereich des originals ueberein")
	}
}

// Nachweis des Fehlerverhaltens: unbekanntes Dokument liefert 404, kein
// Absturz.
func TestHandleContent_UnknownDocumentReturns404(t *testing.T) {
	server, _, _, _, _ := setupTest(t)
	resp, err := http.Get(server.URL + "/documents/00000000-0000-0000-0000-000000000000/content")
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	defer func() { _ = resp.Body.Close() }()
	if resp.StatusCode != http.StatusNotFound {
		t.Fatalf("status = %d, want 404", resp.StatusCode)
	}
}