netmaker/controllers/user_test.go

316 lines
9.2 KiB
Go
Raw Normal View History

2021-04-29 01:49:24 +08:00
package controller
import (
"testing"
2021-09-06 22:36:14 +08:00
"github.com/gravitl/netmaker/database"
2021-10-22 08:32:23 +08:00
"github.com/gravitl/netmaker/logic"
2021-04-29 01:49:24 +08:00
"github.com/gravitl/netmaker/models"
"github.com/stretchr/testify/assert"
)
2021-09-06 22:36:14 +08:00
func deleteAllUsers() {
2021-10-22 08:32:23 +08:00
users, _ := logic.GetUsers()
2021-09-06 22:36:14 +08:00
for _, user := range users {
2021-10-22 08:32:23 +08:00
logic.DeleteUser(user.UserName)
2021-05-10 03:46:31 +08:00
}
2021-04-29 01:49:24 +08:00
}
2021-09-06 22:36:14 +08:00
2021-04-30 06:14:13 +08:00
func TestHasAdmin(t *testing.T) {
2021-09-06 22:36:14 +08:00
//delete all current users
database.InitializeDatabase()
2021-10-22 08:32:23 +08:00
users, _ := logic.GetUsers()
2021-09-06 22:36:14 +08:00
for _, user := range users {
2021-10-22 08:32:23 +08:00
success, err := logic.DeleteUser(user.UserName)
2021-09-06 22:36:14 +08:00
assert.Nil(t, err)
assert.True(t, success)
}
t.Run("NoUser", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
found, err := logic.HasAdmin()
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-09-06 22:36:14 +08:00
assert.False(t, found)
2021-04-30 06:14:13 +08:00
})
2021-09-06 22:36:14 +08:00
t.Run("No admin user", func(t *testing.T) {
var user = models.User{"noadmin", "password", nil, false}
2021-10-22 08:32:23 +08:00
_, err := logic.CreateUser(user)
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-10-22 08:32:23 +08:00
found, err := logic.HasAdmin()
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
assert.False(t, found)
})
2021-09-06 22:36:14 +08:00
t.Run("admin user", func(t *testing.T) {
var user = models.User{"admin", "password", nil, true}
2021-10-22 08:32:23 +08:00
_, err := logic.CreateUser(user)
2021-09-06 22:36:14 +08:00
assert.Nil(t, err)
2021-10-22 08:32:23 +08:00
found, err := logic.HasAdmin()
2021-09-06 22:36:14 +08:00
assert.Nil(t, err)
assert.True(t, found)
})
t.Run("multiple admins", func(t *testing.T) {
var user = models.User{"admin1", "password", nil, true}
2021-10-22 08:32:23 +08:00
_, err := logic.CreateUser(user)
2021-09-06 22:36:14 +08:00
assert.Nil(t, err)
2021-10-22 08:32:23 +08:00
found, err := logic.HasAdmin()
2021-09-06 22:36:14 +08:00
assert.Nil(t, err)
assert.True(t, found)
})
2021-04-30 06:14:13 +08:00
}
func TestCreateUser(t *testing.T) {
2021-09-06 22:36:14 +08:00
database.InitializeDatabase()
deleteAllUsers()
2021-07-02 12:22:08 +08:00
user := models.User{"admin", "password", nil, true}
2021-04-30 06:14:13 +08:00
t.Run("NoUser", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
admin, err := logic.CreateUser(user)
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
assert.Equal(t, user.UserName, admin.UserName)
})
2021-09-06 22:36:14 +08:00
t.Run("UserExists", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
_, err := logic.CreateUser(user)
2021-05-01 11:07:25 +08:00
assert.NotNil(t, err)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "user exists")
2021-04-30 06:14:13 +08:00
})
}
2021-10-15 04:36:14 +08:00
func TestCreateAdmin(t *testing.T) {
database.InitializeDatabase()
deleteAllUsers()
var user models.User
t.Run("NoAdmin", func(t *testing.T) {
user.UserName = "admin"
user.Password = "password"
2021-10-22 08:32:23 +08:00
admin, err := logic.CreateAdmin(user)
2021-10-15 04:36:14 +08:00
assert.Nil(t, err)
assert.Equal(t, user.UserName, admin.UserName)
})
t.Run("AdminExists", func(t *testing.T) {
user.UserName = "admin2"
user.Password = "password1"
2021-10-22 08:32:23 +08:00
admin, err := logic.CreateAdmin(user)
2021-10-15 04:36:14 +08:00
assert.EqualError(t, err, "admin user already exists")
assert.Equal(t, admin, models.User{})
})
}
2021-04-29 01:49:24 +08:00
func TestDeleteUser(t *testing.T) {
2021-09-06 22:36:14 +08:00
database.InitializeDatabase()
deleteAllUsers()
t.Run("NonExistent User", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
deleted, err := logic.DeleteUser("admin")
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "user does not exist")
assert.False(t, deleted)
2021-04-29 01:49:24 +08:00
})
2021-09-06 22:36:14 +08:00
t.Run("Existing User", func(t *testing.T) {
user := models.User{"admin", "password", nil, true}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
deleted, err := logic.DeleteUser("admin")
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-09-06 22:36:14 +08:00
assert.True(t, deleted)
2021-04-29 01:49:24 +08:00
})
}
2021-04-30 06:14:13 +08:00
func TestValidateUser(t *testing.T) {
2021-09-06 22:36:14 +08:00
database.InitializeDatabase()
2021-04-30 06:14:13 +08:00
var user models.User
2021-09-06 22:36:14 +08:00
t.Run("Valid Create", func(t *testing.T) {
2021-04-30 06:14:13 +08:00
user.UserName = "admin"
user.Password = "validpass"
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
})
2021-09-06 22:36:14 +08:00
t.Run("Valid Update", func(t *testing.T) {
2021-04-30 06:14:13 +08:00
user.UserName = "admin"
2021-04-30 23:30:19 +08:00
user.Password = "password"
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
})
2021-09-06 22:36:14 +08:00
t.Run("Invalid UserName", func(t *testing.T) {
t.Skip()
user.UserName = "*invalid"
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-09-06 22:36:14 +08:00
assert.Error(t, err)
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
2021-04-30 06:14:13 +08:00
})
2021-09-06 22:36:14 +08:00
t.Run("Short UserName", func(t *testing.T) {
t.Skip()
user.UserName = "1"
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-05-01 11:07:25 +08:00
assert.NotNil(t, err)
2021-09-06 22:36:14 +08:00
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
})
t.Run("Empty UserName", func(t *testing.T) {
t.Skip()
user.UserName = ""
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "some string")
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
2021-04-30 06:14:13 +08:00
})
t.Run("EmptyPassword", func(t *testing.T) {
user.Password = ""
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "Key: 'User.Password' Error:Field validation for 'Password' failed on the 'required' tag")
2021-04-30 06:14:13 +08:00
})
t.Run("ShortPassword", func(t *testing.T) {
user.Password = "123"
2021-10-22 08:32:23 +08:00
err := logic.ValidateUser(user)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "Key: 'User.Password' Error:Field validation for 'Password' failed on the 'min' tag")
2021-04-30 06:14:13 +08:00
})
}
func TestGetUser(t *testing.T) {
2021-09-06 22:36:14 +08:00
database.InitializeDatabase()
deleteAllUsers()
t.Run("NonExistantUser", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
admin, err := logic.GetUser("admin")
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, "", admin.UserName)
})
2021-04-30 06:14:13 +08:00
t.Run("UserExisits", func(t *testing.T) {
2021-07-02 12:22:08 +08:00
user := models.User{"admin", "password", nil, true}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
admin, err := logic.GetUser("admin")
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
assert.Equal(t, user.UserName, admin.UserName)
})
}
func TestGetUserInternal(t *testing.T) {
database.InitializeDatabase()
deleteAllUsers()
t.Run("NonExistantUser", func(t *testing.T) {
admin, err := GetUserInternal("admin")
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, "", admin.UserName)
})
t.Run("UserExisits", func(t *testing.T) {
user := models.User{"admin", "password", nil, true}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
admin, err := GetUserInternal("admin")
assert.Nil(t, err)
assert.Equal(t, user.UserName, admin.UserName)
})
}
func TestGetUsers(t *testing.T) {
database.InitializeDatabase()
deleteAllUsers()
t.Run("NonExistantUser", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
admin, err := logic.GetUsers()
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, []models.ReturnUser(nil), admin)
})
t.Run("UserExisits", func(t *testing.T) {
user := models.User{"admin", "password", nil, true}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
admins, err := logic.GetUsers()
assert.Nil(t, err)
assert.Equal(t, user.UserName, admins[0].UserName)
})
t.Run("MulipleUsers", func(t *testing.T) {
user := models.User{"user", "password", nil, true}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
admins, err := logic.GetUsers()
assert.Nil(t, err)
2021-10-20 23:23:44 +08:00
for _, u := range admins {
if u.UserName == "admin" {
assert.Equal(t, "admin", u.UserName)
} else {
assert.Equal(t, user.UserName, u.UserName)
}
}
})
}
2021-04-30 06:14:13 +08:00
func TestUpdateUser(t *testing.T) {
2021-09-06 22:36:14 +08:00
database.InitializeDatabase()
deleteAllUsers()
2021-07-02 12:22:08 +08:00
user := models.User{"admin", "password", nil, true}
2021-09-06 22:36:14 +08:00
newuser := models.User{"hello", "world", []string{"wirecat, netmaker"}, true}
t.Run("NonExistantUser", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
admin, err := logic.UpdateUser(newuser, user)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, "", admin.UserName)
})
2021-10-20 23:23:44 +08:00
t.Run("UserExists", func(t *testing.T) {
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
admin, err := logic.UpdateUser(newuser, user)
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
assert.Equal(t, newuser.UserName, admin.UserName)
})
}
2021-12-08 01:46:55 +08:00
// func TestValidateUserToken(t *testing.T) {
// t.Run("EmptyToken", func(t *testing.T) {
// err := ValidateUserToken("", "", false)
// assert.NotNil(t, err)
// assert.Equal(t, "Missing Auth Token.", err.Error())
// })
// t.Run("InvalidToken", func(t *testing.T) {
// err := ValidateUserToken("Bearer: badtoken", "", false)
// assert.NotNil(t, err)
// assert.Equal(t, "Error Verifying Auth Token", err.Error())
// })
// t.Run("InvalidUser", func(t *testing.T) {
// t.Skip()
// err := ValidateUserToken("Bearer: secretkey", "baduser", false)
// assert.NotNil(t, err)
// assert.Equal(t, "Error Verifying Auth Token", err.Error())
// //need authorization
// })
// t.Run("ValidToken", func(t *testing.T) {
// err := ValidateUserToken("Bearer: secretkey", "", true)
// assert.Nil(t, err)
// })
// }
2021-04-30 06:14:13 +08:00
func TestVerifyAuthRequest(t *testing.T) {
2021-09-06 22:36:14 +08:00
database.InitializeDatabase()
deleteAllUsers()
2021-04-30 06:14:13 +08:00
var authRequest models.UserAuthParams
t.Run("EmptyUserName", func(t *testing.T) {
authRequest.UserName = ""
authRequest.Password = "Password"
2021-10-22 08:32:23 +08:00
jwt, err := logic.VerifyAuthRequest(authRequest)
2021-04-30 06:14:13 +08:00
assert.Equal(t, "", jwt)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "username can't be empty")
2021-04-30 06:14:13 +08:00
})
t.Run("EmptyPassword", func(t *testing.T) {
authRequest.UserName = "admin"
authRequest.Password = ""
2021-10-22 08:32:23 +08:00
jwt, err := logic.VerifyAuthRequest(authRequest)
2021-04-30 06:14:13 +08:00
assert.Equal(t, "", jwt)
2021-09-06 22:36:14 +08:00
assert.EqualError(t, err, "password can't be empty")
2021-04-30 06:14:13 +08:00
})
t.Run("NonExistantUser", func(t *testing.T) {
authRequest.UserName = "admin"
authRequest.Password = "password"
2021-10-22 08:32:23 +08:00
jwt, err := logic.VerifyAuthRequest(authRequest)
2021-04-30 06:14:13 +08:00
assert.Equal(t, "", jwt)
assert.EqualError(t, err, "incorrect credentials")
2021-04-30 06:14:13 +08:00
})
t.Run("Non-Admin", func(t *testing.T) {
2021-09-06 22:36:14 +08:00
user := models.User{"nonadmin", "somepass", nil, false}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
2021-09-06 22:36:14 +08:00
authRequest := models.UserAuthParams{"nonadmin", "somepass"}
2021-10-22 08:32:23 +08:00
jwt, err := logic.VerifyAuthRequest(authRequest)
2021-09-06 22:36:14 +08:00
assert.NotNil(t, jwt)
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
})
t.Run("WrongPassword", func(t *testing.T) {
2021-09-06 22:36:14 +08:00
user := models.User{"admin", "password", nil, false}
2021-10-22 08:32:23 +08:00
logic.CreateUser(user)
2021-04-30 06:14:13 +08:00
authRequest := models.UserAuthParams{"admin", "badpass"}
2021-10-22 08:32:23 +08:00
jwt, err := logic.VerifyAuthRequest(authRequest)
2021-04-30 06:14:13 +08:00
assert.Equal(t, "", jwt)
assert.EqualError(t, err, "incorrect credentials")
2021-04-30 06:14:13 +08:00
})
t.Run("Success", func(t *testing.T) {
2021-04-30 23:30:19 +08:00
authRequest := models.UserAuthParams{"admin", "password"}
2021-10-22 08:32:23 +08:00
jwt, err := logic.VerifyAuthRequest(authRequest)
2021-05-01 11:07:25 +08:00
assert.Nil(t, err)
2021-04-30 06:14:13 +08:00
assert.NotNil(t, jwt)
})
}