nexarch/workflow/internal/taskapi/taskapi_test.go

package taskapi

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/migrate"
	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/task"
	"gitea.perlbach24.de/scripte/nexarch/workflow/internal/testdb"
)

func findModuleRoot(t *testing.T) string {
	t.Helper()
	dir, err := os.Getwd()
	if err != nil {
		t.Fatalf("getwd: %v", err)
	}
	for {
		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
			return dir
		}
		parent := filepath.Dir(dir)
		if parent == dir {
			t.Fatal("go.mod nicht gefunden")
		}
		dir = parent
	}
}

func newTestServer(t *testing.T) (*Server, *task.Store) {
	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)
	migrations, err := migrate.Load(filepath.Join(findModuleRoot(t), "migrations", "tenant"))
	if err != nil {
		t.Fatalf("migrationen laden: %v", err)
	}
	if _, err := migrate.Up(ctx, pool, migrations); err != nil {
		t.Fatalf("migrationen anwenden: %v", err)
	}
	store := task.NewStore(pool)
	return NewServer(store), store
}

func TestHandleList_RequiresUser(t *testing.T) {
	s, _ := newTestServer(t)
	mux := http.NewServeMux()
	s.RegisterRoutes(mux)

	req := httptest.NewRequest(http.MethodGet, "/tasks", nil)
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	if rec.Code != http.StatusUnauthorized {
		t.Fatalf("status = %d, want 401 ohne X-User-Id", rec.Code)
	}
}

// TestHandleList_ReturnsAllTasks prueft die Grundlage der Liste/Kanban-
// Ansicht (TSK-04): GET /tasks liefert alle Aufgaben des gebundenen
// Mandanten-Schemas.
func TestHandleList_ReturnsAllTasks(t *testing.T) {
	s, store := newTestServer(t)
	mux := http.NewServeMux()
	s.RegisterRoutes(mux)
	ctx := context.Background()

	if _, err := store.Create(ctx, task.Task{Title: "Rechnung pruefen", AssigneeType: task.AssigneePerson, AssigneeID: "alice"}); err != nil {
		t.Fatalf("create: %v", err)
	}

	req := httptest.NewRequest(http.MethodGet, "/tasks", nil)
	req.Header.Set("X-User-Id", "alice")
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String())
	}
	var tasks []task.Task
	if err := json.NewDecoder(rec.Body).Decode(&tasks); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if len(tasks) != 1 || tasks[0].Status != task.StatusOpen {
		t.Fatalf("tasks = %+v, want genau 1 mit status open", tasks)
	}
}

// TestHandleSetStatus_UpdatesStatus prueft TSK-04 Akzeptanzkriterium 4:
// der HTTP-Endpunkt, ueber den die Kanban-Ansicht beim Drag & Drop den
// Status zurueckschreibt.
func TestHandleSetStatus_UpdatesStatus(t *testing.T) {
	s, store := newTestServer(t)
	mux := http.NewServeMux()
	s.RegisterRoutes(mux)
	ctx := context.Background()

	id, err := store.Create(ctx, task.Task{Title: "Postkorb", AssigneeType: task.AssigneePerson, AssigneeID: "bob"})
	if err != nil {
		t.Fatalf("create: %v", err)
	}

	body := `{"status":"in_progress"}`
	req := httptest.NewRequest(http.MethodPost, "/tasks/"+id+"/status", strings.NewReader(body))
	req.Header.Set("X-User-Id", "bob")
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String())
	}
	var got task.Task
	if err := json.NewDecoder(rec.Body).Decode(&got); err != nil {
		t.Fatalf("decode: %v", err)
	}
	if got.Status != task.StatusInProgress {
		t.Fatalf("status = %q, want in_progress", got.Status)
	}

	stored, err := store.Get(ctx, id)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if stored.Status != task.StatusInProgress {
		t.Fatalf("status in der datenbank nicht aktualisiert: %q", stored.Status)
	}
}

func TestHandleSetStatus_RejectsInvalidStatus(t *testing.T) {
	s, store := newTestServer(t)
	mux := http.NewServeMux()
	s.RegisterRoutes(mux)
	ctx := context.Background()

	id, err := store.Create(ctx, task.Task{Title: "x", AssigneeType: task.AssigneePerson, AssigneeID: "carol"})
	if err != nil {
		t.Fatalf("create: %v", err)
	}

	body := `{"status":"erledigt"}`
	req := httptest.NewRequest(http.MethodPost, "/tasks/"+id+"/status", strings.NewReader(body))
	req.Header.Set("X-User-Id", "carol")
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	if rec.Code != http.StatusUnprocessableEntity {
		t.Fatalf("status = %d, want 422", rec.Code)
	}
}

func TestHandleSetStatus_NotFound(t *testing.T) {
	s, _ := newTestServer(t)
	mux := http.NewServeMux()
	s.RegisterRoutes(mux)

	body := `{"status":"done"}`
	req := httptest.NewRequest(http.MethodPost, "/tasks/00000000-0000-0000-0000-000000000000/status", strings.NewReader(body))
	req.Header.Set("X-User-Id", "carol")
	rec := httptest.NewRecorder()
	mux.ServeHTTP(rec, req)
	if rec.Code != http.StatusNotFound {
		t.Fatalf("status = %d, want 404", rec.Code)
	}
}

// TestTwoTenantServers_ListNeverCrossesTenants ist der zentrale Beleg fuer
// TSK-04 Akzeptanzkriterium 5 / Pruefung 5: zwei taskapi.Server-Instanzen,
// jede an ein eigenes Mandanten-Schema gebunden (wie workflow-app es in
// Produktion je Mandant tut, ueber NEXARCH_WORKFLOW_APP_TENANT_DSN), mit
// Testdaten aus zwei Mandanten. GET /tasks liefert je Server ausschliess-
// lich die Aufgaben seines eigenen Mandanten -- die Trennung ist
// strukturell (ein Pool pro Server), nicht ein Filter, der sich durch
// einen Client-Parameter umgehen liesse.
func TestTwoTenantServers_ListNeverCrossesTenants(t *testing.T) {
	serverA, storeA := newTestServer(t)
	serverB, storeB := newTestServer(t)
	ctx := context.Background()

	if _, err := storeA.Create(ctx, task.Task{Title: "Mandant A Aufgabe", AssigneeType: task.AssigneePerson, AssigneeID: "user-a"}); err != nil {
		t.Fatalf("create in tenant A: %v", err)
	}
	if _, err := storeB.Create(ctx, task.Task{Title: "Mandant B Aufgabe 1", AssigneeType: task.AssigneePerson, AssigneeID: "user-b"}); err != nil {
		t.Fatalf("create in tenant B: %v", err)
	}
	if _, err := storeB.Create(ctx, task.Task{Title: "Mandant B Aufgabe 2", AssigneeType: task.AssigneePerson, AssigneeID: "user-b"}); err != nil {
		t.Fatalf("create in tenant B: %v", err)
	}

	muxA := http.NewServeMux()
	serverA.RegisterRoutes(muxA)
	muxB := http.NewServeMux()
	serverB.RegisterRoutes(muxB)

	reqA := httptest.NewRequest(http.MethodGet, "/tasks", nil)
	reqA.Header.Set("X-User-Id", "user-a")
	recA := httptest.NewRecorder()
	muxA.ServeHTTP(recA, reqA)
	var tasksA []task.Task
	if err := json.NewDecoder(recA.Body).Decode(&tasksA); err != nil {
		t.Fatalf("decode tenant A: %v", err)
	}
	if len(tasksA) != 1 || tasksA[0].Title != "Mandant A Aufgabe" {
		t.Fatalf("mandant A server sieht fremde aufgaben: %+v", tasksA)
	}

	reqB := httptest.NewRequest(http.MethodGet, "/tasks", nil)
	reqB.Header.Set("X-User-Id", "user-b")
	recB := httptest.NewRecorder()
	muxB.ServeHTTP(recB, reqB)
	var tasksB []task.Task
	if err := json.NewDecoder(recB.Body).Decode(&tasksB); err != nil {
		t.Fatalf("decode tenant B: %v", err)
	}
	if len(tasksB) != 2 {
		t.Fatalf("mandant B server sieht falsche anzahl aufgaben: %+v", tasksB)
	}
	for _, tk := range tasksB {
		if !strings.HasPrefix(tk.Title, "Mandant B") {
			t.Fatalf("mandant B server sieht fremde aufgabe: %+v", tk)
		}
	}
}