fix(client): remove token from client args

src/client/files.go

@@ -12,16 +12,16 @@ import (
 
 type FilesClient struct {
 	addr  string
-	r     *gorequest.SuperAgent
 	token *http.Cookie
+	r     *gorequest.SuperAgent
 }
 
 func NewFilesClient(addr string, token *http.Cookie) *FilesClient {
 	gr := gorequest.New()
 	return &FilesClient{
 		addr:  addr,
-		r:     gr,
 		token: token,
+		r:     gr,
 	}
 }
 

src/client/settings.go

@@ -5,21 +5,22 @@ import (
 	"fmt"
 	"net/http"
 
-	// "github.com/ihexxa/quickshare/src/db/sitestore"
 	"github.com/ihexxa/quickshare/src/handlers/settings"
 	"github.com/parnurzeal/gorequest"
 )
 
 type SettingsClient struct {
-	addr string
+	addr  string
-	r    *gorequest.SuperAgent
+	token *http.Cookie
+	r     *gorequest.SuperAgent
 }
 
-func NewSettingsClient(addr string) *SettingsClient {
+func NewSettingsClient(addr string, token *http.Cookie) *SettingsClient {
 	gr := gorequest.New()
 	return &SettingsClient{
-		addr: addr,
+		addr:  addr,
-		r:    gr,
+		token: token,
+		r:     gr,
 	}
 }
 
@@ -32,9 +33,9 @@ func (cl *SettingsClient) Health() (*http.Response, string, []error) {
 		End()
 }
 
-func (cl *SettingsClient) GetClientCfg(token *http.Cookie) (*http.Response, *settings.ClientCfgMsg, []error) {
+func (cl *SettingsClient) GetClientCfg() (*http.Response, *settings.ClientCfgMsg, []error) {
 	resp, body, errs := cl.r.Get(cl.url("/v1/settings/client")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 
 	mResp := &settings.ClientCfgMsg{}
@@ -46,23 +47,23 @@ func (cl *SettingsClient) GetClientCfg(token *http.Cookie) (*http.Response, *set
 	return resp, mResp, nil
 }
 
-func (cl *SettingsClient) SetClientCfg(cfgMsg *settings.ClientCfgMsg, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *SettingsClient) SetClientCfg(cfgMsg *settings.ClientCfgMsg) (*http.Response, string, []error) {
 	return cl.r.Patch(cl.url("/v1/settings/client")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		Send(cfgMsg).
 		End()
 }
 
-func (cl *SettingsClient) ReportErrors(reports *settings.ClientErrorReports, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *SettingsClient) ReportErrors(reports *settings.ClientErrorReports) (*http.Response, string, []error) {
 	return cl.r.Post(cl.url("/v1/settings/errors")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		Send(reports).
 		End()
 }
 
-func (cl *SettingsClient) WorkerQueueLen(token *http.Cookie) (*http.Response, *settings.WorkerQueueLenResp, []error) {
+func (cl *SettingsClient) WorkerQueueLen() (*http.Response, *settings.WorkerQueueLenResp, []error) {
 	resp, body, errs := cl.r.Get(cl.url("/v1/settings/workers/queue-len")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 
 	mResp := &settings.WorkerQueueLenResp{}

src/client/users.go

@@ -12,8 +12,9 @@ import (
 )
 
 type UsersClient struct {
-	addr string
+	addr  string
-	r    *gorequest.SuperAgent
+	token *http.Cookie
+	r     *gorequest.SuperAgent
 }
 
 func NewUsersClient(addr string) *UsersClient {
@@ -28,55 +29,72 @@ func (cl *UsersClient) url(urlpath string) string {
 	return fmt.Sprintf("%s%s", cl.addr, urlpath)
 }
 
+func (cl *UsersClient) SetToken(token *http.Cookie) {
+	cl.token = token
+}
+
+func (cl *UsersClient) Token() *http.Cookie {
+	return cl.token
+}
+
 func (cl *UsersClient) Login(user, pwd string) (*http.Response, string, []error) {
-	return cl.r.Post(cl.url("/v1/users/login")).
+	resp, body, errs := cl.r.Post(cl.url("/v1/users/login")).
 		Send(multiusers.LoginReq{
 			User: user,
 			Pwd:  pwd,
 		}).
 		End()
+
+	if len(errs) == 0 && resp.StatusCode == 200 {
+		// it may overwrite the token
+		httpResp := (*http.Response)(resp)
+		cl.token = GetCookie(httpResp.Cookies(), handlers.TokenCookie)
+	} else {
+		cl.token = &http.Cookie{}
+	}
+	return resp, body, errs
 }
 
-func (cl *UsersClient) Logout(token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) Logout() (*http.Response, string, []error) {
 	return cl.r.Post(cl.url("/v1/users/logout")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }
 
-func (cl *UsersClient) SetPwd(oldPwd, newPwd string, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) SetPwd(oldPwd, newPwd string) (*http.Response, string, []error) {
 	return cl.r.Patch(cl.url("/v1/users/pwd")).
 		Send(multiusers.SetPwdReq{
 			OldPwd: oldPwd,
 			NewPwd: newPwd,
 		}).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }
 
-func (cl *UsersClient) ForceSetPwd(userID, newPwd string, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) ForceSetPwd(userID, newPwd string) (*http.Response, string, []error) {
 	return cl.r.Patch(cl.url("/v1/users/pwd/force-set")).
 		Send(multiusers.ForceSetPwdReq{
 			ID:     userID,
 			NewPwd: newPwd,
 		}).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }
 
-func (cl *UsersClient) SetUser(ID uint64, role string, quota *db.Quota, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) SetUser(ID uint64, role string, quota *db.Quota) (*http.Response, string, []error) {
 	return cl.r.Patch(cl.url("/v1/users/")).
 		Send(multiusers.SetUserReq{
 			ID:    ID,
 			Role:  role,
 			Quota: quota,
 		}).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }
 
-func (cl *UsersClient) AddUser(name, pwd, role string, token *http.Cookie) (*http.Response, *multiusers.AddUserResp, []error) {
+func (cl *UsersClient) AddUser(name, pwd, role string) (*http.Response, *multiusers.AddUserResp, []error) {
 	resp, body, errs := cl.r.Post(cl.url("/v1/users/")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		Send(multiusers.AddUserReq{
 			Name: name,
 			Pwd:  pwd,
@@ -97,16 +115,16 @@ func (cl *UsersClient) AddUser(name, pwd, role string, token *http.Cookie) (*htt
 	return resp, auResp, errs
 }
 
-func (cl *UsersClient) DelUser(id string, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) DelUser(id string) (*http.Response, string, []error) {
 	return cl.r.Delete(cl.url("/v1/users/")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		Param(handlers.UserIDParam, id).
 		End()
 }
 
-func (cl *UsersClient) ListUsers(token *http.Cookie) (*http.Response, *multiusers.ListUsersResp, []error) {
+func (cl *UsersClient) ListUsers() (*http.Response, *multiusers.ListUsersResp, []error) {
 	resp, body, errs := cl.r.Get(cl.url("/v1/users/list")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 	if len(errs) > 0 {
 		return nil, nil, errs
@@ -121,27 +139,27 @@ func (cl *UsersClient) ListUsers(token *http.Cookie) (*http.Response, *multiuser
 	return resp, lsResp, errs
 }
 
-func (cl *UsersClient) AddRole(role string, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) AddRole(role string) (*http.Response, string, []error) {
 	return cl.r.Post(cl.url("/v1/roles/")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		Send(multiusers.AddRoleReq{
 			Role: role,
 		}).
 		End()
 }
 
-func (cl *UsersClient) DelRole(role string, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) DelRole(role string) (*http.Response, string, []error) {
 	return cl.r.Delete(cl.url("/v1/roles/")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		Send(multiusers.DelRoleReq{
 			Role: role,
 		}).
 		End()
 }
 
-func (cl *UsersClient) ListRoles(token *http.Cookie) (*http.Response, *multiusers.ListRolesResp, []error) {
+func (cl *UsersClient) ListRoles() (*http.Response, *multiusers.ListRolesResp, []error) {
 	resp, body, errs := cl.r.Get(cl.url("/v1/roles/list")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 	if len(errs) > 0 {
 		return nil, nil, errs
@@ -156,9 +174,9 @@ func (cl *UsersClient) ListRoles(token *http.Cookie) (*http.Response, *multiuser
 	return resp, lsResp, errs
 }
 
-func (cl *UsersClient) Self(token *http.Cookie) (*http.Response, *multiusers.SelfResp, []error) {
+func (cl *UsersClient) Self() (*http.Response, *multiusers.SelfResp, []error) {
 	resp, body, errs := cl.r.Get(cl.url("/v1/users/self")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 	if len(errs) > 0 {
 		return nil, nil, errs
@@ -173,26 +191,26 @@ func (cl *UsersClient) Self(token *http.Cookie) (*http.Response, *multiusers.Sel
 	return resp, selfResp, errs
 }
 
-func (cl *UsersClient) SetPreferences(prefers *db.Preferences, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) SetPreferences(prefers *db.Preferences) (*http.Response, string, []error) {
 	return cl.r.Patch(cl.url("/v1/users/preferences")).
 		Send(multiusers.SetPreferencesReq{
 			Preferences: prefers,
 		}).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }
 
-func (cl *UsersClient) IsAuthed(token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) IsAuthed() (*http.Response, string, []error) {
 	return cl.r.Get(cl.url("/v1/users/isauthed")).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }
 
-func (cl *UsersClient) ResetUsedSpace(userID uint64, token *http.Cookie) (*http.Response, string, []error) {
+func (cl *UsersClient) ResetUsedSpace(userID uint64) (*http.Response, string, []error) {
 	return cl.r.Put(cl.url("/v1/users/used-space")).
 		Send(multiusers.ResetUsedSpaceReq{
 			UserID: userID,
 		}).
-		AddCookie(token).
+		AddCookie(cl.token).
 		End()
 }

src/server/server_concurrency_test.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"sync"
@@ -48,33 +49,37 @@ func TestConcurrency(t *testing.T) {
 		t.Fatal("fail to start server")
 	}
 
-	usersCl := client.NewUsersClient(addr)
+	adminUsersCli := client.NewUsersClient(addr)
-	resp, _, errs := usersCl.Login(adminName, adminPwd)
+	resp, _, errs := adminUsersCli.Login(adminName, adminPwd)
 	if len(errs) > 0 {
 		t.Fatal(errs)
 	} else if resp.StatusCode != 200 {
 		t.Fatal(resp.StatusCode)
 	}
-	token := client.GetCookie(resp.Cookies(), q.TokenCookie)
+	adminToken := client.GetCookie(resp.Cookies(), q.TokenCookie)
 
 	userCount := 5
 	userPwd := "1234"
-	users := addUsers(t, addr, userPwd, userCount, token)
+	users := addUsers(t, addr, userPwd, userCount, adminToken)
 
 	getFilePath := func(name string, i int) string {
 		return fmt.Sprintf("%s/files/home_file_%d", name, i)
 	}
 
 	filesCount := 10
+	clientErrs := []error{}
 	mockClient := func(name, pwd string, wg *sync.WaitGroup) {
-		usersCl := client.NewUsersClient(addr)
+		defer wg.Done()
-		resp, _, errs := usersCl.Login(name, pwd)
+
+		userUsersCli := client.NewUsersClient(addr)
+		resp, _, errs := userUsersCli.Login(name, pwd)
 		if len(errs) > 0 {
-			t.Fatal(errs)
+			clientErrs = append(clientErrs, errs...)
+			return
 		} else if resp.StatusCode != 200 {
-			t.Fatal("failed to add user")
+			clientErrs = append(clientErrs, fmt.Errorf("failed to login"))
+			return
 		}
-		token := client.GetCookie(resp.Cookies(), q.TokenCookie)
 
 		files := map[string]string{}
 		content := "12345678"
@@ -82,53 +87,75 @@ func TestConcurrency(t *testing.T) {
 			files[getFilePath(name, i)] = content
 		}
 
+		userToken := userUsersCli.Token()
 		for filePath, content := range files {
-			assertUploadOK(t, filePath, content, addr, token)
+			assertUploadOK(t, filePath, content, addr, userToken)
-			assertDownloadOK(t, filePath, content, addr, token)
+			assertDownloadOK(t, filePath, content, addr, userToken)
 		}
 
-		filesCl := client.NewFilesClient(addr, token)
+		filesCl := client.NewFilesClient(addr, userToken)
 		resp, lsResp, errs := filesCl.ListHome()
 		if len(errs) > 0 {
-			t.Fatal(errs)
+			clientErrs = append(clientErrs, errs...)
+			return
 		} else if resp.StatusCode != 200 {
-			t.Fatal("failed to add user")
+			clientErrs = append(clientErrs, errors.New("failed to list home"))
+			return
 		}
 
 		if lsResp.Cwd != fmt.Sprintf("%s/files", name) {
-			t.Fatalf("incorrct cwd (%s)", lsResp.Cwd)
+			clientErrs = append(clientErrs, fmt.Errorf("incorrct cwd (%s)", lsResp.Cwd))
+			return
+
 		} else if len(lsResp.Metadatas) != len(files) {
-			t.Fatalf("incorrct metadata size (%d)", len(lsResp.Metadatas))
+			clientErrs = append(clientErrs, fmt.Errorf("incorrct metadata size (%d)", len(lsResp.Metadatas)))
+			return
 		}
 
-		resp, selfResp, errs := usersCl.Self(token)
+		resp, selfResp, errs := userUsersCli.Self()
 		if len(errs) > 0 {
-			t.Fatal(errs)
+			clientErrs = append(clientErrs, errs...)
+			return
 		} else if resp.StatusCode != 200 {
-			t.Fatal("failed to self")
+			clientErrs = append(clientErrs, errors.New("failed to self"))
+			return
 		}
 		if selfResp.UsedSpace != int64(filesCount*len(content)) {
-			t.Fatalf("usedSpace(%d) doesn't match (%d)", selfResp.UsedSpace, filesCount*len(content))
+			clientErrs = append(
+				clientErrs,
+				fmt.Errorf("usedSpace(%d) doesn't match (%d)", selfResp.UsedSpace, filesCount*len(content)),
+			)
+			return
 		}
 
 		resp, _, errs = filesCl.Delete(getFilePath(name, 0))
 		if len(errs) > 0 {
-			t.Fatal(errs)
+			clientErrs = append(clientErrs, errs...)
+			return
 		} else if resp.StatusCode != 200 {
-			t.Fatal("failed to add user")
+			clientErrs = append(clientErrs, errors.New("failed to add user"))
+			return
 		}
 
-		resp, selfResp, errs = usersCl.Self(token)
+		resp, selfResp, errs = userUsersCli.Self()
 		if len(errs) > 0 {
-			t.Fatal(errs)
+			clientErrs = append(clientErrs, errs...)
+			return
 		} else if resp.StatusCode != 200 {
-			t.Fatal("failed to self")
+			clientErrs = append(clientErrs, errors.New("failed to self"))
+			return
 		}
 		if selfResp.UsedSpace != int64((filesCount-1)*len(content)) {
-			t.Fatalf("usedSpace(%d) doesn't match (%d)", selfResp.UsedSpace, int64((filesCount-1)*len(content)))
+			clientErrs = append(
+				clientErrs,
+				fmt.Errorf(
+					"usedSpace(%d) doesn't match (%d)",
+					selfResp.UsedSpace,
+					int64((filesCount-1)*len(content)),
+				),
+			)
+			return
 		}
-
-		wg.Done()
 	}
 
 	var wg sync.WaitGroup
@@ -139,12 +166,8 @@ func TestConcurrency(t *testing.T) {
 		}
 
 		wg.Wait()
+		if len(clientErrs) > 0 {
+			t.Fatal(joinErrs(clientErrs))
+		}
 	})
-
-	resp, _, errs = usersCl.Logout(token)
-	if len(errs) > 0 {
-		t.Fatal(errs)
-	} else if resp.StatusCode != 200 {
-		t.Fatal(resp.StatusCode)
-	}
 }

src/server/server_files_test.go

@@ -70,7 +70,7 @@ func TestFileHandlers(t *testing.T) {
 		t.Fatal(resp.StatusCode)
 	}
 	token := client.GetCookie(resp.Cookies(), q.TokenCookie)
-	cl := client.NewFilesClient(addr, token)
+	adminFilesClient := client.NewFilesClient(addr, token)
 
 	var err error
 	// TODO: remove all files under home folder before testing
@@ -90,7 +90,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 		}
 
-		resp, lhResp, errs := cl.ListHome()
+		resp, lhResp, errs := adminFilesClient.ListHome()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -140,7 +140,7 @@ func TestFileHandlers(t *testing.T) {
 		}
 
 		for filePath, content := range files {
-			res, _, _ := cl.Create(filePath, int64(len([]byte(content))))
+			res, _, _ := adminFilesClient.Create(filePath, int64(len([]byte(content))))
 			if res.StatusCode != 400 {
 				t.Fatal(res.StatusCode)
 			}
@@ -169,7 +169,7 @@ func TestFileHandlers(t *testing.T) {
 					t.Fatal(err)
 				}
 
-				res, _, errs := cl.Delete(filePath)
+				res, _, errs := adminFilesClient.Delete(filePath)
 				if len(errs) > 0 {
 					t.Fatal(errs)
 				} else if res.StatusCode != 200 {
@@ -187,7 +187,7 @@ func TestFileHandlers(t *testing.T) {
 		} {
 			fileSize := int64(len([]byte(content)))
 			// create a file
-			res, _, errs := cl.Create(filePath, fileSize)
+			res, _, errs := adminFilesClient.Create(filePath, fileSize)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -217,7 +217,7 @@ func TestFileHandlers(t *testing.T) {
 
 				chunk := contentBytes[i:right]
 				chunkBase64 := base64.StdEncoding.EncodeToString(chunk)
-				res, _, errs = cl.UploadChunk(filePath, chunkBase64, int64(i))
+				res, _, errs = adminFilesClient.UploadChunk(filePath, chunkBase64, int64(i))
 				i = right
 				if len(errs) > 0 {
 					t.Fatal(errs)
@@ -226,7 +226,7 @@ func TestFileHandlers(t *testing.T) {
 				}
 
 				if int64(i) != fileSize {
-					_, statusResp, errs := cl.UploadStatus(filePath)
+					_, statusResp, errs := adminFilesClient.UploadStatus(filePath)
 					if len(errs) > 0 {
 						t.Fatal(errs)
 					} else if statusResp.Path != filePath ||
@@ -253,7 +253,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 
 			// metadata
-			_, mRes, errs := cl.Metadata(filePath)
+			_, mRes, errs := adminFilesClient.Metadata(filePath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if mRes.Name != info.Name() ||
@@ -264,7 +264,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 
 			// delete file
-			res, _, errs = cl.Delete(filePath)
+			res, _, errs = adminFilesClient.Delete(filePath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -283,7 +283,7 @@ func TestFileHandlers(t *testing.T) {
 				"f3.md": "3333333",
 			},
 		} {
-			res, _, errs := cl.Mkdir(dirPath)
+			res, _, errs := adminFilesClient.Mkdir(dirPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -300,7 +300,7 @@ func TestFileHandlers(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			_, lResp, errs := cl.List(dirPath)
+			_, lResp, errs := adminFilesClient.List(dirPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			}
@@ -320,7 +320,7 @@ func TestFileHandlers(t *testing.T) {
 		dstDir := "qs/files/move/dst"
 
 		for _, dirPath := range []string{srcDir, dstDir} {
-			res, _, errs := cl.Mkdir(dirPath)
+			res, _, errs := adminFilesClient.Mkdir(dirPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -339,7 +339,7 @@ func TestFileHandlers(t *testing.T) {
 			// fileSize := int64(len([]byte(content)))
 			assertUploadOK(t, oldPath, content, addr, token)
 
-			res, _, errs := cl.Move(oldPath, newPath)
+			res, _, errs := adminFilesClient.Move(oldPath, newPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -352,7 +352,7 @@ func TestFileHandlers(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		_, lResp, errs := cl.List(dstDir)
+		_, lResp, errs := adminFilesClient.List(dstDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		}
@@ -366,7 +366,7 @@ func TestFileHandlers(t *testing.T) {
 		}
 
 		for _, dirPath := range []string{srcDir, dstDir} {
-			res, _, errs := cl.Delete(dirPath)
+			res, _, errs := adminFilesClient.Delete(dirPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -422,31 +422,31 @@ func TestFileHandlers(t *testing.T) {
 				dirPath := filepath.Dir(filePath)
 				sharedPaths[dirPath] = true
 
-				res, _, errs := cl.AddSharing(dirPath)
+				res, _, errs := adminFilesClient.AddSharing(dirPath)
 				if len(errs) > 0 {
 					t.Fatal(errs)
 				} else if res.StatusCode != 200 {
 					t.Fatal(res.StatusCode)
 				}
 
-				res, _, errs = cl.AddSharing(filePath)
+				res, _, errs = adminFilesClient.AddSharing(filePath)
 				if res.StatusCode != 400 {
 					t.Fatal(res.StatusCode)
 				}
 
-				res, _, errs = cl.AddSharing(filepath.Join(filePath, "not_exist"))
+				res, _, errs = adminFilesClient.AddSharing(filepath.Join(filePath, "not_exist"))
 				if res.StatusCode != 500 {
 					t.Fatal(res.StatusCode)
 				}
 			}
 
-			res, _, errs := cl.AddSharing("/")
+			res, _, errs := adminFilesClient.AddSharing("/")
 			if res.StatusCode != 403 {
 				t.Fatal(res.StatusCode)
 			}
 
 			// check listSharings
-			res, shRes, errs := cl.ListSharingIDs()
+			res, shRes, errs := adminFilesClient.ListSharingIDs()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -510,7 +510,7 @@ func TestFileHandlers(t *testing.T) {
 			for filePath := range files {
 				dirPath := filepath.Dir(filePath)
 
-				res, _, errs := cl.DelSharing(dirPath)
+				res, _, errs := adminFilesClient.DelSharing(dirPath)
 				if len(errs) > 0 {
 					t.Fatal(errs)
 				} else if res.StatusCode != 200 {
@@ -519,7 +519,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 
 			// check listSharings
-			res, shRes, errs = cl.ListSharingIDs()
+			res, shRes, errs = adminFilesClient.ListSharingIDs()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -613,7 +613,7 @@ func TestFileHandlers(t *testing.T) {
 
 	t.Run("test uploading APIs: ListUploadings, Create, ListUploadings, DelUploading", func(t *testing.T) {
 		// it should return no error even no file is uploaded
-		res, lResp, errs := cl.ListUploadings()
+		res, lResp, errs := adminFilesClient.ListUploadings()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
@@ -627,7 +627,7 @@ func TestFileHandlers(t *testing.T) {
 
 		for filePath, content := range files {
 			fileSize := int64(len([]byte(content)))
-			res, _, errs := cl.Create(filePath, fileSize)
+			res, _, errs := adminFilesClient.Create(filePath, fileSize)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -635,7 +635,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 		}
 
-		res, lResp, errs = cl.ListUploadings()
+		res, lResp, errs = adminFilesClient.ListUploadings()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
@@ -658,7 +658,7 @@ func TestFileHandlers(t *testing.T) {
 		}
 
 		for filePath := range files {
-			res, _, errs := cl.DelUploading(filePath)
+			res, _, errs := adminFilesClient.DelUploading(filePath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -666,7 +666,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 		}
 
-		res, lResp, errs = cl.ListUploadings()
+		res, lResp, errs = adminFilesClient.ListUploadings()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
@@ -685,7 +685,7 @@ func TestFileHandlers(t *testing.T) {
 
 		for filePath, content := range files {
 			fileSize := int64(len([]byte(content)))
-			res, _, errs := cl.Create(filePath, fileSize)
+			res, _, errs := adminFilesClient.Create(filePath, fileSize)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -699,7 +699,7 @@ func TestFileHandlers(t *testing.T) {
 			offset := int64(0)
 			for _, chunk := range chunks {
 				base64Content := base64.StdEncoding.EncodeToString(chunk)
-				res, bodyStr, errs := cl.UploadChunk(filePath, base64Content, offset)
+				res, bodyStr, errs := adminFilesClient.UploadChunk(filePath, base64Content, offset)
 				offset += int64(len(chunk))
 
 				if len(errs) > 0 {
@@ -715,7 +715,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 
 			// metadata
-			_, mRes, errs := cl.Metadata(filePath)
+			_, mRes, errs := adminFilesClient.Metadata(filePath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if mRes.Size != fileSize {
@@ -737,7 +737,7 @@ func TestFileHandlers(t *testing.T) {
 
 		for filePath, content := range files {
 			fileSize := int64(len([]byte(content)))
-			res, _, errs := cl.Create(filePath, fileSize)
+			res, _, errs := adminFilesClient.Create(filePath, fileSize)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -755,7 +755,7 @@ func TestFileHandlers(t *testing.T) {
 			offset := int64(0)
 			for _, chunk := range chunks {
 				base64Content := base64.StdEncoding.EncodeToString(chunk)
-				res, _, errs := cl.UploadChunk(filePath, base64Content, offset)
+				res, _, errs := adminFilesClient.UploadChunk(filePath, base64Content, offset)
 				offset += int64(len(chunk))
 
 				if len(errs) > 0 {
@@ -771,7 +771,7 @@ func TestFileHandlers(t *testing.T) {
 			}
 
 			// metadata
-			_, mRes, errs := cl.Metadata(filePath)
+			_, mRes, errs := adminFilesClient.Metadata(filePath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if mRes.Size != fileSize {
@@ -793,7 +793,7 @@ func TestFileHandlers(t *testing.T) {
 		srcDir := "qs/files/folder/move/src"
 		dstDir := "qs/files/folder/move/dst"
 
-		res, _, errs := cl.Mkdir(srcDir)
+		res, _, errs := adminFilesClient.Mkdir(srcDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
@@ -810,21 +810,21 @@ func TestFileHandlers(t *testing.T) {
 			assertUploadOK(t, oldPath, content, addr, token)
 		}
 
-		res, _, errs = cl.AddSharing(srcDir)
+		res, _, errs = adminFilesClient.AddSharing(srcDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
 			t.Fatal(res.StatusCode)
 		}
 
-		res, _, errs = cl.Move(srcDir, dstDir)
+		res, _, errs = adminFilesClient.Move(srcDir, dstDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
 			t.Fatal(res.StatusCode)
 		}
 
-		res, _, errs = cl.IsSharing(dstDir)
+		res, _, errs = adminFilesClient.IsSharing(dstDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 404 { // should not be in sharing
@@ -836,7 +836,7 @@ func TestFileHandlers(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		_, lResp, errs := cl.List(dstDir)
+		_, lResp, errs := adminFilesClient.List(dstDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		}
@@ -906,7 +906,7 @@ func TestFileHandlers(t *testing.T) {
 		}
 
 		keywords := []string{"keyword1", "keyword2"}
-		resp, searchItemsResp, errs := cl.SearchItems(keywords)
+		resp, searchItemsResp, errs := adminFilesClient.SearchItems(keywords)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -933,14 +933,14 @@ func TestFileHandlers(t *testing.T) {
 
 		// delete paths
 		for pathname := range toDelete {
-			resp, _, errs := cl.Delete(pathname)
+			resp, _, errs := adminFilesClient.Delete(pathname)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 		}
-		resp, searchItemsResp, errs = cl.SearchItems(keywords)
+		resp, searchItemsResp, errs = adminFilesClient.SearchItems(keywords)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -954,21 +954,21 @@ func TestFileHandlers(t *testing.T) {
 		// move paths
 		for oldPath, newPath := range toMove {
 			newPathDir := filepath.Dir(newPath)
-			resp, _, errs := cl.Mkdir(newPathDir)
+			resp, _, errs := adminFilesClient.Mkdir(newPathDir)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 
-			resp, _, errs = cl.Move(oldPath, newPath)
+			resp, _, errs = adminFilesClient.Move(oldPath, newPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 		}
-		resp, searchItemsResp, errs = cl.SearchItems(keywords)
+		resp, searchItemsResp, errs = adminFilesClient.SearchItems(keywords)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -1000,16 +1000,16 @@ func TestFileHandlers(t *testing.T) {
 		}
 		fs.Sync()
 
-		resp, _, errs := cl.Reindex()
+		resp, _, errs := adminFilesClient.Reindex()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		settingsCl := client.NewSettingsClient(addr)
+		settingsCl := client.NewSettingsClient(addr, token)
 		for {
-			reportResp, wqResp, errs := settingsCl.WorkerQueueLen(token)
+			reportResp, wqResp, errs := settingsCl.WorkerQueueLen()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if reportResp.StatusCode != 200 {
@@ -1027,7 +1027,7 @@ func TestFileHandlers(t *testing.T) {
 		// still need to wait for worker finishing indexing...
 		time.Sleep(3 * time.Second)
 
-		resp, searchItemsResp, errs := cl.SearchItems([]string{"reindexkey"})
+		resp, searchItemsResp, errs := adminFilesClient.SearchItems([]string{"reindexkey"})
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -1039,7 +1039,7 @@ func TestFileHandlers(t *testing.T) {
 		}
 	})
 
-	resp, _, errs = usersCl.Logout(token)
+	resp, _, errs = usersCl.Logout()
 	if len(errs) > 0 {
 		t.Fatal(errs)
 	} else if resp.StatusCode != 200 {

src/server/server_permission_test.go

@@ -115,40 +115,41 @@ func TestPermissions(t *testing.T) {
 			tmpNewRole := "tmpNewRole"
 
 			cl := client.NewUsersClient(addr)
-			token := &http.Cookie{}
+			// token := &http.Cookie{}
 			if requireAuth {
 				resp, _, errs := cl.Login(user, pwd)
 				assertResp(t, resp, errs, 200, desc)
-				token = client.GetCookie(resp.Cookies(), q.TokenCookie)
+				// token = client.GetCookie(resp.Cookies(), q.TokenCookie)
+				// token = cl.Token()
 			} else {
 				resp, _, errs := cl.Login(user, pwd)
 				assertResp(t, resp, errs, 403, desc)
 			}
 
-			resp, _, errs := cl.SetPwd(pwd, newPwd, token)
+			resp, _, errs := cl.SetPwd(pwd, newPwd)
 			assertResp(t, resp, errs, expectedCodes["SetPwd"], fmt.Sprintf("%s-%s", desc, "SetPwd"))
 			// set back the password
-			resp, _, errs = cl.SetPwd(newPwd, pwd, token)
+			resp, _, errs = cl.SetPwd(newPwd, pwd)
 			assertResp(t, resp, errs, expectedCodes["SetPwd"], fmt.Sprintf("%s-%s", desc, "SetPwd"))
 
-			resp, selfResp, errs := cl.Self(token)
+			resp, selfResp, errs := cl.Self()
 			assertResp(t, resp, errs, expectedCodes["Self"], fmt.Sprintf("%s-%s", desc, "Self"))
 
 			prefer := selfResp.Preferences
 
-			resp, _, errs = cl.SetPreferences(prefer, token)
+			resp, _, errs = cl.SetPreferences(prefer)
 			assertResp(t, resp, errs, expectedCodes["SetPreferences"], fmt.Sprintf("%s-%s", desc, "SetPreferences"))
 
-			resp, _, errs = cl.IsAuthed(token)
+			resp, _, errs = cl.IsAuthed()
 			assertResp(t, resp, errs, expectedCodes["IsAuthed"], fmt.Sprintf("%s-%s", desc, "IsAuthed"))
 
 			// user management
-			resp, addUserResp, errs := cl.AddUser(tmpUser, tmpPwd, tmpRole, token)
+			resp, addUserResp, errs := cl.AddUser(tmpUser, tmpPwd, tmpRole)
 			assertResp(t, resp, errs, expectedCodes["AddUser"], fmt.Sprintf("%s-%s", desc, "AddUser"))
-			resp, addAdminResp, errs := cl.AddUser(tmpAdmin, tmpAdminPwd, db.AdminRole, token)
+			resp, addAdminResp, errs := cl.AddUser(tmpAdmin, tmpAdminPwd, db.AdminRole)
 			assertResp(t, resp, errs, expectedCodes["AddUser"], fmt.Sprintf("%s-%s", desc, "AddUser"))
 
-			resp, _, errs = cl.ListUsers(token)
+			resp, _, errs = cl.ListUsers()
 			assertResp(t, resp, errs, expectedCodes["ListUsers"], fmt.Sprintf("%s-%s", desc, "ListUsers"))
 
 			// TODO: the id here should be uint64
@@ -175,48 +176,48 @@ func TestPermissions(t *testing.T) {
 				}
 			}
 
-			resp, _, errs = cl.ForceSetPwd(selfResp.ID, newPwd, token)
+			resp, _, errs = cl.ForceSetPwd(selfResp.ID, newPwd)
 			assertResp(t, resp, errs, expectedCodes["ForceSetPwd"], fmt.Sprintf("%s-%s", desc, "ForceSetPwd"))
-			resp, _, errs = cl.ForceSetPwd(selfResp.ID, pwd, token)
+			resp, _, errs = cl.ForceSetPwd(selfResp.ID, pwd)
 			assertResp(t, resp, errs, expectedCodes["ForceSetPwd"], fmt.Sprintf("%s-%s", desc, "ForceSetPwdBack"))
 
-			resp, _, errs = cl.ForceSetPwd(addUserResp.ID, newPwd, token)
+			resp, _, errs = cl.ForceSetPwd(addUserResp.ID, newPwd)
 			assertResp(t, resp, errs, expectedCodes["ForceSetPwdOther"], fmt.Sprintf("%s-%s", desc, "ForceSetPwdOther"))
-			resp, _, errs = cl.ForceSetPwd(addUserResp.ID, pwd, token)
+			resp, _, errs = cl.ForceSetPwd(addUserResp.ID, pwd)
 			assertResp(t, resp, errs, expectedCodes["ForceSetPwdOther"], fmt.Sprintf("%s-%s", desc, "ForceSetPwdOtherBack"))
 
-			resp, _, errs = cl.ForceSetPwd(addAdminResp.ID, newPwd, token)
+			resp, _, errs = cl.ForceSetPwd(addAdminResp.ID, newPwd)
 			assertResp(t, resp, errs, expectedCodes["ForceSetPwdOtherAdmin"], fmt.Sprintf("%s-%s", desc, "ForceSetPwdOtherAdmin"))
 
 			// update self
-			resp, _, errs = cl.SetUser(userID, newRole, newQuota, token)
+			resp, _, errs = cl.SetUser(userID, newRole, newQuota)
 			assertResp(t, resp, errs, expectedCodes["SetUserSelf"], fmt.Sprintf("%s-%s", desc, "SetUserSelf"))
 			// update other users
-			resp, _, errs = cl.SetUser(tmpUserID, db.AdminRole, newQuota, token)
+			resp, _, errs = cl.SetUser(tmpUserID, db.AdminRole, newQuota)
 			assertResp(t, resp, errs, expectedCodes["SetUserOthers"], fmt.Sprintf("%s-%s", desc, "SetUserOthers"))
-			resp, _, errs = cl.SetUser(tmpAdminID, db.UserRole, newQuota, token)
+			resp, _, errs = cl.SetUser(tmpAdminID, db.UserRole, newQuota)
 			assertResp(t, resp, errs, expectedCodes["SetUserOthersAdmin"], fmt.Sprintf("%s-%s", desc, "SetUserOthersAdmin"))
 
-			resp, _, errs = cl.DelUser(addUserResp.ID, token)
+			resp, _, errs = cl.DelUser(addUserResp.ID)
 			assertResp(t, resp, errs, expectedCodes["DelUser"], fmt.Sprintf("%s-%s", desc, "DelUser"))
-			resp, _, errs = cl.DelUser(addAdminResp.ID, token)
+			resp, _, errs = cl.DelUser(addAdminResp.ID)
 			assertResp(t, resp, errs, expectedCodes["DelUserAdmin"], fmt.Sprintf("%s-%s", desc, "DelUserAdmin"))
 
 			// role management
-			resp, _, errs = cl.AddRole(tmpNewRole, token)
+			resp, _, errs = cl.AddRole(tmpNewRole)
 			assertResp(t, resp, errs, expectedCodes["AddRole"], fmt.Sprintf("%s-%s", desc, "AddRole"))
 
-			resp, _, errs = cl.ListRoles(token)
+			resp, _, errs = cl.ListRoles()
 			assertResp(t, resp, errs, expectedCodes["ListRoles"], fmt.Sprintf("%s-%s", desc, "ListRoles"))
 
-			resp, _, errs = cl.DelRole(tmpNewRole, token)
+			resp, _, errs = cl.DelRole(tmpNewRole)
 			assertResp(t, resp, errs, expectedCodes["DelRole"], fmt.Sprintf("%s-%s", desc, "DelRole"))
 
 			if requireAuth {
-				resp, _, errs := cl.Logout(token)
+				resp, _, errs := cl.Logout()
 				assertResp(t, resp, errs, 200, fmt.Sprintf("%s-%s", desc, "logout"))
 			} else {
-				resp, _, errs := cl.Logout(token)
+				resp, _, errs := cl.Logout()
 				assertResp(t, resp, errs, 403, fmt.Sprintf("%s-%s", desc, "logout"))
 			}
 		}
@@ -339,7 +340,7 @@ func TestPermissions(t *testing.T) {
 			}
 
 			if requireAuth {
-				resp, _, errs := cl.Logout(token)
+				resp, _, errs := cl.Logout()
 				assertResp(t, resp, errs, 200, desc)
 			}
 		}
@@ -498,7 +499,7 @@ func TestPermissions(t *testing.T) {
 			assertResp(t, resp, errs, expectedCodes["SearchTarget"], fmt.Sprintf("%s-%s", desc, "SearchTarget"))
 
 			if requireAuth {
-				resp, _, errs := cl.Logout(token)
+				resp, _, errs := cl.Logout()
 				assertResp(t, resp, errs, 200, desc)
 			}
 		}
@@ -749,21 +750,21 @@ func TestPermissions(t *testing.T) {
 				token = client.GetCookie(resp.Cookies(), q.TokenCookie)
 			}
 
-			settingsCl := client.NewSettingsClient(addr)
+			settingsCl := client.NewSettingsClient(addr, token)
 
 			resp, _, errs := settingsCl.Health()
 			assertResp(t, resp, errs, expectedCodes["Health"], fmt.Sprintf("%s-%s", desc, "Health"))
 
-			resp, gccResp, errs := settingsCl.GetClientCfg(token)
+			resp, gccResp, errs := settingsCl.GetClientCfg()
 			assertResp(t, resp, errs, expectedCodes["GetClientCfg"], fmt.Sprintf("%s-%s", desc, "GetClientCfg"))
 
 			clientCfgMsg := gccResp
 			clientCfgMsg.ClientCfg.SiteName = "new name"
 
-			resp, _, errs = settingsCl.SetClientCfg(clientCfgMsg, token)
+			resp, _, errs = settingsCl.SetClientCfg(clientCfgMsg)
 			assertResp(t, resp, errs, expectedCodes["SetClientCfg"], fmt.Sprintf("%s-%s", desc, "SetClientCfg"))
 
-			resp, _, errs = settingsCl.ReportErrors(errReports, token)
+			resp, _, errs = settingsCl.ReportErrors(errReports)
 			assertResp(t, resp, errs, expectedCodes["ReportErrors"], fmt.Sprintf("%s-%s", desc, "ReportErrors"))
 		}
 

src/server/server_settings_test.go

@@ -73,7 +73,7 @@ func TestSettingsHandlers(t *testing.T) {
 	users := addUsers(t, addr, userPwd, 1, adminToken)
 
 	t.Run("get/set client config", func(t *testing.T) {
-		settingsCl := client.NewSettingsClient(addr)
+		adminSettingsCli := client.NewSettingsClient(addr, adminToken)
 		cfgs := []*db.ClientConfig{
 			&db.ClientConfig{
 				SiteName: "quickshare",
@@ -93,14 +93,14 @@ func TestSettingsHandlers(t *testing.T) {
 				ClientCfg:      cfg,
 				CaptchaEnabled: false,
 			}
-			resp, _, errs := settingsCl.SetClientCfg(clientCfgMsg, adminToken)
+			resp, _, errs := adminSettingsCli.SetClientCfg(clientCfgMsg)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 
-			resp, clientCfgMsgGot, errs := settingsCl.GetClientCfg(adminToken)
+			resp, clientCfgMsgGot, errs := adminSettingsCli.GetClientCfg()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -120,7 +120,8 @@ func TestSettingsHandlers(t *testing.T) {
 				}
 				userToken := client.GetCookie(resp.Cookies(), q.TokenCookie)
 
-				resp, clientCfgMsgGot, errs := settingsCl.GetClientCfg(userToken)
+				userSettingsCli := client.NewSettingsClient(addr, userToken)
+				resp, clientCfgMsgGot, errs := userSettingsCli.GetClientCfg()
 				if len(errs) > 0 {
 					t.Fatal(errs)
 				} else if resp.StatusCode != 200 {
@@ -135,7 +136,7 @@ func TestSettingsHandlers(t *testing.T) {
 	})
 
 	t.Run("ReportErrors", func(t *testing.T) {
-		settingsCl := client.NewSettingsClient(addr)
+		adminSettingsCli := client.NewSettingsClient(addr, adminToken)
 		reports := &settings.ClientErrorReports{
 			Reports: []*settings.ClientErrorReport{
 				&settings.ClientErrorReport{
@@ -149,7 +150,7 @@ func TestSettingsHandlers(t *testing.T) {
 			},
 		}
 
-		reportResp, _, errs := settingsCl.ReportErrors(reports, adminToken)
+		reportResp, _, errs := adminSettingsCli.ReportErrors(reports)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if reportResp.StatusCode != 200 {
@@ -178,9 +179,9 @@ func TestSettingsHandlers(t *testing.T) {
 	})
 
 	t.Run("WorkerQueueLen", func(t *testing.T) {
-		settingsCl := client.NewSettingsClient(addr)
+		adminSettingsCli := client.NewSettingsClient(addr, adminToken)
 
-		reportResp, _, errs := settingsCl.WorkerQueueLen(adminToken)
+		reportResp, _, errs := adminSettingsCli.WorkerQueueLen()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if reportResp.StatusCode != 200 {

src/server/server_space_limit_test.go

@@ -63,14 +63,14 @@ func TestSpaceLimit(t *testing.T) {
 		t.Fatal("fail to start server")
 	}
 
-	usersCl := client.NewUsersClient(addr)
+	adminUsersCli := client.NewUsersClient(addr)
-	resp, _, errs := usersCl.Login(adminName, adminPwd)
+	resp, _, errs := adminUsersCli.Login(adminName, adminPwd)
 	if len(errs) > 0 {
 		t.Fatal(errs)
 	} else if resp.StatusCode != 200 {
 		t.Fatal(resp.StatusCode)
 	}
-	token := client.GetCookie(resp.Cookies(), q.TokenCookie)
+	adminToken := client.GetCookie(resp.Cookies(), q.TokenCookie)
 
 	userCount := 1
 	userPwd := "1234"
@@ -82,7 +82,7 @@ func TestSpaceLimit(t *testing.T) {
 	for i := 0; i < userCount; i++ {
 		userName := getUserName(i)
 
-		resp, adResp, errs := usersCl.AddUser(userName, userPwd, db.UserRole, token)
+		resp, adResp, errs := adminUsersCli.AddUser(userName, userPwd, db.UserRole)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -92,7 +92,7 @@ func TestSpaceLimit(t *testing.T) {
 		users[userName] = adResp.ID
 	}
 
-	resp, _, errs = usersCl.Logout(token)
+	resp, _, errs = adminUsersCli.Logout()
 	if len(errs) > 0 {
 		t.Fatal(errs)
 	} else if resp.StatusCode != 200 {
@@ -100,14 +100,14 @@ func TestSpaceLimit(t *testing.T) {
 	}
 
 	t.Run("test space limiting: Upload", func(t *testing.T) {
-		usersCl := client.NewUsersClient(addr)
+		usersCli := client.NewUsersClient(addr)
-		resp, _, errs := usersCl.Login(getUserName(0), userPwd)
+		resp, _, errs := usersCli.Login(getUserName(0), userPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
-		token := client.GetCookie(resp.Cookies(), q.TokenCookie)
+		userToken := client.GetCookie(resp.Cookies(), q.TokenCookie)
 
 		fileContent := ""
 		for i := 0; i < fileSize; i++ {
@@ -115,12 +115,12 @@ func TestSpaceLimit(t *testing.T) {
 		}
 
 		for i := 0; i < spaceLimit/fileSize; i++ {
-			ok := assertUploadOK(t, fmt.Sprintf("%s/files/spacelimit/f_%d", getUserName(0), i), fileContent, addr, token)
+			ok := assertUploadOK(t, fmt.Sprintf("%s/files/spacelimit/f_%d", getUserName(0), i), fileContent, addr, userToken)
 			if !ok {
 				t.Fatalf("space limit failed at %d", i)
 			}
 
-			resp, selfResp, errs := usersCl.Self(token)
+			resp, selfResp, errs := usersCli.Self()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -130,9 +130,9 @@ func TestSpaceLimit(t *testing.T) {
 			}
 		}
 
-		cl := client.NewFilesClient(addr, token)
+		userFilesClient := client.NewFilesClient(addr, userToken)
 		filePath := fmt.Sprintf("%s/files/spacelimit/f_%d", getUserName(0), 11)
-		res, _, errs := cl.Create(filePath, 1)
+		res, _, errs := userFilesClient.Create(filePath, 1)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 403 {
@@ -140,14 +140,14 @@ func TestSpaceLimit(t *testing.T) {
 		}
 
 		for i := 0; i < spaceLimit/fileSize; i++ {
-			resp, _, errs := cl.Delete(fmt.Sprintf("%s/files/spacelimit/f_%d", getUserName(0), i))
+			resp, _, errs := userFilesClient.Delete(fmt.Sprintf("%s/files/spacelimit/f_%d", getUserName(0), i))
 			if len(errs) > 0 {
 				t.Fatalf("failed to delete %d", i)
 			} else if resp.StatusCode != 200 {
 				t.Fatalf("failed to delete status %d", resp.StatusCode)
 			}
 
-			resp, selfResp, errs := usersCl.Self(token)
+			resp, selfResp, errs := usersCli.Self()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -161,10 +161,10 @@ func TestSpaceLimit(t *testing.T) {
 	t.Run("usedSpace keeps correct in operations: Mkdir-Create-UploadChunk-AddSharing-Move-IsSharing-List", func(t *testing.T) {
 		srcDir := "qs/files/folder/move/src"
 		dstDir := "qs/files/folder/move/dst"
-		filesCl := client.NewFilesClient(addr, token)
+		adminFilesCli := client.NewFilesClient(addr, adminToken)
 
 		getUsedSpace := func() int64 {
-			resp, selfResp, errs := usersCl.Self(token)
+			resp, selfResp, errs := adminUsersCli.Self()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -177,7 +177,7 @@ func TestSpaceLimit(t *testing.T) {
 		initUsedSpace := getUsedSpace()
 
 		for _, dirPath := range []string{srcDir, dstDir} {
-			res, _, errs := filesCl.Mkdir(dirPath)
+			res, _, errs := adminFilesCli.Mkdir(dirPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -195,7 +195,7 @@ func TestSpaceLimit(t *testing.T) {
 		}
 		for fileName, content := range files {
 			oldPath := filepath.Join(srcDir, fileName)
-			assertUploadOK(t, oldPath, content, addr, token)
+			assertUploadOK(t, oldPath, content, addr, adminToken)
 			expectedUsedSpace += int64(len(content))
 		}
 		if getUsedSpace() != expectedUsedSpace {
@@ -205,7 +205,7 @@ func TestSpaceLimit(t *testing.T) {
 		for fileName := range files {
 			oldPath := filepath.Join(srcDir, fileName)
 			newPath := filepath.Join(dstDir, fileName)
-			res, _, errs := filesCl.Move(oldPath, newPath)
+			res, _, errs := adminFilesCli.Move(oldPath, newPath)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if res.StatusCode != 200 {
@@ -217,7 +217,7 @@ func TestSpaceLimit(t *testing.T) {
 			}
 		}
 
-		res, _, errs := filesCl.Delete(dstDir)
+		res, _, errs := adminFilesCli.Delete(dstDir)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if res.StatusCode != 200 {
@@ -230,21 +230,21 @@ func TestSpaceLimit(t *testing.T) {
 	})
 
 	t.Run("ResetUsedSpace", func(t *testing.T) {
-		usersCl := client.NewUsersClient(addr)
+		usersCli := client.NewUsersClient(addr)
-		resp, _, errs := usersCl.Login("test", "test")
+		resp, _, errs := usersCli.Login("test", "test")
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
-		token := client.GetCookie(resp.Cookies(), q.TokenCookie)
+		userToken := client.GetCookie(resp.Cookies(), q.TokenCookie)
 
-		ok := assertUploadOK(t, "test/files/spacelimit/byte1", "0", addr, token)
+		ok := assertUploadOK(t, "test/files/spacelimit/byte1", "0", addr, userToken)
 		if !ok {
 			t.Fatal("upload failed")
 		}
 
-		resp, selfResp, errs := usersCl.Self(token)
+		resp, selfResp, errs := usersCli.Self()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -256,16 +256,16 @@ func TestSpaceLimit(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		resp, _, errs = usersCl.ResetUsedSpace(uidInt, token)
+		resp, _, errs = usersCli.ResetUsedSpace(uidInt)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		settingsCl := client.NewSettingsClient(addr)
+		settingsCli := client.NewSettingsClient(addr, userToken)
 		for i := 0; i < 20; i++ {
-			resp, wqlResp, errs := settingsCl.WorkerQueueLen(token)
+			resp, wqlResp, errs := settingsCli.WorkerQueueLen()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -279,7 +279,7 @@ func TestSpaceLimit(t *testing.T) {
 			time.Sleep(200)
 		}
 
-		resp, selfResp, errs = usersCl.Self(token)
+		resp, selfResp, errs = usersCli.Self()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -288,11 +288,4 @@ func TestSpaceLimit(t *testing.T) {
 			t.Fatalf("used space not equal %d %d", selfResp.UsedSpace, originalUsedSpace)
 		}
 	})
-
-	resp, _, errs = usersCl.Logout(token)
-	if len(errs) > 0 {
-		t.Fatal(errs)
-	} else if resp.StatusCode != 200 {
-		t.Fatal(resp.StatusCode)
-	}
 }

src/server/server_users_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/ihexxa/quickshare/src/db"
 	q "github.com/ihexxa/quickshare/src/handlers"
 	"github.com/ihexxa/quickshare/src/handlers/settings"
-	su "github.com/ihexxa/quickshare/src/handlers/singleuserhdr"
 )
 
 func TestUsersHandlers(t *testing.T) {
@@ -72,8 +71,7 @@ func TestUsersHandlers(t *testing.T) {
 	defer srv.Shutdown()
 	fs := srv.depsFS()
 
-	usersCl := client.NewUsersClient(addr)
+	// adminUsersCli := client.NewUsersClient(addr)
-	settingsCl := client.NewSettingsClient(addr)
 
 	if !isServerReady(addr) {
 		t.Fatal("fail to start server")
@@ -82,16 +80,16 @@ func TestUsersHandlers(t *testing.T) {
 	var err error
 
 	t.Run("test inited users", func(t *testing.T) {
-		usersCl := client.NewUsersClient(addr)
+		usersCli := client.NewUsersClient(addr)
-		resp, _, errs := usersCl.Login(adminName, adminPwd)
+		resp, _, errs := usersCli.Login(adminName, adminPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
-		token := client.GetCookie(resp.Cookies(), su.TokenCookie)
+		// userToken := client.GetCookie(resp.Cookies(), su.TokenCookie)
 
-		resp, lsResp, errs := usersCl.ListUsers(token)
+		resp, lsResp, errs := usersCli.ListUsers()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -164,16 +162,15 @@ func TestUsersHandlers(t *testing.T) {
 		}
 
 		for _, user := range users {
-			usersCl := client.NewUsersClient(addr)
+			userUsersCli := client.NewUsersClient(addr)
-			resp, _, errs := usersCl.Login(user.Name, user.Pwd)
+			resp, _, errs := userUsersCli.Login(user.Name, user.Pwd)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
-			token := client.GetCookie(resp.Cookies(), su.TokenCookie)
 
-			resp, selfResp, errs := usersCl.Self(token)
+			resp, selfResp, errs := userUsersCli.Self()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -193,21 +190,21 @@ func TestUsersHandlers(t *testing.T) {
 				}
 			}
 
-			resp, _, errs = usersCl.SetPwd(user.Pwd, adminNewPwd, token)
+			resp, _, errs = userUsersCli.SetPwd(user.Pwd, adminNewPwd)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 
-			resp, _, errs = usersCl.Logout(token)
+			resp, _, errs = userUsersCli.Logout()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 
-			resp, _, errs = usersCl.Login(user.Name, adminNewPwd)
+			resp, _, errs = userUsersCli.Login(user.Name, adminNewPwd)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -217,16 +214,17 @@ func TestUsersHandlers(t *testing.T) {
 	})
 
 	t.Run("test users APIs: Login-AddUser-Logout-Login-Logout", func(t *testing.T) {
-		resp, _, errs := usersCl.Login(adminName, adminNewPwd)
+		adminUsersCli := client.NewUsersClient(addr)
+		resp, _, errs := adminUsersCli.Login(adminName, adminNewPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
-		token := client.GetCookie(resp.Cookies(), su.TokenCookie)
+		// adminToken := client.GetCookie(resp.Cookies(), su.TokenCookie)
 
 		userName, userPwd := "user_login", "1234"
-		resp, auResp, errs := usersCl.AddUser(userName, userPwd, db.UserRole, token)
+		resp, auResp, errs := adminUsersCli.AddUser(userName, userPwd, db.UserRole)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -247,28 +245,28 @@ func TestUsersHandlers(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		resp, _, errs = usersCl.Logout(token)
+		resp, _, errs = adminUsersCli.Logout()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		resp, _, errs = usersCl.Login(userName, userPwd)
+		resp, _, errs = adminUsersCli.Login(adminName, adminNewPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		resp, _, errs = usersCl.DelUser(auResp.ID, token)
+		resp, _, errs = adminUsersCli.DelUser(auResp.ID)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		resp, _, errs = usersCl.Logout(token)
+		resp, _, errs = adminUsersCli.Logout()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -277,17 +275,18 @@ func TestUsersHandlers(t *testing.T) {
 	})
 
 	t.Run("test users APIs: Login-AddUser-ListUsers-SetUser-ListUsers-DelUser-ListUsers", func(t *testing.T) {
-		resp, _, errs := usersCl.Login(adminName, adminNewPwd)
+		adminUsersCli := client.NewUsersClient(addr)
+		resp, _, errs := adminUsersCli.Login(adminName, adminNewPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		token := client.GetCookie(resp.Cookies(), su.TokenCookie)
+		// token := client.GetCookie(resp.Cookies(), su.TokenCookie)
 
 		userName, userPwd, userRole := "new_user", "1234", db.UserRole
-		resp, auResp, errs := usersCl.AddUser(userName, userPwd, userRole, token)
+		resp, auResp, errs := adminUsersCli.AddUser(userName, userPwd, userRole)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -300,7 +299,7 @@ func TestUsersHandlers(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		resp, lsResp, errs := usersCl.ListUsers(token)
+		resp, lsResp, errs := adminUsersCli.ListUsers()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -330,14 +329,14 @@ func TestUsersHandlers(t *testing.T) {
 			UploadSpeedLimit:   3,
 			DownloadSpeedLimit: 3,
 		}
-		resp, _, errs = usersCl.SetUser(newUserID, newRole, newQuota, token)
+		resp, _, errs = adminUsersCli.SetUser(newUserID, newRole, newQuota)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		resp, lsResp, errs = usersCl.ListUsers(token)
+		resp, lsResp, errs = adminUsersCli.ListUsers()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -360,14 +359,14 @@ func TestUsersHandlers(t *testing.T) {
 			}
 		}
 
-		resp, _, errs = usersCl.DelUser(auResp.ID, token)
+		resp, _, errs = adminUsersCli.DelUser(auResp.ID)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		resp, lsResp, errs = usersCl.ListUsers(token)
+		resp, lsResp, errs = adminUsersCli.ListUsers()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -377,7 +376,7 @@ func TestUsersHandlers(t *testing.T) {
 			t.Fatal(fmt.Errorf("incorrect users size (%d)", len(lsResp.Users)))
 		}
 
-		resp, _, errs = usersCl.Logout(token)
+		resp, _, errs = adminUsersCli.Logout()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -386,18 +385,19 @@ func TestUsersHandlers(t *testing.T) {
 	})
 
 	t.Run("test roles APIs: Login-AddRole-ListRoles-DelRole-ListRoles-Logout", func(t *testing.T) {
-		resp, _, errs := usersCl.Login(adminName, adminNewPwd)
+		adminUsersCli := client.NewUsersClient(addr)
+		resp, _, errs := adminUsersCli.Login(adminName, adminNewPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		token := client.GetCookie(resp.Cookies(), su.TokenCookie)
+		// token := client.GetCookie(resp.Cookies(), su.TokenCookie)
 		roles := []string{"role1", "role2"}
 
 		for _, role := range roles {
-			resp, _, errs := usersCl.AddRole(role, token)
+			resp, _, errs := adminUsersCli.AddRole(role)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -405,7 +405,7 @@ func TestUsersHandlers(t *testing.T) {
 			}
 		}
 
-		resp, lsResp, errs := usersCl.ListRoles(token)
+		resp, lsResp, errs := adminUsersCli.ListRoles()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -422,7 +422,7 @@ func TestUsersHandlers(t *testing.T) {
 		}
 
 		for _, role := range roles {
-			resp, _, errs := usersCl.DelRole(role, token)
+			resp, _, errs := adminUsersCli.DelRole(role)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -430,7 +430,7 @@ func TestUsersHandlers(t *testing.T) {
 			}
 		}
 
-		resp, lsResp, errs = usersCl.ListRoles(token)
+		resp, lsResp, errs = adminUsersCli.ListRoles()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -442,7 +442,7 @@ func TestUsersHandlers(t *testing.T) {
 			}
 		}
 
-		resp, _, errs = usersCl.Logout(token)
+		resp, _, errs = adminUsersCli.Logout()
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -451,15 +451,15 @@ func TestUsersHandlers(t *testing.T) {
 	})
 
 	t.Run("Login, SetPreferences, Self, Logout", func(t *testing.T) {
-		usersCl := client.NewUsersClient(addr)
+		adminUsersCli := client.NewUsersClient(addr)
-		resp, _, errs := usersCl.Login(adminName, adminNewPwd)
+		resp, _, errs := adminUsersCli.Login(adminName, adminNewPwd)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
 			t.Fatal(resp.StatusCode)
 		}
 
-		token := client.GetCookie(resp.Cookies(), su.TokenCookie)
+		// token := client.GetCookie(resp.Cookies(), su.TokenCookie)
 
 		prefers := []*db.Preferences{
 			{
@@ -494,14 +494,14 @@ func TestUsersHandlers(t *testing.T) {
 			},
 		}
 		for _, prefer := range prefers {
-			resp, _, errs := usersCl.SetPreferences(prefer, token)
+			resp, _, errs := adminUsersCli.SetPreferences(prefer)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 
-			resp, selfResp, errs := usersCl.Self(token)
+			resp, selfResp, errs := adminUsersCli.Self()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
@@ -514,6 +514,8 @@ func TestUsersHandlers(t *testing.T) {
 		}
 
 		// disable setting bg in preferences
+
+		settingsCl := client.NewSettingsClient(addr, adminUsersCli.Token())
 		resp, _, errs = settingsCl.SetClientCfg(&settings.ClientCfgMsg{
 			ClientCfg: &db.ClientConfig{
 				SiteName:   "Quickshare",
@@ -523,9 +525,7 @@ func TestUsersHandlers(t *testing.T) {
 				AutoTheme:  true,
 			},
 			CaptchaEnabled: false,
-		},
+		})
-			token,
-		)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -533,14 +533,14 @@ func TestUsersHandlers(t *testing.T) {
 		}
 
 		for _, prefer := range prefers {
-			resp, _, errs := usersCl.SetPreferences(prefer, token)
+			resp, _, errs := adminUsersCli.SetPreferences(prefer)
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {
 				t.Fatal(resp.StatusCode)
 			}
 
-			resp, selfResp, errs := usersCl.Self(token)
+			resp, selfResp, errs := adminUsersCli.Self()
 			if len(errs) > 0 {
 				t.Fatal(errs)
 			} else if resp.StatusCode != 200 {

src/server/test_helpers.go

@@ -59,12 +59,13 @@ func getUserName(id int) string {
 }
 
 func addUsers(t *testing.T, addr, userPwd string, userCount int, adminToken *http.Cookie) map[string]string {
-	usersCl := client.NewUsersClient(addr)
+	adminUsersCli := client.NewUsersClient(addr)
+	adminUsersCli.SetToken(adminToken)
 	users := map[string]string{}
 	for i := range make([]int, userCount) {
 		userName := getUserName(i)
 
-		resp, adResp, errs := usersCl.AddUser(userName, userPwd, db.UserRole, adminToken)
+		resp, adResp, errs := adminUsersCli.AddUser(userName, userPwd, db.UserRole)
 		if len(errs) > 0 {
 			t.Fatal(errs)
 		} else if resp.StatusCode != 200 {
@@ -79,7 +80,7 @@ func addUsers(t *testing.T, addr, userPwd string, userCount int, adminToken *htt
 
 func isServerReady(addr string) bool {
 	retry := 20
-	setCl := client.NewSettingsClient(addr)
+	setCl := client.NewSettingsClient(addr, nil)
 
 	for retry > 0 {
 		_, _, errs := setCl.Health()