2021-11-24 04:49:20 -05:00
// Copyright 2017 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2022-06-15 03:02:00 -04:00
package user_test
2021-11-24 04:49:20 -05:00
import (
"math/rand"
"strings"
"testing"
2022-01-02 08:12:35 -05:00
"code.gitea.io/gitea/models/auth"
2021-11-24 04:49:20 -05:00
"code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/models/unittest"
2022-06-15 03:02:00 -04:00
user_model "code.gitea.io/gitea/models/user"
2021-11-24 04:49:20 -05:00
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
)
func TestOAuth2Application_LoadUser ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
app := unittest . AssertExistsAndLoadBean ( t , & auth . OAuth2Application { ID : 1 } )
2022-06-15 03:02:00 -04:00
user , err := user_model . GetUserByID ( app . UID )
2021-11-24 04:49:20 -05:00
assert . NoError ( t , err )
assert . NotNil ( t , user )
}
func TestGetUserEmailsByNames ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
// ignore none active user email
2022-06-15 03:02:00 -04:00
assert . Equal ( t , [ ] string { "user8@example.com" } , user_model . GetUserEmailsByNames ( db . DefaultContext , [ ] string { "user8" , "user9" } ) )
assert . Equal ( t , [ ] string { "user8@example.com" , "user5@example.com" } , user_model . GetUserEmailsByNames ( db . DefaultContext , [ ] string { "user8" , "user5" } ) )
2021-11-24 04:49:20 -05:00
2022-06-15 03:02:00 -04:00
assert . Equal ( t , [ ] string { "user8@example.com" } , user_model . GetUserEmailsByNames ( db . DefaultContext , [ ] string { "user8" , "user7" } ) )
2021-11-24 04:49:20 -05:00
}
func TestCanCreateOrganization ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
admin := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 1 } )
2021-11-24 04:49:20 -05:00
assert . True ( t , admin . CanCreateOrganization ( ) )
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 2 } )
2021-11-24 04:49:20 -05:00
assert . True ( t , user . CanCreateOrganization ( ) )
// Disable user create organization permission.
user . AllowCreateOrganization = false
assert . False ( t , user . CanCreateOrganization ( ) )
setting . Admin . DisableRegularOrgCreation = true
user . AllowCreateOrganization = true
assert . True ( t , admin . CanCreateOrganization ( ) )
assert . False ( t , user . CanCreateOrganization ( ) )
}
func TestSearchUsers ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-06-15 03:02:00 -04:00
testSuccess := func ( opts * user_model . SearchUserOptions , expectedUserOrOrgIDs [ ] int64 ) {
users , _ , err := user_model . SearchUsers ( opts )
2021-11-24 04:49:20 -05:00
assert . NoError ( t , err )
if assert . Len ( t , users , len ( expectedUserOrOrgIDs ) , opts ) {
for i , expectedID := range expectedUserOrOrgIDs {
assert . EqualValues ( t , expectedID , users [ i ] . ID )
}
}
}
// test orgs
2022-06-15 03:02:00 -04:00
testOrgSuccess := func ( opts * user_model . SearchUserOptions , expectedOrgIDs [ ] int64 ) {
opts . Type = user_model . UserTypeOrganization
2021-11-24 04:49:20 -05:00
testSuccess ( opts , expectedOrgIDs )
}
2022-06-15 03:02:00 -04:00
testOrgSuccess ( & user_model . SearchUserOptions { OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 1 , PageSize : 2 } } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 3 , 6 } )
2022-06-15 03:02:00 -04:00
testOrgSuccess ( & user_model . SearchUserOptions { OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 2 , PageSize : 2 } } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 7 , 17 } )
2022-06-15 03:02:00 -04:00
testOrgSuccess ( & user_model . SearchUserOptions { OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 3 , PageSize : 2 } } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 19 , 25 } )
2022-06-15 03:02:00 -04:00
testOrgSuccess ( & user_model . SearchUserOptions { OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 4 , PageSize : 2 } } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 26 } )
2022-06-15 03:02:00 -04:00
testOrgSuccess ( & user_model . SearchUserOptions { ListOptions : db . ListOptions { Page : 5 , PageSize : 2 } } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { } )
// test users
2022-06-15 03:02:00 -04:00
testUserSuccess := func ( opts * user_model . SearchUserOptions , expectedUserIDs [ ] int64 ) {
opts . Type = user_model . UserTypeIndividual
2021-11-24 04:49:20 -05:00
testSuccess ( opts , expectedUserIDs )
}
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 1 } } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 1 , 2 , 4 , 5 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 18 , 20 , 21 , 24 , 27 , 28 , 29 , 30 , 32 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { ListOptions : db . ListOptions { Page : 1 } , IsActive : util . OptionalBoolFalse } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 9 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 1 } , IsActive : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 1 , 2 , 4 , 5 , 8 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 18 , 20 , 21 , 24 , 28 , 29 , 30 , 32 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { Keyword : "user1" , OrderBy : "id ASC" , ListOptions : db . ListOptions { Page : 1 } , IsActive : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 1 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 18 } )
// order by name asc default
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { Keyword : "user1" , ListOptions : db . ListOptions { Page : 1 } , IsActive : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 1 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 18 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { ListOptions : db . ListOptions { Page : 1 } , IsAdmin : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 1 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { ListOptions : db . ListOptions { Page : 1 } , IsRestricted : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 29 , 30 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { ListOptions : db . ListOptions { Page : 1 } , IsProhibitLogin : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 30 } )
2022-06-15 03:02:00 -04:00
testUserSuccess ( & user_model . SearchUserOptions { ListOptions : db . ListOptions { Page : 1 } , IsTwoFactorEnabled : util . OptionalBoolTrue } ,
2021-11-24 04:49:20 -05:00
[ ] int64 { 24 } )
}
func TestEmailNotificationPreferences ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
for _ , test := range [ ] struct {
expected string
userID int64
} {
2022-06-15 03:02:00 -04:00
{ user_model . EmailNotificationsEnabled , 1 } ,
{ user_model . EmailNotificationsEnabled , 2 } ,
{ user_model . EmailNotificationsOnMention , 3 } ,
{ user_model . EmailNotificationsOnMention , 4 } ,
{ user_model . EmailNotificationsEnabled , 5 } ,
{ user_model . EmailNotificationsEnabled , 6 } ,
{ user_model . EmailNotificationsDisabled , 7 } ,
{ user_model . EmailNotificationsEnabled , 8 } ,
{ user_model . EmailNotificationsOnMention , 9 } ,
2021-11-24 04:49:20 -05:00
} {
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : test . userID } )
2021-11-24 04:49:20 -05:00
assert . Equal ( t , test . expected , user . EmailNotifications ( ) )
// Try all possible settings
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . SetEmailNotifications ( user , user_model . EmailNotificationsEnabled ) )
assert . Equal ( t , user_model . EmailNotificationsEnabled , user . EmailNotifications ( ) )
2021-11-24 04:49:20 -05:00
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . SetEmailNotifications ( user , user_model . EmailNotificationsOnMention ) )
assert . Equal ( t , user_model . EmailNotificationsOnMention , user . EmailNotifications ( ) )
2021-11-24 04:49:20 -05:00
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . SetEmailNotifications ( user , user_model . EmailNotificationsDisabled ) )
assert . Equal ( t , user_model . EmailNotificationsDisabled , user . EmailNotifications ( ) )
2022-07-28 04:30:12 -04:00
assert . NoError ( t , user_model . SetEmailNotifications ( user , user_model . EmailNotificationsAndYourOwn ) )
assert . Equal ( t , user_model . EmailNotificationsAndYourOwn , user . EmailNotifications ( ) )
2021-11-24 04:49:20 -05:00
}
}
func TestHashPasswordDeterministic ( t * testing . T ) {
b := make ( [ ] byte , 16 )
2022-06-15 03:02:00 -04:00
u := & user_model . User { }
2021-11-24 04:49:20 -05:00
algos := [ ] string { "argon2" , "pbkdf2" , "scrypt" , "bcrypt" }
for j := 0 ; j < len ( algos ) ; j ++ {
u . PasswdHashAlgo = algos [ j ]
for i := 0 ; i < 50 ; i ++ {
// generate a random password
rand . Read ( b )
pass := string ( b )
// save the current password in the user - hash it and store the result
u . SetPassword ( pass )
r1 := u . Passwd
// run again
u . SetPassword ( pass )
r2 := u . Passwd
assert . NotEqual ( t , r1 , r2 )
assert . True ( t , u . ValidatePassword ( pass ) )
}
}
}
func BenchmarkHashPassword ( b * testing . B ) {
// BenchmarkHashPassword ensures that it takes a reasonable amount of time
// to hash a password - in order to protect from brute-force attacks.
pass := "password1337"
2022-06-15 03:02:00 -04:00
u := & user_model . User { Passwd : pass }
2021-11-24 04:49:20 -05:00
b . ResetTimer ( )
for i := 0 ; i < b . N ; i ++ {
u . SetPassword ( pass )
}
}
func TestNewGitSig ( t * testing . T ) {
2022-06-15 03:02:00 -04:00
users := make ( [ ] * user_model . User , 0 , 20 )
2021-11-24 04:49:20 -05:00
err := db . GetEngine ( db . DefaultContext ) . Find ( & users )
assert . NoError ( t , err )
for _ , user := range users {
sig := user . NewGitSig ( )
assert . NotContains ( t , sig . Name , "<" )
assert . NotContains ( t , sig . Name , ">" )
assert . NotContains ( t , sig . Name , "\n" )
assert . NotEqual ( t , len ( strings . TrimSpace ( sig . Name ) ) , 0 )
}
}
func TestDisplayName ( t * testing . T ) {
2022-06-15 03:02:00 -04:00
users := make ( [ ] * user_model . User , 0 , 20 )
2021-11-24 04:49:20 -05:00
err := db . GetEngine ( db . DefaultContext ) . Find ( & users )
assert . NoError ( t , err )
for _ , user := range users {
displayName := user . DisplayName ( )
assert . Equal ( t , strings . TrimSpace ( displayName ) , displayName )
if len ( strings . TrimSpace ( user . FullName ) ) == 0 {
assert . Equal ( t , user . Name , displayName )
}
assert . NotEqual ( t , len ( strings . TrimSpace ( displayName ) ) , 0 )
}
}
func TestCreateUserInvalidEmail ( t * testing . T ) {
2022-06-15 03:02:00 -04:00
user := & user_model . User {
2021-11-24 04:49:20 -05:00
Name : "GiteaBot" ,
Email : "GiteaBot@gitea.io\r\n" ,
Passwd : ";p['////..-++']" ,
IsAdmin : false ,
Theme : setting . UI . DefaultTheme ,
MustChangePassword : false ,
}
2022-06-15 03:02:00 -04:00
err := user_model . CreateUser ( user )
2021-11-24 04:49:20 -05:00
assert . Error ( t , err )
2022-06-15 03:02:00 -04:00
assert . True ( t , user_model . IsErrEmailCharIsNotSupported ( err ) )
2021-11-24 04:49:20 -05:00
}
2022-02-18 04:33:00 -05:00
func TestCreateUserEmailAlreadyUsed ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 2 } )
2022-02-18 04:33:00 -05:00
// add new user with user2's email
user . Name = "testuser"
user . LowerName = strings . ToLower ( user . Name )
user . ID = 0
2022-06-15 03:02:00 -04:00
err := user_model . CreateUser ( user )
2022-02-18 04:33:00 -05:00
assert . Error ( t , err )
2022-06-15 03:02:00 -04:00
assert . True ( t , user_model . IsErrEmailAlreadyUsed ( err ) )
2022-02-18 04:33:00 -05:00
}
2021-11-24 04:49:20 -05:00
func TestGetUserIDsByNames ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
// ignore non existing
2022-06-15 03:02:00 -04:00
IDs , err := user_model . GetUserIDsByNames ( [ ] string { "user1" , "user2" , "none_existing_user" } , true )
2021-11-24 04:49:20 -05:00
assert . NoError ( t , err )
assert . Equal ( t , [ ] int64 { 1 , 2 } , IDs )
// ignore non existing
2022-06-15 03:02:00 -04:00
IDs , err = user_model . GetUserIDsByNames ( [ ] string { "user1" , "do_not_exist" } , false )
2021-11-24 04:49:20 -05:00
assert . Error ( t , err )
assert . Equal ( t , [ ] int64 ( nil ) , IDs )
}
func TestGetMaileableUsersByIDs ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-06-15 03:02:00 -04:00
results , err := user_model . GetMaileableUsersByIDs ( [ ] int64 { 1 , 4 } , false )
2021-11-24 04:49:20 -05:00
assert . NoError ( t , err )
assert . Len ( t , results , 1 )
if len ( results ) > 1 {
assert . Equal ( t , results [ 0 ] . ID , 1 )
}
2022-06-15 03:02:00 -04:00
results , err = user_model . GetMaileableUsersByIDs ( [ ] int64 { 1 , 4 } , true )
2021-11-24 04:49:20 -05:00
assert . NoError ( t , err )
assert . Len ( t , results , 2 )
if len ( results ) > 2 {
assert . Equal ( t , results [ 0 ] . ID , 1 )
assert . Equal ( t , results [ 1 ] . ID , 4 )
}
}
func TestUpdateUser ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 2 } )
2021-11-24 04:49:20 -05:00
user . KeepActivityPrivate = true
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . UpdateUser ( db . DefaultContext , user , false ) )
2022-08-15 22:22:25 -04:00
user = unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 2 } )
2021-11-24 04:49:20 -05:00
assert . True ( t , user . KeepActivityPrivate )
setting . Service . AllowedUserVisibilityModesSlice = [ ] bool { true , false , false }
user . KeepActivityPrivate = false
user . Visibility = structs . VisibleTypePrivate
2022-06-15 03:02:00 -04:00
assert . Error ( t , user_model . UpdateUser ( db . DefaultContext , user , false ) )
2022-08-15 22:22:25 -04:00
user = unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 2 } )
2021-11-24 04:49:20 -05:00
assert . True ( t , user . KeepActivityPrivate )
user . Email = "no mail@mail.org"
2022-06-15 03:02:00 -04:00
assert . Error ( t , user_model . UpdateUser ( db . DefaultContext , user , true ) )
2021-11-24 04:49:20 -05:00
}
func TestNewUserRedirect ( t * testing . T ) {
// redirect to a completely new name
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 1 } )
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . NewUserRedirect ( db . DefaultContext , user . ID , user . Name , "newusername" ) )
2021-11-24 04:49:20 -05:00
2022-06-15 03:02:00 -04:00
unittest . AssertExistsAndLoadBean ( t , & user_model . Redirect {
2021-11-24 04:49:20 -05:00
LowerName : user . LowerName ,
RedirectUserID : user . ID ,
} )
2022-06-15 03:02:00 -04:00
unittest . AssertExistsAndLoadBean ( t , & user_model . Redirect {
2021-11-24 04:49:20 -05:00
LowerName : "olduser1" ,
RedirectUserID : user . ID ,
} )
}
func TestNewUserRedirect2 ( t * testing . T ) {
// redirect to previously used name
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 1 } )
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . NewUserRedirect ( db . DefaultContext , user . ID , user . Name , "olduser1" ) )
2021-11-24 04:49:20 -05:00
2022-06-15 03:02:00 -04:00
unittest . AssertExistsAndLoadBean ( t , & user_model . Redirect {
2021-11-24 04:49:20 -05:00
LowerName : user . LowerName ,
RedirectUserID : user . ID ,
} )
2022-06-15 03:02:00 -04:00
unittest . AssertNotExistsBean ( t , & user_model . Redirect {
2021-11-24 04:49:20 -05:00
LowerName : "olduser1" ,
RedirectUserID : user . ID ,
} )
}
func TestNewUserRedirect3 ( t * testing . T ) {
// redirect for a previously-unredirected user
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-08-15 22:22:25 -04:00
user := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 2 } )
2022-06-15 03:02:00 -04:00
assert . NoError ( t , user_model . NewUserRedirect ( db . DefaultContext , user . ID , user . Name , "newusername" ) )
2021-11-24 04:49:20 -05:00
2022-06-15 03:02:00 -04:00
unittest . AssertExistsAndLoadBean ( t , & user_model . Redirect {
2021-11-24 04:49:20 -05:00
LowerName : user . LowerName ,
RedirectUserID : user . ID ,
} )
}
func TestGetUserByOpenID ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
2022-06-15 03:02:00 -04:00
_ , err := user_model . GetUserByOpenID ( "https://unknown" )
2021-11-24 04:49:20 -05:00
if assert . Error ( t , err ) {
2022-06-15 03:02:00 -04:00
assert . True ( t , user_model . IsErrUserNotExist ( err ) )
2021-11-24 04:49:20 -05:00
}
2022-06-15 03:02:00 -04:00
user , err := user_model . GetUserByOpenID ( "https://user1.domain1.tld" )
2021-11-24 04:49:20 -05:00
if assert . NoError ( t , err ) {
assert . Equal ( t , int64 ( 1 ) , user . ID )
}
2022-06-15 03:02:00 -04:00
user , err = user_model . GetUserByOpenID ( "https://domain1.tld/user2/" )
2021-11-24 04:49:20 -05:00
if assert . NoError ( t , err ) {
assert . Equal ( t , int64 ( 2 ) , user . ID )
}
}
2022-06-15 03:02:00 -04:00
func TestFollowUser ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
testSuccess := func ( followerID , followedID int64 ) {
assert . NoError ( t , user_model . FollowUser ( followerID , followedID ) )
unittest . AssertExistsAndLoadBean ( t , & user_model . Follow { UserID : followerID , FollowID : followedID } )
}
testSuccess ( 4 , 2 )
testSuccess ( 5 , 2 )
assert . NoError ( t , user_model . FollowUser ( 2 , 2 ) )
unittest . CheckConsistencyFor ( t , & user_model . User { } )
}
func TestUnfollowUser ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
testSuccess := func ( followerID , followedID int64 ) {
assert . NoError ( t , user_model . UnfollowUser ( followerID , followedID ) )
unittest . AssertNotExistsBean ( t , & user_model . Follow { UserID : followerID , FollowID : followedID } )
}
testSuccess ( 4 , 2 )
testSuccess ( 5 , 2 )
testSuccess ( 2 , 2 )
unittest . CheckConsistencyFor ( t , & user_model . User { } )
}
2022-09-20 03:59:20 -04:00
func TestIsUserVisibleToViewer ( t * testing . T ) {
assert . NoError ( t , unittest . PrepareTestDatabase ( ) )
user1 := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 1 } ) // admin, public
user4 := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 4 } ) // normal, public
user20 := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 20 } ) // public, same team as user31
user29 := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 29 } ) // public, is restricted
user31 := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 31 } ) // private, same team as user20
user33 := unittest . AssertExistsAndLoadBean ( t , & user_model . User { ID : 33 } ) // limited, follows 31
test := func ( u , viewer * user_model . User , expected bool ) {
name := func ( u * user_model . User ) string {
if u == nil {
return "<nil>"
}
return u . Name
}
assert . Equal ( t , expected , user_model . IsUserVisibleToViewer ( db . DefaultContext , u , viewer ) , "user %v should be visible to viewer %v: %v" , name ( u ) , name ( viewer ) , expected )
}
// admin viewer
test ( user1 , user1 , true )
test ( user20 , user1 , true )
test ( user31 , user1 , true )
test ( user33 , user1 , true )
// non admin viewer
test ( user4 , user4 , true )
test ( user20 , user4 , true )
test ( user31 , user4 , false )
test ( user33 , user4 , true )
test ( user4 , nil , true )
// public user
test ( user4 , user20 , true )
test ( user4 , user31 , true )
test ( user4 , user33 , true )
// limited user
test ( user33 , user33 , true )
test ( user33 , user4 , true )
test ( user33 , user29 , false )
test ( user33 , nil , false )
// private user
test ( user31 , user31 , true )
test ( user31 , user4 , false )
test ( user31 , user20 , true )
test ( user31 , user29 , false )
test ( user31 , user33 , true )
test ( user31 , nil , false )
}