nexarch/connect/internal/datevapi/datevapi_test.go

package datevapi

import (
	"bytes"
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"testing"

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

	"gitea.perlbach24.de/scripte/nexarch/common/testdb"
	"gitea.perlbach24.de/scripte/nexarch/connect/internal/archiveclient"
	"gitea.perlbach24.de/scripte/nexarch/connect/internal/datevexport"
	"gitea.perlbach24.de/scripte/nexarch/connect/internal/datevtransfer"
	"gitea.perlbach24.de/scripte/nexarch/connect/internal/migrate"
)

func fakeArchiveRegister(t *testing.T) *httptest.Server {
	t.Helper()
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/register" {
			http.NotFound(w, r)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_ = json.NewEncoder(w).Encode(map[string]string{"id": "reg-1"})
	}))
}

func fakeDatevTarget(t *testing.T, fail bool) *httptest.Server {
	t.Helper()
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if fail {
			http.Error(w, "simulierter fehler", http.StatusServiceUnavailable)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_ = json.NewEncoder(w).Encode(map[string]string{"transferId": "tx-1"})
	}))
}

func openTestPool(t *testing.T) *pgxpool.Pool {
	t.Helper()
	dsn := os.Getenv("TEST_TENANT_DSN")
	if dsn == "" {
		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
	}
	pool := testdb.Pool(t, dsn)

	dir, _ := os.Getwd()
	migDir := ""
	for i := 0; i < 6; i++ {
		p := dir + "/migrations"
		if fi, err := os.Stat(p); err == nil && fi.IsDir() {
			migDir = p
			break
		}
		dir += "/.."
	}
	if migDir == "" {
		t.Fatal("connect/migrations nicht gefunden")
	}
	migrations, err := migrate.Load(migDir)
	if err != nil {
		t.Fatalf("migrationen laden: %v", err)
	}
	if _, err := migrate.Up(context.Background(), pool, migrations); err != nil {
		t.Fatalf("migrationen anwenden: %v", err)
	}
	return pool
}

func newTestServer(t *testing.T, transferFails bool) (*Server, func()) {
	t.Helper()
	pool := openTestPool(t)
	archiveSrv := fakeArchiveRegister(t)
	datevSrv := fakeDatevTarget(t, transferFails)

	exports := &datevexport.Store{
		Pool:        pool,
		Archive:     archiveclient.New(archiveSrv.URL, "svc-tok"),
		CallbackURL: "https://connect.example.internal/datev/callback",
	}
	transfers := &datevtransfer.Store{
		Pool: pool,
		Client: &datevtransfer.Client{
			HTTPClient: http.DefaultClient,
			Config:     datevtransfer.Config{Endpoint: datevSrv.URL, Token: "tok", ConsultantNumber: "1001", ClientNumber: "42"},
		},
	}
	return NewServer(exports, transfers), func() {
		archiveSrv.Close()
		datevSrv.Close()
	}
}

func validTriggerBody() []byte {
	body := map[string]any{
		"consultant_number": "1001",
		"client_number":     "42",
		"fiscal_year_start": "2026-01-01",
		"account_length":    4,
		"description":       "März 2026",
		"period_start":      "2026-03-01",
		"period_end":        "2026-03-31",
		"entries": []map[string]any{
			{
				"Amount": 119.0, "DebitCredit": "S", "Account": "1200", "CounterAccount": "4400",
				"Date": "2026-03-15T00:00:00Z", "Text": "Büromaterial", "DocumentRef": "RE-2026-001",
			},
		},
	}
	b, _ := json.Marshal(body)
	return b
}

// AC1: Export laesst sich ueber die Oberflaeche (per Anfrage an diesen
// Endpunkt) mit Zeitraum-Auswahl anstossen.
func TestHandleTrigger_SuccessfulRun(t *testing.T) {
	srv, cleanup := newTestServer(t, false)
	defer cleanup()
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)

	req := httptest.NewRequest(http.MethodPost, "/datev/exports", bytes.NewReader(validTriggerBody()))
	req.Header.Set("X-User-Id", "u1")
	req.Header.Set("X-Tenant-Slug", "acme")
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)

	if rec.Code != http.StatusCreated {
		t.Fatalf("erwartet 201, bekam %d: %s", rec.Code, rec.Body.String())
	}
	var resp runResponse
	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
		t.Fatalf("antwort dekodieren: %v", err)
	}
	if resp.EntryCount != 1 {
		t.Fatalf("erwartet 1 Beleg, bekam %d", resp.EntryCount)
	}
	if resp.TransferStatus != string(datevtransfer.StatusSuccess) {
		t.Fatalf("erwartet transfer-status success, bekam %q", resp.TransferStatus)
	}
}

func TestHandleTrigger_RequiresIdentity(t *testing.T) {
	srv, cleanup := newTestServer(t, false)
	defer cleanup()
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)

	req := httptest.NewRequest(http.MethodPost, "/datev/exports", bytes.NewReader(validTriggerBody()))
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	if rec.Code != http.StatusUnauthorized {
		t.Fatalf("erwartet 401 ohne Identitaet, bekam %d", rec.Code)
	}
}

// AC3: Fehlgeschlagener Export ist ueber den Transfer-Status klar erkennbar.
func TestHandleTrigger_FailedTransferIsVisible(t *testing.T) {
	srv, cleanup := newTestServer(t, true)
	defer cleanup()
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)

	req := httptest.NewRequest(http.MethodPost, "/datev/exports", bytes.NewReader(validTriggerBody()))
	req.Header.Set("X-User-Id", "u1")
	req.Header.Set("X-Tenant-Slug", "acme")
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)

	if rec.Code != http.StatusCreated {
		t.Fatalf("erwartet 201 (Exportlauf wird trotz Uebertragungsfehler protokolliert), bekam %d: %s", rec.Code, rec.Body.String())
	}
	var resp runResponse
	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
		t.Fatalf("antwort dekodieren: %v", err)
	}
	if resp.TransferStatus != string(datevtransfer.StatusRetryPending) && resp.TransferStatus != string(datevtransfer.StatusFailed) {
		t.Fatalf("erwartet fehlgeschlagenen/retry-status, bekam %q", resp.TransferStatus)
	}
	if resp.TransferError == "" {
		t.Fatal("erwartet sichtbare Fehlermeldung bei fehlgeschlagenem Transfer")
	}
}

// AC2: Exportprotokoll ist je Lauf einsehbar, inkl. echter Testlaeufe.
func TestHandleList_ShowsRealRuns(t *testing.T) {
	srv, cleanup := newTestServer(t, false)
	defer cleanup()
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)

	triggerReq := httptest.NewRequest(http.MethodPost, "/datev/exports", bytes.NewReader(validTriggerBody()))
	triggerReq.Header.Set("X-User-Id", "u1")
	triggerReq.Header.Set("X-Tenant-Slug", "acme-list")
	triggerRec := httptest.NewRecorder()
	mux.ServeHTTP(triggerRec, triggerReq)
	if triggerRec.Code != http.StatusCreated {
		t.Fatalf("vorbereitung fehlgeschlagen: %d %s", triggerRec.Code, triggerRec.Body.String())
	}

	listURL := &url.URL{Path: "/datev/exports"}
	listReq := httptest.NewRequest(http.MethodGet, listURL.String(), nil)
	listReq.Header.Set("X-User-Id", "u1")
	listReq.Header.Set("X-Tenant-Slug", "acme-list")
	listRec := httptest.NewRecorder()
	mux.ServeHTTP(listRec, listReq)

	if listRec.Code != http.StatusOK {
		t.Fatalf("erwartet 200, bekam %d", listRec.Code)
	}
	var runs []runResponse
	if err := json.NewDecoder(listRec.Body).Decode(&runs); err != nil {
		t.Fatalf("antwort dekodieren: %v", err)
	}
	if len(runs) == 0 {
		t.Fatal("erwartet mindestens einen Exportlauf im Protokoll")
	}
	if runs[0].TransferStatus != string(datevtransfer.StatusSuccess) {
		t.Fatalf("erwartet transfer-status success im Protokoll, bekam %q", runs[0].TransferStatus)
	}
}

// Tenant isolation: another tenant's runs must not leak into this list.
func TestHandleList_TenantIsolation(t *testing.T) {
	srv, cleanup := newTestServer(t, false)
	defer cleanup()
	mux := http.NewServeMux()
	srv.RegisterRoutes(mux)

	triggerReq := httptest.NewRequest(http.MethodPost, "/datev/exports", bytes.NewReader(validTriggerBody()))
	triggerReq.Header.Set("X-User-Id", "u1")
	triggerReq.Header.Set("X-Tenant-Slug", "tenant-a-iso")
	triggerRec := httptest.NewRecorder()
	mux.ServeHTTP(triggerRec, triggerReq)
	if triggerRec.Code != http.StatusCreated {
		t.Fatalf("vorbereitung fehlgeschlagen: %d", triggerRec.Code)
	}

	listReq := httptest.NewRequest(http.MethodGet, "/datev/exports", nil)
	listReq.Header.Set("X-User-Id", "u1")
	listReq.Header.Set("X-Tenant-Slug", "tenant-b-iso")
	listRec := httptest.NewRecorder()
	mux.ServeHTTP(listRec, listReq)

	var runs []runResponse
	if err := json.NewDecoder(listRec.Body).Decode(&runs); err != nil {
		t.Fatalf("antwort dekodieren: %v", err)
	}
	for _, r := range runs {
		if r.ID == "" {
			continue
		}
	}
	// tenant-b-iso must see none of tenant-a-iso's runs.
	if len(runs) != 0 {
		t.Fatalf("mandantentrennung verletzt: tenant-b-iso sieht %d Laeufe eines fremden Mandanten", len(runs))
	}
}