photoprism/internal/entity/user_test.go

529 lines
13 KiB
Go
Raw Normal View History

package entity
import (
"testing"
2020-11-21 18:08:41 +01:00
"github.com/photoprism/photoprism/internal/acl"
"github.com/photoprism/photoprism/internal/form"
"github.com/stretchr/testify/assert"
)
func TestFindUserByName(t *testing.T) {
t.Run("admin", func(t *testing.T) {
m := FindUserByName("admin")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, 1, m.ID)
assert.NotEmpty(t, m.UserUID)
assert.Equal(t, "admin", m.UserName)
assert.Equal(t, "Admin", m.FullName)
assert.True(t, m.RoleAdmin)
assert.False(t, m.RoleGuest)
assert.False(t, m.UserDisabled)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
t.Run("alice", func(t *testing.T) {
m := FindUserByName("alice")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, 5, m.ID)
assert.Equal(t, "uqxetse3cy5eo9z2", m.UserUID)
assert.Equal(t, "alice", m.UserName)
assert.Equal(t, "Alice", m.FullName)
assert.Equal(t, "alice@example.com", m.PrimaryEmail)
assert.True(t, m.RoleAdmin)
assert.False(t, m.RoleGuest)
assert.False(t, m.UserDisabled)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
t.Run("bob", func(t *testing.T) {
m := FindUserByName("bob")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, 7, m.ID)
assert.Equal(t, "uqxc08w3d0ej2283", m.UserUID)
assert.Equal(t, "bob", m.UserName)
assert.Equal(t, "Bob", m.FullName)
assert.Equal(t, "bob@example.com", m.PrimaryEmail)
assert.False(t, m.RoleAdmin)
assert.False(t, m.RoleGuest)
assert.False(t, m.UserDisabled)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
t.Run("unknown", func(t *testing.T) {
m := FindUserByName("")
if m != nil {
t.Fatal("result should be nil")
}
})
t.Run("not found", func(t *testing.T) {
m := FindUserByName("xxx")
if m != nil {
t.Fatal("result should be nil")
}
})
}
func TestUser_InvalidPassword(t *testing.T) {
t.Run("admin", func(t *testing.T) {
m := FindUserByName("admin")
if m == nil {
t.Fatal("result should not be nil")
}
assert.False(t, m.InvalidPassword("photoprism"))
})
2021-08-27 15:33:33 +02:00
t.Run("admin invalid password", func(t *testing.T) {
m := FindUserByName("admin")
if m == nil {
t.Fatal("result should not be nil")
}
assert.True(t, m.InvalidPassword("wrong-password"))
})
t.Run("no password existing", func(t *testing.T) {
p := User{UserUID: "u000000000000010", UserName: "Hans", FullName: ""}
err := p.Save()
if err != nil {
t.Fatal(err)
}
assert.True(t, p.InvalidPassword("abcdef"))
})
t.Run("not registered", func(t *testing.T) {
p := User{UserUID: "u12", UserName: "", FullName: ""}
assert.True(t, p.InvalidPassword("abcdef"))
})
t.Run("password empty", func(t *testing.T) {
p := User{UserUID: "u000000000000011", UserName: "User", FullName: ""}
assert.True(t, p.InvalidPassword(""))
})
}
func TestUser_Save(t *testing.T) {
t.Run("success", func(t *testing.T) {
p := User{}
err := p.Save()
if err != nil {
t.Fatal(err)
}
})
}
func TestFirstOrCreateUser(t *testing.T) {
t.Run("not existing", func(t *testing.T) {
p := &User{ID: 555}
result := FirstOrCreateUser(p)
if result == nil {
t.Fatal("result should not be nil")
}
assert.NotEmpty(t, result.ID)
})
t.Run("existing", func(t *testing.T) {
p := &User{ID: 1234}
err := p.Save()
if err != nil {
t.Fatal(err)
}
result := FirstOrCreateUser(p)
if result == nil {
t.Fatal("result should not be nil")
}
assert.NotEmpty(t, result.ID)
})
}
func TestFindUserByUID(t *testing.T) {
t.Run("guest", func(t *testing.T) {
m := FindUserByUID("u000000000000002")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, -2, m.ID)
assert.NotEmpty(t, m.UserUID)
assert.Equal(t, "", m.UserName)
assert.Equal(t, "Guest", m.FullName)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
t.Run("unknown", func(t *testing.T) {
m := FindUserByUID("")
if m != nil {
t.Fatal("result should be nil")
}
})
t.Run("not found", func(t *testing.T) {
m := FindUserByUID("xxx")
if m != nil {
t.Fatal("result should be nil")
}
})
t.Run("alice", func(t *testing.T) {
m := FindUserByUID("uqxetse3cy5eo9z2")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, 5, m.ID)
assert.Equal(t, "uqxetse3cy5eo9z2", m.UserUID)
assert.Equal(t, "alice", m.UserName)
assert.Equal(t, "Alice", m.FullName)
assert.Equal(t, "alice@example.com", m.PrimaryEmail)
assert.True(t, m.RoleAdmin)
assert.False(t, m.RoleGuest)
assert.False(t, m.UserDisabled)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
t.Run("bob", func(t *testing.T) {
m := FindUserByUID("uqxc08w3d0ej2283")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, 7, m.ID)
assert.Equal(t, "uqxc08w3d0ej2283", m.UserUID)
assert.Equal(t, "bob", m.UserName)
assert.Equal(t, "Bob", m.FullName)
assert.Equal(t, "bob@example.com", m.PrimaryEmail)
assert.False(t, m.RoleAdmin)
assert.False(t, m.RoleGuest)
assert.False(t, m.UserDisabled)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
2021-08-12 20:29:15 +02:00
t.Run("friend", func(t *testing.T) {
m := FindUserByUID("uqxqg7i1kperxvu7")
if m == nil {
t.Fatal("result should not be nil")
}
assert.Equal(t, 8, m.ID)
assert.Equal(t, "uqxqg7i1kperxvu7", m.UserUID)
assert.False(t, m.RoleAdmin)
assert.False(t, m.RoleGuest)
assert.True(t, m.RoleFriend)
assert.True(t, m.UserDisabled)
assert.NotEmpty(t, m.CreatedAt)
assert.NotEmpty(t, m.UpdatedAt)
})
}
func TestUser_String(t *testing.T) {
t.Run("return UID", func(t *testing.T) {
p := User{UserUID: "abc123", UserName: "", FullName: ""}
assert.Equal(t, "abc123", p.String())
})
t.Run("return display name", func(t *testing.T) {
p := User{UserUID: "abc123", UserName: "", FullName: "Test"}
assert.Equal(t, "Test", p.String())
})
t.Run("return user name", func(t *testing.T) {
p := User{UserUID: "abc123", UserName: "Super-User", FullName: "Test"}
assert.Equal(t, "Super-User", p.String())
})
}
func TestUser_Admin(t *testing.T) {
t.Run("true", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleAdmin: true}
assert.True(t, p.Admin())
})
t.Run("false", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleAdmin: false}
assert.False(t, p.Admin())
})
}
func TestUser_Anonymous(t *testing.T) {
t.Run("true", func(t *testing.T) {
p := User{UserUID: "", UserName: "Hanna", FullName: ""}
assert.True(t, p.Anonymous())
})
t.Run("false", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleAdmin: true}
assert.False(t, p.Anonymous())
})
}
func TestUser_Guest(t *testing.T) {
t.Run("true", func(t *testing.T) {
p := User{UserUID: "", UserName: "Hanna", FullName: "", RoleGuest: true}
assert.True(t, p.Guest())
})
t.Run("false", func(t *testing.T) {
p := User{UserUID: "", UserName: "Hanna", FullName: ""}
assert.False(t, p.Guest())
})
}
func TestUser_SetPassword(t *testing.T) {
t.Run("success", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: ""}
if err := p.SetPassword("abcdefgt"); err != nil {
t.Fatal(err)
}
})
t.Run("not registered", func(t *testing.T) {
p := User{UserUID: "", UserName: "Hanna", FullName: ""}
assert.Error(t, p.SetPassword("abchjy"))
})
t.Run("password too short", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: ""}
assert.Error(t, p.SetPassword("abc"))
})
}
func TestUser_InitPassword(t *testing.T) {
t.Run("success", func(t *testing.T) {
p := User{UserUID: "u000000000000009", UserName: "Hanna", FullName: ""}
assert.Nil(t, FindPassword("u000000000000009"))
p.InitPassword("abcdek")
m := FindPassword("u000000000000009")
if m == nil {
t.Fatal("result should not be nil")
}
})
t.Run("already existing", func(t *testing.T) {
p := User{UserUID: "u000000000000010", UserName: "Hans", FullName: ""}
if err := p.Save(); err != nil {
t.Logf("can't user %s: ", err)
}
if err := p.SetPassword("hutfdt"); err != nil {
t.Fatal(err)
}
assert.NotNil(t, FindPassword("u000000000000010"))
p.InitPassword("hutfdt")
m := FindPassword("u000000000000010")
if m == nil {
t.Fatal("result should not be nil")
}
})
t.Run("not registered", func(t *testing.T) {
p := User{UserUID: "u12", UserName: "", FullName: ""}
assert.Nil(t, FindPassword("u12"))
p.InitPassword("dcjygkh")
assert.Nil(t, FindPassword("u12"))
})
t.Run("password empty", func(t *testing.T) {
p := User{UserUID: "u000000000000011", UserName: "User", FullName: ""}
assert.Nil(t, FindPassword("u000000000000011"))
p.InitPassword("")
assert.Nil(t, FindPassword("u000000000000011"))
})
}
func TestUser_Role(t *testing.T) {
t.Run("admin", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleAdmin: true}
assert.Equal(t, acl.Role("admin"), p.Role())
})
t.Run("child", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleChild: true}
assert.Equal(t, acl.Role("child"), p.Role())
})
t.Run("family", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleFamily: true}
assert.Equal(t, acl.Role("family"), p.Role())
})
t.Run("friend", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleFriend: true}
assert.Equal(t, acl.Role("friend"), p.Role())
})
t.Run("guest", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: "", RoleGuest: true}
assert.Equal(t, acl.Role("guest"), p.Role())
})
t.Run("default", func(t *testing.T) {
p := User{UserUID: "u000000000000008", UserName: "Hanna", FullName: ""}
assert.Equal(t, acl.Role("*"), p.Role())
})
}
func TestUser_Validate(t *testing.T) {
t.Run("valid", func(t *testing.T) {
u := &User{
AddressID: 1,
UserName: "validate",
FullName: "Validate",
PrimaryEmail: "validate@example.com",
}
err := u.Validate()
assert.Nil(t, err)
})
t.Run("username empty", func(t *testing.T) {
u := &User{
AddressID: 1,
UserName: "",
FullName: "Validate",
PrimaryEmail: "validate@example.com",
}
err := u.Validate()
assert.Error(t, err)
})
t.Run("username too short", func(t *testing.T) {
u := &User{
AddressID: 1,
UserName: "val",
FullName: "Validate",
PrimaryEmail: "validate@example.com",
}
err := u.Validate()
assert.Error(t, err)
})
t.Run("username not unique", func(t *testing.T) {
FirstOrCreateUser(&User{
AddressID: 1,
UserName: "notunique1",
})
2021-08-27 15:33:33 +02:00
u := &User{
AddressID: 1,
UserName: "notunique1",
FullName: "Not Unique",
PrimaryEmail: "notunique1@example.com",
}
2021-08-27 15:33:33 +02:00
assert.Error(t, u.Validate())
})
t.Run("email not unique", func(t *testing.T) {
FirstOrCreateUser(&User{
AddressID: 1,
PrimaryEmail: "notunique2@example.com",
})
2021-08-27 15:33:33 +02:00
u := &User{
AddressID: 1,
UserName: "notunique2",
FullName: "Not Unique",
PrimaryEmail: "notunique2@example.com",
}
2021-08-27 15:33:33 +02:00
assert.Error(t, u.Validate())
})
t.Run("update user - email not unique", func(t *testing.T) {
FirstOrCreateUser(&User{
AddressID: 1,
UserName: "notunique3",
FullName: "Not Unique",
PrimaryEmail: "notunique3@example.com",
})
u := FirstOrCreateUser(&User{
AddressID: 1,
UserName: "notunique30",
FullName: "Not Unique",
PrimaryEmail: "notunique3@example.com",
})
u.UserName = "notunique3"
assert.Error(t, u.Validate())
})
2021-08-27 15:33:33 +02:00
t.Run("primary email empty", func(t *testing.T) {
FirstOrCreateUser(&User{
AddressID: 1,
UserName: "nnomail",
})
u := &User{
AddressID: 1,
UserName: "nomail",
FullName: "No Mail",
PrimaryEmail: "",
}
assert.Nil(t, u.Validate())
})
}
func TestCreateWithPassword(t *testing.T) {
t.Run("password too short", func(t *testing.T) {
u := form.UserCreate{
UserName: "thomas1",
FullName: "Thomas One",
Email: "thomas1@example.com",
Password: "hel",
}
err := CreateWithPassword(u)
assert.Error(t, err)
})
t.Run("valid", func(t *testing.T) {
u := form.UserCreate{
UserName: "thomas2",
FullName: "Thomas Two",
Email: "thomas2@example.com",
Password: "helloworld",
}
err := CreateWithPassword(u)
assert.Nil(t, err)
})
}
2021-08-23 11:52:37 +02:00
func TestDeleteUser(t *testing.T) {
t.Run("delete user - success", func(t *testing.T) {
u := &User{
AddressID: 1,
UserName: "thomasdel",
FullName: "Thomas Delete",
PrimaryEmail: "thomasdel@example.com",
}
u = FirstOrCreateUser(u)
err := u.Delete()
assert.NoError(t, err)
})
t.Run("delete user - not in db", func(t *testing.T) {
u := &User{
AddressID: 1,
UserName: "thomasdel2",
FullName: "Thomas Delete 2",
PrimaryEmail: "thomasdel2@example.com",
}
err := u.Delete()
assert.Error(t, err)
})
}
2021-08-27 15:33:33 +02:00
func TestUser_Deleted(t *testing.T) {
assert.False(t, UserFixtures.Pointer("alice").Deleted())
assert.True(t, UserFixtures.Pointer("deleted").Deleted())
}