feat(rbac): tenant member management + invite_only gate (PR 3 of 3, #1303)

Wire the human-facing surface for the tenant-RBAC system that PR 1
introduced and PR 2 enforced: REST endpoints + UI for managing tenant
members, plus the long-pending invite_only registration gate.

Backend
- internal/handler/auth.go: Register now rejects with 403 when
  auth.registration_mode=invite_only. PR 1 already exposes the mode via
  /auth/config so the frontend hides the sign-up link; this is the
  server-side enforcement for direct API calls.
- internal/handler/tenant_member.go: new TenantMemberHandler with
  ListMembers / AddMember / UpdateMemberRole / RemoveMember. Maps
  service-layer sentinels onto HTTP semantics (ErrLastOwner -> 409,
  ErrMembershipAlreadyExists -> 409, ErrUserNotFound on AddMember -> 404,
  ErrInvalidTenantRole -> 400). AddMember requires the invitee to
  already have an account; SMTP-driven email invites are deferred.
- internal/types/tenant_member.go: new TenantMemberResponse projection
  carrying the fields the management UI renders (email, username,
  avatar, role, joined_at).
- internal/router/router.go: four routes under /tenants/:id/members
  gated per the matrix (Viewer+ for list, Owner+ for every mutation).
- internal/container/container.go: dig provider for the new handler.

Tests
- handler/tenant_member_test.go: 12 table-driven cases covering happy
  path, dangling-user tolerance, ErrLastOwner -> 409, ErrMembershipNotFound
  -> 404, ErrMembershipAlreadyExists -> 409, unknown email -> 404,
  invalid role rejected before user lookup, bad tenant id -> 400.
- handler/auth_register_invite_only_test.go: invite_only -> 403,
  self_serve -> 201, nil Auth config falls through.

Frontend
- src/api/tenant/members.ts: typed client (TenantRole/TenantMember/...)
  for the four endpoints.
- src/views/settings/TenantMembers.vue: members table with add dialog,
  inline role select, confirm-remove modal. All mutation widgets gated
  behind currentTenantRole === 'owner'; server still enforces.
- src/views/settings/Settings.vue: register the Members tab; show only
  when currentTenantRole is loaded (avoids tab flash on cold nav).
- i18n in en-US/zh-CN/ko-KR/ru-RU: new tenantMember namespace covering
  all UI strings and structured error messages (lastOwner / userNotFound
  / alreadyMember / invalidRole etc).

This completes the #1303 RBAC rollout. With cfg.Tenant.EnableRBAC=true
operators now have a full management surface; with EnableRBAC=false
the routes still exist but mutations log-and-pass per PR 2 contract.
This commit is contained in:
wizardchen
2026-05-13 22:23:59 +08:00
committed by lyingbug
parent 0f0f7e4339
commit 3f7150cb5c
14 changed files with 1570 additions and 17 deletions
+10
View File
@@ -67,6 +67,16 @@ func (h *AuthHandler) Register(c *gin.Context) {
return
}
// 当 auth.registration_mode=invite_only 时,public 注册被关闭。
// 新成员只能由 Owner 通过 /tenants/:id/members 添加(PR 3 of #1303)。
// 前端在 PR 1 已经会读 /auth/config 隐藏注册入口;这里是直接 API 调用的兜底。
if h.configInfo != nil && h.configInfo.Auth != nil && h.configInfo.Auth.IsInviteOnly() {
logger.Warn(ctx, "Registration rejected: auth.registration_mode=invite_only")
appErr := errors.NewForbiddenError("Registration is invite-only")
c.Error(appErr)
return
}
var req types.RegisterRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse registration request parameters", err)
@@ -0,0 +1,144 @@
package handler
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"github.com/Tencent/WeKnora/internal/config"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// stubRegisterUserService is a UserService whose ONLY useful method is
// Register; every other call panics. Using an interface embedding plus a
// targeted override keeps the test focused on the Register handler's
// branching logic without dragging in the entire user service surface.
type stubRegisterUserService struct {
interfaces.UserService
register func(ctx context.Context, req *types.RegisterRequest) (*types.User, error)
}
func (s *stubRegisterUserService) Register(ctx context.Context, req *types.RegisterRequest) (*types.User, error) {
return s.register(ctx, req)
}
// errorCapture mirrors gin's default ErrorHandler behaviour for tests:
// when a handler calls c.Error(), we surface it as an HTTP response so the
// recorder reflects the real client-visible status. The production
// middleware does the same thing in middleware/error_handler.go.
func errorCapture() gin.HandlerFunc {
return func(c *gin.Context) {
c.Next()
if len(c.Errors) == 0 {
return
}
err := c.Errors.Last().Err
if appErr, ok := err.(*apperrors.AppError); ok {
c.JSON(appErr.HTTPCode, gin.H{"error": appErr.Message})
return
}
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
}
}
func newRegisterTestRouter(h *AuthHandler) *gin.Engine {
gin.SetMode(gin.TestMode)
r := gin.New()
r.Use(errorCapture())
r.POST("/auth/register", h.Register)
return r
}
func doRegister(t *testing.T, r *gin.Engine, body any) *httptest.ResponseRecorder {
t.Helper()
buf, _ := json.Marshal(body)
req := httptest.NewRequest(http.MethodPost, "/auth/register", bytes.NewReader(buf))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
return w
}
// validRegisterBody returns a payload that passes parameter validation, so
// each test is exercising the gate logic and not the body parser.
func validRegisterBody() map[string]string {
return map[string]string{
"username": "alice",
"email": "alice@example.com",
"password": "supersecret",
}
}
func TestRegister_InviteOnlyRejects(t *testing.T) {
// PR 3 (#1303): when auth.registration_mode=invite_only, Register
// must respond 403 BEFORE touching the user service. The frontend
// already hides the sign-up link via /auth/config; this is the
// server-side enforcement for direct API hits.
called := false
us := &stubRegisterUserService{
register: func(context.Context, *types.RegisterRequest) (*types.User, error) {
called = true
return &types.User{ID: "u1"}, nil
},
}
h := NewAuthHandler(&config.Config{
Auth: &config.AuthConfig{RegistrationMode: config.AuthRegistrationModeInviteOnly},
}, us, nil)
w := doRegister(t, newRegisterTestRouter(h), validRegisterBody())
if w.Code != http.StatusForbidden {
t.Fatalf("invite_only must return 403, got %d body=%s", w.Code, w.Body.String())
}
if called {
t.Fatalf("UserService.Register must not be called when invite_only blocks the request")
}
}
func TestRegister_SelfServeAllowsRegistration(t *testing.T) {
// Default registration_mode keeps PR 1 behaviour intact: the gate
// is dormant and the request reaches the user service. We don't
// exercise the real service here — just confirm the gate let it
// through by observing the stub being invoked.
called := false
us := &stubRegisterUserService{
register: func(_ context.Context, _ *types.RegisterRequest) (*types.User, error) {
called = true
return &types.User{ID: "u1", Email: "alice@example.com"}, nil
},
}
h := NewAuthHandler(&config.Config{
Auth: &config.AuthConfig{RegistrationMode: config.AuthRegistrationModeSelfServe},
}, us, nil)
w := doRegister(t, newRegisterTestRouter(h), validRegisterBody())
if w.Code != http.StatusCreated {
t.Fatalf("self_serve must allow registration, got %d body=%s", w.Code, w.Body.String())
}
if !called {
t.Fatalf("UserService.Register should have been invoked")
}
}
func TestRegister_NilAuthConfigDoesNotPanic(t *testing.T) {
// Defensive: a nil Auth section means the operator hasn't set the
// registration mode at all, which must not crash and must keep the
// legacy "registration enabled" behaviour. Mirrors the nil guard in
// the handler so a config-loading bug doesn't take the server down.
us := &stubRegisterUserService{
register: func(_ context.Context, _ *types.RegisterRequest) (*types.User, error) {
return &types.User{ID: "u1", Email: "alice@example.com"}, nil
},
}
h := NewAuthHandler(&config.Config{}, us, nil)
w := doRegister(t, newRegisterTestRouter(h), validRegisterBody())
if w.Code != http.StatusCreated {
t.Fatalf("nil Auth config must fall back to allow, got %d body=%s", w.Code, w.Body.String())
}
}
+312
View File
@@ -0,0 +1,312 @@
package handler
import (
"errors"
"net/http"
"strconv"
"strings"
"github.com/gin-gonic/gin"
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/application/service"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
secutils "github.com/Tencent/WeKnora/internal/utils"
)
// TenantMemberHandler exposes /tenants/:id/members CRUD. The route layer
// enforces RBAC (Viewer for list, Owner for any mutation) — see
// router.RegisterTenantRoutes — so we don't re-check role here.
//
// Tenant scoping: we trust :id == active-tenant because the auth
// middleware has already verified the caller is a member of that tenant.
// Operations on a foreign tenant via :id would have been rejected upstream
// when the user has no membership row in it.
type TenantMemberHandler struct {
memberService interfaces.TenantMemberService
userService interfaces.UserService
}
// NewTenantMemberHandler wires the dependencies. PR 1 already provides
// both services through the dig container; we just consume them.
func NewTenantMemberHandler(
memberService interfaces.TenantMemberService,
userService interfaces.UserService,
) *TenantMemberHandler {
return &TenantMemberHandler{
memberService: memberService,
userService: userService,
}
}
// addMemberRequest is the JSON body for POST /tenants/:id/members.
// Email is the user-facing invite identifier; the handler resolves it to a
// User via UserService.GetUserByEmail. PR 3 does not implement
// email-based invitations for users that don't exist yet — the invitee
// must already have an account. Sending an email invite is tracked as a
// PR 4 candidate.
type addMemberRequest struct {
Email string `json:"email" binding:"required,email"`
Role types.TenantRole `json:"role" binding:"required"`
}
// updateMemberRoleRequest is the JSON body for PUT /tenants/:id/members/:user_id.
type updateMemberRoleRequest struct {
Role types.TenantRole `json:"role" binding:"required"`
}
// parseTenantIDFromPath reads :id from the gin route and validates it as
// a tenant ID. Returning (0, false) means we already wrote the error to
// the gin context and the caller should `return` immediately.
func parseTenantIDFromPath(c *gin.Context) (uint64, bool) {
raw := strings.TrimSpace(c.Param("id"))
if raw == "" {
c.Error(apperrors.NewValidationError("tenant id is required"))
return 0, false
}
v, err := strconv.ParseUint(raw, 10, 64)
if err != nil || v == 0 {
c.Error(apperrors.NewValidationError("tenant id must be a positive integer"))
return 0, false
}
return v, true
}
// ListMembers godoc
// @Summary 列出租户成员
// @Description 返回当前租户内全部 active 成员(含每位成员的角色、邮箱、头像)
// @Tags 租户成员
// @Produce json
// @Param id path string true "租户 ID"
// @Success 200 {object} map[string]interface{}
// @Security Bearer
// @Router /tenants/{id}/members [get]
func (h *TenantMemberHandler) ListMembers(c *gin.Context) {
ctx := c.Request.Context()
tenantID, ok := parseTenantIDFromPath(c)
if !ok {
return
}
members, err := h.memberService.ListByTenant(ctx, tenantID)
if err != nil {
logger.Errorf(ctx, "ListByTenant failed: tenant=%d err=%v", tenantID, err)
c.Error(apperrors.NewInternalServerError("failed to list members").WithDetails(err.Error()))
return
}
// Hydrate each row with user-facing fields. We do this in the handler
// rather than in the service because it's a pure presentation concern
// — the service stays free of UserService coupling and easier to test.
resp := make([]types.TenantMemberResponse, 0, len(members))
for _, m := range members {
row := types.TenantMemberResponse{
UserID: m.UserID,
Role: m.Role,
Status: m.Status,
InvitedBy: m.InvitedBy,
JoinedAt: m.JoinedAt,
}
// User lookup is best-effort: a deleted user account shouldn't
// drop the row from the management UI, otherwise an Owner can
// no longer remove the dangling membership.
if u, err := h.userService.GetUserByID(ctx, m.UserID); err == nil && u != nil {
row.Email = u.Email
row.Username = u.Username
row.Avatar = u.Avatar
}
resp = append(resp, row)
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"members": resp,
"total": len(resp),
},
})
}
// AddMember godoc
// @Summary 添加租户成员
// @Description Owner 通过 email 邀请已经存在的用户加入当前租户
// @Tags 租户成员
// @Accept json
// @Produce json
// @Param id path string true "租户 ID"
// @Param request body addMemberRequest true "邀请请求"
// @Success 201 {object} map[string]interface{}
// @Security Bearer
// @Router /tenants/{id}/members [post]
func (h *TenantMemberHandler) AddMember(c *gin.Context) {
ctx := c.Request.Context()
tenantID, ok := parseTenantIDFromPath(c)
if !ok {
return
}
var req addMemberRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.Error(apperrors.NewValidationError("invalid request body").WithDetails(err.Error()))
return
}
// Defence in depth — service also re-validates, but rejecting early
// gives the client a better error message than the generic service
// sentinel-mapped 400.
if !req.Role.IsValid() {
c.Error(apperrors.NewValidationError("role must be one of owner/admin/contributor/viewer"))
return
}
user, err := h.userService.GetUserByEmail(ctx, strings.TrimSpace(req.Email))
if err != nil {
// ErrUserNotFound is the deliberate "not registered yet" signal;
// mapping it to 404 lets the UI render "ask them to sign up first"
// instead of a generic failure.
if errors.Is(err, apprepo.ErrUserNotFound) {
c.Error(apperrors.NewNotFoundError(
"user with this email is not registered; ask them to sign up first"))
return
}
logger.Errorf(ctx, "GetUserByEmail failed: email=%s err=%v",
secutils.SanitizeForLog(req.Email), err)
c.Error(apperrors.NewInternalServerError("failed to look up user").WithDetails(err.Error()))
return
}
caller, _ := types.UserIDFromContext(ctx)
var invitedBy *string
if caller != "" {
invitedBy = &caller
}
member, err := h.memberService.AddMember(ctx, user.ID, tenantID, req.Role, invitedBy)
if err != nil {
switch {
case errors.Is(err, service.ErrInvalidTenantRole):
c.Error(apperrors.NewValidationError(err.Error()))
case errors.Is(err, service.ErrMembershipAlreadyExists):
// 409 reads better than 400 here: the request was syntactically
// fine, the conflict is semantic ("already a member").
c.Error(apperrors.NewConflictError(err.Error()))
default:
logger.Errorf(ctx, "AddMember failed: user=%s tenant=%d err=%v",
user.ID, tenantID, err)
c.Error(apperrors.NewInternalServerError("failed to add member").WithDetails(err.Error()))
}
return
}
// Project the freshly added row through the same response shape the
// list endpoint uses, so the UI can swap "Add Member" UX into the
// table without an extra round-trip.
resp := types.TenantMemberResponse{
UserID: member.UserID,
Email: user.Email,
Username: user.Username,
Avatar: user.Avatar,
Role: member.Role,
Status: member.Status,
InvitedBy: member.InvitedBy,
JoinedAt: member.JoinedAt,
}
c.JSON(http.StatusCreated, gin.H{
"success": true,
"data": resp,
})
}
// UpdateMemberRole godoc
// @Summary 修改租户成员角色
// @Description Owner 修改某位成员在当前租户内的角色;不能将最后一位 Owner 降级
// @Tags 租户成员
// @Accept json
// @Produce json
// @Param id path string true "租户 ID"
// @Param user_id path string true "用户 ID"
// @Param request body updateMemberRoleRequest true "目标角色"
// @Success 200 {object} map[string]interface{}
// @Security Bearer
// @Router /tenants/{id}/members/{user_id} [put]
func (h *TenantMemberHandler) UpdateMemberRole(c *gin.Context) {
ctx := c.Request.Context()
tenantID, ok := parseTenantIDFromPath(c)
if !ok {
return
}
userID := strings.TrimSpace(c.Param("user_id"))
if userID == "" {
c.Error(apperrors.NewValidationError("user_id is required"))
return
}
var req updateMemberRoleRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.Error(apperrors.NewValidationError("invalid request body").WithDetails(err.Error()))
return
}
if !req.Role.IsValid() {
c.Error(apperrors.NewValidationError("role must be one of owner/admin/contributor/viewer"))
return
}
if err := h.memberService.UpdateRole(ctx, userID, tenantID, req.Role); err != nil {
switch {
case errors.Is(err, service.ErrMembershipNotFound):
c.Error(apperrors.NewNotFoundError("membership not found"))
case errors.Is(err, service.ErrLastOwner):
c.Error(apperrors.NewConflictError(err.Error()))
case errors.Is(err, service.ErrInvalidTenantRole):
c.Error(apperrors.NewValidationError(err.Error()))
default:
logger.Errorf(ctx, "UpdateRole failed: user=%s tenant=%d err=%v",
userID, tenantID, err)
c.Error(apperrors.NewInternalServerError("failed to update member role").WithDetails(err.Error()))
}
return
}
c.JSON(http.StatusOK, gin.H{"success": true})
}
// RemoveMember godoc
// @Summary 移除租户成员
// @Description Owner 将某位成员从当前租户中移除(软删除 tenant_members 行);不能移除最后一位 Owner
// @Tags 租户成员
// @Produce json
// @Param id path string true "租户 ID"
// @Param user_id path string true "用户 ID"
// @Success 200 {object} map[string]interface{}
// @Security Bearer
// @Router /tenants/{id}/members/{user_id} [delete]
func (h *TenantMemberHandler) RemoveMember(c *gin.Context) {
ctx := c.Request.Context()
tenantID, ok := parseTenantIDFromPath(c)
if !ok {
return
}
userID := strings.TrimSpace(c.Param("user_id"))
if userID == "" {
c.Error(apperrors.NewValidationError("user_id is required"))
return
}
if err := h.memberService.RemoveMember(ctx, userID, tenantID); err != nil {
switch {
case errors.Is(err, service.ErrMembershipNotFound):
c.Error(apperrors.NewNotFoundError("membership not found"))
case errors.Is(err, service.ErrLastOwner):
c.Error(apperrors.NewConflictError(err.Error()))
default:
logger.Errorf(ctx, "RemoveMember failed: user=%s tenant=%d err=%v",
userID, tenantID, err)
c.Error(apperrors.NewInternalServerError("failed to remove member").WithDetails(err.Error()))
}
return
}
c.JSON(http.StatusOK, gin.H{"success": true})
}
+357
View File
@@ -0,0 +1,357 @@
package handler
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// stubMemberService is a TenantMemberService whose individual methods can
// be overridden per-test. Embedding the interface keeps the fixture
// minimal — any method not set in a given test will nil-panic if it's
// reached, which is exactly what we want for "the test should not have
// gotten here" assertions.
type stubMemberService struct {
interfaces.TenantMemberService
add func(ctx context.Context, userID string, tenantID uint64, role types.TenantRole, invitedBy *string) (*types.TenantMember, error)
listTenant func(ctx context.Context, tenantID uint64) ([]*types.TenantMember, error)
updateRole func(ctx context.Context, userID string, tenantID uint64, newRole types.TenantRole) error
remove func(ctx context.Context, userID string, tenantID uint64) error
}
func (s *stubMemberService) AddMember(ctx context.Context, userID string, tenantID uint64, role types.TenantRole, invitedBy *string) (*types.TenantMember, error) {
return s.add(ctx, userID, tenantID, role, invitedBy)
}
func (s *stubMemberService) ListByTenant(ctx context.Context, tenantID uint64) ([]*types.TenantMember, error) {
return s.listTenant(ctx, tenantID)
}
func (s *stubMemberService) UpdateRole(ctx context.Context, userID string, tenantID uint64, newRole types.TenantRole) error {
return s.updateRole(ctx, userID, tenantID, newRole)
}
func (s *stubMemberService) RemoveMember(ctx context.Context, userID string, tenantID uint64) error {
return s.remove(ctx, userID, tenantID)
}
// stubMemberUserService satisfies just the two UserService methods the
// handler reaches: GetUserByEmail (AddMember translation) and
// GetUserByID (ListMembers hydration).
type stubMemberUserService struct {
interfaces.UserService
getByEmail func(ctx context.Context, email string) (*types.User, error)
getByID func(ctx context.Context, id string) (*types.User, error)
}
func (s *stubMemberUserService) GetUserByEmail(ctx context.Context, email string) (*types.User, error) {
return s.getByEmail(ctx, email)
}
func (s *stubMemberUserService) GetUserByID(ctx context.Context, id string) (*types.User, error) {
return s.getByID(ctx, id)
}
// memberTestRouter wires the handler with the same errorCapture middleware
// production uses, so c.Error() shows up as a real HTTP status in the
// recorder.
func memberTestRouter(h *TenantMemberHandler) *gin.Engine {
gin.SetMode(gin.TestMode)
r := gin.New()
r.Use(errorCapture()) // defined in auth_register_invite_only_test.go
r.GET("/tenants/:id/members", h.ListMembers)
r.POST("/tenants/:id/members", h.AddMember)
r.PUT("/tenants/:id/members/:user_id", h.UpdateMemberRole)
r.DELETE("/tenants/:id/members/:user_id", h.RemoveMember)
return r
}
// withCallerUser injects the authenticated caller's user ID into the
// request context just like middleware/auth.go does. Several handler
// branches (notably AddMember's invited_by attribution) read this.
func withCallerUser(req *http.Request, callerUserID string) *http.Request {
ctx := context.WithValue(req.Context(), types.UserIDContextKey, callerUserID)
return req.WithContext(ctx)
}
func doJSON(t *testing.T, r *gin.Engine, method, path string, body any, callerID string) *httptest.ResponseRecorder {
t.Helper()
var reader *bytes.Reader
if body != nil {
buf, _ := json.Marshal(body)
reader = bytes.NewReader(buf)
} else {
reader = bytes.NewReader(nil)
}
req := httptest.NewRequest(method, path, reader)
req.Header.Set("Content-Type", "application/json")
if callerID != "" {
req = withCallerUser(req, callerID)
}
w := httptest.NewRecorder()
r.ServeHTTP(w, req)
return w
}
// ---------- ListMembers ----------
func TestTenantMember_ListMembers_HappyPath(t *testing.T) {
now := time.Now()
ms := &stubMemberService{
listTenant: func(_ context.Context, tenantID uint64) ([]*types.TenantMember, error) {
if tenantID != 1 {
t.Fatalf("tenantID parsed wrong: got %d", tenantID)
}
return []*types.TenantMember{
{UserID: "u-owner", TenantID: 1, Role: types.TenantRoleOwner, Status: types.TenantMemberStatusActive, JoinedAt: now},
{UserID: "u-c", TenantID: 1, Role: types.TenantRoleContributor, Status: types.TenantMemberStatusActive, JoinedAt: now},
}, nil
},
}
us := &stubMemberUserService{
getByID: func(_ context.Context, id string) (*types.User, error) {
return &types.User{ID: id, Username: id, Email: id + "@x.com"}, nil
},
}
h := NewTenantMemberHandler(ms, us)
w := doJSON(t, memberTestRouter(h), http.MethodGet, "/tenants/1/members", nil, "u-owner")
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d body=%s", w.Code, w.Body.String())
}
var resp struct {
Success bool `json:"success"`
Data struct {
Members []types.TenantMemberResponse `json:"members"`
Total int `json:"total"`
} `json:"data"`
}
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode response: %v", err)
}
if resp.Data.Total != 2 || len(resp.Data.Members) != 2 {
t.Fatalf("expected 2 members, got total=%d len=%d", resp.Data.Total, len(resp.Data.Members))
}
// Hydration must have populated email so the UI can render avatars.
if resp.Data.Members[0].Email == "" {
t.Fatalf("expected hydrated email, got empty")
}
}
func TestTenantMember_ListMembers_TolerantToDeletedUsers(t *testing.T) {
// A dangling membership (user account deleted) must still appear in
// the listing so the Owner can clean it up. The service returned the
// row; the user lookup error is silently swallowed.
ms := &stubMemberService{
listTenant: func(_ context.Context, _ uint64) ([]*types.TenantMember, error) {
return []*types.TenantMember{
{UserID: "u-ghost", TenantID: 1, Role: types.TenantRoleViewer, Status: types.TenantMemberStatusActive},
}, nil
},
}
us := &stubMemberUserService{
getByID: func(_ context.Context, _ string) (*types.User, error) {
return nil, apprepo.ErrUserNotFound
},
}
h := NewTenantMemberHandler(ms, us)
w := doJSON(t, memberTestRouter(h), http.MethodGet, "/tenants/1/members", nil, "u-owner")
if w.Code != http.StatusOK {
t.Fatalf("expected 200 even when user lookup fails, got %d", w.Code)
}
if !strings.Contains(w.Body.String(), `"user_id":"u-ghost"`) {
t.Fatalf("dangling membership must remain in response: %s", w.Body.String())
}
}
func TestTenantMember_ListMembers_RejectsBadTenantID(t *testing.T) {
h := NewTenantMemberHandler(&stubMemberService{}, &stubMemberUserService{})
w := doJSON(t, memberTestRouter(h), http.MethodGet, "/tenants/abc/members", nil, "u1")
if w.Code != http.StatusBadRequest {
t.Fatalf("non-numeric tenant id must 400, got %d", w.Code)
}
}
// ---------- AddMember ----------
func TestTenantMember_AddMember_HappyPath(t *testing.T) {
caller := "u-owner"
now := time.Now()
ms := &stubMemberService{
add: func(_ context.Context, userID string, tenantID uint64, role types.TenantRole, invitedBy *string) (*types.TenantMember, error) {
if invitedBy == nil || *invitedBy != caller {
t.Fatalf("invited_by must be the caller, got %v", invitedBy)
}
return &types.TenantMember{UserID: userID, TenantID: tenantID, Role: role, Status: types.TenantMemberStatusActive, JoinedAt: now, InvitedBy: invitedBy}, nil
},
}
us := &stubMemberUserService{
getByEmail: func(_ context.Context, email string) (*types.User, error) {
return &types.User{ID: "u-bob", Email: email, Username: "bob"}, nil
},
}
h := NewTenantMemberHandler(ms, us)
body := map[string]any{"email": "bob@x.com", "role": "contributor"}
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, caller)
if w.Code != http.StatusCreated {
t.Fatalf("expected 201, got %d body=%s", w.Code, w.Body.String())
}
}
func TestTenantMember_AddMember_UnknownEmailReturns404(t *testing.T) {
// PR 3 requires the invitee to already have an account; mapping
// ErrUserNotFound to 404 lets the UI prompt "ask them to sign up
// first" rather than the generic "something failed".
us := &stubMemberUserService{
getByEmail: func(_ context.Context, _ string) (*types.User, error) {
return nil, apprepo.ErrUserNotFound
},
}
h := NewTenantMemberHandler(&stubMemberService{}, us)
body := map[string]any{"email": "ghost@x.com", "role": "viewer"}
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, "u-owner")
if w.Code != http.StatusNotFound {
t.Fatalf("unknown email must surface as 404, got %d body=%s", w.Code, w.Body.String())
}
}
func TestTenantMember_AddMember_DuplicateMaps409(t *testing.T) {
ms := &stubMemberService{
add: func(_ context.Context, _ string, _ uint64, _ types.TenantRole, _ *string) (*types.TenantMember, error) {
return nil, service.ErrMembershipAlreadyExists
},
}
us := &stubMemberUserService{
getByEmail: func(_ context.Context, _ string) (*types.User, error) {
return &types.User{ID: "u-bob", Email: "bob@x.com"}, nil
},
}
h := NewTenantMemberHandler(ms, us)
body := map[string]any{"email": "bob@x.com", "role": "contributor"}
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, "u-owner")
if w.Code != http.StatusConflict {
t.Fatalf("duplicate must surface as 409, got %d", w.Code)
}
}
func TestTenantMember_AddMember_InvalidRoleRejectedUpfront(t *testing.T) {
// Reject obviously bogus roles before paying for the user lookup.
called := false
us := &stubMemberUserService{
getByEmail: func(_ context.Context, _ string) (*types.User, error) {
called = true
return &types.User{ID: "u-bob"}, nil
},
}
h := NewTenantMemberHandler(&stubMemberService{}, us)
body := map[string]any{"email": "bob@x.com", "role": "wizard"}
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/members", body, "u-owner")
if w.Code != http.StatusBadRequest {
t.Fatalf("invalid role must 400, got %d", w.Code)
}
if called {
t.Fatalf("user lookup must not run for invalid role")
}
}
// ---------- UpdateMemberRole ----------
func TestTenantMember_UpdateRole_HappyPath(t *testing.T) {
ms := &stubMemberService{
updateRole: func(_ context.Context, userID string, tenantID uint64, newRole types.TenantRole) error {
if userID != "u-bob" || tenantID != 1 || newRole != types.TenantRoleAdmin {
t.Fatalf("unexpected args: user=%s tenant=%d role=%s", userID, tenantID, newRole)
}
return nil
},
}
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
body := map[string]any{"role": "admin"}
w := doJSON(t, memberTestRouter(h), http.MethodPut, "/tenants/1/members/u-bob", body, "u-owner")
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d body=%s", w.Code, w.Body.String())
}
}
func TestTenantMember_UpdateRole_LastOwnerMaps409(t *testing.T) {
// Service-layer invariant: the last Owner cannot be demoted. Mapping
// ErrLastOwner to 409 lets the UI render the message inline rather
// than as a generic failure.
ms := &stubMemberService{
updateRole: func(_ context.Context, _ string, _ uint64, _ types.TenantRole) error {
return service.ErrLastOwner
},
}
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
body := map[string]any{"role": "viewer"}
w := doJSON(t, memberTestRouter(h), http.MethodPut, "/tenants/1/members/u-only-owner", body, "u-only-owner")
if w.Code != http.StatusConflict {
t.Fatalf("last owner demote must 409, got %d", w.Code)
}
}
func TestTenantMember_UpdateRole_UnknownMembershipMaps404(t *testing.T) {
ms := &stubMemberService{
updateRole: func(_ context.Context, _ string, _ uint64, _ types.TenantRole) error {
return service.ErrMembershipNotFound
},
}
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
body := map[string]any{"role": "admin"}
w := doJSON(t, memberTestRouter(h), http.MethodPut, "/tenants/1/members/u-ghost", body, "u-owner")
if w.Code != http.StatusNotFound {
t.Fatalf("missing membership must 404, got %d", w.Code)
}
}
// ---------- RemoveMember ----------
func TestTenantMember_RemoveMember_HappyPath(t *testing.T) {
ms := &stubMemberService{
remove: func(_ context.Context, userID string, tenantID uint64) error {
if userID != "u-bob" || tenantID != 1 {
t.Fatalf("unexpected args: user=%s tenant=%d", userID, tenantID)
}
return nil
},
}
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
w := doJSON(t, memberTestRouter(h), http.MethodDelete, "/tenants/1/members/u-bob", nil, "u-owner")
if w.Code != http.StatusOK {
t.Fatalf("expected 200, got %d", w.Code)
}
}
func TestTenantMember_RemoveMember_LastOwnerMaps409(t *testing.T) {
ms := &stubMemberService{
remove: func(_ context.Context, _ string, _ uint64) error {
return service.ErrLastOwner
},
}
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
w := doJSON(t, memberTestRouter(h), http.MethodDelete, "/tenants/1/members/u-only-owner", nil, "u-only-owner")
if w.Code != http.StatusConflict {
t.Fatalf("last-owner remove must 409, got %d", w.Code)
}
}