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.

21.1 KB
Raw Blame
package hosted

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

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

type mockAuthProvider struct {
	manager   AuthManager
	err       error
	calls     int
	lastOrgID string
	removeErr error
	removeIDs []string
}

func (m *mockAuthProvider) GetManager(orgID string) (AuthManager, error) {
	m.calls++
	m.lastOrgID = orgID
	if m.err != nil {
		return nil, m.err
	}
	return m.manager, nil
}

func (m *mockAuthProvider) RemoveTenant(orgID string) error {
	m.removeIDs = append(m.removeIDs, orgID)
	return m.removeErr
}

type mockAuthManager struct {
	updateErr error
	calls     int
	lastUser  string
	lastRoles []string
}

func (m *mockAuthManager) UpdateUserRoles(userID string, roles []string) error {
	m.calls++
	m.lastUser = userID
	m.lastRoles = append([]string(nil), roles...)
	return m.updateErr
}

type mockOrgPersistence struct {
	base    *config.MultiTenantPersistence
	saveErr error
}

func TestProvisionTenantSuccess(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}

	provisioner := NewProvisioner(persistence, authProvider)
	provisioner.newOrgID = func() string { return "org-success" }
	provisioner.newUserID = func() (string, error) { return "u_owner_success", nil }
	provisioner.now = func() time.Time { return time.Unix(1700000000, 0).UTC() }

	result, err := provisioner.ProvisionTenant(context.Background(), ProvisionRequest{
		Email:    "[email protected]",
		Password: "securepass123",
		OrgName:  "My Organization",
	})
	if err != nil {
		t.Fatalf("ProvisionTenant returned error: %v", err)
	}
	if result == nil {
		t.Fatal("expected result, got nil")
	}
	if result.Status != ProvisionStatusCreated {
		t.Fatalf("expected status %q, got %q", ProvisionStatusCreated, result.Status)
	}
	if result.OrgID != "org-success" {
		t.Fatalf("expected org ID org-success, got %q", result.OrgID)
	}
	if result.UserID != "u_owner_success" {
		t.Fatalf("expected stable user ID u_owner_success, got %q", result.UserID)
	}
	if result.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", result.OwnerEmail)
	}

	org, err := persistence.LoadOrganization("org-success")
	if err != nil {
		t.Fatalf("LoadOrganization returned error: %v", err)
	}
	if org.DisplayName != "My Organization" {
		t.Fatalf("expected org display name My Organization, got %q", org.DisplayName)
	}
	if org.OwnerUserID != "u_owner_success" {
		t.Fatalf("expected owner u_owner_success, got %q", org.OwnerUserID)
	}
	if org.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", org.OwnerEmail)
	}
	if len(org.Members) != 1 {
		t.Fatalf("expected 1 member, got %d", len(org.Members))
	}
	if org.Members[0].UserID != "u_owner_success" {
		t.Fatalf("expected member user ID u_owner_success, got %q", org.Members[0].UserID)
	}
	if org.Members[0].Email != "[email protected]" {
		t.Fatalf("expected member email [email protected], got %q", org.Members[0].Email)
	}
	if org.Members[0].Role != models.OrgRoleOwner {
		t.Fatalf("expected owner role, got %q", org.Members[0].Role)
	}

	if authProvider.calls != 1 {
		t.Fatalf("expected GetManager to be called once, got %d", authProvider.calls)
	}
	if authProvider.lastOrgID != "org-success" {
		t.Fatalf("expected GetManager org ID org-success, got %q", authProvider.lastOrgID)
	}
	if authManager.calls != 1 {
		t.Fatalf("expected UpdateUserRoles to be called once, got %d", authManager.calls)
	}
	if authManager.lastUser != "u_owner_success" {
		t.Fatalf("expected UpdateUserRoles for u_owner_success, got %q", authManager.lastUser)
	}
	if len(authManager.lastRoles) != 1 || authManager.lastRoles[0] != auth.RoleAdmin {
		t.Fatalf("expected roles [%s], got %v", auth.RoleAdmin, authManager.lastRoles)
	}
}

func TestProvisionTenantIdempotentDuplicateEmail(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}
	provisioner := NewProvisioner(persistence, authProvider)

	existingOrg := &models.Organization{
		ID:          "existing-org",
		DisplayName: "Existing Org",
		CreatedAt:   time.Now().UTC(),
		OwnerUserID: "u_existing_owner",
		OwnerEmail:  "[email protected]",
		Members: []models.OrganizationMember{
			{
				UserID:  "u_existing_owner",
				Email:   "[email protected]",
				Role:    models.OrgRoleOwner,
				AddedAt: time.Now().UTC(),
				AddedBy: "u_existing_owner",
			},
		},
	}
	if err := persistence.SaveOrganization(existingOrg); err != nil {
		t.Fatalf("SaveOrganization returned error: %v", err)
	}

	result, err := provisioner.ProvisionTenant(context.Background(), ProvisionRequest{
		Email:    "[email protected]",
		Password: "securepass123",
		OrgName:  "New Org Name",
	})
	if err != nil {
		t.Fatalf("ProvisionTenant returned error: %v", err)
	}
	if result == nil {
		t.Fatal("expected result, got nil")
	}
	if result.Status != ProvisionStatusExisting {
		t.Fatalf("expected status %q, got %q", ProvisionStatusExisting, result.Status)
	}
	if result.OrgID != "existing-org" {
		t.Fatalf("expected org ID existing-org, got %q", result.OrgID)
	}
	if result.UserID != "u_existing_owner" {
		t.Fatalf("expected stable user ID u_existing_owner, got %q", result.UserID)
	}
	if result.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", result.OwnerEmail)
	}
	if authProvider.calls != 0 {
		t.Fatalf("expected GetManager to not be called for idempotent path, got %d", authProvider.calls)
	}
	if authManager.calls != 0 {
		t.Fatalf("expected UpdateUserRoles to not be called for idempotent path, got %d", authManager.calls)
	}
}

func TestProvisionTenantIdempotentDuplicateEmailCaseInsensitive(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}
	provisioner := NewProvisioner(persistence, authProvider)

	existingOrg := &models.Organization{
		ID:          "existing-org",
		DisplayName: "Existing Org",
		CreatedAt:   time.Now().UTC(),
		OwnerUserID: "u_existing_owner",
		OwnerEmail:  "[email protected]",
		Members: []models.OrganizationMember{
			{
				UserID:  "u_existing_owner",
				Email:   "[email protected]",
				Role:    models.OrgRoleOwner,
				AddedAt: time.Now().UTC(),
				AddedBy: "u_existing_owner",
			},
		},
	}
	if err := persistence.SaveOrganization(existingOrg); err != nil {
		t.Fatalf("SaveOrganization returned error: %v", err)
	}

	result, err := provisioner.ProvisionTenant(context.Background(), ProvisionRequest{
		Email:    "[email protected]",
		Password: "securepass123",
		OrgName:  "New Org Name",
	})
	if err != nil {
		t.Fatalf("ProvisionTenant returned error: %v", err)
	}
	if result == nil {
		t.Fatal("expected result, got nil")
	}
	if result.Status != ProvisionStatusExisting {
		t.Fatalf("expected status %q, got %q", ProvisionStatusExisting, result.Status)
	}
	if result.OrgID != "existing-org" {
		t.Fatalf("expected org ID existing-org, got %q", result.OrgID)
	}
	if result.UserID != "u_existing_owner" {
		t.Fatalf("expected stable user ID u_existing_owner, got %q", result.UserID)
	}
	if result.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", result.OwnerEmail)
	}
	if authProvider.calls != 0 {
		t.Fatalf("expected GetManager to not be called for idempotent path, got %d", authProvider.calls)
	}
	if authManager.calls != 0 {
		t.Fatalf("expected UpdateUserRoles to not be called for idempotent path, got %d", authManager.calls)
	}
}

func TestProvisionTenantValidationFailures(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authProvider := &mockAuthProvider{manager: &mockAuthManager{}}
	provisioner := NewProvisioner(persistence, authProvider)

	testCases := []struct {
		name          string
		request       ProvisionRequest
		expectedField string
	}{
		{
			name: "invalid email",
			request: ProvisionRequest{
				Email:    "invalid-email",
				Password: "securepass123",
				OrgName:  "Valid Org",
			},
			expectedField: "email",
		},
		{
			name: "email with control characters",
			request: ProvisionRequest{
				Email:    "owner@\nexample.com",
				Password: "securepass123",
				OrgName:  "Valid Org",
			},
			expectedField: "email",
		},
		{
			name: "short password",
			request: ProvisionRequest{
				Email:    "[email protected]",
				Password: "short",
				OrgName:  "Valid Org",
			},
			expectedField: "password",
		},
		{
			name: "password exceeds maximum length",
			request: ProvisionRequest{
				Email:    "[email protected]",
				Password: strings.Repeat("a", maxHostedSignupPasswordLength+1),
				OrgName:  "Valid Org",
			},
			expectedField: "password",
		},
		{
			name: "bad org name",
			request: ProvisionRequest{
				Email:    "[email protected]",
				Password: "securepass123",
				OrgName:  "../evil",
			},
			expectedField: "org_name",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			_, err := provisioner.ProvisionTenant(context.Background(), tc.request)
			if err == nil {
				t.Fatal("expected validation error, got nil")
			}

			var validationErr *ValidationError
			if !errors.As(err, &validationErr) {
				t.Fatalf("expected ValidationError, got %T (%v)", err, err)
			}
			if validationErr.Field != tc.expectedField {
				t.Fatalf("expected validation field %q, got %q", tc.expectedField, validationErr.Field)
			}
		})
	}
}

func TestProvisionTenantPartialFailureRollback(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{updateErr: errors.New("rbac update failed")}
	authProvider := &mockAuthProvider{manager: authManager}
	provisioner := NewProvisioner(persistence, authProvider)
	provisioner.newOrgID = func() string { return "rollback-org" }

	_, err := provisioner.ProvisionTenant(context.Background(), ProvisionRequest{
		Email:    "[email protected]",
		Password: "securepass123",
		OrgName:  "Rollback Org",
	})
	if err == nil {
		t.Fatal("expected provisioning error, got nil")
	}

	var systemErr *SystemError
	if !errors.As(err, &systemErr) {
		t.Fatalf("expected SystemError, got %T (%v)", err, err)
	}
	if len(authProvider.removeIDs) != 1 || authProvider.removeIDs[0] != "rollback-org" {
		t.Fatalf("expected RemoveTenant rollback for rollback-org, got %v", authProvider.removeIDs)
	}

	orgDir := filepath.Join(baseDir, "orgs", "rollback-org")
	_, statErr := os.Stat(orgDir)
	if !os.IsNotExist(statErr) {
		t.Fatalf("expected org dir to be removed, stat error: %v", statErr)
	}
}

func TestProvisionHostedSignupSuccess(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}

	provisioner := NewProvisioner(persistence, authProvider)
	provisioner.newOrgID = func() string { return "org-hosted-signup" }
	provisioner.newUserID = func() (string, error) { return "u_hosted_signup_owner", nil }
	provisioner.now = func() time.Time { return time.Unix(1700000100, 0).UTC() }

	result, err := provisioner.ProvisionHostedSignup(context.Background(), HostedSignupRequest{
		Email:   " [email protected] ",
		OrgName: "My Organization",
	})
	if err != nil {
		t.Fatalf("ProvisionHostedSignup returned error: %v", err)
	}
	if result == nil {
		t.Fatal("expected result, got nil")
	}
	if result.Status != ProvisionStatusCreated {
		t.Fatalf("expected status %q, got %q", ProvisionStatusCreated, result.Status)
	}
	if result.OrgID != "org-hosted-signup" {
		t.Fatalf("expected org ID org-hosted-signup, got %q", result.OrgID)
	}
	if result.UserID != "u_hosted_signup_owner" {
		t.Fatalf("expected stable user ID u_hosted_signup_owner, got %q", result.UserID)
	}
	if result.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", result.OwnerEmail)
	}

	org, err := persistence.LoadOrganization("org-hosted-signup")
	if err != nil {
		t.Fatalf("LoadOrganization returned error: %v", err)
	}
	if org.DisplayName != "My Organization" {
		t.Fatalf("expected org display name My Organization, got %q", org.DisplayName)
	}
	if org.OwnerUserID != "u_hosted_signup_owner" {
		t.Fatalf("expected owner u_hosted_signup_owner, got %q", org.OwnerUserID)
	}
	if org.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", org.OwnerEmail)
	}
	if authProvider.calls != 1 || authProvider.lastOrgID != "org-hosted-signup" {
		t.Fatalf("expected auth manager lookup for org-hosted-signup, got calls=%d org=%q", authProvider.calls, authProvider.lastOrgID)
	}
	if authManager.calls != 1 || authManager.lastUser != "u_hosted_signup_owner" {
		t.Fatalf("expected admin role assignment for u_hosted_signup_owner, got calls=%d user=%q", authManager.calls, authManager.lastUser)
	}
}

func TestProvisionHostedSignupIdempotentDuplicateEmailCaseInsensitive(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}
	provisioner := NewProvisioner(persistence, authProvider)

	existingOrg := &models.Organization{
		ID:          "existing-org",
		DisplayName: "Existing Org",
		CreatedAt:   time.Now().UTC(),
		OwnerUserID: "u_existing_owner",
		OwnerEmail:  "[email protected]",
		Members: []models.OrganizationMember{
			{
				UserID:  "u_existing_owner",
				Email:   "[email protected]",
				Role:    models.OrgRoleOwner,
				AddedAt: time.Now().UTC(),
				AddedBy: "u_existing_owner",
			},
		},
	}
	if err := persistence.SaveOrganization(existingOrg); err != nil {
		t.Fatalf("SaveOrganization returned error: %v", err)
	}

	result, err := provisioner.ProvisionHostedSignup(context.Background(), HostedSignupRequest{
		Email:   "[email protected]",
		OrgName: "Another Org",
	})
	if err != nil {
		t.Fatalf("ProvisionHostedSignup returned error: %v", err)
	}
	if result == nil {
		t.Fatal("expected result, got nil")
	}
	if result.Status != ProvisionStatusExisting {
		t.Fatalf("expected status %q, got %q", ProvisionStatusExisting, result.Status)
	}
	if result.OrgID != "existing-org" {
		t.Fatalf("expected org ID existing-org, got %q", result.OrgID)
	}
	if result.UserID != "u_existing_owner" {
		t.Fatalf("expected stable user ID u_existing_owner, got %q", result.UserID)
	}
	if result.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", result.OwnerEmail)
	}
	if authProvider.calls != 0 {
		t.Fatalf("expected GetManager to not be called for idempotent hosted signup, got %d", authProvider.calls)
	}
	if authManager.calls != 0 {
		t.Fatalf("expected UpdateUserRoles to not be called for idempotent hosted signup, got %d", authManager.calls)
	}
}

func TestProvisionHostedSignupCanonicalizesLegacyEmailOwnerPrincipal(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}
	provisioner := NewProvisioner(persistence, authProvider)
	provisioner.newUserID = func() (string, error) { return "u_migrated_owner", nil }
	provisioner.now = func() time.Time { return time.Unix(1700000200, 0).UTC() }

	legacyOrg := &models.Organization{
		ID:          "legacy-org",
		DisplayName: "Legacy Org",
		CreatedAt:   time.Now().UTC(),
		OwnerUserID: "[email protected]",
		Members: []models.OrganizationMember{
			{
				UserID:  "[email protected]",
				Role:    models.OrgRoleOwner,
				AddedAt: time.Now().UTC(),
				AddedBy: "[email protected]",
			},
		},
	}
	if err := persistence.SaveOrganization(legacyOrg); err != nil {
		t.Fatalf("SaveOrganization returned error: %v", err)
	}

	result, err := provisioner.ProvisionHostedSignup(context.Background(), HostedSignupRequest{
		Email:   "[email protected]",
		OrgName: "Another Org",
	})
	if err != nil {
		t.Fatalf("ProvisionHostedSignup returned error: %v", err)
	}
	if result == nil {
		t.Fatal("expected result, got nil")
	}
	if result.Status != ProvisionStatusExisting {
		t.Fatalf("expected status %q, got %q", ProvisionStatusExisting, result.Status)
	}
	if result.OrgID != "legacy-org" {
		t.Fatalf("expected org ID legacy-org, got %q", result.OrgID)
	}
	if result.UserID != "u_migrated_owner" {
		t.Fatalf("expected migrated owner user ID, got %q", result.UserID)
	}
	if result.OwnerEmail != "[email protected]" {
		t.Fatalf("expected owner email [email protected], got %q", result.OwnerEmail)
	}

	org, err := persistence.LoadOrganization("legacy-org")
	if err != nil {
		t.Fatalf("LoadOrganization returned error: %v", err)
	}
	if org.OwnerUserID != "u_migrated_owner" {
		t.Fatalf("owner user ID = %q, want u_migrated_owner", org.OwnerUserID)
	}
	if org.OwnerEmail != "[email protected]" {
		t.Fatalf("owner email = %q, want [email protected]", org.OwnerEmail)
	}
	if len(org.Members) != 1 {
		t.Fatalf("expected 1 member, got %d", len(org.Members))
	}
	if org.Members[0].UserID != "u_migrated_owner" || org.Members[0].Email != "[email protected]" || org.Members[0].Role != models.OrgRoleOwner {
		t.Fatalf("member = %+v, want migrated owner member", org.Members[0])
	}
	if org.Members[0].AddedBy != "u_migrated_owner" {
		t.Fatalf("member AddedBy = %q, want u_migrated_owner", org.Members[0].AddedBy)
	}
	if authProvider.calls != 1 || authProvider.lastOrgID != "legacy-org" {
		t.Fatalf("expected auth manager lookup for legacy-org, got calls=%d org=%q", authProvider.calls, authProvider.lastOrgID)
	}
	if authManager.calls != 1 || authManager.lastUser != "u_migrated_owner" {
		t.Fatalf("expected admin role assignment for u_migrated_owner, got calls=%d user=%q", authManager.calls, authManager.lastUser)
	}
	if len(authManager.lastRoles) != 1 || authManager.lastRoles[0] != auth.RoleAdmin {
		t.Fatalf("expected roles [%s], got %v", auth.RoleAdmin, authManager.lastRoles)
	}
}

func TestProvisionHostedSignupCanonicalizesBlankOwnerPrincipal(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	authManager := &mockAuthManager{}
	authProvider := &mockAuthProvider{manager: authManager}
	provisioner := NewProvisioner(persistence, authProvider)
	provisioner.newUserID = func() (string, error) { return "u_blank_owner_migrated", nil }
	provisioner.now = func() time.Time { return time.Unix(1700000300, 0).UTC() }

	if err := persistence.SaveOrganization(&models.Organization{
		ID:          "blank-owner-org",
		DisplayName: "Blank Owner Org",
		CreatedAt:   time.Now().UTC(),
		OwnerEmail:  "[email protected]",
	}); err != nil {
		t.Fatalf("SaveOrganization returned error: %v", err)
	}

	result, err := provisioner.ProvisionHostedSignup(context.Background(), HostedSignupRequest{
		Email:   "[email protected]",
		OrgName: "Another Org",
	})
	if err != nil {
		t.Fatalf("ProvisionHostedSignup returned error: %v", err)
	}
	if result.UserID != "u_blank_owner_migrated" || result.Status != ProvisionStatusExisting {
		t.Fatalf("result = %+v, want existing migrated owner", result)
	}

	org, err := persistence.LoadOrganization("blank-owner-org")
	if err != nil {
		t.Fatalf("LoadOrganization returned error: %v", err)
	}
	if org.OwnerUserID != "u_blank_owner_migrated" || org.OwnerEmail != "[email protected]" {
		t.Fatalf("owner identity = (%q, %q), want migrated stable owner", org.OwnerUserID, org.OwnerEmail)
	}
	if len(org.Members) != 1 {
		t.Fatalf("expected appended owner member, got %d members", len(org.Members))
	}
	if org.Members[0].UserID != "u_blank_owner_migrated" || org.Members[0].Email != "[email protected]" || org.Members[0].Role != models.OrgRoleOwner {
		t.Fatalf("member = %+v, want appended stable owner", org.Members[0])
	}
	if authManager.calls != 1 || authManager.lastUser != "u_blank_owner_migrated" {
		t.Fatalf("expected admin role assignment for migrated owner, got calls=%d user=%q", authManager.calls, authManager.lastUser)
	}
}

func TestCleanupOrgDirectorySkipsUnsafePath(t *testing.T) {
	baseDir := t.TempDir()
	p := &Provisioner{}

	unsafeDir := filepath.Join(baseDir, "not-orgs", "unsafe-org")
	if err := os.MkdirAll(unsafeDir, 0700); err != nil {
		t.Fatalf("MkdirAll returned error: %v", err)
	}

	p.cleanupOrgDirectory("unsafe-org", unsafeDir)

	if _, err := os.Stat(unsafeDir); err != nil {
		t.Fatalf("expected unsafe directory to be preserved, stat error: %v", err)
	}
}

func TestCleanupOrgDirectoryUsesOrganizationDeleter(t *testing.T) {
	baseDir := t.TempDir()
	persistence := config.NewMultiTenantPersistence(baseDir)
	orgID := "rollback-delete-org"

	if _, err := persistence.GetPersistence(orgID); err != nil {
		t.Fatalf("GetPersistence returned error: %v", err)
	}

	orgDir := filepath.Join(baseDir, "orgs", orgID)
	if _, err := os.Stat(orgDir); err != nil {
		t.Fatalf("expected org directory to exist before cleanup, stat error: %v", err)
	}

	p := &Provisioner{persistence: persistence}
	p.cleanupOrgDirectory(orgID, filepath.Join(baseDir, "wrong", "path"))

	if _, err := os.Stat(orgDir); !os.IsNotExist(err) {
		t.Fatalf("expected org directory to be removed by organization deleter, stat error: %v", err)
	}
}