harbor/dao/dao_test.go

682 lines
20 KiB
Go
Raw Normal View History

2016-02-01 12:59:10 +01:00
/*
Copyright (c) 2016 VMware, Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
2016-02-26 11:54:14 +01:00
2016-02-24 11:16:16 +01:00
package dao
2016-02-01 12:59:10 +01:00
import (
"fmt"
2016-02-01 12:59:10 +01:00
"log"
"os"
"testing"
"time"
"github.com/vmware/harbor/models"
"github.com/astaxie/beego/orm"
)
func execUpdate(o orm.Ormer, sql string, params interface{}) error {
p, err := o.Raw(sql).Prepare()
if err != nil {
return err
}
defer p.Close()
_, err = p.Exec(params)
if err != nil {
return err
}
return nil
}
func clearUp(username string) {
o := orm.NewOrm()
o.Begin()
err := execUpdate(o, `delete upr from user_project_role upr
left join project_role pr on upr.pr_id = pr.pr_id
left join project p on pr.project_id = p.project_id
left join user u on u.user_id = p.owner_id
where u.username = ?`, username)
if err != nil {
o.Rollback()
log.Println(err)
}
err = execUpdate(o, `delete pr from project_role pr
left join project p on pr.project_id = p.project_id
left join user u on u.user_id = p.owner_id
where u.username = ?`, username)
if err != nil {
o.Rollback()
log.Println(err)
}
err = execUpdate(o, `delete a from access_log a
left join user u on a.user_id = u.user_id
where u.username = ?`, username)
if err != nil {
o.Rollback()
log.Println(err)
}
err = execUpdate(o, `delete p from project p
left join user u on p.owner_id = u.user_id
where u.username = ?`, username)
if err != nil {
o.Rollback()
log.Println(err)
}
err = execUpdate(o, `delete u from user u
where u.username = ?`, username)
if err != nil {
o.Rollback()
log.Println(err)
}
o.Commit()
}
2016-02-26 04:26:54 +01:00
const username string = "Tester01"
const projectName string = "test_project"
const SysAdmin int = 1
const projectAdmin int = 2
const developer int = 3
const guest int = 4
2016-02-01 12:59:10 +01:00
2016-02-26 04:26:54 +01:00
const publicityOn = 1
const publicityOff = 0
2016-02-01 12:59:10 +01:00
func TestMain(m *testing.M) {
2016-02-23 13:49:59 +01:00
dbHost := os.Getenv("DB_HOST")
if len(dbHost) == 0 {
log.Fatalf("environment variable DB_HOST is not set")
}
dbUser := os.Getenv("DB_USR")
if len(dbUser) == 0 {
log.Fatalf("environment variable DB_USR is not set")
}
dbPort := os.Getenv("DB_PORT")
if len(dbPort) == 0 {
2016-02-24 03:53:25 +01:00
log.Fatalf("environment variable DB_PORT is not set")
2016-02-23 13:49:59 +01:00
}
dbPassword := os.Getenv("DB_PWD")
2016-02-01 12:59:10 +01:00
fmt.Printf("DB_HOST: %s, DB_USR: %s, DB_PORT: %s, DB_PWD: %s\n", dbHost, dbUser, dbPort, dbPassword)
2016-02-23 13:49:59 +01:00
os.Setenv("MYSQL_PORT_3306_TCP_ADDR", dbHost)
os.Setenv("MYSQL_PORT_3306_TCP_PORT", dbPort)
os.Setenv("MYSQL_USR", dbUser)
os.Setenv("MYSQL_PWD", dbPassword)
os.Setenv("AUTH_MODE", "db_auth")
2016-02-24 11:16:16 +01:00
InitDB()
2016-02-26 04:26:54 +01:00
clearUp(username)
2016-02-23 13:49:59 +01:00
os.Exit(m.Run())
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
func TestRegister(t *testing.T) {
2016-02-01 12:59:10 +01:00
user := models.User{
2016-02-26 04:26:54 +01:00
Username: username,
2016-02-01 12:59:10 +01:00
Email: "tester01@vmware.com",
Password: "Abc12345",
Realname: "tester01",
Comment: "register",
}
2016-02-24 11:16:16 +01:00
_, err := Register(user)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in Register: %v", err)
2016-02-01 12:59:10 +01:00
}
//Check if user registered successfully.
queryUser := models.User{
2016-02-26 04:26:54 +01:00
Username: username,
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
newUser, err := GetUser(queryUser)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetUser: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
if newUser.Username != username {
t.Errorf("Username does not match, expected: %s, actual: %s", username, newUser.Username)
2016-02-23 13:49:59 +01:00
}
if newUser.Email != "tester01@vmware.com" {
t.Errorf("Email does not match, expected: %s, actual: %s", "tester01@vmware.com", newUser.Email)
}
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
func TestUserExists(t *testing.T) {
2016-02-01 12:59:10 +01:00
var exists bool
var err error
2016-02-26 04:26:54 +01:00
exists, err = UserExists(models.User{Username: username}, "username")
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in UserExists: %v", err)
}
if !exists {
2016-02-26 04:26:54 +01:00
t.Errorf("User %s was inserted but does not exist", username)
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
exists, err = UserExists(models.User{Email: "tester01@vmware.com"}, "email")
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in UserExists: %v", err)
}
if !exists {
t.Errorf("User with email %s inserted but does not exist", "tester01@vmware.com")
}
2016-02-24 11:16:16 +01:00
exists, err = UserExists(models.User{Username: "NOTHERE"}, "username")
2016-02-23 13:49:59 +01:00
if err != nil {
t.Errorf("Error occurred in UserExists: %v", err)
}
if exists {
t.Errorf("User %s was not inserted but does exist", "NOTHERE")
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestLoginByUserName(t *testing.T) {
2016-02-01 12:59:10 +01:00
userQuery := models.User{
2016-02-26 04:26:54 +01:00
Username: username,
2016-02-01 12:59:10 +01:00
Password: "Abc12345",
}
2016-02-24 11:16:16 +01:00
loginUser, err := LoginByDb(models.AuthModel{userQuery.Username, userQuery.Password})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in LoginByDb: %v", err)
2016-02-01 12:59:10 +01:00
}
if loginUser == nil {
2016-02-23 13:49:59 +01:00
t.Errorf("No found for user logined by username and password: %v", userQuery)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
if loginUser.Username != username {
t.Errorf("User's username does not match after login, expected: %s, actual: %s", username, loginUser.Username)
2016-02-23 13:49:59 +01:00
}
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
func TestLoginByEmail(t *testing.T) {
2016-02-01 12:59:10 +01:00
userQuery := models.User{
Email: "tester01@vmware.com",
Password: "Abc12345",
}
2016-02-24 11:16:16 +01:00
loginUser, err := LoginByDb(models.AuthModel{userQuery.Email, userQuery.Password})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in LoginByDb: %v", err)
2016-02-01 12:59:10 +01:00
}
if loginUser == nil {
2016-02-23 13:49:59 +01:00
t.Errorf("No found for user logined by email and password : %v", userQuery)
}
2016-02-26 04:26:54 +01:00
if loginUser.Username != username {
t.Errorf("User's username does not match after login, expected: %s, actual: %s", username, loginUser.Username)
2016-02-01 12:59:10 +01:00
}
}
var currentUser *models.User
2016-02-23 13:49:59 +01:00
func TestGetUser(t *testing.T) {
2016-02-01 12:59:10 +01:00
queryUser := models.User{
2016-02-26 04:26:54 +01:00
Username: username,
2016-02-01 12:59:10 +01:00
}
var err error
2016-02-24 11:16:16 +01:00
currentUser, err = GetUser(queryUser)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetUser: %v", err)
2016-02-01 12:59:10 +01:00
}
if currentUser == nil {
2016-02-23 13:49:59 +01:00
t.Errorf("No user found queried by user query: %+v", queryUser)
}
if currentUser.Email != "tester01@vmware.com" {
t.Errorf("the user's email does not match, expected: tester01@vmware.com, actual: %s", currentUser.Email)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestListUsers(t *testing.T) {
2016-02-24 11:16:16 +01:00
users, err := ListUsers(models.User{})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ListUsers: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
if len(users) != 1 {
t.Errorf("Expect one user in list, but the acutal length is %d, the list: %+v", len(users), users)
}
2016-02-26 04:26:54 +01:00
users2, err := ListUsers(models.User{Username: username})
2016-02-23 13:49:59 +01:00
if len(users2) != 1 {
t.Errorf("Expect one user in list, but the acutal length is %d, the list: %+v", len(users), users)
}
2016-02-26 04:26:54 +01:00
if users2[0].Username != username {
t.Errorf("The username in result list does not match, expected: %s, actual: %s", username, users2[0].Username)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestResetUserPassword(t *testing.T) {
2016-02-24 11:16:16 +01:00
uuid, err := GenerateRandomString()
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GenerateRandomString: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
err = UpdateUserResetUUID(models.User{ResetUUID: uuid, Email: currentUser.Email})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in UpdateUserResetUuid: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 03:15:01 +01:00
err = ResetUserPassword(models.User{UserID: currentUser.UserID, Password: "HarborTester12345", ResetUUID: uuid, Salt: currentUser.Salt})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ResetUserPassword: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
loginedUser, err := LoginByDb(models.AuthModel{Principal: currentUser.Username, Password: "HarborTester12345"})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in LoginByDb: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
if loginedUser.Username != username {
t.Errorf("The username returned by Login does not match, expected: %s, acutal: %s", username, loginedUser.Username)
2016-02-23 13:49:59 +01:00
}
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
func TestChangeUserPassword(t *testing.T) {
2016-02-26 03:15:01 +01:00
err := ChangeUserPassword(models.User{UserID: currentUser.UserID, Password: "NewHarborTester12345", Salt: currentUser.Salt})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ChangeUserPassword: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
loginedUser, err := LoginByDb(models.AuthModel{Principal: currentUser.Username, Password: "NewHarborTester12345"})
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in LoginByDb: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
if loginedUser.Username != username {
t.Errorf("The username returned by Login does not match, expected: %s, acutal: %s", username, loginedUser.Username)
2016-02-23 13:49:59 +01:00
}
2016-02-01 12:59:10 +01:00
}
func TestChangeUserPasswordWithOldPassword(t *testing.T) {
2016-02-26 03:15:01 +01:00
err := ChangeUserPassword(models.User{UserID: currentUser.UserID, Password: "NewerHarborTester12345", Salt: currentUser.Salt}, "NewHarborTester12345")
if err != nil {
t.Errorf("Error occurred in ChangeUserPassword: %v", err)
}
2016-02-24 11:16:16 +01:00
loginedUser, err := LoginByDb(models.AuthModel{Principal: currentUser.Username, Password: "NewerHarborTester12345"})
if err != nil {
t.Errorf("Error occurred in LoginByDb: %v", err)
}
2016-02-26 04:26:54 +01:00
if loginedUser.Username != username {
t.Errorf("The username returned by Login does not match, expected: %s, acutal: %s", username, loginedUser.Username)
}
}
func TestChangeUserPasswordWithIncorrectOldPassword(t *testing.T) {
2016-02-26 03:15:01 +01:00
err := ChangeUserPassword(models.User{UserID: currentUser.UserID, Password: "NNewerHarborTester12345", Salt: currentUser.Salt}, "WrongNewerHarborTester12345")
if err == nil {
t.Errorf("Error does not occurred due to old password is incorrect.")
}
2016-02-24 11:16:16 +01:00
loginedUser, err := LoginByDb(models.AuthModel{Principal: currentUser.Username, Password: "NNewerHarborTester12345"})
if err != nil {
t.Errorf("Error occurred in LoginByDb: %v", err)
}
if loginedUser != nil {
t.Errorf("The login user is not nil, acutal: %+v", loginedUser)
}
}
2016-02-23 13:49:59 +01:00
func TestQueryRelevantProjectsWhenNoProjectAdded(t *testing.T) {
2016-02-26 03:15:01 +01:00
projects, err := QueryRelevantProjects(currentUser.UserID)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in QueryRelevantProjects: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
if len(projects) != 1 {
t.Errorf("Expected only one project in DB, but actual: %d", len(projects))
}
if projects[0].Name != "library" {
t.Errorf("There name of the project does not match, expected: %s, actual: %s", "library", projects[0].Name)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestAddProject(t *testing.T) {
2016-02-01 12:59:10 +01:00
project := models.Project{
2016-02-26 03:15:01 +01:00
OwnerID: currentUser.UserID,
2016-02-26 04:26:54 +01:00
Name: projectName,
2016-02-01 12:59:10 +01:00
CreationTime: time.Now(),
OwnerName: currentUser.Username,
}
2016-02-24 11:16:16 +01:00
err := AddProject(project)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in AddProject: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
newProject, err := GetProjectByName(projectName)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetProjectByName: %v", err)
2016-02-01 12:59:10 +01:00
}
if newProject == nil {
2016-02-26 04:26:54 +01:00
t.Errorf("No project found queried by project name: %v", projectName)
2016-02-01 12:59:10 +01:00
}
}
var currentProject *models.Project
2016-02-23 13:49:59 +01:00
func TestGetProject(t *testing.T) {
2016-02-01 12:59:10 +01:00
var err error
2016-02-26 04:26:54 +01:00
currentProject, err = GetProjectByName(projectName)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetProjectByName: %v", err)
2016-02-01 12:59:10 +01:00
}
if currentProject == nil {
2016-02-26 04:26:54 +01:00
t.Errorf("No project found queried by project name: %v", projectName)
2016-02-23 13:49:59 +01:00
}
2016-02-26 04:26:54 +01:00
if currentProject.Name != projectName {
t.Errorf("Project name does not match, expected: %s, actual: %s", projectName, currentProject.Name)
2016-02-01 12:59:10 +01:00
}
}
2016-02-26 04:26:54 +01:00
func getProjectRole(projectID int64) []models.Role {
2016-02-01 12:59:10 +01:00
o := orm.NewOrm()
var r []models.Role
_, err := o.Raw(`select r.role_id, r.name
2016-02-23 13:49:59 +01:00
from project_role pr
2016-02-01 12:59:10 +01:00
left join role r on pr.role_id = r.role_id
2016-02-26 04:26:54 +01:00
where project_id = ?`, projectID).QueryRows(&r)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
log.Printf("Error occurred in querying project_role: %v", err)
2016-02-01 12:59:10 +01:00
}
return r
}
2016-02-23 13:49:59 +01:00
func TestCheckProjectRoles(t *testing.T) {
2016-02-26 03:15:01 +01:00
r := getProjectRole(currentProject.ProjectID)
2016-02-23 13:49:59 +01:00
if len(r) != 3 {
t.Errorf("The length of project roles is not 3")
}
2016-02-26 03:15:01 +01:00
if r[1].RoleID != 3 {
t.Errorf("The role id does not match, expected: 3, acutal: %d", r[1].RoleID)
2016-02-23 13:49:59 +01:00
}
if r[1].Name != "developer" {
t.Errorf("The name of role id: 3 should be developer, actual:%s", r[1].Name)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestGetAccessLog(t *testing.T) {
2016-02-01 12:59:10 +01:00
queryAccessLog := models.AccessLog{
2016-02-26 03:15:01 +01:00
UserID: currentUser.UserID,
ProjectID: currentProject.ProjectID,
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
accessLogs, err := GetAccessLogs(queryAccessLog)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetAccessLog: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
if len(accessLogs) != 1 {
t.Errorf("The length of accesslog list should be 1, actual: %d", len(accessLogs))
}
2016-02-26 04:26:54 +01:00
if accessLogs[0].RepoName != projectName+"/" {
t.Errorf("The project name does not match, expected: %s, actual: %s", projectName+"/", accessLogs[0].RepoName)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestProjectExists(t *testing.T) {
2016-02-01 12:59:10 +01:00
var exists bool
var err error
2016-02-26 03:15:01 +01:00
exists, err = ProjectExists(currentProject.ProjectID)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ProjectExists: %v", err)
}
if !exists {
2016-02-26 03:15:01 +01:00
t.Errorf("The project with id: %d, does not exist", currentProject.ProjectID)
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
exists, err = ProjectExists(currentProject.Name)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ProjectExists: %v", err)
}
if !exists {
t.Errorf("The project with name: %s, does not exist", currentProject.Name)
2016-02-01 12:59:10 +01:00
}
}
2016-02-24 11:16:16 +01:00
func TestGetProjectById(t *testing.T) {
2016-02-26 03:15:01 +01:00
id := currentProject.ProjectID
2016-02-26 04:26:54 +01:00
p, err := GetProjectByID(id)
2016-02-24 11:16:16 +01:00
if err != nil {
t.Errorf("Error in GetProjectById: %v, id: %d", err, id)
}
if p.Name != currentProject.Name {
t.Errorf("project name does not match, expected: %s, actual: %s", currentProject.Name, p.Name)
}
}
func TestGetUserByProject(t *testing.T) {
2016-02-26 03:15:01 +01:00
pid := currentProject.ProjectID
2016-02-24 11:16:16 +01:00
u1 := models.User{
Username: "%%Tester%%",
}
u2 := models.User{
Username: "nononono",
}
users, err := GetUserByProject(pid, u1)
if err != nil {
2016-02-26 07:24:44 +01:00
t.Errorf("Error happened in GetUserByProject: %v, project Id: %d, user: %+v", err, pid, u1)
2016-02-24 11:16:16 +01:00
}
if len(users) != 1 {
t.Errorf("unexpected length of user list, expected: 1, the users list: %+v", users)
}
users, err = GetUserByProject(pid, u2)
if err != nil {
2016-02-26 07:24:44 +01:00
t.Errorf("Error happened in GetUserByProject: %v, project Id: %d, user: %+v", err, pid, u2)
2016-02-24 11:16:16 +01:00
}
if len(users) != 0 {
t.Errorf("unexpected length of user list, expected: 0, the users list: %+v", users)
}
}
2016-02-23 13:49:59 +01:00
func TestToggleProjectPublicity(t *testing.T) {
2016-02-26 04:26:54 +01:00
err := ToggleProjectPublicity(currentProject.ProjectID, publicityOn)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ToggleProjectPublicity: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
currentProject, err = GetProjectByName(projectName)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetProjectByName: %v", err)
}
2016-02-26 04:26:54 +01:00
if currentProject.Public != publicityOn {
2016-02-26 03:15:01 +01:00
t.Errorf("project, id: %d, its publicity is not on", currentProject.ProjectID)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
err = ToggleProjectPublicity(currentProject.ProjectID, publicityOff)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in ToggleProjectPublicity: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
currentProject, err = GetProjectByName(projectName)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetProjectByName: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
if currentProject.Public != publicityOff {
2016-02-26 03:15:01 +01:00
t.Errorf("project, id: %d, its publicity is not off", currentProject.ProjectID)
2016-02-23 13:49:59 +01:00
}
2016-02-24 11:16:16 +01:00
}
func TestIsProjectPublic(t *testing.T) {
2016-02-26 04:26:54 +01:00
if isPublic := IsProjectPublic(projectName); isPublic {
2016-02-26 03:15:01 +01:00
t.Errorf("project, id: %d, its publicity is not false after turning off", currentProject.ProjectID)
2016-02-24 11:16:16 +01:00
}
}
func TestQueryProject(t *testing.T) {
query1 := models.Project{
2016-02-26 03:15:01 +01:00
UserID: 1,
2016-02-24 11:16:16 +01:00
}
projects, err := QueryProject(query1)
if err != nil {
t.Errorf("Error in Query Project: %v, query: %+v", err, query1)
}
if len(projects) != 2 {
t.Errorf("Expecting get 2 projects, but actual: %d, the list: %+v", len(projects), projects)
}
query2 := models.Project{
Public: 1,
}
projects, err = QueryProject(query2)
if err != nil {
t.Errorf("Error in Query Project: %v, query: %+v", err, query2)
}
if len(projects) != 1 {
t.Errorf("Expecting get 1 project, but actual: %d, the list: %+v", len(projects), projects)
}
query3 := models.Project{
2016-02-26 03:15:01 +01:00
UserID: 9,
2016-02-24 11:16:16 +01:00
}
projects, err = QueryProject(query3)
if err != nil {
t.Errorf("Error in Query Project: %v, query: %+v", err, query3)
}
if len(projects) != 0 {
t.Errorf("Expecting get 0 project, but actual: %d, the list: %+v", len(projects), projects)
}
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
func getUserProjectRole(projectID int64, userID int) []models.Role {
2016-02-01 12:59:10 +01:00
o := orm.NewOrm()
var r []models.Role
2016-02-23 13:49:59 +01:00
_, err := o.Raw(`select r.role_id, r.name
2016-02-01 12:59:10 +01:00
from user_project_role upr
left join project_role pr on upr.pr_id = pr.pr_id
left join role r on r.role_id = pr.role_id
2016-02-26 04:26:54 +01:00
where pr.project_id = ? and upr.user_id = ?`, projectID, userID).QueryRows(&r)
2016-02-01 12:59:10 +01:00
if err != nil {
log.Fatalf("Error occurred in querying user_project_role: %v", err)
}
return r
}
2016-02-24 11:16:16 +01:00
func TestGetUserProjectRoles(t *testing.T) {
user := *currentUser
2016-02-26 03:15:01 +01:00
r, err := GetUserProjectRoles(user, currentProject.ProjectID)
2016-02-24 11:16:16 +01:00
if err != nil {
2016-02-26 03:15:01 +01:00
t.Errorf("Error happened in GetUserProjectRole: %v, user: %+v, project Id: %d", err, user, currentProject.ProjectID)
2016-02-24 11:16:16 +01:00
}
2016-02-01 12:59:10 +01:00
//Get the size of current user project role.
2016-02-23 13:49:59 +01:00
if len(r) != 1 {
2016-02-26 03:15:01 +01:00
t.Errorf("The user, id: %d, should only have one role in project, id: %d, but actual: %d", currentUser.UserID, currentProject.ProjectID, len(r))
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
if r[0].Name != "projectAdmin" {
t.Errorf("the expected rolename is: projectAdmin, actual: %s", r[0].Name)
}
2016-02-26 03:15:01 +01:00
user.RoleID = 1
2016-02-24 11:16:16 +01:00
2016-02-26 03:15:01 +01:00
r, err = GetUserProjectRoles(user, currentProject.ProjectID)
2016-02-24 11:16:16 +01:00
if err != nil {
2016-02-26 03:15:01 +01:00
t.Errorf("Error happened in GetUserProjectRole: %v, user: %+v, project Id: %d", err, user, currentProject.ProjectID)
2016-02-24 11:16:16 +01:00
}
//Get the size of current user project role.
if len(r) != 0 {
2016-02-26 03:15:01 +01:00
t.Errorf("The user, id: %d, should not have role id: 1 in project id: %d, actual role list: %v", currentUser.UserID, currentProject.ProjectID, r)
2016-02-24 11:16:16 +01:00
}
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
func TestProjectPermission(t *testing.T) {
2016-02-24 11:16:16 +01:00
roleCode, err := GetPermission(currentUser.Username, currentProject.Name)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetPermission: %v", err)
}
if roleCode != "MDRWS" {
t.Errorf("The expected role code is MDRWS,but actual: %s", roleCode)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestQueryRelevantProjects(t *testing.T) {
2016-02-26 03:15:01 +01:00
projects, err := QueryRelevantProjects(currentUser.UserID)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in QueryRelevantProjects: %v", err)
}
if len(projects) != 2 {
t.Errorf("Expected length of relevant projects is 2, but actual: %d, the projects: %+v", len(projects), projects)
2016-02-01 12:59:10 +01:00
}
2016-02-26 04:26:54 +01:00
if projects[1].Name != projectName {
t.Errorf("Expected project name in the list: %s, actual: %s", projectName, projects[1].Name)
2016-02-01 12:59:10 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestAssignUserProjectRole(t *testing.T) {
2016-02-26 04:26:54 +01:00
err := AddUserProjectRole(currentUser.UserID, currentProject.ProjectID, developer)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in AddUserProjectRole: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 03:15:01 +01:00
r := getUserProjectRole(currentProject.ProjectID, currentUser.UserID)
2016-02-01 12:59:10 +01:00
//Get the size of current user project role info.
2016-02-23 13:49:59 +01:00
if len(r) != 2 {
t.Errorf("Expected length of role list is 2, actual: %d", len(r))
2016-02-01 12:59:10 +01:00
}
2016-02-26 03:15:01 +01:00
if r[1].RoleID != 3 {
t.Errorf("Expected role id of the second role in list is 3, actual: %d", r[1].RoleID)
2016-02-23 13:49:59 +01:00
}
2016-02-01 12:59:10 +01:00
}
2016-02-23 13:49:59 +01:00
func TestDeleteUserProjectRole(t *testing.T) {
2016-02-26 03:15:01 +01:00
err := DeleteUserProjectRoles(currentUser.UserID, currentProject.ProjectID)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in DeleteUserProjectRoles: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-26 03:15:01 +01:00
r := getUserProjectRole(currentProject.ProjectID, currentUser.UserID)
2016-02-01 12:59:10 +01:00
//Get the size of current user project role.
2016-02-23 13:49:59 +01:00
if len(r) != 0 {
t.Errorf("Expected role list length is 0, actual: %d, role list: %+v", len(r), r)
2016-02-01 12:59:10 +01:00
}
}
2016-02-24 11:16:16 +01:00
func TestToggleAdminRole(t *testing.T) {
err := ToggleUserAdminRole(*currentUser)
if err != nil {
t.Errorf("Error in toggle ToggleUserAdmin role: %v, user: %+v", err, currentUser)
}
2016-02-26 03:15:01 +01:00
isAdmin, err := IsAdminRole(currentUser.UserID)
2016-02-24 11:16:16 +01:00
if err != nil {
2016-02-26 03:15:01 +01:00
t.Errorf("Error in IsAdminRole: %v, user id: %d", err, currentUser.UserID)
2016-02-24 11:16:16 +01:00
}
if !isAdmin {
2016-02-26 03:15:01 +01:00
t.Errorf("User is not admin after toggled, user id: %d", currentUser.UserID)
2016-02-24 11:16:16 +01:00
}
err = ToggleUserAdminRole(*currentUser)
if err != nil {
t.Errorf("Error in toggle ToggleUserAdmin role: %v, user: %+v", err, currentUser)
}
2016-02-26 03:15:01 +01:00
isAdmin, err = IsAdminRole(currentUser.UserID)
2016-02-24 11:16:16 +01:00
if err != nil {
2016-02-26 03:15:01 +01:00
t.Errorf("Error in IsAdminRole: %v, user id: %d", err, currentUser.UserID)
2016-02-24 11:16:16 +01:00
}
if isAdmin {
2016-02-26 03:15:01 +01:00
t.Errorf("User is still admin after toggled, user id: %d", currentUser.UserID)
2016-02-24 11:16:16 +01:00
}
}
2016-02-23 13:49:59 +01:00
func TestDeleteUser(t *testing.T) {
2016-02-26 03:15:01 +01:00
err := DeleteUser(currentUser.UserID)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in DeleteUser: %v", err)
2016-02-01 12:59:10 +01:00
}
2016-02-24 11:16:16 +01:00
user, err := GetUser(*currentUser)
2016-02-01 12:59:10 +01:00
if err != nil {
2016-02-23 13:49:59 +01:00
t.Errorf("Error occurred in GetUser: %v", err)
}
if user != nil {
2016-02-26 07:24:44 +01:00
t.Errorf("user is not nil after deletion, user: %+v", user)
2016-02-01 12:59:10 +01:00
}
}