ae7cd02cd6
Self-review of PR 3's TenantMembers.vue surfaced a handful of real bugs
and a few rough edges. This commit fixes them and adds the self-leave
endpoint that PR 3's design called out as a follow-up.
Frontend bug fixes
- Read err.status (not err.response.status). The axios interceptor in
utils/request.ts already flattens errors into { status, message,
... }, so the original branch-by-status code never matched and every
4xx fell through to the generic toast. Fixes 404/409 surfacing as
"userNotFound" / "alreadyMember" / "lastOwner" instead of "Something
went wrong".
- t-dialog @confirm replaces :on-confirm so the dialog stays open on
validation failure and on API error. Users can fix and retry without
retyping the email.
- Drop the t-select revert hack; with :model-value the rendered value
is already source-of-truth-on-row.role, so no setTimeout dance is
needed.
- Don't toast "no active tenant" on cold mount; watch the activeTenantId
ref and load once the auth store hydrates.
Frontend UX additions
- Empty state via t-empty (also covers the search-no-results case).
- Compact role-permissions matrix above the table, mirroring
OrganizationSettingsModal so Owners can see what each role grants
before promoting/inviting.
- Search box filtering by username/email (client-side, sufficient for
expected per-tenant member counts).
- "Leave Tenant" button — visible to any active member except the
last-Owner case (server still enforces).
Backend
- New POST /tenants/:id/leave route. Calls TenantMemberService.RemoveMember
with the caller's own user id so non-Owners can quit on their own.
Gated Viewer+ in the matrix; the existing last-Owner invariant in the
service still rejects last-Owner self-leave with 409.
- 3 new handler tests cover the happy path, the last-Owner 409 path,
and the missing-caller-id 401 path (defensive — auth middleware
always attaches a user, but the test pins the contract).
i18n
- Add tenantMember.permissions / search / leave / empty strings in all
four locales (en/zh/ko/ru).
421 lines
15 KiB
Go
421 lines
15 KiB
Go
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)
|
|
r.POST("/tenants/:id/leave", h.LeaveTenant)
|
|
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)
|
|
}
|
|
}
|
|
|
|
// ---------- LeaveTenant ----------
|
|
|
|
func TestTenantMember_LeaveTenant_HappyPath(t *testing.T) {
|
|
// LeaveTenant must invoke RemoveMember with the caller's own user
|
|
// id, regardless of any path :user_id segment. The route doesn't
|
|
// have a :user_id; the caller's id comes from the auth context.
|
|
ms := &stubMemberService{
|
|
remove: func(_ context.Context, userID string, tenantID uint64) error {
|
|
if userID != "u-self" || tenantID != 1 {
|
|
t.Fatalf("LeaveTenant must use caller id; got user=%s tenant=%d", userID, tenantID)
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
|
|
|
|
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/leave", nil, "u-self")
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d body=%s", w.Code, w.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestTenantMember_LeaveTenant_LastOwnerMaps409(t *testing.T) {
|
|
// The whole point of having a separate leave endpoint is that
|
|
// non-Owners can quit, but the same last-Owner invariant still
|
|
// applies — an Owner that's the only one left must transfer
|
|
// ownership before they can leave.
|
|
ms := &stubMemberService{
|
|
remove: func(_ context.Context, _ string, _ uint64) error {
|
|
return service.ErrLastOwner
|
|
},
|
|
}
|
|
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
|
|
|
|
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/leave", nil, "u-only-owner")
|
|
if w.Code != http.StatusConflict {
|
|
t.Fatalf("last-owner self-leave must 409, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestTenantMember_LeaveTenant_MissingCallerReturns401(t *testing.T) {
|
|
// Defensive: if the auth middleware ever fails to attach a user id,
|
|
// LeaveTenant must NOT silently call RemoveMember(""), it should
|
|
// surface 401 so the caller knows their session is broken.
|
|
called := false
|
|
ms := &stubMemberService{
|
|
remove: func(_ context.Context, _ string, _ uint64) error {
|
|
called = true
|
|
return nil
|
|
},
|
|
}
|
|
h := NewTenantMemberHandler(ms, &stubMemberUserService{})
|
|
|
|
w := doJSON(t, memberTestRouter(h), http.MethodPost, "/tenants/1/leave", nil, "")
|
|
if w.Code != http.StatusUnauthorized {
|
|
t.Fatalf("missing caller must 401, got %d", w.Code)
|
|
}
|
|
if called {
|
|
t.Fatalf("RemoveMember must not be called without a caller id")
|
|
}
|
|
}
|