diff --git a/management/server/account_test.go b/management/server/account_test.go
index d211973c2..5b4b1cc17 100644
--- a/management/server/account_test.go
+++ b/management/server/account_test.go
@@ -462,30 +462,15 @@ func TestDefaultAccountManager_GetAccountFromToken(t *testing.T) {
 func TestAccountManager_GetAccountFromPAT(t *testing.T) {
 	store := newStore(t)
 	account := newAccountWithId("account_id", "testuser", "")
-	account.Peers["testpeer"] = &Peer{
-		Key:      "peerkey",
-		SetupKey: "peerkeysetupkey",
-		IP:       net.IP{127, 0, 0, 1},
-		Meta:     PeerSystemMeta{},
-		Name:     "peer name",
-		Status:   &PeerStatus{Connected: true, LastSeen: time.Now()},
-	}
 
 	token := "nbp_9999EUDNdkeusjentDLSJEn1902u84390W6W"
 	hashedToken := sha256.Sum256([]byte(token))
 	account.Users["someUser"] = &User{
-		Id:         "someUser",
-		Role:       "",
-		AutoGroups: nil,
+		Id: "someUser",
 		PATs: map[string]*PersonalAccessToken{
 			"pat1": {
-				ID:             "tokenId",
-				Description:    "some Description",
-				HashedToken:    string(hashedToken[:]),
-				ExpirationDate: time.Time{},
-				CreatedBy:      "testuser",
-				CreatedAt:      time.Time{},
-				LastUsed:       time.Time{},
+				ID:          "tokenId",
+				HashedToken: string(hashedToken[:]),
 			},
 		},
 	}
@@ -495,18 +480,7 @@ func TestAccountManager_GetAccountFromPAT(t *testing.T) {
 	}
 
 	am := DefaultAccountManager{
-		Store:                   store,
-		cacheMux:                sync.Mutex{},
-		cacheLoading:            nil,
-		peersUpdateManager:      nil,
-		idpManager:              nil,
-		cacheManager:            nil,
-		ctx:                     nil,
-		eventStore:              nil,
-		singleAccountMode:       false,
-		singleAccountModeDomain: "",
-		dnsDomain:               "",
-		peerLoginExpiry:         nil,
+		Store: store,
 	}
 
 	account, user, err := am.GetAccountFromPAT(token)
diff --git a/management/server/user_test.go b/management/server/user_test.go
index b3cd1db9a..20f2ca4f1 100644
--- a/management/server/user_test.go
+++ b/management/server/user_test.go
@@ -1,101 +1,66 @@
 package server
 
 import (
-	"net"
-	"sync"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 )
 
+const (
+	mockAccountID = "accountID"
+	mockUserID    = "userID"
+	mockTokenID   = "tokenID"
+	mockToken     = "SoMeHaShEdToKeN"
+)
+
 func TestUser_AddPATToUser(t *testing.T) {
 	store := newStore(t)
-	account := newAccountWithId("account_id", "testuser", "")
-	account.Peers["testpeer"] = &Peer{
-		Key:      "peerkey",
-		SetupKey: "peerkeysetupkey",
-		IP:       net.IP{127, 0, 0, 1},
-		Meta:     PeerSystemMeta{},
-		Name:     "peer name",
-		Status:   &PeerStatus{Connected: true, LastSeen: time.Now()},
-	}
+	account := newAccountWithId(mockAccountID, mockUserID, "")
+
 	err := store.SaveAccount(account)
 	if err != nil {
 		t.Fatalf("Error when saving account: %s", err)
 	}
 
 	am := DefaultAccountManager{
-		Store:                   store,
-		cacheMux:                sync.Mutex{},
-		cacheLoading:            nil,
-		peersUpdateManager:      nil,
-		idpManager:              nil,
-		cacheManager:            nil,
-		ctx:                     nil,
-		eventStore:              nil,
-		singleAccountMode:       false,
-		singleAccountModeDomain: "",
-		dnsDomain:               "",
-		peerLoginExpiry:         nil,
+		Store: store,
 	}
 
-	token := "someToken"
 	pat := PersonalAccessToken{
-		ID:             "tokenID",
-		Description:    "some Description",
-		HashedToken:    token,
-		ExpirationDate: time.Time{},
-		CreatedBy:      "testuser",
-		CreatedAt:      time.Time{},
-		LastUsed:       time.Time{},
+		ID:          mockTokenID,
+		HashedToken: mockToken,
 	}
 
-	err = am.AddPATToUser("account_id", "testuser", &pat)
+	err = am.AddPATToUser(mockAccountID, mockUserID, &pat)
 	if err != nil {
 		t.Fatalf("Error when adding PAT to user: %s", err)
 	}
 
 	fileStore := am.Store.(*FileStore)
-	tokenID := fileStore.HashedPAT2TokenID[token[:]]
+	tokenID := fileStore.HashedPAT2TokenID[mockToken[:]]
 
 	if tokenID == "" {
 		t.Fatal("GetTokenIDByHashedToken failed after adding PAT")
 	}
 
-	assert.Equal(t, "tokenID", tokenID)
+	assert.Equal(t, mockTokenID, tokenID)
 
 	userID := fileStore.TokenID2UserID[tokenID]
 	if userID == "" {
 		t.Fatal("GetUserByTokenId failed after adding PAT")
 	}
-	assert.Equal(t, "testuser", userID)
+	assert.Equal(t, mockUserID, userID)
 }
 
 func TestUser_DeletePAT(t *testing.T) {
 	store := newStore(t)
-	account := newAccountWithId("account_id", "testuser", "")
-	account.Peers["testpeer"] = &Peer{
-		Key:      "peerkey",
-		SetupKey: "peerkeysetupkey",
-		IP:       net.IP{127, 0, 0, 1},
-		Meta:     PeerSystemMeta{},
-		Name:     "peer name",
-		Status:   &PeerStatus{Connected: true, LastSeen: time.Now()},
-	}
-	account.Users["user1"] = &User{
-		Id:         "user1",
-		Role:       "admin",
-		AutoGroups: nil,
+	account := newAccountWithId(mockAccountID, mockUserID, "")
+	account.Users[mockUserID] = &User{
+		Id: mockUserID,
 		PATs: map[string]*PersonalAccessToken{
-			"tokenID": {
-				ID:             "tokenID",
-				Description:    "some Description",
-				HashedToken:    "SoMeHaShEdToKeN",
-				ExpirationDate: time.Now().AddDate(0, 0, 7),
-				CreatedBy:      "user1",
-				CreatedAt:      time.Now(),
-				LastUsed:       time.Now(),
+			mockTokenID: {
+				ID:          mockTokenID,
+				HashedToken: mockToken,
 			},
 		},
 	}
@@ -105,26 +70,15 @@ func TestUser_DeletePAT(t *testing.T) {
 	}
 
 	am := DefaultAccountManager{
-		Store:                   store,
-		cacheMux:                sync.Mutex{},
-		cacheLoading:            nil,
-		peersUpdateManager:      nil,
-		idpManager:              nil,
-		cacheManager:            nil,
-		ctx:                     nil,
-		eventStore:              nil,
-		singleAccountMode:       false,
-		singleAccountModeDomain: "",
-		dnsDomain:               "",
-		peerLoginExpiry:         nil,
+		Store: store,
 	}
 
-	err = am.DeletePAT("account_id", "user1", "tokenID")
+	err = am.DeletePAT(mockAccountID, mockUserID, mockTokenID)
 	if err != nil {
 		t.Fatalf("Error when adding PAT to user: %s", err)
 	}
 
-	assert.Nil(t, store.Accounts["account_id"].Users["user1"].PATs["tokenID"])
-	assert.Empty(t, store.HashedPAT2TokenID["SoMeHaShEdToKeN"])
-	assert.Empty(t, store.TokenID2UserID["tokenID"])
+	assert.Nil(t, store.Accounts[mockAccountID].Users[mockUserID].PATs[mockTokenID])
+	assert.Empty(t, store.HashedPAT2TokenID[mockToken])
+	assert.Empty(t, store.TokenID2UserID[mockTokenID])
 }