From 698f0490f2bcae85d250e0ede616a4ca7f2027e6 Mon Sep 17 00:00:00 2001 From: patrick Date: Wed, 28 Oct 2026 23:08:57 +0100 Subject: [PATCH] RBAC #369: Rolle aus dem Token durchreichen, Policy-Pruefung fail-closed workflow bearerauth setzt X-User-Role nur aus den Claims (Client-Header werden entfernt); taskapi und connectorsetupapi fragen mit dieser Rolle, Default user. Migration 0029: connect.setup.write nur fuer tenant_admin. ai-app, workflow-app, connect-app starten ohne POLICY_URL nicht mehr, ausser mit NEXARCH__APP_POLICY_DISABLED=1. Co-Authored-By: Claude Sonnet 5.5 --- ai/cmd/ai-app/main.go | 10 +++++--- ai/cmd/ai-app/main_test.go | 20 ++++++++++++++-- connect/cmd/connect-app/main.go | 9 +++++--- .../connectorsetupapi/connectorsetupapi.go | 11 ++++++--- .../connectorsetupapi_policy_test.go | 16 +++++++++++++ docs/BETRIEB-PORTAL.md | 2 +- .../0029_task_setup_policy_rules.up.sql | 5 ++-- workflow/cmd/workflow-app/main.go | 9 +++++--- workflow/docs/ENG-11-PRUEFPROTOKOLL.md | 4 ++-- workflow/internal/bearerauth/bearerauth.go | 7 +++++- .../internal/bearerauth/bearerauth_test.go | 23 +++++++++++++++---- workflow/internal/taskapi/taskapi.go | 11 ++++++--- .../internal/taskapi/taskapi_policy_test.go | 16 +++++++++++++ 13 files changed, 115 insertions(+), 28 deletions(-) diff --git a/ai/cmd/ai-app/main.go b/ai/cmd/ai-app/main.go index 52787409..c039e182 100644 --- a/ai/cmd/ai-app/main.go +++ b/ai/cmd/ai-app/main.go @@ -62,10 +62,10 @@ type config struct { coreServiceToken string policyURL string policyServiceToken string + policyDisabled bool } -// policyClient liefert nil, solange NEXARCH_AI_APP_POLICY_URL fehlt -// (Uebergang; Pruefung dann deaktiviert, wird beim Start geloggt). +// policyClient liefert nil nur mit NEXARCH_AI_APP_POLICY_DISABLED=1. func (c config) policyClient() *policyclient.Client { if c.policyURL == "" { return nil @@ -105,6 +105,7 @@ func loadConfig(getenv func(string) string) (config, error) { coreServiceToken: getenv("NEXARCH_AI_APP_CORE_SERVICE_TOKEN"), policyURL: getenv("NEXARCH_AI_APP_POLICY_URL"), policyServiceToken: getenv("NEXARCH_AI_APP_POLICY_SERVICE_TOKEN"), + policyDisabled: getenv("NEXARCH_AI_APP_POLICY_DISABLED") == "1", } if cfg.policyURL != "" && cfg.policyServiceToken == "" { return config{}, errors.New("ai-app: NEXARCH_AI_APP_POLICY_SERVICE_TOKEN ist erforderlich, wenn NEXARCH_AI_APP_POLICY_URL gesetzt ist") @@ -115,6 +116,9 @@ func loadConfig(getenv func(string) string) (config, error) { if cfg.serviceToken == "" { return config{}, errors.New("ai-app: NEXARCH_AI_APP_SERVICE_TOKEN ist erforderlich") } + if cfg.policyURL == "" && !cfg.policyDisabled { + return config{}, errors.New("ai-app: NEXARCH_AI_APP_POLICY_URL ist erforderlich (oder NEXARCH_AI_APP_POLICY_DISABLED=1 als Uebergang)") + } if cfg.addr == "" { cfg.addr = defaultListenAddr } @@ -148,7 +152,7 @@ func build(pool *pgxpool.Pool, cfg config, prov provider.Provider, workerID stri searchSvc := semanticsearch.New(prov, vectorindex.New(pool), cfg.model) policy := cfg.policyClient() if policy == nil { - log.Print("ai-app: WARNUNG: NEXARCH_AI_APP_POLICY_URL nicht gesetzt, Rechtepruefung ai.search.read (Issue #369) deaktiviert") + log.Print("ai-app: WARNUNG: Rechtepruefung ai.search.read deaktiviert (NEXARCH_AI_APP_POLICY_DISABLED=1)") } semanticsearchapi.NewServer(searchSvc, cfg.serviceToken).WithPolicy(policy).RegisterRoutes(mux) diff --git a/ai/cmd/ai-app/main_test.go b/ai/cmd/ai-app/main_test.go index a18ca427..84b0dd0f 100644 --- a/ai/cmd/ai-app/main_test.go +++ b/ai/cmd/ai-app/main_test.go @@ -71,8 +71,9 @@ func TestLoadConfig_PolicyURLRequiresServiceToken(t *testing.T) { func TestLoadConfig_Defaults(t *testing.T) { env := map[string]string{ - "NEXARCH_AI_APP_TENANT_DSN": "postgres://x", - "NEXARCH_AI_APP_SERVICE_TOKEN": "tok", + "NEXARCH_AI_APP_TENANT_DSN": "postgres://x", + "NEXARCH_AI_APP_SERVICE_TOKEN": "tok", + "NEXARCH_AI_APP_POLICY_DISABLED": "1", } cfg, err := loadConfig(func(k string) string { return env[k] }) if err != nil { @@ -209,3 +210,18 @@ func TestBuild_QueueWorkerProcessesJobWithQuota(t *testing.T) { t.Errorf("quota-zaehlerstand = %d, want 1 (GOV-04-Verbrauchszaehlung nicht verdrahtet)", value) } } + +func TestLoadConfig_PolicyRequiredUnlessDisabled(t *testing.T) { + env := map[string]string{ + "NEXARCH_AI_APP_TENANT_DSN": "postgres://x", + "NEXARCH_AI_APP_SERVICE_TOKEN": "tok", + } + get := func(k string) string { return env[k] } + if _, err := loadConfig(get); err == nil || !strings.Contains(err.Error(), "NEXARCH_AI_APP_POLICY_URL") { + t.Fatalf("erwartete fehler zur fehlenden NEXARCH_AI_APP_POLICY_URL, bekam %v", err) + } + env["NEXARCH_AI_APP_POLICY_DISABLED"] = "1" + if _, err := loadConfig(get); err != nil { + t.Fatalf("mit POLICY_DISABLED=1 darf der Start nicht scheitern: %v", err) + } +} diff --git a/connect/cmd/connect-app/main.go b/connect/cmd/connect-app/main.go index 4d1b856d..d8e806f4 100644 --- a/connect/cmd/connect-app/main.go +++ b/connect/cmd/connect-app/main.go @@ -36,12 +36,15 @@ func (f fixedKEK) TenantKEK(ctx context.Context, tenantSlug string) ([]byte, err return f.kek, nil } -// buildPolicyClient liefert nil, solange NEXARCH_CONNECT_APP_POLICY_URL fehlt -// (Uebergang; Rechtepruefung dann deaktiviert, Warnung im Log). +// buildPolicyClient liefert nil nur mit NEXARCH_CONNECT_APP_POLICY_DISABLED=1; +// ohne URL und ohne diesen Schalter startet der Dienst nicht. func buildPolicyClient() *policyclient.Client { policyURL := os.Getenv("NEXARCH_CONNECT_APP_POLICY_URL") if policyURL == "" { - log.Print("connect-app: WARNUNG: NEXARCH_CONNECT_APP_POLICY_URL nicht gesetzt, Rechtepruefung connect.status.read/connect.setup.* (Issue #369) deaktiviert") + if os.Getenv("NEXARCH_CONNECT_APP_POLICY_DISABLED") != "1" { + log.Fatal("connect-app: NEXARCH_CONNECT_APP_POLICY_URL fehlt (oder NEXARCH_CONNECT_APP_POLICY_DISABLED=1 als Uebergang setzen)") + } + log.Print("connect-app: WARNUNG: Rechtepruefung connect.status.read/connect.setup.* deaktiviert (NEXARCH_CONNECT_APP_POLICY_DISABLED=1)") return nil } token := os.Getenv("NEXARCH_CONNECT_APP_POLICY_SERVICE_TOKEN") diff --git a/connect/internal/connectorsetupapi/connectorsetupapi.go b/connect/internal/connectorsetupapi/connectorsetupapi.go index e3463cf2..0d4050d6 100644 --- a/connect/internal/connectorsetupapi/connectorsetupapi.go +++ b/connect/internal/connectorsetupapi/connectorsetupapi.go @@ -34,8 +34,6 @@ func NewServer(credentials *credential.Store, mappings *fieldmapping.Store) *Ser } // WithPolicy aktiviert die Rechtepruefung gegen Core (POST /authorize). -// Rolle ist mangels Rollenkonzept in Connect fest "user" (Uebergang, wie -// statusapi). func (s *Server) WithPolicy(client *policyclient.Client) *Server { s.policy = client return s @@ -54,7 +52,7 @@ func (s *Server) RegisterRoutes(mux *http.ServeMux) { func (s *Server) requirePermission(permission string, next handler) handler { return func(w http.ResponseWriter, r *http.Request, tenantSlug, userID string) { if s.policy != nil { - allowed, err := s.policy.Allowed(r.Context(), tenantSlug, "user", permission) + allowed, err := s.policy.Allowed(r.Context(), tenantSlug, roleOf(r), permission) if err != nil { writeError(w, http.StatusServiceUnavailable, "berechtigungsdienst nicht erreichbar") return @@ -253,3 +251,10 @@ func writeJSON(w http.ResponseWriter, status int, v any) { func writeError(w http.ResponseWriter, status int, msg string) { writeJSON(w, status, map[string]string{"error": msg}) } + +func roleOf(r *http.Request) string { + if role := r.Header.Get("X-User-Role"); role != "" { + return role + } + return "user" +} diff --git a/connect/internal/connectorsetupapi/connectorsetupapi_policy_test.go b/connect/internal/connectorsetupapi/connectorsetupapi_policy_test.go index 47dd2fda..afe087cf 100644 --- a/connect/internal/connectorsetupapi/connectorsetupapi_policy_test.go +++ b/connect/internal/connectorsetupapi/connectorsetupapi_policy_test.go @@ -121,3 +121,19 @@ func TestCatalog_PolicyNotAskedWithoutIdentity(t *testing.T) { t.Fatalf("policy darf ohne identitaet nicht befragt werden: %+v", seen) } } + +func TestPolicyAsked_WithRoleFromHeader_DefaultUser(t *testing.T) { + var seen []map[string]string + policyAPI := newFakePolicyAPI(t, false, &seen) + defer policyAPI.Close() + mux := policyMux(policyAPI.URL) + + mux.ServeHTTP(httptest.NewRecorder(), authedRequest("GET", "/connectors/catalog", nil)) + admin := authedRequest("GET", "/connectors/catalog", nil) + admin.Header.Set("X-User-Role", "tenant_admin") + mux.ServeHTTP(httptest.NewRecorder(), admin) + + if len(seen) != 2 || seen[0]["role"] != "user" || seen[1]["role"] != "tenant_admin" { + t.Fatalf("falsche rollen in policy-anfragen: %+v", seen) + } +} diff --git a/docs/BETRIEB-PORTAL.md b/docs/BETRIEB-PORTAL.md index 761a5d98..30f03527 100644 --- a/docs/BETRIEB-PORTAL.md +++ b/docs/BETRIEB-PORTAL.md @@ -17,7 +17,7 @@ ## Rechtepruefung in ai-app, workflow-app, connect-app (Issue #369) - Migration `migrations/0029_task_setup_policy_rules.up.sql` (Core-DB, vor dem Binary-Rollout) legt `workflow.task.read/write` und `connect.setup.read/write` fuer `user` und `tenant_admin` an; `ai.search.read` stammt aus 0018. - Je Dienst zwei Variablen in der Env-Datei: `NEXARCH_AI_APP_POLICY_URL`/`NEXARCH_AI_APP_POLICY_SERVICE_TOKEN`, `NEXARCH_WORKFLOW_APP_POLICY_URL`/`NEXARCH_WORKFLOW_APP_POLICY_SERVICE_TOKEN`, `NEXARCH_CONNECT_APP_POLICY_URL`/`NEXARCH_CONNECT_APP_POLICY_SERVICE_TOKEN` (URL der policy-api, z. B. `http://127.0.0.1:8093`; Token wie `NEXARCH_POLICY_SERVICE_TOKEN` der policy-api, analog `NEXARCH_DMS_APP_POLICY_*`). -- Ohne `*_POLICY_URL` startet der Dienst mit Warnung im Log und ohne Pruefung (Uebergang). Mit URL: Core nicht erreichbar → 503, kein Recht → 403. Rolle ist in allen drei Diensten vorerst fest `user`, weil weder bearerauth noch die Connect-/AI-Aufrufer eine Rolle durchreichen. +- Ohne `*_POLICY_URL` startet der Dienst nicht (fail-closed). Uebergang: `NEXARCH_{AI,WORKFLOW,CONNECT}_APP_POLICY_DISABLED=1` (Warnung im Log, keine Pruefung). Mit URL: Core nicht erreichbar → 503, kein Recht → 403. Rolle: workflow-app und connect-app reichen die Rolle aus dem Token als `X-User-Role` durch (nur aus dem Token, Client-Header werden entfernt); ohne Rolle gilt `user`. `connect.setup.write` hat nur `tenant_admin`. ai-app wird von Modulen mit Service-Token gerufen und fragt mit Rolle `user`. - `taskapi` (`GET /tasks`, `PATCH /tasks/{id}/status`) ist seit #369 in `workflow-app` verdrahtet und liegt damit hinter bearerauth. ## 204: Workflow-Demo und Bearer (Stand 2026-10-28) diff --git a/migrations/0029_task_setup_policy_rules.up.sql b/migrations/0029_task_setup_policy_rules.up.sql index e3e54813..b8fd9230 100644 --- a/migrations/0029_task_setup_policy_rules.up.sql +++ b/migrations/0029_task_setup_policy_rules.up.sql @@ -1,7 +1,7 @@ -- Issue #369: workflow/internal/taskapi und connect/internal/connectorsetupapi -- hatten keine Rechte-Schluessel; Muster wie 0018_module_policy_rules. --- Beide Rollen, weil die Aufrufer (bearerauth/X-User-Id) noch keine Rolle --- liefern und die Module mit fester Rolle 'user' pruefen (siehe statusapi). +-- connect.setup.write (Zugangsdaten, Mapping) nur fuer tenant_admin; die Rolle +-- kommt aus dem Token (X-User-Role), ohne Rolle gilt 'user'. WITH grants(role, permission) AS ( VALUES ('user', 'workflow.task.read'), @@ -10,7 +10,6 @@ WITH grants(role, permission) AS ( ('tenant_admin', 'workflow.task.write'), ('user', 'connect.setup.read'), - ('user', 'connect.setup.write'), ('tenant_admin', 'connect.setup.read'), ('tenant_admin', 'connect.setup.write') ), diff --git a/workflow/cmd/workflow-app/main.go b/workflow/cmd/workflow-app/main.go index 45a1cfcb..e241dc21 100644 --- a/workflow/cmd/workflow-app/main.go +++ b/workflow/cmd/workflow-app/main.go @@ -160,12 +160,15 @@ func buildMux(pool *pgxpool.Pool, taskStore *task.Store, serviceToken, tenantSlu return mux, nil } -// buildPolicyClient liefert nil, solange NEXARCH_WORKFLOW_APP_POLICY_URL fehlt -// (Uebergang; Rechtepruefung dann deaktiviert, Warnung im Log). +// buildPolicyClient liefert nil nur mit NEXARCH_WORKFLOW_APP_POLICY_DISABLED=1; +// ohne URL und ohne diesen Schalter startet der Dienst nicht. func buildPolicyClient() *policyclient.Client { policyURL := os.Getenv("NEXARCH_WORKFLOW_APP_POLICY_URL") if policyURL == "" { - log.Print("workflow-app: WARNUNG: NEXARCH_WORKFLOW_APP_POLICY_URL nicht gesetzt, Rechtepruefung workflow.task.read/write (Issue #369) deaktiviert") + if os.Getenv("NEXARCH_WORKFLOW_APP_POLICY_DISABLED") != "1" { + log.Fatal("workflow-app: NEXARCH_WORKFLOW_APP_POLICY_URL fehlt (oder NEXARCH_WORKFLOW_APP_POLICY_DISABLED=1 als Uebergang setzen)") + } + log.Print("workflow-app: WARNUNG: Rechtepruefung workflow.task.read/write deaktiviert (NEXARCH_WORKFLOW_APP_POLICY_DISABLED=1)") return nil } return policyclient.New(policyURL, requireEnv("NEXARCH_WORKFLOW_APP_POLICY_SERVICE_TOKEN")) diff --git a/workflow/docs/ENG-11-PRUEFPROTOKOLL.md b/workflow/docs/ENG-11-PRUEFPROTOKOLL.md index 4f7ec8ca..9a5875bd 100644 --- a/workflow/docs/ENG-11-PRUEFPROTOKOLL.md +++ b/workflow/docs/ENG-11-PRUEFPROTOKOLL.md @@ -45,8 +45,8 @@ Optional: - `NEXARCH_WORKFLOW_APP_ESCALATION_INTERVAL` (Go-Duration, Default `5m`) - `NEXARCH_WORKFLOW_APP_POLICY_URL` / `NEXARCH_WORKFLOW_APP_POLICY_SERVICE_TOKEN` (Issue #369: Rechtepruefung `workflow.task.read`/`workflow.task.write` fuer - `taskapi` gegen Core `POST /authorize`; ohne URL startet der Dienst mit - Warnung ohne Pruefung, URL ohne Token ist ein Startfehler) + `taskapi` gegen Core `POST /authorize`; ohne URL bricht der Dienst + mit Startfehler ab, ausser `NEXARCH_WORKFLOW_APP_POLICY_DISABLED=1`; URL ohne Token ist ein Startfehler; Rolle aus dem Token als `X-User-Role`) Keine Zugangsdaten im Code — ausschließlich über Umgebungsvariablen (AC2). diff --git a/workflow/internal/bearerauth/bearerauth.go b/workflow/internal/bearerauth/bearerauth.go index e5dd429b..efef3e4b 100644 --- a/workflow/internal/bearerauth/bearerauth.go +++ b/workflow/internal/bearerauth/bearerauth.go @@ -1,7 +1,7 @@ // Package bearerauth setzt die Identitaet der Workflow-APIs aus einem // verifizierten Core-Modul-Token. Die Handler lesen weiter X-User-Id und // X-Tenant-Slug; die Middleware ueberschreibt beide aus den Claims, sodass ein -// Client sie nicht frei setzen kann. +// Client sie nicht frei setzen kann. X-User-Role kommt nur aus dem Token. package bearerauth import ( @@ -16,6 +16,7 @@ import ( const ( headerUser = "X-User-Id" headerTenant = "X-Tenant-Slug" + headerRole = "X-User-Role" ) // Middleware verlangt fuer Anfragen mit Authorization: Bearer ein gueltiges @@ -23,6 +24,7 @@ const ( // allowHeaderAuth ist gesetzt (Uebergang, bis alle Clients Bearer senden). func Middleware(v *moduleauth.Verifier, allowHeaderAuth bool, next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + r.Header.Del(headerRole) token, ok := bearer(r) if !ok { if !allowHeaderAuth { @@ -47,6 +49,9 @@ func Middleware(v *moduleauth.Verifier, allowHeaderAuth bool, next http.Handler) } r.Header.Set(headerUser, claims.Subject) r.Header.Set(headerTenant, claims.Tenant) + if claims.Role != "" { + r.Header.Set(headerRole, claims.Role) + } next.ServeHTTP(w, r) }) } diff --git a/workflow/internal/bearerauth/bearerauth_test.go b/workflow/internal/bearerauth/bearerauth_test.go index 1df4724d..685f2fbe 100644 --- a/workflow/internal/bearerauth/bearerauth_test.go +++ b/workflow/internal/bearerauth/bearerauth_test.go @@ -10,7 +10,7 @@ import ( func echo() http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - _, _ = w.Write([]byte(r.Header.Get("X-User-Id") + "|" + r.Header.Get("X-Tenant-Slug"))) + _, _ = w.Write([]byte(r.Header.Get("X-User-Id") + "|" + r.Header.Get("X-Tenant-Slug") + "|" + r.Header.Get("X-User-Role"))) }) } @@ -31,7 +31,7 @@ func TestBearerOverridesClientSuppliedHeaders(t *testing.T) { "Authorization": "Bearer " + iss.Token("u1", "acme", "user", "", ""), "X-User-Id": "fremd", "X-Tenant-Slug": "fremd", }) - if rec.Code != 200 || rec.Body.String() != "u1|acme" { + if rec.Code != 200 || rec.Body.String() != "u1|acme|user" { t.Fatalf("code=%d body=%q", rec.Code, rec.Body.String()) } } @@ -51,10 +51,25 @@ func TestInvalidBearerIs401(t *testing.T) { func TestWithoutBearerHeadersStrippedUnlessAllowed(t *testing.T) { v, _ := moduleauth.NewTestVerifierAndIssuer() hdr := map[string]string{"X-User-Id": "u9", "X-Tenant-Slug": "t9"} - if rec := do(Middleware(v, false, echo()), hdr); rec.Body.String() != "|" { + if rec := do(Middleware(v, false, echo()), hdr); rec.Body.String() != "||" { t.Fatalf("Header muessen entfernt werden, bekam %q", rec.Body.String()) } - if rec := do(Middleware(v, true, echo()), hdr); rec.Body.String() != "u9|t9" { + if rec := do(Middleware(v, true, echo()), hdr); rec.Body.String() != "u9|t9|" { t.Fatalf("Uebergangsmodus muss Header durchlassen, bekam %q", rec.Body.String()) } } + +func TestRoleOnlyFromToken(t *testing.T) { + v, iss := moduleauth.NewTestVerifierAndIssuer() + h := Middleware(v, true, echo()) + rec := do(h, map[string]string{ + "Authorization": "Bearer " + iss.Token("u1", "acme", "tenant_admin", "", ""), + "X-User-Role": "tenant_admin_fremd", + }) + if rec.Body.String() != "u1|acme|tenant_admin" { + t.Fatalf("Rolle muss aus dem Token kommen, bekam %q", rec.Body.String()) + } + if rec := do(h, map[string]string{"X-User-Role": "tenant_admin"}); rec.Body.String() != "||" { + t.Fatalf("Rolle ohne Token muss entfernt werden, bekam %q", rec.Body.String()) + } +} diff --git a/workflow/internal/taskapi/taskapi.go b/workflow/internal/taskapi/taskapi.go index 90ffae49..3f0eab38 100644 --- a/workflow/internal/taskapi/taskapi.go +++ b/workflow/internal/taskapi/taskapi.go @@ -35,8 +35,6 @@ func NewServer(store *task.Store, ownTenantSlug string) *Server { } // WithPolicy aktiviert die Rechtepruefung gegen Core (POST /authorize). -// Rolle ist fest "user": bearerauth reicht nur Subject und Tenant aus den -// Claims durch, keine Rolle (Uebergang, wie connect/internal/statusapi). func (s *Server) WithPolicy(client *policyclient.Client) *Server { s.policy = client return s @@ -64,7 +62,7 @@ func (s *Server) requireAuth(permission string, next http.HandlerFunc) http.Hand return } if s.policy != nil { - allowed, err := s.policy.Allowed(r.Context(), tenantSlug, "user", permission) + allowed, err := s.policy.Allowed(r.Context(), tenantSlug, roleOf(r), permission) if err != nil { writeError(w, http.StatusServiceUnavailable, "berechtigungsdienst nicht erreichbar") return @@ -120,3 +118,10 @@ func writeJSON(w http.ResponseWriter, status int, v any) { func writeError(w http.ResponseWriter, status int, msg string) { writeJSON(w, status, map[string]string{"error": msg}) } + +func roleOf(r *http.Request) string { + if role := r.Header.Get("X-User-Role"); role != "" { + return role + } + return "user" +} diff --git a/workflow/internal/taskapi/taskapi_policy_test.go b/workflow/internal/taskapi/taskapi_policy_test.go index 1f7efcfe..d50a8661 100644 --- a/workflow/internal/taskapi/taskapi_policy_test.go +++ b/workflow/internal/taskapi/taskapi_policy_test.go @@ -119,3 +119,19 @@ func TestHandleList_PolicyAllows_Passes(t *testing.T) { t.Fatalf("erwartet 200 mit berechtigung, bekam %d: %s", rec.Code, rec.Body.String()) } } + +func TestPolicyAsked_WithRoleFromHeader_DefaultUser(t *testing.T) { + var seen []map[string]string + policyAPI := newFakePolicyAPI(t, false, &seen) + defer policyAPI.Close() + mux := policyMux(t, policyAPI.URL) + + mux.ServeHTTP(httptest.NewRecorder(), authed(httptest.NewRequest(http.MethodGet, "/tasks", nil))) + admin := authed(httptest.NewRequest(http.MethodGet, "/tasks", nil)) + admin.Header.Set("X-User-Role", "tenant_admin") + mux.ServeHTTP(httptest.NewRecorder(), admin) + + if len(seen) != 2 || seen[0]["role"] != "user" || seen[1]["role"] != "tenant_admin" { + t.Fatalf("falsche rollen in policy-anfragen: %+v", seen) + } +}