Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

23.2 KB
Raw Blame
package api

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

	"github.com/rcourtman/pulse-go-rewrite/internal/config"
	"github.com/rcourtman/pulse-go-rewrite/internal/models"
	internalauth "github.com/rcourtman/pulse-go-rewrite/pkg/auth"
)

const orgAccessTestAdmin = "admin"

func enableSharedMultiOrgForTest(t *testing.T) {
	t.Helper()
	previous := IsMultiTenantEnabled()
	SetMultiTenantEnabled(true)
	t.Cleanup(func() { SetMultiTenantEnabled(previous) })
}

// newOrgAccessFixture builds persistence with one tenant, "acme": alice owns
// it, bob is a member, and carol only holds a pending invitation.
func newOrgAccessFixture(t *testing.T, hosted bool) (*config.MultiTenantPersistence, *DefaultAuthorizationChecker) {
	t.Helper()
	persistence := config.NewMultiTenantPersistence(t.TempDir())
	acme := &models.Organization{
		ID:          "acme",
		DisplayName: "Acme",
		OwnerUserID: "alice",
		Members: []models.OrganizationMember{
			{UserID: "alice", Role: models.OrgRoleOwner},
			{UserID: "bob", Role: models.OrgRoleViewer},
		},
		PendingInvitations: []models.OrganizationInvitation{
			{UserID: "carol", Role: models.OrgRoleViewer},
		},
	}
	if err := persistence.SaveOrganization(acme); err != nil {
		t.Fatalf("save acme: %v", err)
	}
	return persistence, newOrgAccessChecker(&config.Config{AuthUser: orgAccessTestAdmin}, persistence, hosted)
}

func saveDefaultOrgMembers(t *testing.T, persistence *config.MultiTenantPersistence, userIDs ...string) {
	t.Helper()
	org := &models.Organization{ID: "default", DisplayName: "default"}
	for _, userID := range userIDs {
		org.Members = append(org.Members, models.OrganizationMember{UserID: userID, Role: models.OrgRoleViewer})
	}
	if err := persistence.SaveOrganization(org); err != nil {
		t.Fatalf("save default org: %v", err)
	}
}

func TestOrgAccessPolicy_DefaultOrgNeedsAdminOrMembershipInSharedMultiOrgMode(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	persistence, checker := newOrgAccessFixture(t, false)

	for _, user := range []string{"bob", "carol", "nobody"} {
		res := checker.CheckAccess(nil, user, "default")
		if res.Allowed {
			t.Fatalf("%s reached the default organization without membership", user)
		}
		if res.Reason != "User is not a member of the default organization" {
			t.Fatalf("unexpected reason for %s: %q", user, res.Reason)
		}
		if checker.UserCanAccessOrg(user, "default") || checker.CanAccessOrg(user, nil, "default") {
			t.Fatalf("%s reached the default organization through another entry point", user)
		}
	}
	if !checker.CheckAccess(nil, orgAccessTestAdmin, "default").Allowed {
		t.Fatal("configured instance administrator must reach the default organization")
	}
	if !checker.CheckAccess(nil, "bob", "acme").Allowed {
		t.Fatal("tenant membership must still grant the tenant")
	}

	saveDefaultOrgMembers(t, persistence, "dave")
	if !checker.CheckAccess(nil, "dave", "default").Allowed {
		t.Fatal("explicit default-organization member must reach it")
	}
	if checker.CheckAccess(nil, "bob", "default").Allowed {
		t.Fatal("another user's default membership must not grant bob")
	}

	// Token rules are unchanged: unbound tokens keep default access and
	// org-bound tokens need an explicit default binding.
	if !checker.CheckAccess(&config.APITokenRecord{}, "", "default").Allowed {
		t.Fatal("legacy unbound token must keep default-organization access")
	}
	if checker.CheckAccess(&config.APITokenRecord{OrgID: "acme"}, "", "default").Allowed {
		t.Fatal("acme-bound token must not reach the default organization")
	}
}

func TestOrgAccessPolicy_DefaultOrgStaysOpenOutsideSharedMultiOrgMode(t *testing.T) {
	installTestRBACManager(t)

	t.Run("single tenant", func(t *testing.T) {
		previous := IsMultiTenantEnabled()
		SetMultiTenantEnabled(false)
		t.Cleanup(func() { SetMultiTenantEnabled(previous) })
		_, checker := newOrgAccessFixture(t, false)
		if !checker.CheckAccess(nil, "bob", "default").Allowed {
			t.Fatal("single-tenant default organization must stay open to signed-in users")
		}
	})

	t.Run("hosted", func(t *testing.T) {
		enableSharedMultiOrgForTest(t)
		_, checker := newOrgAccessFixture(t, true)
		if !checker.CheckAccess(nil, "bob", "default").Allowed {
			t.Fatal("hosted runtimes do not share the default organization with other tenants")
		}
	})
}

func TestOrgAccessPolicy_DefaultOrgMetadataIsReadStrictly(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	persistence, checker := newOrgAccessFixture(t, false)

	// Missing org.json is no membership, not a synthesized open organization.
	if checker.CheckAccess(nil, "dave", "default").Allowed {
		t.Fatal("missing default metadata must not grant access")
	}

	saveDefaultOrgMembers(t, persistence, "dave")
	orgFile := filepath.Join(persistence.BaseDataDir(), "org.json")
	if err := os.WriteFile(orgFile, []byte("{not json"), 0o600); err != nil {
		t.Fatalf("corrupt default org metadata: %v", err)
	}
	if checker.CheckAccess(nil, "dave", "default").Allowed {
		t.Fatal("unreadable default metadata must deny members")
	}
	if !checker.CheckAccess(nil, orgAccessTestAdmin, "default").Allowed {
		t.Fatal("instance administrators do not depend on default metadata")
	}
}

func TestOrgAccessPolicy_ProxyAdminAuthorityIsBoundToItsPrincipal(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	_, checker := newOrgAccessFixture(t, false)

	proxyCtx := func(username string, isAdmin bool) context.Context {
		req := httptest.NewRequest(http.MethodGet, "/api/state", nil)
		return attachProxyPrincipal(req, username, isAdmin).Context()
	}

	if !checker.CheckAccessContext(proxyCtx("bob", true), nil, "bob", "default").Allowed {
		t.Fatal("proxy administrator must reach the default organization")
	}
	if checker.CheckAccessContext(proxyCtx("bob", false), nil, "bob", "default").Allowed {
		t.Fatal("proxy non-administrator must not reach the default organization")
	}
	if checker.CheckAccessContext(proxyCtx("mallory", true), nil, "bob", "default").Allowed {
		t.Fatal("proxy admin authority must not transfer to another username")
	}
	// A proxy user named like the local administrator is judged by the
	// proxy's role, not by the local administrator's name.
	if checker.CheckAccessContext(proxyCtx(orgAccessTestAdmin, false), nil, orgAccessTestAdmin, "default").Allowed {
		t.Fatal("proxy non-administrator must not inherit the local administrator's authority")
	}
	// Without a request context the proxy role is unknown, so it never grants.
	if checker.CheckAccess(nil, "bob", "default").Allowed {
		t.Fatal("proxy admin authority must not apply without its request context")
	}
}

func TestOrgAccessPolicy_LandingOrgForUsersWithoutDefaultAccess(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	persistence, checker := newOrgAccessFixture(t, false)
	saveDefaultOrgMembers(t, persistence, "dave")
	if err := persistence.SaveOrganization(&models.Organization{
		ID: "zeta", DisplayName: "Zeta", OwnerUserID: "bob",
		Members: []models.OrganizationMember{{UserID: "bob", Role: models.OrgRoleOwner}},
	}); err != nil {
		t.Fatalf("save zeta: %v", err)
	}

	ctx := context.Background()
	if got := checker.LandingOrgID(ctx, "bob"); got != "acme" {
		t.Fatalf("bob landing org = %q, want first membership acme", got)
	}
	for _, user := range []string{"carol", "nobody", orgAccessTestAdmin, "dave"} {
		if got := checker.LandingOrgID(ctx, user); got != "" {
			t.Fatalf("%s landing org = %q, want none", user, got)
		}
	}
}

func TestMigrateDefaultOrgAccessSeedsExistingDefaultUsersOnce(t *testing.T) {
	manager := installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	persistence, checker := newOrgAccessFixture(t, false)
	cfg := &config.Config{AuthUser: orgAccessTestAdmin}

	assign := func(user string, roleIDs ...string) {
		t.Helper()
		if err := manager.UpdateUserRoles(user, roleIDs); err != nil {
			t.Fatalf("assign %s: %v", user, err)
		}
	}
	assign("dave", internalauth.RoleViewer)      // default-only user: seeded
	assign("bob", internalauth.RoleViewer)       // acme member: not seeded
	assign("carol", internalauth.RoleViewer)     // acme invitee: not seeded
	assign("rbac-admin", internalauth.RoleAdmin) // reaches default by authority
	assign("token:abc", internalauth.RoleViewer) // never a person
	assign("empty")                              // no roles

	if err := migrateDefaultOrgAccess(persistence, manager, cfg, false); err != nil {
		t.Fatalf("migrate: %v", err)
	}
	defaultOrg, err := persistence.LoadOrganizationStrict("default")
	if err != nil {
		t.Fatalf("load default org: %v", err)
	}
	if len(defaultOrg.Members) != 1 || defaultOrg.Members[0].UserID != "dave" ||
		defaultOrg.Members[0].Role != models.OrgRoleViewer ||
		defaultOrg.Members[0].AddedBy != defaultOrgAccessMigrationActor {
		t.Fatalf("unexpected seeded members: %+v", defaultOrg.Members)
	}
	if !checker.CheckAccess(nil, "dave", "default").Allowed {
		t.Fatal("seeded user must keep default-organization access")
	}

	raw, err := os.ReadFile(filepath.Join(persistence.BaseDataDir(), defaultOrgAccessMigrationFile))
	if err != nil {
		t.Fatalf("read migration marker: %v", err)
	}
	var record defaultOrgAccessMigrationRecord
	if err := json.Unmarshal(raw, &record); err != nil || len(record.Seeded) != 1 || record.Seeded[0] != "dave" {
		t.Fatalf("unexpected migration record %s (%v)", raw, err)
	}

	// The marker stops a second run from re-granting a revoked user.
	saveDefaultOrgMembers(t, persistence)
	if err := migrateDefaultOrgAccess(persistence, manager, cfg, false); err != nil {
		t.Fatalf("second migrate: %v", err)
	}
	if checker.CheckAccess(nil, "dave", "default").Allowed {
		t.Fatal("migration must not run twice")
	}
}

func TestMigrateDefaultOrgAccessSkipsOutsideSharedMultiOrgMode(t *testing.T) {
	manager := installTestRBACManager(t)
	previous := IsMultiTenantEnabled()
	SetMultiTenantEnabled(false)
	t.Cleanup(func() { SetMultiTenantEnabled(previous) })
	persistence := config.NewMultiTenantPersistence(t.TempDir())

	if err := migrateDefaultOrgAccess(persistence, manager, &config.Config{}, false); err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if _, err := os.Stat(filepath.Join(persistence.BaseDataDir(), defaultOrgAccessMigrationFile)); !os.IsNotExist(err) {
		t.Fatalf("single-tenant start must not record the migration: %v", err)
	}
}

func TestMigrateDefaultOrgAccessRetriesWhenTenantMetadataIsUnreadable(t *testing.T) {
	manager := installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	persistence, _ := newOrgAccessFixture(t, false)
	if err := os.WriteFile(filepath.Join(persistence.BaseDataDir(), "orgs", "acme", "org.json"), []byte("{"), 0o600); err != nil {
		t.Fatalf("corrupt acme metadata: %v", err)
	}
	if err := migrateDefaultOrgAccess(persistence, manager, &config.Config{}, false); err == nil {
		t.Fatal("migration must fail on unreadable tenant metadata")
	}
	// A tenant directory without metadata hides its members just the same.
	if err := os.Remove(filepath.Join(persistence.BaseDataDir(), "orgs", "acme", "org.json")); err != nil {
		t.Fatalf("remove acme metadata: %v", err)
	}
	if err := migrateDefaultOrgAccess(persistence, manager, &config.Config{}, false); err == nil {
		t.Fatal("migration must fail when a tenant's members are unknown")
	}
	if _, err := os.Stat(filepath.Join(persistence.BaseDataDir(), defaultOrgAccessMigrationFile)); !os.IsNotExist(err) {
		t.Fatalf("failed migration must not record completion: %v", err)
	}
}

func orgAccessTestRequest(t *testing.T, method, path, user string, configure func(*http.Request)) *http.Request {
	t.Helper()
	req := httptest.NewRequest(method, path, nil)
	if user != "" {
		req = req.WithContext(internalauth.WithUser(req.Context(), user))
	}
	if configure != nil {
		configure(req)
	}
	return req
}

func TestTenantMiddleware_SharedMultiOrgDefaultAccess(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	t.Setenv("PULSE_DEV", "true")
	persistence, checker := newOrgAccessFixture(t, false)
	mw := NewTenantMiddlewareWithConfig(TenantMiddlewareConfig{Persistence: persistence, AuthChecker: checker})

	serve := func(req *http.Request) (int, string) {
		t.Helper()
		servedOrg := ""
		handler := mw.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			servedOrg = GetOrgID(r.Context())
			if resolved := resolveTenantOrgID(r); resolved != servedOrg {
				t.Fatalf("handler org %q disagrees with the authorized org %q", resolved, servedOrg)
			}
			w.WriteHeader(http.StatusNoContent)
		}))
		rec := httptest.NewRecorder()
		handler.ServeHTTP(rec, req)
		return rec.Code, servedOrg
	}

	// The reported proof of concept: an acme-only user selecting default.
	code, _ := serve(orgAccessTestRequest(t, http.MethodGet, "/api/state", "bob", func(r *http.Request) {
		r.Header.Set("X-Pulse-Org-ID", "default")
	}))
	if code != http.StatusForbidden {
		t.Fatalf("explicit default header: status %d, want 403", code)
	}
	code, _ = serve(orgAccessTestRequest(t, http.MethodGet, "/api/state", "bob", func(r *http.Request) {
		r.AddCookie(&http.Cookie{Name: CookieNameOrgID, Value: "default"})
	}))
	if code != http.StatusForbidden {
		t.Fatalf("default org cookie: status %d, want 403", code)
	}

	// Without a selection, bob lands in his own organization.
	for _, path := range []string{"/", "/api/security/status", "/api/orgs", "/api/state"} {
		code, org := serve(orgAccessTestRequest(t, http.MethodGet, path, "bob", nil))
		if code != http.StatusNoContent || org != "acme" {
			t.Fatalf("bob %s: status %d org %q, want acme", path, code, org)
		}
	}

	// A user with no organization keeps only the organization-neutral routes.
	for _, path := range []string{"/", "/settings", "/api/health", "/api/security/status", "/api/logout", "/api/orgs", "/api/org-invitations"} {
		code, org := serve(orgAccessTestRequest(t, http.MethodGet, path, "carol", nil))
		if code != http.StatusNoContent || org != "default" {
			t.Fatalf("carol %s: status %d org %q, want neutral admission", path, code, org)
		}
	}
	for _, path := range []string{"/api/state", "/api/resources", "/ws", "/simple-stats"} {
		if code, _ := serve(orgAccessTestRequest(t, http.MethodGet, path, "carol", nil)); code != http.StatusForbidden {
			t.Fatalf("carol %s: status %d, want 403", path, code)
		}
	}
	if code, _ := serve(orgAccessTestRequest(t, http.MethodPost, "/api/orgs", "carol", nil)); code != http.StatusForbidden {
		t.Fatalf("carol POST /api/orgs: status %d, want 403", code)
	}
	// A stale default selection still loads the shell and the bootstrap
	// routes, and data routes say why they refused so the client can recover.
	for _, path := range []string{"/", "/api/security/status", "/api/orgs"} {
		code, org := serve(orgAccessTestRequest(t, http.MethodGet, path, "bob", func(r *http.Request) {
			r.AddCookie(&http.Cookie{Name: CookieNameOrgID, Value: "default"})
		}))
		if code != http.StatusNoContent || org != "default" {
			t.Fatalf("bob %s with a default cookie: status %d org %q", path, code, org)
		}
	}
	rec := httptest.NewRecorder()
	mw.Middleware(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
		t.Fatal("data route must not be served from a refused default selection")
	})).ServeHTTP(rec, orgAccessTestRequest(t, http.MethodGet, "/api/state/summary", "bob", func(r *http.Request) {
		r.Header.Set("X-Pulse-Org-ID", "default")
	}))
	if rec.Code != http.StatusForbidden || !strings.Contains(rec.Body.String(), `"default_org_access_denied"`) {
		t.Fatalf("refused default selection: %d %s", rec.Code, rec.Body.String())
	}

	// Instance administrators keep the default organization.
	code, org := serve(orgAccessTestRequest(t, http.MethodGet, "/api/state", orgAccessTestAdmin, nil))
	if code != http.StatusNoContent || org != "default" {
		t.Fatalf("admin: status %d org %q, want default", code, org)
	}
}

func TestOrgAccessRevalidatorEndsStreamsWhenAccessIsRevoked(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	persistence, checker := newOrgAccessFixture(t, false)
	saveDefaultOrgMembers(t, persistence, "dave")

	previousInterval := orgAccessRecheckInterval
	orgAccessRecheckInterval = 0
	t.Cleanup(func() { orgAccessRecheckInterval = previousInterval })

	req := orgAccessTestRequest(t, http.MethodGet, "/ws", "dave", nil)
	ctx := context.WithValue(req.Context(), OrgIDContextKey, "default")
	req = req.WithContext(withOrgAccessChecker(ctx, checker))

	allowed := orgAccessRevalidator(req)
	if allowed == nil || !allowed() {
		t.Fatal("member stream must start allowed")
	}
	saveDefaultOrgMembers(t, persistence)
	if allowed() {
		t.Fatal("stream must end once default membership is revoked")
	}
	saveDefaultOrgMembers(t, persistence, "dave")
	if allowed() {
		t.Fatal("an ended stream must stay ended")
	}

	// Token streams keep their own credential revalidation.
	tokenReq := req.WithContext(internalauth.WithAPIToken(req.Context(), &config.APITokenRecord{ID: "t"}))
	if orgAccessRevalidator(tokenReq) != nil {
		t.Fatal("token streams must not get the user revalidator")
	}
}

func TestOrgHandlers_DefaultOrgMembersInSharedMultiOrgMode(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	t.Setenv("PULSE_DEV", "true")
	persistence, checker := newOrgAccessFixture(t, false)
	h := NewOrgHandlers(persistence, nil)
	h.SetAccessPolicy(checker)

	call := func(handler http.HandlerFunc, method, path, user, body string, pathValues map[string]string) *httptest.ResponseRecorder {
		t.Helper()
		req := httptest.NewRequest(method, path, strings.NewReader(body))
		req = req.WithContext(internalauth.WithUser(req.Context(), user))
		for key, value := range pathValues {
			req.SetPathValue(key, value)
		}
		rec := httptest.NewRecorder()
		handler(rec, req)
		return rec
	}
	listOrgIDs := func(user string) []string {
		t.Helper()
		rec := call(h.HandleListOrgs, http.MethodGet, "/api/orgs", user, "", nil)
		if rec.Code != http.StatusOK {
			t.Fatalf("list orgs for %s: %d %s", user, rec.Code, rec.Body.String())
		}
		var orgs []models.Organization
		if err := json.Unmarshal(rec.Body.Bytes(), &orgs); err != nil {
			t.Fatalf("decode orgs: %v", err)
		}
		ids := make([]string, 0, len(orgs))
		for _, org := range orgs {
			ids = append(ids, org.ID)
		}
		return ids
	}

	if got := strings.Join(listOrgIDs("bob"), ","); got != "acme" {
		t.Fatalf("bob sees %q, want only acme", got)
	}
	if got := strings.Join(listOrgIDs(orgAccessTestAdmin), ","); got != "default" {
		t.Fatalf("admin sees %q, want default", got)
	}
	defaultPath := map[string]string{"id": "default"}
	if rec := call(h.HandleGetOrg, http.MethodGet, "/api/orgs/default", "bob", "", defaultPath); rec.Code != http.StatusForbidden {
		t.Fatalf("bob GET default: %d, want 403", rec.Code)
	}
	rec := call(h.HandleGetOrg, http.MethodGet, "/api/orgs/default", orgAccessTestAdmin, "", defaultPath)
	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"canManageMembers":true`) {
		t.Fatalf("admin GET default: %d %s", rec.Code, rec.Body.String())
	}

	rec = call(h.HandleListInvitations, http.MethodGet, "/api/orgs/default/invitations", orgAccessTestAdmin, "", defaultPath)
	if rec.Code != http.StatusOK || strings.TrimSpace(rec.Body.String()) != "[]" {
		t.Fatalf("admin listing default invitations: %d %q, want an empty list", rec.Code, rec.Body.String())
	}

	// Only instance administrators manage default members, and only as viewers.
	if rec := call(h.HandleInviteMember, http.MethodPost, "/api/orgs/default/members", "alice", `{"userId":"bob"}`, defaultPath); rec.Code != http.StatusForbidden {
		t.Fatalf("tenant owner adding a default member: %d, want 403", rec.Code)
	}
	if rec := call(h.HandleInviteMember, http.MethodPost, "/api/orgs/default/members", orgAccessTestAdmin, `{"userId":"bob","role":"admin"}`, defaultPath); rec.Code != http.StatusBadRequest {
		t.Fatalf("admin role on default: %d, want 400", rec.Code)
	}
	rec = call(h.HandleInviteMember, http.MethodPost, "/api/orgs/default/members", orgAccessTestAdmin, `{"userId":"bob"}`, defaultPath)
	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), `"kind":"member"`) {
		t.Fatalf("admin adding bob: %d %s", rec.Code, rec.Body.String())
	}
	if !checker.CheckAccess(nil, "bob", "default").Allowed {
		t.Fatal("added member must reach the default organization")
	}
	if got := strings.Join(listOrgIDs("bob"), ","); got != "acme,default" {
		t.Fatalf("bob sees %q after the grant", got)
	}
	rec = call(h.HandleGetOrg, http.MethodGet, "/api/orgs/default", "bob", "", defaultPath)
	if rec.Code != http.StatusOK || strings.Contains(rec.Body.String(), "canManageMembers") {
		t.Fatalf("member GET default: %d %s", rec.Code, rec.Body.String())
	}

	removePath := map[string]string{"id": "default", "userId": "bob"}
	if rec := call(h.HandleRemoveMember, http.MethodDelete, "/api/orgs/default/members/bob", "bob", "", removePath); rec.Code != http.StatusForbidden {
		t.Fatalf("member removing themself: %d, want 403", rec.Code)
	}
	if rec := call(h.HandleRemoveMember, http.MethodDelete, "/api/orgs/default/members/bob", orgAccessTestAdmin, "", removePath); rec.Code != http.StatusNoContent {
		t.Fatalf("admin removing bob: %d %s", rec.Code, rec.Body.String())
	}
	if checker.CheckAccess(nil, "bob", "default").Allowed {
		t.Fatal("removed member must lose the default organization")
	}
}

func TestOrgHandlers_DefaultOrgOwnerIsRevocableAndStaleSavesKeepMembers(t *testing.T) {
	installTestRBACManager(t)
	enableSharedMultiOrgForTest(t)
	t.Setenv("PULSE_DEV", "true")
	persistence, checker := newOrgAccessFixture(t, false)
	h := NewOrgHandlers(persistence, nil)
	h.SetAccessPolicy(checker)

	// An owner field alone grants nothing; membership does.
	if err := persistence.SaveOrganization(&models.Organization{ID: "default", DisplayName: "default", OwnerUserID: "olivia"}); err != nil {
		t.Fatalf("save default org: %v", err)
	}
	if checker.CheckAccess(nil, "olivia", "default").Allowed {
		t.Fatal("default ownership without membership must not grant access")
	}

	// Removing a member who also owns the default organization revokes them.
	saveDefaultOrgMembers(t, persistence, "olivia", "dave")
	org, err := persistence.LoadOrganizationStrict("default")
	if err != nil {
		t.Fatalf("load default org: %v", err)
	}
	org.OwnerUserID = "olivia"
	if err := persistence.SaveOrganization(org); err != nil {
		t.Fatalf("save default owner: %v", err)
	}
	req := httptest.NewRequest(http.MethodDelete, "/api/orgs/default/members/olivia", nil)
	req = req.WithContext(internalauth.WithUser(req.Context(), orgAccessTestAdmin))
	req.SetPathValue("id", "default")
	req.SetPathValue("userId", "olivia")
	rec := httptest.NewRecorder()
	h.HandleRemoveMember(rec, req)
	if rec.Code != http.StatusNoContent {
		t.Fatalf("remove owner member: %d %s", rec.Code, rec.Body.String())
	}
	if checker.CheckAccess(nil, "olivia", "default").Allowed {
		t.Fatal("removed default owner kept access")
	}

	// A save from a snapshot taken before dave's removal must not restore him.
	stale, err := persistence.LoadOrganizationStrict("default")
	if err != nil {
		t.Fatalf("load stale snapshot: %v", err)
	}
	saveDefaultOrgMembers(t, persistence)
	stale.SharedResources = append(stale.SharedResources, models.OrganizationShare{ID: "share-1", TargetOrgID: "acme", ResourceType: "vm", ResourceID: "vm-1"})
	if err := h.saveOrganization(stale); err != nil {
		t.Fatalf("save stale snapshot: %v", err)
	}
	if checker.CheckAccess(nil, "dave", "default").Allowed {
		t.Fatal("a stale default snapshot restored a removed member")
	}
	saved, err := persistence.LoadOrganizationStrict("default")
	if err != nil || len(saved.SharedResources) != 1 {
		t.Fatalf("share change was lost: %+v (%v)", saved, err)
	}
}