Files
Enterprise-Knowledge-Base/internal/router/rbac_selfcheck_test.go
T
wizardchen d2ffc1b973 refactor(api-keys): simplify authorization to a single-role gate
Redesign tenant API key authorization around one dimension (role) plus a
central default-deny gate, replacing the previous role + KB-scoped flag model.

- Add APIKeyGate as the single authority for API-key authorization: routes
  declare one policy (MinRole) via apiKeyGroup/apiKeyRoute helpers; undeclared
  routes are denied by default. JWT principals short-circuit the gate and the
  JWT-centric RBAC guards short-circuit for API-key principals.
- Roles: viewer/contributor/admin are knowledge-base data-plane only (KB scope
  is a pure downstream data filter); owner is a full-access tenant tier that
  unlocks tenant-level infrastructure routes and is required for every method.
- Drop the KBScoped policy flag and the KB-restricted-vs-tenant branching.
- Security hardening: never disclose HMAC secret (return presence only), abort
  writes on API-key encryption failure, deny KB-restricted keys on /files, and
  backfill legacy key hashes at startup instead of O(N) plaintext scans.
- Frontend: two-level create dialog (access type -> permission level), rename
  role labels to reflect actual scope, sync en/zh/ko/ru locales.
- Fix startup self-check false-positive on trailing-slash routes and normalize
  gin paths before comparison; add regression tests.
2026-07-07 12:00:13 +08:00

54 lines
1.6 KiB
Go

package router
import (
"net/http"
"testing"
"github.com/gin-gonic/gin"
)
// TestAssertAPIKeyPoliciesMatchRoutes_TrailingSlash guards the class of bug
// where a route registered with a "/" rel (gin path ".../x/") was flagged as
// missing against the normalized policy key (".../x"), panicking at startup.
func TestAssertAPIKeyPoliciesMatchRoutes_TrailingSlash(t *testing.T) {
gin.SetMode(gin.TestMode)
engine := gin.New()
v1 := engine.Group("/api/v1")
g := &rbacGuards{}
noop := func(c *gin.Context) {}
// Register through the apiKey helpers using both "" and "/" rel plus a
// nested path, mirroring real route declarations.
empty := g.apiKeyGroup(v1.Group("/knowledge-bases"), apiKeyViewer())
empty.GET("", noop)
slash := g.apiKeyGroup(v1.Group("/evaluation"), apiKeyOwner())
slash.POST("/", noop)
slash.GET("/", noop)
g.apiKeyRoute(v1, http.MethodGet, "/tenants", apiKeyOwner(), noop)
// Must not panic: every declared policy resolves to a real route despite
// the trailing-slash difference on /evaluation.
g.assertAPIKeyPoliciesMatchRoutes(engine)
}
// TestAssertAPIKeyPoliciesMatchRoutes_Missing verifies the self-check still
// panics when a policy points at a genuinely non-existent route.
func TestAssertAPIKeyPoliciesMatchRoutes_Missing(t *testing.T) {
gin.SetMode(gin.TestMode)
engine := gin.New()
g := &rbacGuards{}
// Declare a policy for a path that is never registered on the engine.
g.ensureAPIKeyAuthorizer().Register(http.MethodPost, "/api/v1/does-not-exist", apiKeyOwner())
defer func() {
if recover() == nil {
t.Fatal("expected panic for policy on non-existent route")
}
}()
g.assertAPIKeyPoliciesMatchRoutes(engine)
}