tailscale/ipn/ipnlocal/profiles_test.go

// Copyright (c) Tailscale Inc & contributors
// SPDX-License-Identifier: BSD-3-Clause

package ipnlocal

import (
	"errors"
	"fmt"
	"os/user"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	_ "tailscale.com/clientupdate" // for feature registration side effects
	"tailscale.com/feature"
	"tailscale.com/health"
	"tailscale.com/ipn"
	"tailscale.com/ipn/store/mem"
	"tailscale.com/tailcfg"
	"tailscale.com/tstest"
	"tailscale.com/tstime"
	"tailscale.com/types/key"
	"tailscale.com/types/logger"
	"tailscale.com/types/persist"
	"tailscale.com/util/eventbus/eventbustest"
	"tailscale.com/util/must"
)

func TestProfileCurrentUserSwitch(t *testing.T) {
	store := new(mem.Store)

	pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	id := 0
	newProfile := func(t *testing.T, loginName string) ipn.PrefsView {
		id++
		t.Helper()
		pm.SwitchToNewProfile()
		p := pm.CurrentPrefs().AsStruct()
		p.Persist = &persist.Persist{
			NodeID:         tailcfg.StableNodeID(fmt.Sprint(id)),
			PrivateNodeKey: key.NewNode(),
			UserProfile: tailcfg.UserProfile{
				ID:        tailcfg.UserID(id),
				LoginName: loginName,
			},
		}
		if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
			t.Fatal(err)
		}
		return p.View()
	}

	pm.SetCurrentUserID("user1")
	newProfile(t, "user1")
	cp := pm.currentProfile
	pm.DeleteProfile(cp.ID())
	if !pm.currentProfile.Valid() {
		t.Fatal("currentProfile is nil")
	} else if pm.currentProfile.ID() != "" {
		t.Fatalf("currentProfile.ID = %q, want empty", pm.currentProfile.ID())
	}
	if !pm.CurrentPrefs().Equals(defaultPrefs) {
		t.Fatalf("CurrentPrefs() = %v, want emptyPrefs", pm.CurrentPrefs().Pretty())
	}

	pm, err = newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	pm.SetCurrentUserID("user1")
	if !pm.currentProfile.Valid() {
		t.Fatal("currentProfile is nil")
	} else if pm.currentProfile.ID() != "" {
		t.Fatalf("currentProfile.ID = %q, want empty", pm.currentProfile.ID())
	}
	if !pm.CurrentPrefs().Equals(defaultPrefs) {
		t.Fatalf("CurrentPrefs() = %v, want emptyPrefs", pm.CurrentPrefs().Pretty())
	}
}

func TestProfileList(t *testing.T) {
	store := new(mem.Store)

	pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	id := 0
	newProfile := func(t *testing.T, loginName string) ipn.PrefsView {
		id++
		t.Helper()
		pm.SwitchToNewProfile()
		p := pm.CurrentPrefs().AsStruct()
		p.Persist = &persist.Persist{
			NodeID:         tailcfg.StableNodeID(fmt.Sprint(id)),
			PrivateNodeKey: key.NewNode(),
			UserProfile: tailcfg.UserProfile{
				ID:        tailcfg.UserID(id),
				LoginName: loginName,
			},
		}
		if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
			t.Fatal(err)
		}
		return p.View()
	}
	checkProfiles := func(t *testing.T, want ...string) {
		t.Helper()
		got := pm.Profiles()
		if len(got) != len(want) {
			t.Fatalf("got %d profiles, want %d", len(got), len(want))
		}
		for i, w := range want {
			if got[i].Name() != w {
				t.Errorf("got profile %d name %q, want %q", i, got[i].Name(), w)
			}
		}
	}

	pm.SetCurrentUserID("user1")
	newProfile(t, "alice")
	newProfile(t, "bob")
	checkProfiles(t, "alice", "bob")

	pm.SetCurrentUserID("user2")
	checkProfiles(t)
	newProfile(t, "carol")
	carol := pm.currentProfile
	checkProfiles(t, "carol")

	pm.SetCurrentUserID("user1")
	checkProfiles(t, "alice", "bob")
	if lp := pm.findProfileByKey("user1", carol.Key()); lp.Valid() {
		t.Fatalf("found profile for user2 in user1's profile list")
	}
	if lp := pm.findProfileByName("user1", carol.Name()); lp.Valid() {
		t.Fatalf("found profile for user2 in user1's profile list")
	}

	pm.SetCurrentUserID("user2")
	checkProfiles(t, "carol")
}

func TestProfileDupe(t *testing.T) {
	newPersist := func(user, node int) *persist.Persist {
		return &persist.Persist{
			NodeID: tailcfg.StableNodeID(fmt.Sprintf("node%d", node)),
			UserProfile: tailcfg.UserProfile{
				ID:        tailcfg.UserID(user),
				LoginName: fmt.Sprintf("user%d@example.com", user),
			},
			AttestationKey: nil,
		}
	}
	user1Node1 := newPersist(1, 1)
	user1Node2 := newPersist(1, 2)
	user2Node1 := newPersist(2, 1)
	user2Node2 := newPersist(2, 2)
	user3Node3 := newPersist(3, 3)

	reauth := func(pm *profileManager, p *persist.Persist) {
		prefs := ipn.NewPrefs()
		prefs.Persist = p
		must.Do(pm.SetPrefs(prefs.View(), ipn.NetworkProfile{}))
	}
	login := func(pm *profileManager, p *persist.Persist) {
		pm.SwitchToNewProfile()
		reauth(pm, p)
	}

	type step struct {
		fn func(pm *profileManager, p *persist.Persist)
		p  *persist.Persist
	}

	tests := []struct {
		name  string
		steps []step
		profs []*persist.Persist
	}{
		{
			name: "reauth-new-node",
			steps: []step{
				{login, user1Node1},
				{reauth, user3Node3},
			},
			profs: []*persist.Persist{
				user3Node3,
			},
		},
		{
			name: "reauth-same-node",
			steps: []step{
				{login, user1Node1},
				{reauth, user1Node1},
			},
			profs: []*persist.Persist{
				user1Node1,
			},
		},
		{
			name: "reauth-other-profile",
			steps: []step{
				{login, user1Node1},
				{login, user2Node2},
				{reauth, user1Node1},
			},
			profs: []*persist.Persist{
				user1Node1,
				user2Node2,
			},
		},
		{
			name: "reauth-replace-user",
			steps: []step{
				{login, user1Node1},
				{login, user3Node3},
				{reauth, user2Node1},
			},
			profs: []*persist.Persist{
				user2Node1,
				user3Node3,
			},
		},
		{
			name: "reauth-replace-node",
			steps: []step{
				{login, user1Node1},
				{login, user3Node3},
				{reauth, user1Node2},
			},
			profs: []*persist.Persist{
				user1Node2,
				user3Node3,
			},
		},
		{
			name: "login-same-node",
			steps: []step{
				{login, user1Node1},
				{login, user3Node3}, // random other profile
				{login, user1Node1},
			},
			profs: []*persist.Persist{
				user1Node1,
				user3Node3,
			},
		},
		{
			name: "login-replace-user",
			steps: []step{
				{login, user1Node1},
				{login, user3Node3}, // random other profile
				{login, user2Node1},
			},
			profs: []*persist.Persist{
				user2Node1,
				user3Node3,
			},
		},
		{
			name: "login-replace-node",
			steps: []step{
				{login, user1Node1},
				{login, user3Node3}, // random other profile
				{login, user1Node2},
			},
			profs: []*persist.Persist{
				user1Node2,
				user3Node3,
			},
		},
		{
			name: "login-new-node",
			steps: []step{
				{login, user1Node1},
				{login, user2Node2},
			},
			profs: []*persist.Persist{
				user1Node1,
				user2Node2,
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			store := new(mem.Store)
			pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
			if err != nil {
				t.Fatal(err)
			}
			for _, s := range tc.steps {
				s.fn(pm, s.p)
			}
			profs := pm.Profiles()
			var got []*persist.Persist
			for _, p := range profs {
				prefs, err := pm.loadSavedPrefs(p.Key())
				if err != nil {
					t.Fatal(err)
				}
				got = append(got, prefs.Persist().AsStruct())
			}
			d := cmp.Diff(tc.profs, got, cmpopts.SortSlices(func(a, b *persist.Persist) bool {
				if a.NodeID != b.NodeID {
					return a.NodeID < b.NodeID
				}
				return a.UserProfile.ID < b.UserProfile.ID
			}))
			if d != "" {
				t.Fatal(d)
			}
		})
	}
}

// TestProfileManagement tests creating, loading, and switching profiles.
func TestProfileManagement(t *testing.T) {
	store := new(mem.Store)

	pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	wantCurProfile := ""
	wantProfiles := map[string]ipn.PrefsView{
		"": defaultPrefs,
	}
	checkProfiles := func(t *testing.T) {
		t.Helper()
		prof := pm.CurrentProfile()
		t.Logf("\tCurrentProfile = %q", prof.Name())
		if prof.Name() != wantCurProfile {
			t.Fatalf("CurrentProfile = %q; want %q", prof.Name(), wantCurProfile)
		}
		profiles := pm.Profiles()
		wantLen := len(wantProfiles)
		if _, ok := wantProfiles[""]; ok {
			wantLen--
		}
		if len(profiles) != wantLen {
			t.Fatalf("Profiles = %v; want %v", profiles, wantProfiles)
		}
		p := pm.CurrentPrefs()
		t.Logf("\tCurrentPrefs = %s", p.Pretty())
		if !p.Valid() {
			t.Fatalf("CurrentPrefs = %v; want valid", p)
		}
		if !p.Equals(wantProfiles[wantCurProfile]) {
			t.Fatalf("CurrentPrefs = %v; want %v", p.Pretty(), wantProfiles[wantCurProfile].Pretty())
		}
		for _, p := range profiles {
			got, err := pm.loadSavedPrefs(p.Key())
			if err != nil {
				t.Fatal(err)
			}
			// Use Hostname as a proxy for all prefs.
			if !got.Equals(wantProfiles[p.Name()]) {
				t.Fatalf("Prefs for profile %q =\n got=%+v\nwant=%v", p.Name(), got.Pretty(), wantProfiles[p.Name()].Pretty())
			}
		}
	}
	logins := make(map[string]tailcfg.UserID)
	nodeIDs := make(map[string]tailcfg.StableNodeID)
	setPrefs := func(t *testing.T, loginName string) ipn.PrefsView {
		t.Helper()
		p := pm.CurrentPrefs().AsStruct()
		uid := logins[loginName]
		if uid.IsZero() {
			uid = tailcfg.UserID(len(logins) + 1)
			logins[loginName] = uid
		}
		nid := nodeIDs[loginName]
		if nid.IsZero() {
			nid = tailcfg.StableNodeID(fmt.Sprint(len(nodeIDs) + 1))
			nodeIDs[loginName] = nid
		}
		p.Persist = &persist.Persist{
			PrivateNodeKey: key.NewNode(),
			UserProfile: tailcfg.UserProfile{
				ID:        uid,
				LoginName: loginName,
			},
			NodeID: nid,
		}
		if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
			t.Fatal(err)
		}
		return p.View()
	}
	t.Logf("Check initial state from empty store")
	checkProfiles(t)

	{
		t.Logf("Set prefs for default profile")
		wantProfiles["user@1.example.com"] = setPrefs(t, "user@1.example.com")
		wantCurProfile = "user@1.example.com"
		delete(wantProfiles, "")
	}
	checkProfiles(t)

	t.Logf("Create new profile")
	pm.SwitchToNewProfile()
	wantCurProfile = ""
	wantProfiles[""] = defaultPrefs
	checkProfiles(t)

	{
		t.Logf("Set prefs for test profile")
		wantProfiles["user@2.example.com"] = setPrefs(t, "user@2.example.com")
		wantCurProfile = "user@2.example.com"
		delete(wantProfiles, "")
	}
	checkProfiles(t)

	t.Logf("Recreate profile manager from store")
	// Recreate the profile manager to ensure that it can load the profiles
	// from the store at startup.
	pm, err = newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	checkProfiles(t)

	t.Logf("Delete default profile")
	if err := pm.DeleteProfile(pm.ProfileIDForName("user@1.example.com")); err != nil {
		t.Fatal(err)
	}
	delete(wantProfiles, "user@1.example.com")
	checkProfiles(t)

	t.Logf("Recreate profile manager from store after deleting default profile")
	// Recreate the profile manager to ensure that it can load the profiles
	// from the store at startup.
	pm, err = newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	checkProfiles(t)

	t.Logf("Create new profile - 2")
	pm.SwitchToNewProfile()
	wantCurProfile = ""
	wantProfiles[""] = defaultPrefs
	checkProfiles(t)

	t.Logf("Login with the existing profile")
	wantProfiles["user@2.example.com"] = setPrefs(t, "user@2.example.com")
	delete(wantProfiles, "")
	wantCurProfile = "user@2.example.com"
	checkProfiles(t)

	t.Logf("Tag the current the profile")
	nodeIDs["tagged-node.2.ts.net"] = nodeIDs["user@2.example.com"]
	wantProfiles["tagged-node.2.ts.net"] = setPrefs(t, "tagged-node.2.ts.net")
	delete(wantProfiles, "user@2.example.com")
	wantCurProfile = "tagged-node.2.ts.net"
	checkProfiles(t)

	t.Logf("Relogin")
	wantProfiles["user@2.example.com"] = setPrefs(t, "user@2.example.com")
	delete(wantProfiles, "tagged-node.2.ts.net")
	wantCurProfile = "user@2.example.com"
	checkProfiles(t)

	if !feature.CanAutoUpdate() {
		t.Logf("Save an invalid AutoUpdate pref value")
		prefs := pm.CurrentPrefs().AsStruct()
		prefs.AutoUpdate.Apply.Set(true)
		if err := pm.SetPrefs(prefs.View(), ipn.NetworkProfile{}); err != nil {
			t.Fatal(err)
		}
		if !pm.CurrentPrefs().AutoUpdate().Apply.EqualBool(true) {
			t.Fatal("SetPrefs failed to save auto-update setting")
		}
		// Re-load profiles to trigger migration for invalid auto-update value.
		pm, err = newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
		if err != nil {
			t.Fatal(err)
		}
		checkProfiles(t)
		if pm.CurrentPrefs().AutoUpdate().Apply.EqualBool(true) {
			t.Fatal("invalid auto-update setting persisted after reload")
		}
	}
}

// TestProfileManagementWindows tests going into and out of Unattended mode on
// Windows.
func TestProfileManagementWindows(t *testing.T) {
	u, err := user.Current()
	if err != nil {
		t.Fatal(err)
	}
	uid := ipn.WindowsUserID(u.Uid)

	store := new(mem.Store)

	pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "windows")
	if err != nil {
		t.Fatal(err)
	}
	wantCurProfile := ""
	wantProfiles := map[string]ipn.PrefsView{
		"": defaultPrefs,
	}
	checkProfiles := func(t *testing.T) {
		t.Helper()
		prof := pm.CurrentProfile()
		t.Logf("\tCurrentProfile = %q", prof.Name())
		if prof.Name() != wantCurProfile {
			t.Fatalf("CurrentProfile = %q; want %q", prof.Name(), wantCurProfile)
		}
		if p := pm.CurrentPrefs(); !p.Equals(wantProfiles[wantCurProfile]) {
			t.Fatalf("CurrentPrefs = %+v; want %+v", p.Pretty(), wantProfiles[wantCurProfile].Pretty())
		}
	}
	logins := make(map[string]tailcfg.UserID)
	setPrefs := func(t *testing.T, loginName string, forceDaemon bool) ipn.PrefsView {
		id := logins[loginName]
		if id.IsZero() {
			id = tailcfg.UserID(len(logins) + 1)
			logins[loginName] = id
		}
		p := pm.CurrentPrefs().AsStruct()
		p.ForceDaemon = forceDaemon
		p.Persist = &persist.Persist{
			UserProfile: tailcfg.UserProfile{
				ID:        id,
				LoginName: loginName,
			},
			NodeID: tailcfg.StableNodeID(strconv.Itoa(int(id))),
		}
		if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
			t.Fatal(err)
		}
		return p.View()
	}
	t.Logf("Check initial state from empty store")
	checkProfiles(t)

	{
		t.Logf("Set user1 as logged in user")
		pm.SetCurrentUserID(uid)
		checkProfiles(t)
		t.Logf("Save prefs for user1")
		wantProfiles["default"] = setPrefs(t, "default", false)
		wantCurProfile = "default"
	}
	checkProfiles(t)

	{
		t.Logf("Create new profile")
		pm.SwitchToNewProfile()
		wantCurProfile = ""
		wantProfiles[""] = defaultPrefs
		checkProfiles(t)

		t.Logf("Save as test profile")
		wantProfiles["test"] = setPrefs(t, "test", false)
		wantCurProfile = "test"
		checkProfiles(t)
	}

	t.Logf("Recreate profile manager from store, should reset prefs")
	// Recreate the profile manager to ensure that it can load the profiles
	// from the store at startup.
	pm, err = newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "windows")
	if err != nil {
		t.Fatal(err)
	}
	wantCurProfile = ""
	wantProfiles[""] = defaultPrefs
	checkProfiles(t)

	{
		t.Logf("Set user1 as current user")
		pm.SetCurrentUserID(uid)
		wantCurProfile = "test"
	}
	checkProfiles(t)
	{
		t.Logf("set unattended mode")
		wantProfiles["test"] = setPrefs(t, "test", true)
	}
	if pm.CurrentUserID() != uid {
		t.Fatalf("CurrentUserID = %q; want %q", pm.CurrentUserID(), uid)
	}

	// Recreate the profile manager to ensure that it starts with test profile.
	pm, err = newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "windows")
	if err != nil {
		t.Fatal(err)
	}
	checkProfiles(t)
	if pm.CurrentUserID() != uid {
		t.Fatalf("CurrentUserID = %q; want %q", pm.CurrentUserID(), uid)
	}
}

// TestDefaultPrefs tests that defaultPrefs is just NewPrefs with
// LoggedOut=true (the Prefs we use before connecting to control). We shouldn't
// be putting any defaulting there, and instead put all defaults in NewPrefs.
func TestDefaultPrefs(t *testing.T) {
	p1 := ipn.NewPrefs()
	p1.LoggedOut = true
	p1.WantRunning = false
	p2 := defaultPrefs
	if !p1.View().Equals(p2) {
		t.Errorf("defaultPrefs is %s, want %s; defaultPrefs should only modify WantRunning and LoggedOut, all other defaults should be in ipn.NewPrefs.", p2.Pretty(), p1.Pretty())
	}
}

// mutPrefsFn is a function that mutates the prefs.
// Deserialization pre‑populates prefs with default (non‑zero) values.
// After saving prefs and reading them back, we may not get exactly what we set.
// For this reason, tests apply changes through a helper that mutates
// [ipn.NewPrefs] instead of hard‑coding expected values in each case.
type mutPrefsFn func(*ipn.Prefs)

type profileState struct {
	*ipn.LoginProfile
	mutPrefs mutPrefsFn
}

func (s *profileState) prefs() ipn.PrefsView {
	prefs := ipn.NewPrefs() // apply changes to the default prefs
	s.mutPrefs(prefs)
	return prefs.View()
}

type profileStateChange struct {
	*ipn.LoginProfile
	mutPrefs mutPrefsFn
	sameNode bool
}

func wantProfileChange(state profileState) profileStateChange {
	return profileStateChange{
		LoginProfile: state.LoginProfile,
		mutPrefs:     state.mutPrefs,
		sameNode:     false,
	}
}

func wantPrefsChange(state profileState) profileStateChange {
	return profileStateChange{
		LoginProfile: state.LoginProfile,
		mutPrefs:     state.mutPrefs,
		sameNode:     true,
	}
}

func makeDefaultPrefs(p *ipn.Prefs) { *p = *defaultPrefs.AsStruct() }

func makeKnownProfileState(id int, nameSuffix string, uid ipn.WindowsUserID, mutPrefs mutPrefsFn) profileState {
	lowerNameSuffix := strings.ToLower(nameSuffix)
	nid := "node-" + tailcfg.StableNodeID(lowerNameSuffix)
	up := tailcfg.UserProfile{
		ID:          tailcfg.UserID(id),
		LoginName:   fmt.Sprintf("user-%s@example.com", lowerNameSuffix),
		DisplayName: "User " + nameSuffix,
	}
	return profileState{
		LoginProfile: &ipn.LoginProfile{
			LocalUserID: uid,
			Name:        up.LoginName,
			ID:          ipn.ProfileID(fmt.Sprintf("%04X", id)),
			Key:         "profile-" + ipn.StateKey(nameSuffix),
			NodeID:      nid,
			UserProfile: up,
		},
		mutPrefs: func(p *ipn.Prefs) {
			p.Hostname = "Hostname-" + nameSuffix
			if mutPrefs != nil {
				mutPrefs(p) // apply any additional changes
			}
			p.Persist = &persist.Persist{NodeID: nid, UserProfile: up}
		},
	}
}

func TestProfileStateChangeCallback(t *testing.T) {
	t.Parallel()

	// A few well-known profiles to use in tests.
	emptyProfile := profileState{
		LoginProfile: &ipn.LoginProfile{},
		mutPrefs:     makeDefaultPrefs,
	}
	profile0000 := profileState{
		LoginProfile: &ipn.LoginProfile{ID: "0000", Key: "profile-0000"},
		mutPrefs:     makeDefaultPrefs,
	}
	profileA := makeKnownProfileState(0xA, "A", "", nil)
	profileB := makeKnownProfileState(0xB, "B", "", nil)
	profileC := makeKnownProfileState(0xC, "C", "", nil)

	aliceUserID := ipn.WindowsUserID("S-1-5-21-1-2-3-4")
	aliceEmptyProfile := profileState{
		LoginProfile: &ipn.LoginProfile{LocalUserID: aliceUserID},
		mutPrefs:     makeDefaultPrefs,
	}
	bobUserID := ipn.WindowsUserID("S-1-5-21-3-4-5-6")
	bobEmptyProfile := profileState{
		LoginProfile: &ipn.LoginProfile{LocalUserID: bobUserID},
		mutPrefs:     makeDefaultPrefs,
	}
	bobKnownProfile := makeKnownProfileState(0xB0B, "Bob", bobUserID, nil)

	tests := []struct {
		name          string
		initial       *profileState         // if non-nil, this is the initial profile and prefs to start wit
		knownProfiles []profileState        // known profiles we can switch to
		action        func(*profileManager) // action to take on the profile manager
		wantChanges   []profileStateChange  // expected state changes
	}{
		{
			name: "no-changes",
			action: func(*profileManager) {
				// do nothing
			},
			wantChanges: nil,
		},
		{
			name: "no-initial/new-profile",
			action: func(pm *profileManager) {
				// The profile manager is new and started with a new empty profile.
				// This should not trigger a state change callback.
				pm.SwitchToNewProfile()
			},
			wantChanges: nil,
		},
		{
			name: "no-initial/new-profile-for-user",
			action: func(pm *profileManager) {
				// But switching to a new profile for a specific user should trigger
				// a state change callback.
				pm.SwitchToNewProfileForUser(aliceUserID)
			},
			wantChanges: []profileStateChange{
				// We want a new empty profile (owned by the specified user)
				// and the default prefs.
				wantProfileChange(aliceEmptyProfile),
			},
		},
		{
			name:    "with-initial/new-profile",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// And so does switching to a new profile when the initial profile
				// is non-empty.
				pm.SwitchToNewProfile()
			},
			wantChanges: []profileStateChange{
				// We want a new empty profile and the default prefs.
				wantProfileChange(emptyProfile),
			},
		},
		{
			name:    "with-initial/new-profile/twice",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// If we switch to a new profile twice, we should only get one state change.
				pm.SwitchToNewProfile()
				pm.SwitchToNewProfile()
			},
			wantChanges: []profileStateChange{
				// We want a new empty profile and the default prefs.
				wantProfileChange(emptyProfile),
			},
		},
		{
			name:    "with-initial/new-profile-for-user/twice",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// Unless we switch to a new profile for a specific user,
				// in which case we should get a state change twice.
				pm.SwitchToNewProfileForUser(aliceUserID)
				pm.SwitchToNewProfileForUser(aliceUserID) // no change here
				pm.SwitchToNewProfileForUser(bobUserID)
			},
			wantChanges: []profileStateChange{
				// Both profiles are empty, but they are owned by different users.
				wantProfileChange(aliceEmptyProfile),
				wantProfileChange(bobEmptyProfile),
			},
		},
		{
			name:    "with-initial/new-profile/twice/with-prefs-change",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// Or unless we switch to a new profile, change the prefs,
				// then switch to a new profile again. Since the current
				// profile is not empty after the prefs change, we should
				// get state changes for all three actions.
				pm.SwitchToNewProfile()
				p := pm.CurrentPrefs().AsStruct()
				p.WantRunning = true
				pm.SetPrefs(p.View(), ipn.NetworkProfile{})
				pm.SwitchToNewProfile()
			},
			wantChanges: []profileStateChange{
				wantProfileChange(emptyProfile), // new empty profile
				wantPrefsChange(profileState{ // prefs change, same profile
					LoginProfile: &ipn.LoginProfile{},
					mutPrefs: func(p *ipn.Prefs) {
						*p = *defaultPrefs.AsStruct()
						p.WantRunning = true
					},
				}),
				wantProfileChange(emptyProfile), // new empty profile again
			},
		},
		{
			name:          "switch-to-profile/by-id",
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// Switching to a known profile by ID should trigger a state change callback.
				pm.SwitchToProfileByID(profileB.ID)
			},
			wantChanges: []profileStateChange{
				wantProfileChange(profileB),
			},
		},
		{
			name:          "switch-to-profile/by-id/non-existent",
			knownProfiles: []profileState{profileA, profileC}, // no profileB
			action: func(pm *profileManager) {
				// Switching to a non-existent profile should fail and not trigger a state change callback.
				pm.SwitchToProfileByID(profileB.ID)
			},
			wantChanges: []profileStateChange{},
		},
		{
			name:          "switch-to-profile/by-id/twice-same",
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// But only for the first switch.
				// The second switch to the same profile should not trigger a state change callback.
				pm.SwitchToProfileByID(profileB.ID)
				pm.SwitchToProfileByID(profileB.ID)
			},
			wantChanges: []profileStateChange{
				wantProfileChange(profileB),
			},
		},
		{
			name:          "switch-to-profile/by-id/many",
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// Same idea, but with multiple switches.
				pm.SwitchToProfileByID(profileB.ID) // switch to Profile-B
				pm.SwitchToProfileByID(profileB.ID) // then to Profile-B again (no change)
				pm.SwitchToProfileByID(profileC.ID) // then to Profile-C (change)
				pm.SwitchToProfileByID(profileA.ID) // then to Profile-A (change)
				pm.SwitchToProfileByID(profileB.ID) // then to Profile-B (change)
			},
			wantChanges: []profileStateChange{
				wantProfileChange(profileB),
				wantProfileChange(profileC),
				wantProfileChange(profileA),
				wantProfileChange(profileB),
			},
		},
		{
			name:          "switch-to-profile/by-view",
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// Switching to a known profile by an [ipn.LoginProfileView]
				// should also trigger a state change callback.
				pm.SwitchToProfile(profileB.View())
			},
			wantChanges: []profileStateChange{
				wantProfileChange(profileB),
			},
		},
		{
			name:    "switch-to-profile/by-view/empty",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// SwitchToProfile supports switching to an empty profile.
				emptyProfile := &ipn.LoginProfile{}
				pm.SwitchToProfile(emptyProfile.View())
			},
			wantChanges: []profileStateChange{
				wantProfileChange(emptyProfile),
			},
		},
		{
			name:          "switch-to-profile/by-view/non-existent",
			knownProfiles: []profileState{profileA, profileC},
			action: func(pm *profileManager) {
				// Switching to a an unknown profile by an [ipn.LoginProfileView]
				// should fail and not trigger a state change callback.
				pm.SwitchToProfile(profileB.View())
			},
			wantChanges: []profileStateChange{},
		},
		{
			name:    "switch-to-profile/by-view/empty-for-user",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// And switching to an empty profile for a specific user also works.
				pm.SwitchToProfile(bobEmptyProfile.View())
			},
			wantChanges: []profileStateChange{
				wantProfileChange(bobEmptyProfile),
			},
		},
		{
			name:    "switch-to-profile/by-view/invalid",
			initial: &profile0000,
			action: func(pm *profileManager) {
				// Switching to an invalid profile should create and switch
				// to a new empty profile.
				pm.SwitchToProfile(ipn.LoginProfileView{})
			},
			wantChanges: []profileStateChange{
				wantProfileChange(emptyProfile),
			},
		},
		{
			name:          "delete-profile/current",
			initial:       &profileA, // profileA is the current profile
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// Deleting the current profile should switch to a new empty profile.
				pm.DeleteProfile(profileA.ID)
			},
			wantChanges: []profileStateChange{
				wantProfileChange(emptyProfile),
			},
		},
		{
			name:          "delete-profile/current-with-user",
			initial:       &bobKnownProfile,
			knownProfiles: []profileState{profileA, profileB, profileC, bobKnownProfile},
			action: func(pm *profileManager) {
				// Similarly, deleting the current profile for a specific user should switch
				// to a new empty profile for that user (at least while the "current user"
				// is still a thing on Windows).
				pm.DeleteProfile(bobKnownProfile.ID)
			},
			wantChanges: []profileStateChange{
				wantProfileChange(bobEmptyProfile),
			},
		},
		{
			name:          "delete-profile/non-current",
			initial:       &profileA, // profileA is the current profile
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// But deleting a non-current profile should not trigger a state change callback.
				pm.DeleteProfile(profileB.ID)
			},
			wantChanges: []profileStateChange{},
		},
		{
			name:    "set-prefs/new-profile",
			initial: &emptyProfile, // the current profile is empty
			action: func(pm *profileManager) {
				// The current profile is new and empty, but we can still set p.
				// This should trigger a state change callback.
				p := pm.CurrentPrefs().AsStruct()
				p.WantRunning = true
				p.Hostname = "New-Hostname"
				pm.SetPrefs(p.View(), ipn.NetworkProfile{})
			},
			wantChanges: []profileStateChange{
				// Still an empty profile, but with new prefs.
				wantPrefsChange(profileState{
					LoginProfile: emptyProfile.LoginProfile,
					mutPrefs: func(p *ipn.Prefs) {
						*p = *emptyProfile.prefs().AsStruct()
						p.WantRunning = true
						p.Hostname = "New-Hostname"
					},
				}),
			},
		},
		{
			name:          "set-prefs/current-profile",
			initial:       &profileA, // profileA is the current profile
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				p := pm.CurrentPrefs().AsStruct()
				p.WantRunning = true
				p.Hostname = "New-Hostname"
				pm.SetPrefs(p.View(), ipn.NetworkProfile{})
			},
			wantChanges: []profileStateChange{
				wantPrefsChange(profileState{
					LoginProfile: profileA.LoginProfile, // same profile
					mutPrefs: func(p *ipn.Prefs) { // but with new prefs
						*p = *profileA.prefs().AsStruct()
						p.WantRunning = true
						p.Hostname = "New-Hostname"
					},
				}),
			},
		},
		{
			name:          "set-prefs/current-profile/profile-name",
			initial:       &profileA, // profileA is the current profile
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				p := pm.CurrentPrefs().AsStruct()
				p.ProfileName = "This is User A"
				pm.SetPrefs(p.View(), ipn.NetworkProfile{})
			},
			wantChanges: []profileStateChange{
				// Still the same profile, but with a new profile name
				// populated from the prefs. The prefs are also updated.
				wantPrefsChange(profileState{
					LoginProfile: func() *ipn.LoginProfile {
						p := profileA.Clone()
						p.Name = "This is User A"
						return p
					}(),
					mutPrefs: func(p *ipn.Prefs) {
						*p = *profileA.prefs().AsStruct()
						p.ProfileName = "This is User A"
					},
				}),
			},
		},
		{
			name:          "set-prefs/implicit-switch/from-new",
			initial:       &emptyProfile, // a new, empty profile
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// The user attempted to add a new profile but actually logged in as the same
				// node/user as profileB. When [LocalBackend.SetControlClientStatus] calls
				// [profileManager.SetPrefs] with the [persist.Persist] for profileB, we
				// implicitly switch to that profile instead of creating a duplicate for the
				// same node/user.
				//
				// TODO(nickkhyl): currently, [LocalBackend.SetControlClientStatus] uses the p
				// of the current profile, not those of the profile we switch to. This is all wrong
				// and should be fixed. But for now, we just test that the state change callback
				// is called with the new profile and p.
				p := pm.CurrentPrefs().AsStruct()
				p.Persist = profileB.prefs().Persist().AsStruct()
				p.WantRunning = true
				p.LoggedOut = false
				pm.SetPrefs(p.View(), ipn.NetworkProfile{})
			},
			wantChanges: []profileStateChange{
				// Calling [profileManager.SetPrefs] like this is effectively a profile switch
				// rather than a prefs change.
				wantProfileChange(profileState{
					LoginProfile: profileB.LoginProfile,
					mutPrefs: func(p *ipn.Prefs) {
						*p = *emptyProfile.prefs().AsStruct()
						p.Persist = profileB.prefs().Persist().AsStruct()
						p.WantRunning = true
						p.LoggedOut = false
					},
				}),
			},
		},
		{
			name:          "set-prefs/implicit-switch/from-other",
			initial:       &profileA, // profileA is the current profile
			knownProfiles: []profileState{profileA, profileB, profileC},
			action: func(pm *profileManager) {
				// Same idea, but the current profile is profileA rather than a new empty profile.
				// Note: this is all wrong. See the comment above and [profileManager.SetPrefs].
				p := pm.CurrentPrefs().AsStruct()
				p.Persist = profileB.prefs().Persist().AsStruct()
				p.WantRunning = true
				p.LoggedOut = false
				pm.SetPrefs(p.View(), ipn.NetworkProfile{})
			},
			wantChanges: []profileStateChange{
				wantProfileChange(profileState{
					LoginProfile: profileB.LoginProfile,
					mutPrefs: func(p *ipn.Prefs) {
						*p = *profileA.prefs().AsStruct()
						p.Persist = profileB.prefs().Persist().AsStruct()
						p.WantRunning = true
						p.LoggedOut = false
					},
				}),
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			store := new(mem.Store)
			pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
			if err != nil {
				t.Fatalf("newProfileManagerWithGOOS: %v", err)
			}
			for _, p := range tt.knownProfiles {
				pm.writePrefsToStore(p.Key, p.prefs())
				pm.knownProfiles[p.ID] = p.View()
			}
			if err := pm.writeKnownProfiles(); err != nil {
				t.Fatalf("writeKnownProfiles: %v", err)
			}

			if tt.initial != nil {
				pm.currentUserID = tt.initial.LocalUserID
				pm.currentProfile = tt.initial.View()
				pm.prefs = tt.initial.prefs()
			}

			type stateChange struct {
				Profile  *ipn.LoginProfile
				Prefs    *ipn.Prefs
				SameNode bool
			}
			wantChanges := make([]stateChange, 0, len(tt.wantChanges))
			for _, w := range tt.wantChanges {
				wantPrefs := ipn.NewPrefs()
				w.mutPrefs(wantPrefs) // apply changes to the default prefs
				wantChanges = append(wantChanges, stateChange{
					Profile:  w.LoginProfile,
					Prefs:    wantPrefs,
					SameNode: w.sameNode,
				})
			}

			gotChanges := make([]stateChange, 0, len(tt.wantChanges))
			pm.StateChangeHook = func(profile ipn.LoginProfileView, prefView ipn.PrefsView, sameNode bool) {
				prefs := prefView.AsStruct()
				prefs.Sync = prefs.Sync.Normalized()
				gotChanges = append(gotChanges, stateChange{
					Profile:  profile.AsStruct(),
					Prefs:    prefs,
					SameNode: sameNode,
				})
			}

			tt.action(pm)

			if diff := cmp.Diff(wantChanges, gotChanges, defaultCmpOpts...); diff != "" {
				t.Errorf("StateChange callbacks: (-want +got): %v", diff)
			}
		})
	}
}

func TestProfileBadAttestationKey(t *testing.T) {
	store := new(mem.Store)
	pm, err := newProfileManagerWithGOOS(store, t.Logf, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	fk := new(failingHardwareAttestationKey)
	pm.newEmptyHardwareAttestationKey = func() (key.HardwareAttestationKey, error) {
		return fk, nil
	}
	sk := ipn.StateKey(t.Name())
	if err := pm.store.WriteState(sk, []byte(`{"Config": {"AttestationKey": {}}}`)); err != nil {
		t.Fatal(err)
	}
	prefs, err := pm.loadSavedPrefs(sk)
	if err != nil {
		t.Fatal(err)
	}
	ak := prefs.Persist().AsStruct().AttestationKey
	if _, ok := ak.(noopAttestationKey); !ok {
		t.Errorf("loaded attestation key of type %T, want noopAttestationKey", ak)
	}
	if !fk.unmarshalCalled {
		t.Error("UnmarshalJSON was not called on failingHardwareAttestationKey")
	}
}

type failingHardwareAttestationKey struct {
	noopAttestationKey
	unmarshalCalled bool
}

func (k *failingHardwareAttestationKey) UnmarshalJSON([]byte) error {
	k.unmarshalCalled = true
	return errors.New("failed to unmarshal attestation key!")
}

func TestDeleteProfileClearsState(t *testing.T) {
	store := new(mem.Store)

	pm, err := newProfileManagerWithGOOS(store, logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}

	pm.SetCurrentUserID("user1")
	pm.SwitchToNewProfile()
	p := pm.CurrentPrefs().AsStruct()
	p.Persist = &persist.Persist{
		NodeID:         "node1",
		PrivateNodeKey: key.NewNode(),
		UserProfile: tailcfg.UserProfile{
			ID:        1,
			LoginName: "user@example.com",
		},
	}
	if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
		t.Fatal(err)
	}

	profileKey := pm.currentProfile.Key()
	if profileKey == "" {
		t.Fatal("profile key is empty")
	}

	// Verify profile state exists in store.
	if _, err := store.ReadState(profileKey); err != nil {
		t.Fatalf("ReadState before delete: %v", err)
	}

	profileID := pm.currentProfile.ID()
	if err := pm.DeleteProfile(profileID); err != nil {
		t.Fatal(err)
	}

	// Verify profile state is deleted from store.
	if _, err := store.ReadState(profileKey); err != ipn.ErrStateNotExist {
		t.Fatalf("ReadState after delete: got err %v, want ErrStateNotExist", err)
	}
}

// TestProfileSortOrder verifies that allProfilesFor sorts zero-Created
// (legacy) profiles before stamped profiles, with stamped profiles
// ordered oldest-first so the most recently added one lands at the
// bottom. Name then DomainName break ties within either group.
func TestProfileSortOrder(t *testing.T) {
	pm, err := newProfileManagerWithGOOS(new(mem.Store), logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}

	base := time.Date(2026, 6, 23, 12, 0, 0, 0, time.UTC)
	add := func(id ipn.ProfileID, name, domain string, created time.Time) {
		pm.knownProfiles[id] = (&ipn.LoginProfile{
			ID:             id,
			Name:           name,
			NetworkProfile: ipn.NetworkProfile{DomainName: domain},
			Created:        created,
		}).View()
	}

	add("a", "alice", "example.com", time.Time{})
	add("a2", "alice", "acme.com", time.Time{}) // legacy ties alice on Name; DomainName breaks it
	add("b", "bob", "example.com", time.Time{})
	add("c", "carol", "example.com", base)
	add("d", "dave", "example.com", base.Add(time.Minute))
	add("e", "eve", "example.com", base.Add(time.Minute)) // ties dave on Created; Name breaks it
	add("e2", "eve", "acme.com", base.Add(time.Minute))   // ties eve on Created+Name; DomainName breaks it

	got := pm.allProfilesFor("")
	type want struct{ name, domain string }
	wantOrder := []want{
		// Legacy first, Name asc then DomainName asc.
		{"alice", "acme.com"},
		{"alice", "example.com"},
		{"bob", "example.com"},
		// Stamped, oldest first.
		{"carol", "example.com"},
		{"dave", "example.com"},
		{"eve", "acme.com"},
		{"eve", "example.com"},
	}
	if len(got) != len(wantOrder) {
		t.Fatalf("got %d profiles, want %d", len(got), len(wantOrder))
	}
	for i, w := range wantOrder {
		if got[i].Name() != w.name || got[i].NetworkProfile().DomainName != w.domain {
			t.Errorf("position %d: got (%q,%q), want (%q,%q) (full: %v)",
				i, got[i].Name(), got[i].NetworkProfile().DomainName, w.name, w.domain, profileNames(got))
		}
	}
}

func profileNames(ps []ipn.LoginProfileView) []string {
	out := make([]string, len(ps))
	for i, p := range ps {
		out[i] = p.Name()
	}
	return out
}

// TestProfileCreatedStamped verifies that Created is set on profile creation
// from the injected clock, and is preserved across an update even when the
// clock advances.
func TestProfileCreatedStamped(t *testing.T) {
	pm, err := newProfileManagerWithGOOS(new(mem.Store), logger.Discard, health.NewTracker(eventbustest.NewBus(t)), "linux")
	if err != nil {
		t.Fatal(err)
	}
	start := time.Date(2026, 6, 23, 12, 0, 0, 0, time.UTC)
	clock := tstest.NewClock(tstest.ClockOpts{Start: start})
	pm.clock = tstime.DefaultClock{Clock: clock}

	pm.SwitchToNewProfile()
	p := pm.CurrentPrefs().AsStruct()
	p.Persist = &persist.Persist{
		NodeID:         "n1",
		PrivateNodeKey: key.NewNode(),
		UserProfile: tailcfg.UserProfile{
			ID:        1,
			LoginName: "alice@example.com",
		},
	}
	if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
		t.Fatal(err)
	}

	if got := pm.currentProfile.Created(); !got.Equal(start) {
		t.Errorf("Created = %v after create, want %v", got, start)
	}

	// Advancing the clock and then performing an unrelated update (e.g.
	// ProfileName change) must not move Created.
	clock.Advance(time.Hour)
	p = pm.CurrentPrefs().AsStruct()
	p.ProfileName = "Alice"
	if err := pm.SetPrefs(p.View(), ipn.NetworkProfile{}); err != nil {
		t.Fatal(err)
	}
	if got := pm.currentProfile.Created(); !got.Equal(start) {
		t.Errorf("Created changed across update: got %v, want %v", got, start)
	}
}