doesnm/quickshare
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(client): remove token from client args

Browse source
This commit is contained in:
hexxa 2022-08-10 13:12:32 +08:00 • committed by Hexxa
parent 6cc99312bf
commit 0cce1bd090
10 changed files with 294 additions and 256 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/client/files.go
View file

@ -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,
}
}

29
src/client/settings.go
View file

@ -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
r *gorequest.SuperAgent
addr string
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,
r: gr,
addr: addr,
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{}

80
src/client/users.go
View file

@ -12,8 +12,9 @@ import (
)
type UsersClient struct {
addr string
r *gorequest.SuperAgent
addr string
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()
}

93
src/server/server_concurrency_test.go
View file

@ -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)
resp, _, errs := usersCl.Login(adminName, adminPwd)
adminUsersCli := client.NewUsersClient(addr)
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)
resp, _, errs := usersCl.Login(name, pwd)
defer wg.Done()
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)
assertDownloadOK(t, filePath, content, addr, token)
assertUploadOK(t, filePath, content, addr, userToken)
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)
}
}

98
src/server/server_files_test.go
View file

@ -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 {

63
src/server/server_permission_test.go
View file

@ -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"))
}

17
src/server/server_settings_test.go
View file

@ -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 {

65
src/server/server_space_limit_test.go
View file

@ -63,14 +63,14 @@ func TestSpaceLimit(t *testing.T) {
t.Fatal("fail to start server")
}
usersCl := client.NewUsersClient(addr)
resp, _, errs := usersCl.Login(adminName, adminPwd)
adminUsersCli := client.NewUsersClient(addr)
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)
resp, _, errs := usersCl.Login(getUserName(0), userPwd)
usersCli := client.NewUsersClient(addr)
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)
resp, _, errs := usersCl.Login("test", "test")
usersCli := client.NewUsersClient(addr)
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)
}
}

94
src/server/server_users_test.go
View file

@ -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)
settingsCl := client.NewSettingsClient(addr)
// adminUsersCli := client.NewUsersClient(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)
resp, _, errs := usersCl.Login(adminName, adminPwd)
usersCli := client.NewUsersClient(addr)
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)
resp, _, errs := usersCl.Login(user.Name, user.Pwd)
userUsersCli := client.NewUsersClient(addr)
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)
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)
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 {

7
src/server/test_helpers.go
View file

@ -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()