github.com/jfrerich/mattermost-server@v5.8.0-rc2+incompatible/store/storetest/user_store.go (about)

     1  // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
     2  // See License.txt for license information.
     3  
     4  package storetest
     5  
     6  import (
     7  	"strings"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  
    14  	"github.com/mattermost/mattermost-server/model"
    15  	"github.com/mattermost/mattermost-server/store"
    16  )
    17  
    18  func TestUserStore(t *testing.T, ss store.Store) {
    19  	result := <-ss.User().GetAll()
    20  	require.Nil(t, result.Err, "failed cleaning up test users")
    21  	users := result.Data.([]*model.User)
    22  
    23  	for _, u := range users {
    24  		result := <-ss.User().PermanentDelete(u.Id)
    25  		require.Nil(t, result.Err, "failed cleaning up test user %s", u.Username)
    26  	}
    27  
    28  	t.Run("Save", func(t *testing.T) { testUserStoreSave(t, ss) })
    29  	t.Run("Update", func(t *testing.T) { testUserStoreUpdate(t, ss) })
    30  	t.Run("UpdateUpdateAt", func(t *testing.T) { testUserStoreUpdateUpdateAt(t, ss) })
    31  	t.Run("UpdateFailedPasswordAttempts", func(t *testing.T) { testUserStoreUpdateFailedPasswordAttempts(t, ss) })
    32  	t.Run("Get", func(t *testing.T) { testUserStoreGet(t, ss) })
    33  	t.Run("UserCount", func(t *testing.T) { testUserCount(t, ss) })
    34  	t.Run("GetAllUsingAuthService", func(t *testing.T) { testGetAllUsingAuthService(t, ss) })
    35  	t.Run("GetAllProfiles", func(t *testing.T) { testUserStoreGetAllProfiles(t, ss) })
    36  	t.Run("GetProfiles", func(t *testing.T) { testUserStoreGetProfiles(t, ss) })
    37  	t.Run("GetProfilesInChannel", func(t *testing.T) { testUserStoreGetProfilesInChannel(t, ss) })
    38  	t.Run("GetProfilesInChannelByStatus", func(t *testing.T) { testUserStoreGetProfilesInChannelByStatus(t, ss) })
    39  	t.Run("GetProfilesWithoutTeam", func(t *testing.T) { testUserStoreGetProfilesWithoutTeam(t, ss) })
    40  	t.Run("GetAllProfilesInChannel", func(t *testing.T) { testUserStoreGetAllProfilesInChannel(t, ss) })
    41  	t.Run("GetProfilesNotInChannel", func(t *testing.T) { testUserStoreGetProfilesNotInChannel(t, ss) })
    42  	t.Run("GetProfilesByIds", func(t *testing.T) { testUserStoreGetProfilesByIds(t, ss) })
    43  	t.Run("GetProfilesByUsernames", func(t *testing.T) { testUserStoreGetProfilesByUsernames(t, ss) })
    44  	t.Run("GetSystemAdminProfiles", func(t *testing.T) { testUserStoreGetSystemAdminProfiles(t, ss) })
    45  	t.Run("GetByEmail", func(t *testing.T) { testUserStoreGetByEmail(t, ss) })
    46  	t.Run("GetByAuthData", func(t *testing.T) { testUserStoreGetByAuthData(t, ss) })
    47  	t.Run("GetByUsername", func(t *testing.T) { testUserStoreGetByUsername(t, ss) })
    48  	t.Run("GetForLogin", func(t *testing.T) { testUserStoreGetForLogin(t, ss) })
    49  	t.Run("UpdatePassword", func(t *testing.T) { testUserStoreUpdatePassword(t, ss) })
    50  	t.Run("Delete", func(t *testing.T) { testUserStoreDelete(t, ss) })
    51  	t.Run("UpdateAuthData", func(t *testing.T) { testUserStoreUpdateAuthData(t, ss) })
    52  	t.Run("UserUnreadCount", func(t *testing.T) { testUserUnreadCount(t, ss) })
    53  	t.Run("UpdateMfaSecret", func(t *testing.T) { testUserStoreUpdateMfaSecret(t, ss) })
    54  	t.Run("UpdateMfaActive", func(t *testing.T) { testUserStoreUpdateMfaActive(t, ss) })
    55  	t.Run("GetRecentlyActiveUsersForTeam", func(t *testing.T) { testUserStoreGetRecentlyActiveUsersForTeam(t, ss) })
    56  	t.Run("GetNewUsersForTeam", func(t *testing.T) { testUserStoreGetNewUsersForTeam(t, ss) })
    57  	t.Run("Search", func(t *testing.T) { testUserStoreSearch(t, ss) })
    58  	t.Run("SearchNotInChannel", func(t *testing.T) { testUserStoreSearchNotInChannel(t, ss) })
    59  	t.Run("SearchInChannel", func(t *testing.T) { testUserStoreSearchInChannel(t, ss) })
    60  	t.Run("SearchNotInTeam", func(t *testing.T) { testUserStoreSearchNotInTeam(t, ss) })
    61  	t.Run("SearchWithoutTeam", func(t *testing.T) { testUserStoreSearchWithoutTeam(t, ss) })
    62  	t.Run("AnalyticsGetInactiveUsersCount", func(t *testing.T) { testUserStoreAnalyticsGetInactiveUsersCount(t, ss) })
    63  	t.Run("AnalyticsGetSystemAdminCount", func(t *testing.T) { testUserStoreAnalyticsGetSystemAdminCount(t, ss) })
    64  	t.Run("GetProfilesNotInTeam", func(t *testing.T) { testUserStoreGetProfilesNotInTeam(t, ss) })
    65  	t.Run("ClearAllCustomRoleAssignments", func(t *testing.T) { testUserStoreClearAllCustomRoleAssignments(t, ss) })
    66  	t.Run("GetAllAfter", func(t *testing.T) { testUserStoreGetAllAfter(t, ss) })
    67  }
    68  
    69  func testUserStoreSave(t *testing.T, ss store.Store) {
    70  	teamId := model.NewId()
    71  	maxUsersPerTeam := 50
    72  
    73  	u1 := model.User{}
    74  	u1.Email = MakeEmail()
    75  	u1.Username = model.NewId()
    76  
    77  	if err := (<-ss.User().Save(&u1)).Err; err != nil {
    78  		t.Fatal("couldn't save user", err)
    79  	}
    80  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
    81  
    82  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, maxUsersPerTeam))
    83  
    84  	if err := (<-ss.User().Save(&u1)).Err; err == nil {
    85  		t.Fatal("shouldn't be able to update user from save")
    86  	}
    87  
    88  	u1.Id = ""
    89  	if err := (<-ss.User().Save(&u1)).Err; err == nil {
    90  		t.Fatal("should be unique email")
    91  	}
    92  
    93  	u1.Email = ""
    94  	if err := (<-ss.User().Save(&u1)).Err; err == nil {
    95  		t.Fatal("should be unique username")
    96  	}
    97  
    98  	u1.Email = strings.Repeat("0123456789", 20)
    99  	u1.Username = ""
   100  	if err := (<-ss.User().Save(&u1)).Err; err == nil {
   101  		t.Fatal("should be unique username")
   102  	}
   103  
   104  	for i := 0; i < 49; i++ {
   105  		u1.Id = ""
   106  		u1.Email = MakeEmail()
   107  		u1.Username = model.NewId()
   108  		if err := (<-ss.User().Save(&u1)).Err; err != nil {
   109  			t.Fatal("couldn't save item", err)
   110  		}
   111  		defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   112  
   113  		store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, maxUsersPerTeam))
   114  	}
   115  
   116  	u1.Id = ""
   117  	u1.Email = MakeEmail()
   118  	u1.Username = model.NewId()
   119  	if err := (<-ss.User().Save(&u1)).Err; err != nil {
   120  		t.Fatal("couldn't save item", err)
   121  	}
   122  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   123  
   124  	if err := (<-ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, maxUsersPerTeam)).Err; err == nil {
   125  		t.Fatal("should be the limit")
   126  	}
   127  }
   128  
   129  func testUserStoreUpdate(t *testing.T, ss store.Store) {
   130  	u1 := &model.User{}
   131  	u1.Email = MakeEmail()
   132  	store.Must(ss.User().Save(u1))
   133  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   134  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1))
   135  
   136  	u2 := &model.User{}
   137  	u2.Email = MakeEmail()
   138  	u2.AuthService = "ldap"
   139  	store.Must(ss.User().Save(u2))
   140  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   141  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u2.Id}, -1))
   142  
   143  	time.Sleep(100 * time.Millisecond)
   144  
   145  	if err := (<-ss.User().Update(u1, false)).Err; err != nil {
   146  		t.Fatal(err)
   147  	}
   148  
   149  	u1.Id = "missing"
   150  	if err := (<-ss.User().Update(u1, false)).Err; err == nil {
   151  		t.Fatal("Update should have failed because of missing key")
   152  	}
   153  
   154  	u1.Id = model.NewId()
   155  	if err := (<-ss.User().Update(u1, false)).Err; err == nil {
   156  		t.Fatal("Update should have faile because id change")
   157  	}
   158  
   159  	u2.Email = MakeEmail()
   160  	if err := (<-ss.User().Update(u2, false)).Err; err == nil {
   161  		t.Fatal("Update should have failed because you can't modify AD/LDAP fields")
   162  	}
   163  
   164  	u3 := &model.User{}
   165  	u3.Email = MakeEmail()
   166  	oldEmail := u3.Email
   167  	u3.AuthService = "gitlab"
   168  	store.Must(ss.User().Save(u3))
   169  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
   170  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u3.Id}, -1))
   171  
   172  	u3.Email = MakeEmail()
   173  	if result := <-ss.User().Update(u3, false); result.Err != nil {
   174  		t.Fatal("Update should not have failed")
   175  	} else {
   176  		newUser := result.Data.([2]*model.User)[0]
   177  		if newUser.Email != oldEmail {
   178  			t.Fatal("Email should not have been updated as the update is not trusted")
   179  		}
   180  	}
   181  
   182  	u3.Email = MakeEmail()
   183  	if result := <-ss.User().Update(u3, true); result.Err != nil {
   184  		t.Fatal("Update should not have failed")
   185  	} else {
   186  		newUser := result.Data.([2]*model.User)[0]
   187  		if newUser.Email == oldEmail {
   188  			t.Fatal("Email should have been updated as the update is trusted")
   189  		}
   190  	}
   191  
   192  	if result := <-ss.User().UpdateLastPictureUpdate(u1.Id); result.Err != nil {
   193  		t.Fatal("Update should not have failed")
   194  	}
   195  }
   196  
   197  func testUserStoreUpdateUpdateAt(t *testing.T, ss store.Store) {
   198  	u1 := &model.User{}
   199  	u1.Email = MakeEmail()
   200  	store.Must(ss.User().Save(u1))
   201  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   202  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1))
   203  
   204  	time.Sleep(10 * time.Millisecond)
   205  
   206  	if err := (<-ss.User().UpdateUpdateAt(u1.Id)).Err; err != nil {
   207  		t.Fatal(err)
   208  	}
   209  
   210  	if r1 := <-ss.User().Get(u1.Id); r1.Err != nil {
   211  		t.Fatal(r1.Err)
   212  	} else {
   213  		if r1.Data.(*model.User).UpdateAt <= u1.UpdateAt {
   214  			t.Fatal("UpdateAt not updated correctly")
   215  		}
   216  	}
   217  
   218  }
   219  
   220  func testUserStoreUpdateFailedPasswordAttempts(t *testing.T, ss store.Store) {
   221  	u1 := &model.User{}
   222  	u1.Email = MakeEmail()
   223  	store.Must(ss.User().Save(u1))
   224  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   225  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1))
   226  
   227  	if err := (<-ss.User().UpdateFailedPasswordAttempts(u1.Id, 3)).Err; err != nil {
   228  		t.Fatal(err)
   229  	}
   230  
   231  	if r1 := <-ss.User().Get(u1.Id); r1.Err != nil {
   232  		t.Fatal(r1.Err)
   233  	} else {
   234  		if r1.Data.(*model.User).FailedAttempts != 3 {
   235  			t.Fatal("FailedAttempts not updated correctly")
   236  		}
   237  	}
   238  
   239  }
   240  
   241  func testUserStoreGet(t *testing.T, ss store.Store) {
   242  	u1 := &model.User{}
   243  	u1.Email = MakeEmail()
   244  	store.Must(ss.User().Save(u1))
   245  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   246  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1))
   247  
   248  	if r1 := <-ss.User().Get(u1.Id); r1.Err != nil {
   249  		t.Fatal(r1.Err)
   250  	} else {
   251  		if r1.Data.(*model.User).ToJson() != u1.ToJson() {
   252  			t.Fatal("invalid returned user")
   253  		}
   254  	}
   255  
   256  	if err := (<-ss.User().Get("")).Err; err == nil {
   257  		t.Fatal("Missing id should have failed")
   258  	}
   259  }
   260  
   261  func testUserCount(t *testing.T, ss store.Store) {
   262  	u1 := &model.User{}
   263  	u1.Email = MakeEmail()
   264  	store.Must(ss.User().Save(u1))
   265  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   266  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1))
   267  
   268  	if result := <-ss.User().GetTotalUsersCount(); result.Err != nil {
   269  		t.Fatal(result.Err)
   270  	} else {
   271  		count := result.Data.(int64)
   272  		require.False(t, count <= 0, "expected count > 0, got %d", count)
   273  	}
   274  }
   275  
   276  func testGetAllUsingAuthService(t *testing.T, ss store.Store) {
   277  	u1 := &model.User{}
   278  	u1.Email = MakeEmail()
   279  	u1.AuthService = "someservice"
   280  	store.Must(ss.User().Save(u1))
   281  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   282  
   283  	u2 := &model.User{}
   284  	u2.Email = MakeEmail()
   285  	u2.AuthService = "someservice"
   286  	store.Must(ss.User().Save(u2))
   287  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   288  
   289  	if r1 := <-ss.User().GetAllUsingAuthService(u1.AuthService); r1.Err != nil {
   290  		t.Fatal(r1.Err)
   291  	} else {
   292  		users := r1.Data.([]*model.User)
   293  		if len(users) < 2 {
   294  			t.Fatal("invalid returned users")
   295  		}
   296  	}
   297  }
   298  
   299  func testUserStoreGetAllProfiles(t *testing.T, ss store.Store) {
   300  	u1 := &model.User{}
   301  	u1.Email = MakeEmail()
   302  	store.Must(ss.User().Save(u1))
   303  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   304  
   305  	u2 := &model.User{}
   306  	u2.Email = MakeEmail()
   307  	store.Must(ss.User().Save(u2))
   308  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   309  
   310  	options := &model.UserGetOptions{Page: 0, PerPage: 100}
   311  
   312  	if r1 := <-ss.User().GetAllProfiles(options); r1.Err != nil {
   313  		t.Fatal(r1.Err)
   314  	} else {
   315  		users := r1.Data.([]*model.User)
   316  		if len(users) < 2 {
   317  			t.Fatal("invalid returned users")
   318  		}
   319  	}
   320  
   321  	options = &model.UserGetOptions{Page: 0, PerPage: 1}
   322  	if r2 := <-ss.User().GetAllProfiles(options); r2.Err != nil {
   323  		t.Fatal(r2.Err)
   324  	} else {
   325  		users := r2.Data.([]*model.User)
   326  		if len(users) != 1 {
   327  			t.Fatal("invalid returned users, limit did not work")
   328  		}
   329  	}
   330  
   331  	if r2 := <-ss.User().GetAll(); r2.Err != nil {
   332  		t.Fatal(r2.Err)
   333  	} else {
   334  		users := r2.Data.([]*model.User)
   335  		if len(users) < 2 {
   336  			t.Fatal("invalid returned users")
   337  		}
   338  	}
   339  
   340  	etag := ""
   341  	if r2 := <-ss.User().GetEtagForAllProfiles(); r2.Err != nil {
   342  		t.Fatal(r2.Err)
   343  	} else {
   344  		etag = r2.Data.(string)
   345  	}
   346  
   347  	u3 := &model.User{}
   348  	u3.Email = MakeEmail()
   349  	u3.Roles = "system_user some-other-role"
   350  	store.Must(ss.User().Save(u3))
   351  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
   352  
   353  	if r2 := <-ss.User().GetEtagForAllProfiles(); r2.Err != nil {
   354  		t.Fatal(r2.Err)
   355  	} else {
   356  		if etag == r2.Data.(string) {
   357  			t.Fatal("etags should not match")
   358  		}
   359  	}
   360  
   361  	u4 := &model.User{}
   362  	u4.Email = MakeEmail()
   363  	u4.Roles = "system_admin some-other-role"
   364  	store.Must(ss.User().Save(u4))
   365  	defer func() { store.Must(ss.User().PermanentDelete(u4.Id)) }()
   366  
   367  	u5 := &model.User{}
   368  	u5.Email = MakeEmail()
   369  	u5.Roles = "system_admin"
   370  	store.Must(ss.User().Save(u5))
   371  	defer func() { store.Must(ss.User().PermanentDelete(u5.Id)) }()
   372  
   373  	options = &model.UserGetOptions{Page: 0, PerPage: 10, Role: "system_admin"}
   374  	if r2 := <-ss.User().GetAllProfiles(options); r2.Err != nil {
   375  		t.Fatal(r2.Err)
   376  	} else {
   377  		users := r2.Data.([]*model.User)
   378  		if len(users) != 2 {
   379  			t.Fatal("invalid returned users, role filter did not work")
   380  		}
   381  		assert.ElementsMatch(t, []string{u4.Id, u5.Id}, []string{users[0].Id, users[1].Id})
   382  	}
   383  
   384  	u6 := &model.User{}
   385  	u6.Email = MakeEmail()
   386  	u6.DeleteAt = model.GetMillis()
   387  	u6.Roles = "system_admin"
   388  	store.Must(ss.User().Save(u6))
   389  	defer func() { store.Must(ss.User().PermanentDelete(u6.Id)) }()
   390  
   391  	u7 := &model.User{}
   392  	u7.Email = MakeEmail()
   393  	u7.DeleteAt = model.GetMillis()
   394  	store.Must(ss.User().Save(u7))
   395  	defer func() { store.Must(ss.User().PermanentDelete(u7.Id)) }()
   396  
   397  	options = &model.UserGetOptions{Page: 0, PerPage: 10, Role: "system_admin", Inactive: true}
   398  	if r2 := <-ss.User().GetAllProfiles(options); r2.Err != nil {
   399  		t.Fatal(r2.Err)
   400  	} else {
   401  		users := r2.Data.([]*model.User)
   402  		if len(users) != 1 {
   403  			t.Fatal("invalid returned users, Role and Inactive filter did not work")
   404  		}
   405  		assert.Equal(t, u6.Id, users[0].Id)
   406  	}
   407  
   408  	options = &model.UserGetOptions{Page: 0, PerPage: 10, Inactive: true}
   409  	if r2 := <-ss.User().GetAllProfiles(options); r2.Err != nil {
   410  		t.Fatal(r2.Err)
   411  	} else {
   412  		users := r2.Data.([]*model.User)
   413  		if len(users) != 2 {
   414  			t.Fatal("invalid returned users, Inactive filter did not work")
   415  		}
   416  		assert.ElementsMatch(t, []string{u6.Id, u7.Id}, []string{users[0].Id, users[1].Id})
   417  	}
   418  }
   419  
   420  func testUserStoreGetProfiles(t *testing.T, ss store.Store) {
   421  	teamId := model.NewId()
   422  
   423  	u1 := &model.User{}
   424  	u1.Email = MakeEmail()
   425  	store.Must(ss.User().Save(u1))
   426  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   427  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   428  
   429  	u2 := &model.User{}
   430  	u2.Email = MakeEmail()
   431  	store.Must(ss.User().Save(u2))
   432  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   433  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
   434  
   435  	options := &model.UserGetOptions{InTeamId: teamId, Page: 0, PerPage: 100}
   436  	if r1 := <-ss.User().GetProfiles(options); r1.Err != nil {
   437  		t.Fatal(r1.Err)
   438  	} else {
   439  		users := r1.Data.([]*model.User)
   440  		if len(users) != 2 {
   441  			t.Fatal("invalid returned users")
   442  		}
   443  
   444  		found := false
   445  		for _, u := range users {
   446  			if u.Id == u1.Id {
   447  				found = true
   448  			}
   449  		}
   450  
   451  		if !found {
   452  			t.Fatal("missing user")
   453  		}
   454  	}
   455  
   456  	options = &model.UserGetOptions{InTeamId: "123", Page: 0, PerPage: 100}
   457  	if r2 := <-ss.User().GetProfiles(options); r2.Err != nil {
   458  		t.Fatal(r2.Err)
   459  	} else {
   460  		if len(r2.Data.([]*model.User)) != 0 {
   461  			t.Fatal("should have returned empty map")
   462  		}
   463  	}
   464  
   465  	etag := ""
   466  	if r2 := <-ss.User().GetEtagForProfiles(teamId); r2.Err != nil {
   467  		t.Fatal(r2.Err)
   468  	} else {
   469  		etag = r2.Data.(string)
   470  	}
   471  
   472  	u3 := &model.User{}
   473  	u3.Email = MakeEmail()
   474  	store.Must(ss.User().Save(u3))
   475  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
   476  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u3.Id}, -1))
   477  
   478  	if r2 := <-ss.User().GetEtagForProfiles(teamId); r2.Err != nil {
   479  		t.Fatal(r2.Err)
   480  	} else {
   481  		if etag == r2.Data.(string) {
   482  			t.Fatal("etags should not match")
   483  		}
   484  	}
   485  
   486  	u4 := &model.User{}
   487  	u4.Email = MakeEmail()
   488  	u4.Roles = "system_admin"
   489  	store.Must(ss.User().Save(u4))
   490  	defer func() { store.Must(ss.User().PermanentDelete(u4.Id)) }()
   491  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u4.Id}, -1))
   492  
   493  	u5 := &model.User{}
   494  	u5.Email = MakeEmail()
   495  	u5.DeleteAt = model.GetMillis()
   496  	store.Must(ss.User().Save(u5))
   497  	defer func() { store.Must(ss.User().PermanentDelete(u5.Id)) }()
   498  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u5.Id}, -1))
   499  
   500  	options = &model.UserGetOptions{InTeamId: teamId, Page: 0, PerPage: 100}
   501  	if r1 := <-ss.User().GetProfiles(options); r1.Err != nil {
   502  		t.Fatal(r1.Err)
   503  	} else {
   504  		users := r1.Data.([]*model.User)
   505  		if len(users) != 5 {
   506  			t.Fatal("invalid returned users")
   507  		}
   508  	}
   509  
   510  	options = &model.UserGetOptions{InTeamId: teamId, Role: "system_admin", Inactive: false, Page: 0, PerPage: 100}
   511  	if r1 := <-ss.User().GetProfiles(options); r1.Err != nil {
   512  		t.Fatal(r1.Err)
   513  	} else {
   514  		users := r1.Data.([]*model.User)
   515  		if len(users) != 1 {
   516  			t.Fatal("invalid returned users")
   517  		}
   518  		assert.Equal(t, u4.Id, users[0].Id)
   519  	}
   520  
   521  	options = &model.UserGetOptions{InTeamId: teamId, Inactive: true, Page: 0, PerPage: 100}
   522  	if r1 := <-ss.User().GetProfiles(options); r1.Err != nil {
   523  		t.Fatal(r1.Err)
   524  	} else {
   525  		users := r1.Data.([]*model.User)
   526  		if len(users) != 1 {
   527  			t.Fatal("invalid returned users")
   528  		}
   529  		assert.Equal(t, u5.Id, users[0].Id)
   530  	}
   531  
   532  }
   533  
   534  func testUserStoreGetProfilesInChannel(t *testing.T, ss store.Store) {
   535  	teamId := model.NewId()
   536  
   537  	u1 := &model.User{}
   538  	u1.Email = MakeEmail()
   539  	store.Must(ss.User().Save(u1))
   540  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   541  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   542  
   543  	u2 := &model.User{}
   544  	u2.Email = MakeEmail()
   545  	store.Must(ss.User().Save(u2))
   546  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   547  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
   548  
   549  	c1 := model.Channel{}
   550  	c1.TeamId = teamId
   551  	c1.DisplayName = "Profiles in channel"
   552  	c1.Name = "profiles-" + model.NewId()
   553  	c1.Type = model.CHANNEL_OPEN
   554  
   555  	c2 := model.Channel{}
   556  	c2.TeamId = teamId
   557  	c2.DisplayName = "Profiles in private"
   558  	c2.Name = "profiles-" + model.NewId()
   559  	c2.Type = model.CHANNEL_PRIVATE
   560  
   561  	store.Must(ss.Channel().Save(&c1, -1))
   562  	store.Must(ss.Channel().Save(&c2, -1))
   563  
   564  	m1 := model.ChannelMember{}
   565  	m1.ChannelId = c1.Id
   566  	m1.UserId = u1.Id
   567  	m1.NotifyProps = model.GetDefaultChannelNotifyProps()
   568  
   569  	m2 := model.ChannelMember{}
   570  	m2.ChannelId = c1.Id
   571  	m2.UserId = u2.Id
   572  	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
   573  
   574  	m3 := model.ChannelMember{}
   575  	m3.ChannelId = c2.Id
   576  	m3.UserId = u1.Id
   577  	m3.NotifyProps = model.GetDefaultChannelNotifyProps()
   578  
   579  	store.Must(ss.Channel().SaveMember(&m1))
   580  	store.Must(ss.Channel().SaveMember(&m2))
   581  	store.Must(ss.Channel().SaveMember(&m3))
   582  
   583  	if r1 := <-ss.User().GetProfilesInChannel(c1.Id, 0, 100); r1.Err != nil {
   584  		t.Fatal(r1.Err)
   585  	} else {
   586  		users := r1.Data.([]*model.User)
   587  		if len(users) != 2 {
   588  			t.Fatal("invalid returned users")
   589  		}
   590  
   591  		found := false
   592  		for _, u := range users {
   593  			if u.Id == u1.Id {
   594  				found = true
   595  			}
   596  		}
   597  
   598  		if !found {
   599  			t.Fatal("missing user")
   600  		}
   601  	}
   602  
   603  	if r2 := <-ss.User().GetProfilesInChannel(c2.Id, 0, 1); r2.Err != nil {
   604  		t.Fatal(r2.Err)
   605  	} else {
   606  		if len(r2.Data.([]*model.User)) != 1 {
   607  			t.Fatal("should have returned only 1 user")
   608  		}
   609  	}
   610  }
   611  
   612  func testUserStoreGetProfilesInChannelByStatus(t *testing.T, ss store.Store) {
   613  	teamId := model.NewId()
   614  
   615  	u1 := &model.User{}
   616  	u1.Email = MakeEmail()
   617  	store.Must(ss.User().Save(u1))
   618  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   619  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   620  
   621  	u2 := &model.User{}
   622  	u2.Email = MakeEmail()
   623  	store.Must(ss.User().Save(u2))
   624  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   625  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
   626  
   627  	c1 := model.Channel{}
   628  	c1.TeamId = teamId
   629  	c1.DisplayName = "Profiles in channel"
   630  	c1.Name = "profiles-" + model.NewId()
   631  	c1.Type = model.CHANNEL_OPEN
   632  
   633  	c2 := model.Channel{}
   634  	c2.TeamId = teamId
   635  	c2.DisplayName = "Profiles in private"
   636  	c2.Name = "profiles-" + model.NewId()
   637  	c2.Type = model.CHANNEL_PRIVATE
   638  
   639  	store.Must(ss.Channel().Save(&c1, -1))
   640  	store.Must(ss.Channel().Save(&c2, -1))
   641  
   642  	m1 := model.ChannelMember{}
   643  	m1.ChannelId = c1.Id
   644  	m1.UserId = u1.Id
   645  	m1.NotifyProps = model.GetDefaultChannelNotifyProps()
   646  
   647  	m2 := model.ChannelMember{}
   648  	m2.ChannelId = c1.Id
   649  	m2.UserId = u2.Id
   650  	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
   651  
   652  	m3 := model.ChannelMember{}
   653  	m3.ChannelId = c2.Id
   654  	m3.UserId = u1.Id
   655  	m3.NotifyProps = model.GetDefaultChannelNotifyProps()
   656  
   657  	store.Must(ss.Channel().SaveMember(&m1))
   658  	store.Must(ss.Channel().SaveMember(&m2))
   659  	store.Must(ss.Channel().SaveMember(&m3))
   660  
   661  	if r1 := <-ss.User().GetProfilesInChannelByStatus(c1.Id, 0, 100); r1.Err != nil {
   662  		t.Fatal(r1.Err)
   663  	} else {
   664  		users := r1.Data.([]*model.User)
   665  		if len(users) != 2 {
   666  			t.Fatal("invalid returned users")
   667  		}
   668  
   669  		found := false
   670  		for _, u := range users {
   671  			if u.Id == u1.Id {
   672  				found = true
   673  			}
   674  		}
   675  
   676  		if !found {
   677  			t.Fatal("missing user")
   678  		}
   679  	}
   680  
   681  	if r2 := <-ss.User().GetProfilesInChannelByStatus(c2.Id, 0, 1); r2.Err != nil {
   682  		t.Fatal(r2.Err)
   683  	} else {
   684  		if len(r2.Data.([]*model.User)) != 1 {
   685  			t.Fatal("should have returned only 1 user")
   686  		}
   687  	}
   688  }
   689  
   690  func testUserStoreGetProfilesWithoutTeam(t *testing.T, ss store.Store) {
   691  	teamId := model.NewId()
   692  
   693  	// These usernames need to appear in the first 100 users for this to work
   694  
   695  	u1 := &model.User{}
   696  	u1.Username = "a000000000" + model.NewId()
   697  	u1.Email = MakeEmail()
   698  	store.Must(ss.User().Save(u1))
   699  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   700  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   701  
   702  	u2 := &model.User{}
   703  	u2.Username = "a000000001" + model.NewId()
   704  	u2.Email = MakeEmail()
   705  	store.Must(ss.User().Save(u2))
   706  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   707  
   708  	if r1 := <-ss.User().GetProfilesWithoutTeam(0, 100); r1.Err != nil {
   709  		t.Fatal(r1.Err)
   710  	} else {
   711  		users := r1.Data.([]*model.User)
   712  
   713  		found1 := false
   714  		found2 := false
   715  		for _, u := range users {
   716  			if u.Id == u1.Id {
   717  				found1 = true
   718  			} else if u.Id == u2.Id {
   719  				found2 = true
   720  			}
   721  		}
   722  
   723  		if found1 {
   724  			t.Fatal("shouldn't have returned user on team")
   725  		} else if !found2 {
   726  			t.Fatal("should've returned user without any teams")
   727  		}
   728  	}
   729  }
   730  
   731  func testUserStoreGetAllProfilesInChannel(t *testing.T, ss store.Store) {
   732  	teamId := model.NewId()
   733  
   734  	u1 := &model.User{}
   735  	u1.Email = MakeEmail()
   736  	store.Must(ss.User().Save(u1))
   737  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   738  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   739  
   740  	u2 := &model.User{}
   741  	u2.Email = MakeEmail()
   742  	store.Must(ss.User().Save(u2))
   743  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   744  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
   745  
   746  	c1 := model.Channel{}
   747  	c1.TeamId = teamId
   748  	c1.DisplayName = "Profiles in channel"
   749  	c1.Name = "profiles-" + model.NewId()
   750  	c1.Type = model.CHANNEL_OPEN
   751  
   752  	c2 := model.Channel{}
   753  	c2.TeamId = teamId
   754  	c2.DisplayName = "Profiles in private"
   755  	c2.Name = "profiles-" + model.NewId()
   756  	c2.Type = model.CHANNEL_PRIVATE
   757  
   758  	store.Must(ss.Channel().Save(&c1, -1))
   759  	store.Must(ss.Channel().Save(&c2, -1))
   760  
   761  	m1 := model.ChannelMember{}
   762  	m1.ChannelId = c1.Id
   763  	m1.UserId = u1.Id
   764  	m1.NotifyProps = model.GetDefaultChannelNotifyProps()
   765  
   766  	m2 := model.ChannelMember{}
   767  	m2.ChannelId = c1.Id
   768  	m2.UserId = u2.Id
   769  	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
   770  
   771  	m3 := model.ChannelMember{}
   772  	m3.ChannelId = c2.Id
   773  	m3.UserId = u1.Id
   774  	m3.NotifyProps = model.GetDefaultChannelNotifyProps()
   775  
   776  	store.Must(ss.Channel().SaveMember(&m1))
   777  	store.Must(ss.Channel().SaveMember(&m2))
   778  	store.Must(ss.Channel().SaveMember(&m3))
   779  
   780  	if r1 := <-ss.User().GetAllProfilesInChannel(c1.Id, false); r1.Err != nil {
   781  		t.Fatal(r1.Err)
   782  	} else {
   783  		users := r1.Data.(map[string]*model.User)
   784  		if len(users) != 2 {
   785  			t.Fatal("invalid returned users")
   786  		}
   787  
   788  		if users[u1.Id].Id != u1.Id {
   789  			t.Fatal("invalid returned user")
   790  		}
   791  	}
   792  
   793  	if r2 := <-ss.User().GetAllProfilesInChannel(c2.Id, false); r2.Err != nil {
   794  		t.Fatal(r2.Err)
   795  	} else {
   796  		if len(r2.Data.(map[string]*model.User)) != 1 {
   797  			t.Fatal("should have returned empty map")
   798  		}
   799  	}
   800  
   801  	if r2 := <-ss.User().GetAllProfilesInChannel(c2.Id, true); r2.Err != nil {
   802  		t.Fatal(r2.Err)
   803  	} else {
   804  		if len(r2.Data.(map[string]*model.User)) != 1 {
   805  			t.Fatal("should have returned empty map")
   806  		}
   807  	}
   808  
   809  	if r2 := <-ss.User().GetAllProfilesInChannel(c2.Id, true); r2.Err != nil {
   810  		t.Fatal(r2.Err)
   811  	} else {
   812  		if len(r2.Data.(map[string]*model.User)) != 1 {
   813  			t.Fatal("should have returned empty map")
   814  		}
   815  	}
   816  
   817  	ss.User().InvalidateProfilesInChannelCacheByUser(u1.Id)
   818  	ss.User().InvalidateProfilesInChannelCache(c2.Id)
   819  }
   820  
   821  func testUserStoreGetProfilesNotInChannel(t *testing.T, ss store.Store) {
   822  	teamId := model.NewId()
   823  
   824  	u1 := &model.User{}
   825  	u1.Email = MakeEmail()
   826  	store.Must(ss.User().Save(u1))
   827  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   828  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   829  
   830  	u2 := &model.User{}
   831  	u2.Email = MakeEmail()
   832  	store.Must(ss.User().Save(u2))
   833  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   834  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
   835  
   836  	c1 := model.Channel{}
   837  	c1.TeamId = teamId
   838  	c1.DisplayName = "Profiles in channel"
   839  	c1.Name = "profiles-" + model.NewId()
   840  	c1.Type = model.CHANNEL_OPEN
   841  
   842  	c2 := model.Channel{}
   843  	c2.TeamId = teamId
   844  	c2.DisplayName = "Profiles in private"
   845  	c2.Name = "profiles-" + model.NewId()
   846  	c2.Type = model.CHANNEL_PRIVATE
   847  
   848  	store.Must(ss.Channel().Save(&c1, -1))
   849  	store.Must(ss.Channel().Save(&c2, -1))
   850  
   851  	if r1 := <-ss.User().GetProfilesNotInChannel(teamId, c1.Id, 0, 100); r1.Err != nil {
   852  		t.Fatal(r1.Err)
   853  	} else {
   854  		users := r1.Data.([]*model.User)
   855  		if len(users) != 2 {
   856  			t.Fatal("invalid returned users")
   857  		}
   858  
   859  		found := false
   860  		for _, u := range users {
   861  			if u.Id == u1.Id {
   862  				found = true
   863  			}
   864  		}
   865  
   866  		if !found {
   867  			t.Fatal("missing user")
   868  		}
   869  	}
   870  
   871  	if r2 := <-ss.User().GetProfilesNotInChannel(teamId, c2.Id, 0, 100); r2.Err != nil {
   872  		t.Fatal(r2.Err)
   873  	} else {
   874  		if len(r2.Data.([]*model.User)) != 2 {
   875  			t.Fatal("invalid returned users")
   876  		}
   877  	}
   878  
   879  	m1 := model.ChannelMember{}
   880  	m1.ChannelId = c1.Id
   881  	m1.UserId = u1.Id
   882  	m1.NotifyProps = model.GetDefaultChannelNotifyProps()
   883  
   884  	m2 := model.ChannelMember{}
   885  	m2.ChannelId = c1.Id
   886  	m2.UserId = u2.Id
   887  	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
   888  
   889  	m3 := model.ChannelMember{}
   890  	m3.ChannelId = c2.Id
   891  	m3.UserId = u1.Id
   892  	m3.NotifyProps = model.GetDefaultChannelNotifyProps()
   893  
   894  	store.Must(ss.Channel().SaveMember(&m1))
   895  	store.Must(ss.Channel().SaveMember(&m2))
   896  	store.Must(ss.Channel().SaveMember(&m3))
   897  
   898  	if r1 := <-ss.User().GetProfilesNotInChannel(teamId, c1.Id, 0, 100); r1.Err != nil {
   899  		t.Fatal(r1.Err)
   900  	} else {
   901  		users := r1.Data.([]*model.User)
   902  		if len(users) != 0 {
   903  			t.Fatal("invalid returned users")
   904  		}
   905  	}
   906  
   907  	if r2 := <-ss.User().GetProfilesNotInChannel(teamId, c2.Id, 0, 100); r2.Err != nil {
   908  		t.Fatal(r2.Err)
   909  	} else {
   910  		if len(r2.Data.([]*model.User)) != 1 {
   911  			t.Fatal("should have had 1 user not in channel")
   912  		}
   913  	}
   914  }
   915  
   916  func testUserStoreGetProfilesByIds(t *testing.T, ss store.Store) {
   917  	teamId := model.NewId()
   918  
   919  	u1 := &model.User{}
   920  	u1.Email = MakeEmail()
   921  	store.Must(ss.User().Save(u1))
   922  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
   923  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
   924  
   925  	u2 := &model.User{}
   926  	u2.Email = MakeEmail()
   927  	store.Must(ss.User().Save(u2))
   928  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
   929  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
   930  
   931  	if r1 := <-ss.User().GetProfileByIds([]string{u1.Id}, false); r1.Err != nil {
   932  		t.Fatal(r1.Err)
   933  	} else {
   934  		users := r1.Data.([]*model.User)
   935  		if len(users) != 1 {
   936  			t.Fatal("invalid returned users")
   937  		}
   938  
   939  		found := false
   940  		for _, u := range users {
   941  			if u.Id == u1.Id {
   942  				found = true
   943  			}
   944  		}
   945  
   946  		if !found {
   947  			t.Fatal("missing user")
   948  		}
   949  	}
   950  
   951  	if r1 := <-ss.User().GetProfileByIds([]string{u1.Id}, true); r1.Err != nil {
   952  		t.Fatal(r1.Err)
   953  	} else {
   954  		users := r1.Data.([]*model.User)
   955  		if len(users) != 1 {
   956  			t.Fatal("invalid returned users")
   957  		}
   958  
   959  		found := false
   960  		for _, u := range users {
   961  			if u.Id == u1.Id {
   962  				found = true
   963  			}
   964  		}
   965  
   966  		if !found {
   967  			t.Fatal("missing user")
   968  		}
   969  	}
   970  
   971  	if r1 := <-ss.User().GetProfileByIds([]string{u1.Id, u2.Id}, true); r1.Err != nil {
   972  		t.Fatal(r1.Err)
   973  	} else {
   974  		users := r1.Data.([]*model.User)
   975  		if len(users) != 2 {
   976  			t.Fatal("invalid returned users")
   977  		}
   978  
   979  		found := false
   980  		for _, u := range users {
   981  			if u.Id == u1.Id {
   982  				found = true
   983  			}
   984  		}
   985  
   986  		if !found {
   987  			t.Fatal("missing user")
   988  		}
   989  	}
   990  
   991  	if r1 := <-ss.User().GetProfileByIds([]string{u1.Id, u2.Id}, true); r1.Err != nil {
   992  		t.Fatal(r1.Err)
   993  	} else {
   994  		users := r1.Data.([]*model.User)
   995  		if len(users) != 2 {
   996  			t.Fatal("invalid returned users")
   997  		}
   998  
   999  		found := false
  1000  		for _, u := range users {
  1001  			if u.Id == u1.Id {
  1002  				found = true
  1003  			}
  1004  		}
  1005  
  1006  		if !found {
  1007  			t.Fatal("missing user")
  1008  		}
  1009  	}
  1010  
  1011  	if r1 := <-ss.User().GetProfileByIds([]string{u1.Id, u2.Id}, false); r1.Err != nil {
  1012  		t.Fatal(r1.Err)
  1013  	} else {
  1014  		users := r1.Data.([]*model.User)
  1015  		if len(users) != 2 {
  1016  			t.Fatal("invalid returned users")
  1017  		}
  1018  
  1019  		found := false
  1020  		for _, u := range users {
  1021  			if u.Id == u1.Id {
  1022  				found = true
  1023  			}
  1024  		}
  1025  
  1026  		if !found {
  1027  			t.Fatal("missing user")
  1028  		}
  1029  	}
  1030  
  1031  	if r1 := <-ss.User().GetProfileByIds([]string{u1.Id}, false); r1.Err != nil {
  1032  		t.Fatal(r1.Err)
  1033  	} else {
  1034  		users := r1.Data.([]*model.User)
  1035  		if len(users) != 1 {
  1036  			t.Fatal("invalid returned users")
  1037  		}
  1038  
  1039  		found := false
  1040  		for _, u := range users {
  1041  			if u.Id == u1.Id {
  1042  				found = true
  1043  			}
  1044  		}
  1045  
  1046  		if !found {
  1047  			t.Fatal("missing user")
  1048  		}
  1049  	}
  1050  
  1051  	options := &model.UserGetOptions{InTeamId: "123", Page: 0, PerPage: 100}
  1052  	if r2 := <-ss.User().GetProfiles(options); r2.Err != nil {
  1053  		t.Fatal(r2.Err)
  1054  	} else {
  1055  		if len(r2.Data.([]*model.User)) != 0 {
  1056  			t.Fatal("should have returned empty array")
  1057  		}
  1058  	}
  1059  }
  1060  
  1061  func testUserStoreGetProfilesByUsernames(t *testing.T, ss store.Store) {
  1062  	teamId := model.NewId()
  1063  
  1064  	u1 := &model.User{}
  1065  	u1.Email = MakeEmail()
  1066  	u1.Username = "username1" + model.NewId()
  1067  	store.Must(ss.User().Save(u1))
  1068  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1069  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1070  
  1071  	u2 := &model.User{}
  1072  	u2.Email = MakeEmail()
  1073  	u2.Username = "username2" + model.NewId()
  1074  	store.Must(ss.User().Save(u2))
  1075  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  1076  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
  1077  
  1078  	if r1 := <-ss.User().GetProfilesByUsernames([]string{u1.Username, u2.Username}, teamId); r1.Err != nil {
  1079  		t.Fatal(r1.Err)
  1080  	} else {
  1081  		users := r1.Data.([]*model.User)
  1082  		if len(users) != 2 {
  1083  			t.Fatal("invalid returned users")
  1084  		}
  1085  
  1086  		if users[0].Id != u1.Id && users[1].Id != u1.Id {
  1087  			t.Fatal("invalid returned user 1")
  1088  		}
  1089  
  1090  		if users[0].Id != u2.Id && users[1].Id != u2.Id {
  1091  			t.Fatal("invalid returned user 2")
  1092  		}
  1093  	}
  1094  
  1095  	if r1 := <-ss.User().GetProfilesByUsernames([]string{u1.Username}, teamId); r1.Err != nil {
  1096  		t.Fatal(r1.Err)
  1097  	} else {
  1098  		users := r1.Data.([]*model.User)
  1099  		if len(users) != 1 {
  1100  			t.Fatal("invalid returned users")
  1101  		}
  1102  
  1103  		if users[0].Id != u1.Id {
  1104  			t.Fatal("invalid returned user")
  1105  		}
  1106  	}
  1107  
  1108  	team2Id := model.NewId()
  1109  
  1110  	u3 := &model.User{}
  1111  	u3.Email = MakeEmail()
  1112  	u3.Username = "username3" + model.NewId()
  1113  	store.Must(ss.User().Save(u3))
  1114  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  1115  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: team2Id, UserId: u3.Id}, -1))
  1116  
  1117  	if r1 := <-ss.User().GetProfilesByUsernames([]string{u1.Username, u3.Username}, ""); r1.Err != nil {
  1118  		t.Fatal(r1.Err)
  1119  	} else {
  1120  		users := r1.Data.([]*model.User)
  1121  		if len(users) != 2 {
  1122  			t.Fatal("invalid returned users")
  1123  		}
  1124  
  1125  		if users[0].Id != u1.Id && users[1].Id != u1.Id {
  1126  			t.Fatal("invalid returned user 1")
  1127  		}
  1128  
  1129  		if users[0].Id != u3.Id && users[1].Id != u3.Id {
  1130  			t.Fatal("invalid returned user 3")
  1131  		}
  1132  	}
  1133  
  1134  	if r1 := <-ss.User().GetProfilesByUsernames([]string{u1.Username, u3.Username}, teamId); r1.Err != nil {
  1135  		t.Fatal(r1.Err)
  1136  	} else {
  1137  		users := r1.Data.([]*model.User)
  1138  		if len(users) != 1 {
  1139  			t.Fatal("invalid returned users")
  1140  		}
  1141  
  1142  		if users[0].Id != u1.Id {
  1143  			t.Fatal("invalid returned user")
  1144  		}
  1145  	}
  1146  }
  1147  
  1148  func testUserStoreGetSystemAdminProfiles(t *testing.T, ss store.Store) {
  1149  	teamId := model.NewId()
  1150  
  1151  	u1 := &model.User{}
  1152  	u1.Email = MakeEmail()
  1153  	u1.Roles = model.SYSTEM_USER_ROLE_ID + " " + model.SYSTEM_ADMIN_ROLE_ID
  1154  	store.Must(ss.User().Save(u1))
  1155  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1156  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1157  
  1158  	u2 := &model.User{}
  1159  	u2.Email = MakeEmail()
  1160  	store.Must(ss.User().Save(u2))
  1161  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  1162  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
  1163  
  1164  	if r1 := <-ss.User().GetSystemAdminProfiles(); r1.Err != nil {
  1165  		t.Fatal(r1.Err)
  1166  	} else {
  1167  		users := r1.Data.(map[string]*model.User)
  1168  		if len(users) <= 0 {
  1169  			t.Fatal("invalid returned system admin users")
  1170  		}
  1171  	}
  1172  }
  1173  
  1174  func testUserStoreGetByEmail(t *testing.T, ss store.Store) {
  1175  	teamid := model.NewId()
  1176  
  1177  	u1 := &model.User{}
  1178  	u1.Email = MakeEmail()
  1179  	store.Must(ss.User().Save(u1))
  1180  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1181  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamid, UserId: u1.Id}, -1))
  1182  
  1183  	if err := (<-ss.User().GetByEmail(u1.Email)).Err; err != nil {
  1184  		t.Fatal(err)
  1185  	}
  1186  
  1187  	if err := (<-ss.User().GetByEmail("")).Err; err == nil {
  1188  		t.Fatal("Should have failed because of missing email")
  1189  	}
  1190  }
  1191  
  1192  func testUserStoreGetByAuthData(t *testing.T, ss store.Store) {
  1193  	teamId := model.NewId()
  1194  
  1195  	auth := "123" + model.NewId()
  1196  
  1197  	u1 := &model.User{}
  1198  	u1.Email = MakeEmail()
  1199  	u1.AuthData = &auth
  1200  	u1.AuthService = "service"
  1201  	store.Must(ss.User().Save(u1))
  1202  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1203  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1204  
  1205  	if err := (<-ss.User().GetByAuth(u1.AuthData, u1.AuthService)).Err; err != nil {
  1206  		t.Fatal(err)
  1207  	}
  1208  
  1209  	rauth := ""
  1210  	if err := (<-ss.User().GetByAuth(&rauth, "")).Err; err == nil {
  1211  		t.Fatal("Should have failed because of missing auth data")
  1212  	}
  1213  }
  1214  
  1215  func testUserStoreGetByUsername(t *testing.T, ss store.Store) {
  1216  	teamId := model.NewId()
  1217  
  1218  	u1 := &model.User{}
  1219  	u1.Email = MakeEmail()
  1220  	u1.Username = model.NewId()
  1221  	store.Must(ss.User().Save(u1))
  1222  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1223  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1224  
  1225  	if err := (<-ss.User().GetByUsername(u1.Username)).Err; err != nil {
  1226  		t.Fatal(err)
  1227  	}
  1228  
  1229  	if err := (<-ss.User().GetByUsername("")).Err; err == nil {
  1230  		t.Fatal("Should have failed because of missing username")
  1231  	}
  1232  }
  1233  
  1234  func testUserStoreGetForLogin(t *testing.T, ss store.Store) {
  1235  	auth := model.NewId()
  1236  
  1237  	u1 := &model.User{
  1238  		Email:       MakeEmail(),
  1239  		Username:    model.NewId(),
  1240  		AuthService: model.USER_AUTH_SERVICE_GITLAB,
  1241  		AuthData:    &auth,
  1242  	}
  1243  	store.Must(ss.User().Save(u1))
  1244  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1245  
  1246  	auth2 := model.NewId()
  1247  
  1248  	u2 := &model.User{
  1249  		Email:       MakeEmail(),
  1250  		Username:    model.NewId(),
  1251  		AuthService: model.USER_AUTH_SERVICE_LDAP,
  1252  		AuthData:    &auth2,
  1253  	}
  1254  	store.Must(ss.User().Save(u2))
  1255  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  1256  
  1257  	if result := <-ss.User().GetForLogin(u1.Username, true, true); result.Err != nil {
  1258  		t.Fatal("Should have gotten user by username", result.Err)
  1259  	} else if result.Data.(*model.User).Id != u1.Id {
  1260  		t.Fatal("Should have gotten user1 by username")
  1261  	}
  1262  
  1263  	if result := <-ss.User().GetForLogin(u1.Email, true, true); result.Err != nil {
  1264  		t.Fatal("Should have gotten user by email", result.Err)
  1265  	} else if result.Data.(*model.User).Id != u1.Id {
  1266  		t.Fatal("Should have gotten user1 by email")
  1267  	}
  1268  
  1269  	// prevent getting user when different login methods are disabled
  1270  	if result := <-ss.User().GetForLogin(u1.Username, false, true); result.Err == nil {
  1271  		t.Fatal("Should have failed to get user1 by username")
  1272  	}
  1273  
  1274  	if result := <-ss.User().GetForLogin(u1.Email, true, false); result.Err == nil {
  1275  		t.Fatal("Should have failed to get user1 by email")
  1276  	}
  1277  }
  1278  
  1279  func testUserStoreUpdatePassword(t *testing.T, ss store.Store) {
  1280  	teamId := model.NewId()
  1281  
  1282  	u1 := &model.User{}
  1283  	u1.Email = MakeEmail()
  1284  	store.Must(ss.User().Save(u1))
  1285  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1286  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1287  
  1288  	hashedPassword := model.HashPassword("newpwd")
  1289  
  1290  	if err := (<-ss.User().UpdatePassword(u1.Id, hashedPassword)).Err; err != nil {
  1291  		t.Fatal(err)
  1292  	}
  1293  
  1294  	if r1 := <-ss.User().GetByEmail(u1.Email); r1.Err != nil {
  1295  		t.Fatal(r1.Err)
  1296  	} else {
  1297  		user := r1.Data.(*model.User)
  1298  		if user.Password != hashedPassword {
  1299  			t.Fatal("Password was not updated correctly")
  1300  		}
  1301  	}
  1302  }
  1303  
  1304  func testUserStoreDelete(t *testing.T, ss store.Store) {
  1305  	u1 := &model.User{}
  1306  	u1.Email = MakeEmail()
  1307  	store.Must(ss.User().Save(u1))
  1308  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1309  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: model.NewId(), UserId: u1.Id}, -1))
  1310  
  1311  	if err := (<-ss.User().PermanentDelete(u1.Id)).Err; err != nil {
  1312  		t.Fatal(err)
  1313  	}
  1314  }
  1315  
  1316  func testUserStoreUpdateAuthData(t *testing.T, ss store.Store) {
  1317  	teamId := model.NewId()
  1318  
  1319  	u1 := &model.User{}
  1320  	u1.Email = MakeEmail()
  1321  	store.Must(ss.User().Save(u1))
  1322  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1323  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1324  
  1325  	service := "someservice"
  1326  	authData := model.NewId()
  1327  
  1328  	if err := (<-ss.User().UpdateAuthData(u1.Id, service, &authData, "", true)).Err; err != nil {
  1329  		t.Fatal(err)
  1330  	}
  1331  
  1332  	if r1 := <-ss.User().GetByEmail(u1.Email); r1.Err != nil {
  1333  		t.Fatal(r1.Err)
  1334  	} else {
  1335  		user := r1.Data.(*model.User)
  1336  		if user.AuthService != service {
  1337  			t.Fatal("AuthService was not updated correctly")
  1338  		}
  1339  		if *user.AuthData != authData {
  1340  			t.Fatal("AuthData was not updated correctly")
  1341  		}
  1342  		if user.Password != "" {
  1343  			t.Fatal("Password was not cleared properly")
  1344  		}
  1345  	}
  1346  }
  1347  
  1348  func testUserUnreadCount(t *testing.T, ss store.Store) {
  1349  	teamId := model.NewId()
  1350  
  1351  	c1 := model.Channel{}
  1352  	c1.TeamId = teamId
  1353  	c1.DisplayName = "Unread Messages"
  1354  	c1.Name = "unread-messages-" + model.NewId()
  1355  	c1.Type = model.CHANNEL_OPEN
  1356  
  1357  	c2 := model.Channel{}
  1358  	c2.TeamId = teamId
  1359  	c2.DisplayName = "Unread Direct"
  1360  	c2.Name = "unread-direct-" + model.NewId()
  1361  	c2.Type = model.CHANNEL_DIRECT
  1362  
  1363  	u1 := &model.User{}
  1364  	u1.Username = "user1" + model.NewId()
  1365  	u1.Email = MakeEmail()
  1366  	store.Must(ss.User().Save(u1))
  1367  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1368  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  1369  
  1370  	u2 := &model.User{}
  1371  	u2.Email = MakeEmail()
  1372  	u2.Username = "user2" + model.NewId()
  1373  	store.Must(ss.User().Save(u2))
  1374  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  1375  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
  1376  
  1377  	if err := (<-ss.Channel().Save(&c1, -1)).Err; err != nil {
  1378  		t.Fatal("couldn't save item", err)
  1379  	}
  1380  
  1381  	m1 := model.ChannelMember{}
  1382  	m1.ChannelId = c1.Id
  1383  	m1.UserId = u1.Id
  1384  	m1.NotifyProps = model.GetDefaultChannelNotifyProps()
  1385  
  1386  	m2 := model.ChannelMember{}
  1387  	m2.ChannelId = c1.Id
  1388  	m2.UserId = u2.Id
  1389  	m2.NotifyProps = model.GetDefaultChannelNotifyProps()
  1390  
  1391  	store.Must(ss.Channel().SaveMember(&m1))
  1392  	store.Must(ss.Channel().SaveMember(&m2))
  1393  
  1394  	m1.ChannelId = c2.Id
  1395  	m2.ChannelId = c2.Id
  1396  
  1397  	if err := (<-ss.Channel().SaveDirectChannel(&c2, &m1, &m2)).Err; err != nil {
  1398  		t.Fatal("couldn't save direct channel", err)
  1399  	}
  1400  
  1401  	p1 := model.Post{}
  1402  	p1.ChannelId = c1.Id
  1403  	p1.UserId = u1.Id
  1404  	p1.Message = "this is a message for @" + u2.Username
  1405  
  1406  	// Post one message with mention to open channel
  1407  	store.Must(ss.Post().Save(&p1))
  1408  	store.Must(ss.Channel().IncrementMentionCount(c1.Id, u2.Id))
  1409  
  1410  	// Post 2 messages without mention to direct channel
  1411  	p2 := model.Post{}
  1412  	p2.ChannelId = c2.Id
  1413  	p2.UserId = u1.Id
  1414  	p2.Message = "first message"
  1415  	store.Must(ss.Post().Save(&p2))
  1416  	store.Must(ss.Channel().IncrementMentionCount(c2.Id, u2.Id))
  1417  
  1418  	p3 := model.Post{}
  1419  	p3.ChannelId = c2.Id
  1420  	p3.UserId = u1.Id
  1421  	p3.Message = "second message"
  1422  	store.Must(ss.Post().Save(&p3))
  1423  	store.Must(ss.Channel().IncrementMentionCount(c2.Id, u2.Id))
  1424  
  1425  	badge := (<-ss.User().GetUnreadCount(u2.Id)).Data.(int64)
  1426  	if badge != 3 {
  1427  		t.Fatal("should have 3 unread messages")
  1428  	}
  1429  
  1430  	badge = (<-ss.User().GetUnreadCountForChannel(u2.Id, c1.Id)).Data.(int64)
  1431  	if badge != 1 {
  1432  		t.Fatal("should have 1 unread messages for that channel")
  1433  	}
  1434  
  1435  	badge = (<-ss.User().GetUnreadCountForChannel(u2.Id, c2.Id)).Data.(int64)
  1436  	if badge != 2 {
  1437  		t.Fatal("should have 2 unread messages for that channel")
  1438  	}
  1439  }
  1440  
  1441  func testUserStoreUpdateMfaSecret(t *testing.T, ss store.Store) {
  1442  	u1 := model.User{}
  1443  	u1.Email = MakeEmail()
  1444  	store.Must(ss.User().Save(&u1))
  1445  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1446  
  1447  	time.Sleep(100 * time.Millisecond)
  1448  
  1449  	if err := (<-ss.User().UpdateMfaSecret(u1.Id, "12345")).Err; err != nil {
  1450  		t.Fatal(err)
  1451  	}
  1452  
  1453  	// should pass, no update will occur though
  1454  	if err := (<-ss.User().UpdateMfaSecret("junk", "12345")).Err; err != nil {
  1455  		t.Fatal(err)
  1456  	}
  1457  }
  1458  
  1459  func testUserStoreUpdateMfaActive(t *testing.T, ss store.Store) {
  1460  	u1 := model.User{}
  1461  	u1.Email = MakeEmail()
  1462  	store.Must(ss.User().Save(&u1))
  1463  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1464  
  1465  	time.Sleep(100 * time.Millisecond)
  1466  
  1467  	if err := (<-ss.User().UpdateMfaActive(u1.Id, true)).Err; err != nil {
  1468  		t.Fatal(err)
  1469  	}
  1470  
  1471  	if err := (<-ss.User().UpdateMfaActive(u1.Id, false)).Err; err != nil {
  1472  		t.Fatal(err)
  1473  	}
  1474  
  1475  	// should pass, no update will occur though
  1476  	if err := (<-ss.User().UpdateMfaActive("junk", true)).Err; err != nil {
  1477  		t.Fatal(err)
  1478  	}
  1479  }
  1480  
  1481  func testUserStoreGetRecentlyActiveUsersForTeam(t *testing.T, ss store.Store) {
  1482  	u1 := &model.User{}
  1483  	u1.Email = MakeEmail()
  1484  	store.Must(ss.User().Save(u1))
  1485  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1486  	store.Must(ss.Status().SaveOrUpdate(&model.Status{UserId: u1.Id, Status: model.STATUS_ONLINE, Manual: false, LastActivityAt: model.GetMillis(), ActiveChannel: ""}))
  1487  	tid := model.NewId()
  1488  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u1.Id}, -1))
  1489  
  1490  	if r1 := <-ss.User().GetRecentlyActiveUsersForTeam(tid, 0, 100); r1.Err != nil {
  1491  		t.Fatal(r1.Err)
  1492  	}
  1493  }
  1494  
  1495  func testUserStoreGetNewUsersForTeam(t *testing.T, ss store.Store) {
  1496  	u1 := &model.User{}
  1497  	u1.Email = MakeEmail()
  1498  	store.Must(ss.User().Save(u1))
  1499  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1500  	store.Must(ss.Status().SaveOrUpdate(&model.Status{UserId: u1.Id, Status: model.STATUS_ONLINE, Manual: false, LastActivityAt: model.GetMillis(), ActiveChannel: ""}))
  1501  	tid := model.NewId()
  1502  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u1.Id}, -1))
  1503  
  1504  	if r1 := <-ss.User().GetNewUsersForTeam(tid, 0, 100); r1.Err != nil {
  1505  		t.Fatal(r1.Err)
  1506  	}
  1507  }
  1508  
  1509  func assertUsers(t *testing.T, expected, actual []*model.User) {
  1510  	expectedUsernames := make([]string, 0, len(expected))
  1511  	for _, user := range expected {
  1512  		expectedUsernames = append(expectedUsernames, user.Username)
  1513  	}
  1514  
  1515  	actualUsernames := make([]string, 0, len(actual))
  1516  	for _, user := range actual {
  1517  		actualUsernames = append(actualUsernames, user.Username)
  1518  	}
  1519  
  1520  	if assert.Equal(t, expectedUsernames, actualUsernames) {
  1521  		assert.Equal(t, expected, actual)
  1522  	}
  1523  }
  1524  
  1525  func assertUsersMatchInAnyOrder(t *testing.T, expected, actual []*model.User) {
  1526  	expectedUsernames := make([]string, 0, len(expected))
  1527  	for _, user := range expected {
  1528  		expectedUsernames = append(expectedUsernames, user.Username)
  1529  	}
  1530  
  1531  	actualUsernames := make([]string, 0, len(actual))
  1532  	for _, user := range actual {
  1533  		actualUsernames = append(actualUsernames, user.Username)
  1534  	}
  1535  
  1536  	if assert.ElementsMatch(t, expectedUsernames, actualUsernames) {
  1537  		assert.ElementsMatch(t, expected, actual)
  1538  	}
  1539  }
  1540  
  1541  func testUserStoreSearch(t *testing.T, ss store.Store) {
  1542  	u1 := &model.User{
  1543  		Username:  "jimbo1" + model.NewId(),
  1544  		FirstName: "Tim",
  1545  		LastName:  "Bill",
  1546  		Nickname:  "Rob",
  1547  		Email:     "harold" + model.NewId() + "@simulator.amazonses.com",
  1548  		Roles:     "system_user system_admin",
  1549  	}
  1550  	store.Must(ss.User().Save(u1))
  1551  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1552  
  1553  	u2 := &model.User{
  1554  		Username: "jim-bobby" + model.NewId(),
  1555  		Email:    MakeEmail(),
  1556  		Roles:    "system_user",
  1557  	}
  1558  	store.Must(ss.User().Save(u2))
  1559  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  1560  
  1561  	u3 := &model.User{
  1562  		Username: "jimbo3" + model.NewId(),
  1563  		Email:    MakeEmail(),
  1564  		DeleteAt: 1,
  1565  		Roles:    "system_admin",
  1566  	}
  1567  	store.Must(ss.User().Save(u3))
  1568  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  1569  
  1570  	u5 := &model.User{
  1571  		Username:  "yu" + model.NewId(),
  1572  		FirstName: "En",
  1573  		LastName:  "Yu",
  1574  		Nickname:  "enyu",
  1575  		Email:     MakeEmail(),
  1576  	}
  1577  	store.Must(ss.User().Save(u5))
  1578  	defer func() { store.Must(ss.User().PermanentDelete(u5.Id)) }()
  1579  
  1580  	u6 := &model.User{
  1581  		Username:  "underscore" + model.NewId(),
  1582  		FirstName: "Du_",
  1583  		LastName:  "_DE",
  1584  		Nickname:  "lodash",
  1585  		Email:     MakeEmail(),
  1586  	}
  1587  	store.Must(ss.User().Save(u6))
  1588  	defer func() { store.Must(ss.User().PermanentDelete(u6.Id)) }()
  1589  
  1590  	tid := model.NewId()
  1591  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u1.Id}, -1))
  1592  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u2.Id}, -1))
  1593  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u3.Id}, -1))
  1594  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u5.Id}, -1))
  1595  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u6.Id}, -1))
  1596  
  1597  	// The users returned from the database will have AuthData as an empty string.
  1598  	nilAuthData := new(string)
  1599  	*nilAuthData = ""
  1600  
  1601  	u1.AuthData = nilAuthData
  1602  	u2.AuthData = nilAuthData
  1603  	u3.AuthData = nilAuthData
  1604  	u5.AuthData = nilAuthData
  1605  	u6.AuthData = nilAuthData
  1606  
  1607  	testCases := []struct {
  1608  		Description string
  1609  		TeamId      string
  1610  		Term        string
  1611  		Options     *model.UserSearchOptions
  1612  		Expected    []*model.User
  1613  	}{
  1614  		{
  1615  			"search jimb",
  1616  			tid,
  1617  			"jimb",
  1618  			&model.UserSearchOptions{
  1619  				AllowFullNames: true,
  1620  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1621  			},
  1622  			[]*model.User{u1},
  1623  		},
  1624  		{
  1625  			"search en",
  1626  			tid,
  1627  			"en",
  1628  			&model.UserSearchOptions{
  1629  				AllowFullNames: true,
  1630  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1631  			},
  1632  			[]*model.User{u5},
  1633  		},
  1634  		{
  1635  			"search email",
  1636  			tid,
  1637  			u1.Email,
  1638  			&model.UserSearchOptions{
  1639  				AllowEmails:    true,
  1640  				AllowFullNames: true,
  1641  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1642  			},
  1643  			[]*model.User{u1},
  1644  		},
  1645  		{
  1646  			"search maps * to space",
  1647  			tid,
  1648  			"jimb*",
  1649  			&model.UserSearchOptions{
  1650  				AllowFullNames: true,
  1651  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1652  			},
  1653  			[]*model.User{u1},
  1654  		},
  1655  		{
  1656  			"should not return spurious matches",
  1657  			tid,
  1658  			"harol",
  1659  			&model.UserSearchOptions{
  1660  				AllowFullNames: true,
  1661  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1662  			},
  1663  			[]*model.User{},
  1664  		},
  1665  		{
  1666  			"% should be escaped",
  1667  			tid,
  1668  			"h%",
  1669  			&model.UserSearchOptions{
  1670  				AllowFullNames: true,
  1671  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1672  			},
  1673  			[]*model.User{},
  1674  		},
  1675  		{
  1676  			"_ should be escaped",
  1677  			tid,
  1678  			"h_",
  1679  			&model.UserSearchOptions{
  1680  				AllowFullNames: true,
  1681  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1682  			},
  1683  			[]*model.User{},
  1684  		},
  1685  		{
  1686  			"_ should be escaped (2)",
  1687  			tid,
  1688  			"Du_",
  1689  			&model.UserSearchOptions{
  1690  				AllowFullNames: true,
  1691  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1692  			},
  1693  			[]*model.User{u6},
  1694  		},
  1695  		{
  1696  			"_ should be escaped (2)",
  1697  			tid,
  1698  			"_dE",
  1699  			&model.UserSearchOptions{
  1700  				AllowFullNames: true,
  1701  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1702  			},
  1703  			[]*model.User{u6},
  1704  		},
  1705  		{
  1706  			"search jimb, allowing inactive",
  1707  			tid,
  1708  			"jimb",
  1709  			&model.UserSearchOptions{
  1710  				AllowFullNames: true,
  1711  				AllowInactive:  true,
  1712  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1713  			},
  1714  			[]*model.User{u1, u3},
  1715  		},
  1716  		{
  1717  			"search jimb, no team id",
  1718  			"",
  1719  			"jimb",
  1720  			&model.UserSearchOptions{
  1721  				AllowFullNames: true,
  1722  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1723  			},
  1724  			[]*model.User{u1},
  1725  		},
  1726  		{
  1727  			"search jim-bobb, no team id",
  1728  			"",
  1729  			"jim-bobb",
  1730  			&model.UserSearchOptions{
  1731  				AllowFullNames: true,
  1732  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1733  			},
  1734  			[]*model.User{u2},
  1735  		},
  1736  
  1737  		{
  1738  			"search harol, search all fields",
  1739  			tid,
  1740  			"harol",
  1741  			&model.UserSearchOptions{
  1742  				AllowFullNames: true,
  1743  				AllowEmails:    true,
  1744  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1745  			},
  1746  			[]*model.User{u1},
  1747  		},
  1748  		{
  1749  			"search Tim, search all fields",
  1750  			tid,
  1751  			"Tim",
  1752  			&model.UserSearchOptions{
  1753  				AllowFullNames: true,
  1754  				AllowEmails:    true,
  1755  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1756  			},
  1757  			[]*model.User{u1},
  1758  		},
  1759  		{
  1760  			"search Tim, don't search full names",
  1761  			tid,
  1762  			"Tim",
  1763  			&model.UserSearchOptions{
  1764  				AllowFullNames: false,
  1765  				AllowEmails:    true,
  1766  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1767  			},
  1768  			[]*model.User{},
  1769  		},
  1770  		{
  1771  			"search Bill, search all fields",
  1772  			tid,
  1773  			"Bill",
  1774  			&model.UserSearchOptions{
  1775  				AllowFullNames: true,
  1776  				AllowEmails:    true,
  1777  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1778  			},
  1779  			[]*model.User{u1},
  1780  		},
  1781  		{
  1782  			"search Rob, search all fields",
  1783  			tid,
  1784  			"Rob",
  1785  			&model.UserSearchOptions{
  1786  				AllowFullNames: true,
  1787  				AllowEmails:    true,
  1788  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1789  			},
  1790  			[]*model.User{u1},
  1791  		},
  1792  		{
  1793  			"leading @ should be ignored",
  1794  			tid,
  1795  			"@jimb",
  1796  			&model.UserSearchOptions{
  1797  				AllowFullNames: true,
  1798  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1799  			},
  1800  			[]*model.User{u1},
  1801  		},
  1802  		{
  1803  			"search jim-bobby with system_user roles",
  1804  			tid,
  1805  			"jim-bobby",
  1806  			&model.UserSearchOptions{
  1807  				AllowFullNames: true,
  1808  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1809  				Role:           "system_user",
  1810  			},
  1811  			[]*model.User{u2},
  1812  		},
  1813  		{
  1814  			"search jim with system_admin roles",
  1815  			tid,
  1816  			"jim",
  1817  			&model.UserSearchOptions{
  1818  				AllowFullNames: true,
  1819  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1820  				Role:           "system_admin",
  1821  			},
  1822  			[]*model.User{u1},
  1823  		},
  1824  		{
  1825  			"search ji with system_user roles",
  1826  			tid,
  1827  			"ji",
  1828  			&model.UserSearchOptions{
  1829  				AllowFullNames: true,
  1830  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1831  				Role:           "system_user",
  1832  			},
  1833  			[]*model.User{u1, u2},
  1834  		},
  1835  	}
  1836  
  1837  	for _, testCase := range testCases {
  1838  		t.Run(testCase.Description, func(t *testing.T) {
  1839  			result := <-ss.User().Search(testCase.TeamId, testCase.Term, testCase.Options)
  1840  			require.Nil(t, result.Err)
  1841  			assertUsersMatchInAnyOrder(t, testCase.Expected, result.Data.([]*model.User))
  1842  		})
  1843  	}
  1844  
  1845  	t.Run("search empty string", func(t *testing.T) {
  1846  		searchOptions := &model.UserSearchOptions{
  1847  			AllowFullNames: true,
  1848  			Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1849  		}
  1850  
  1851  		r1 := <-ss.User().Search(tid, "", searchOptions)
  1852  		require.Nil(t, r1.Err)
  1853  		assert.Len(t, r1.Data.([]*model.User), 4)
  1854  		// Don't assert contents, since Postgres' default collation order is left up to
  1855  		// the operating system, and jimbo1 might sort before or after jim-bo.
  1856  		// assertUsers(t, []*model.User{u2, u1, u6, u5}, r1.Data.([]*model.User))
  1857  	})
  1858  
  1859  	t.Run("search empty string, limit 2", func(t *testing.T) {
  1860  		searchOptions := &model.UserSearchOptions{
  1861  			AllowFullNames: true,
  1862  			Limit:          2,
  1863  		}
  1864  
  1865  		r1 := <-ss.User().Search(tid, "", searchOptions)
  1866  		require.Nil(t, r1.Err)
  1867  		assert.Len(t, r1.Data.([]*model.User), 2)
  1868  		// Don't assert contents, since Postgres' default collation order is left up to
  1869  		// the operating system, and jimbo1 might sort before or after jim-bo.
  1870  		// assertUsers(t, []*model.User{u2, u1, u6, u5}, r1.Data.([]*model.User))
  1871  	})
  1872  }
  1873  
  1874  func testUserStoreSearchNotInChannel(t *testing.T, ss store.Store) {
  1875  	u1 := &model.User{
  1876  		Username:  "jimbo1" + model.NewId(),
  1877  		FirstName: "Tim",
  1878  		LastName:  "Bill",
  1879  		Nickname:  "Rob",
  1880  		Email:     "harold" + model.NewId() + "@simulator.amazonses.com",
  1881  	}
  1882  	store.Must(ss.User().Save(u1))
  1883  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  1884  
  1885  	u2 := &model.User{
  1886  		Username: "jim2-bobby" + model.NewId(),
  1887  		Email:    MakeEmail(),
  1888  	}
  1889  	store.Must(ss.User().Save(u2))
  1890  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  1891  
  1892  	u3 := &model.User{
  1893  		Username: "jimbo3" + model.NewId(),
  1894  		Email:    MakeEmail(),
  1895  		DeleteAt: 1,
  1896  	}
  1897  	store.Must(ss.User().Save(u3))
  1898  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  1899  
  1900  	tid := model.NewId()
  1901  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u1.Id}, -1))
  1902  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u2.Id}, -1))
  1903  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u3.Id}, -1))
  1904  
  1905  	// The users returned from the database will have AuthData as an empty string.
  1906  	nilAuthData := new(string)
  1907  	*nilAuthData = ""
  1908  
  1909  	u1.AuthData = nilAuthData
  1910  	u2.AuthData = nilAuthData
  1911  	u3.AuthData = nilAuthData
  1912  
  1913  	c1 := model.Channel{
  1914  		TeamId:      tid,
  1915  		DisplayName: "NameName",
  1916  		Name:        "zz" + model.NewId() + "b",
  1917  		Type:        model.CHANNEL_OPEN,
  1918  	}
  1919  	c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel)
  1920  
  1921  	c2 := model.Channel{
  1922  		TeamId:      tid,
  1923  		DisplayName: "NameName",
  1924  		Name:        "zz" + model.NewId() + "b",
  1925  		Type:        model.CHANNEL_OPEN,
  1926  	}
  1927  	c2 = *store.Must(ss.Channel().Save(&c2, -1)).(*model.Channel)
  1928  
  1929  	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
  1930  		ChannelId:   c2.Id,
  1931  		UserId:      u1.Id,
  1932  		NotifyProps: model.GetDefaultChannelNotifyProps(),
  1933  	}))
  1934  	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
  1935  		ChannelId:   c1.Id,
  1936  		UserId:      u3.Id,
  1937  		NotifyProps: model.GetDefaultChannelNotifyProps(),
  1938  	}))
  1939  	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
  1940  		ChannelId:   c2.Id,
  1941  		UserId:      u2.Id,
  1942  		NotifyProps: model.GetDefaultChannelNotifyProps(),
  1943  	}))
  1944  
  1945  	testCases := []struct {
  1946  		Description string
  1947  		TeamId      string
  1948  		ChannelId   string
  1949  		Term        string
  1950  		Options     *model.UserSearchOptions
  1951  		Expected    []*model.User
  1952  	}{
  1953  		{
  1954  			"search jimb, channel 1",
  1955  			tid,
  1956  			c1.Id,
  1957  			"jimb",
  1958  			&model.UserSearchOptions{
  1959  				AllowFullNames: true,
  1960  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1961  			},
  1962  			[]*model.User{u1},
  1963  		},
  1964  		{
  1965  			"search jimb, allow inactive, channel 1",
  1966  			tid,
  1967  			c1.Id,
  1968  			"jimb",
  1969  			&model.UserSearchOptions{
  1970  				AllowFullNames: true,
  1971  				AllowInactive:  true,
  1972  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1973  			},
  1974  			[]*model.User{u1},
  1975  		},
  1976  		{
  1977  			"search jimb, channel 1, no team id",
  1978  			"",
  1979  			c1.Id,
  1980  			"jimb",
  1981  			&model.UserSearchOptions{
  1982  				AllowFullNames: true,
  1983  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1984  			},
  1985  			[]*model.User{u1},
  1986  		},
  1987  		{
  1988  			"search jimb, channel 1, junk team id",
  1989  			"junk",
  1990  			c1.Id,
  1991  			"jimb",
  1992  			&model.UserSearchOptions{
  1993  				AllowFullNames: true,
  1994  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  1995  			},
  1996  			[]*model.User{},
  1997  		},
  1998  		{
  1999  			"search jimb, channel 2",
  2000  			tid,
  2001  			c2.Id,
  2002  			"jimb",
  2003  			&model.UserSearchOptions{
  2004  				AllowFullNames: true,
  2005  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2006  			},
  2007  			[]*model.User{},
  2008  		},
  2009  		{
  2010  			"search jimb, allow inactive, channel 2",
  2011  			tid,
  2012  			c2.Id,
  2013  			"jimb",
  2014  			&model.UserSearchOptions{
  2015  				AllowFullNames: true,
  2016  				AllowInactive:  true,
  2017  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2018  			},
  2019  			[]*model.User{u3},
  2020  		},
  2021  		{
  2022  			"search jimb, channel 2, no team id",
  2023  			"",
  2024  			c2.Id,
  2025  			"jimb",
  2026  			&model.UserSearchOptions{
  2027  				AllowFullNames: true,
  2028  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2029  			},
  2030  			[]*model.User{},
  2031  		},
  2032  		{
  2033  			"search jimb, channel 2, junk team id",
  2034  			"junk",
  2035  			c2.Id,
  2036  			"jimb",
  2037  			&model.UserSearchOptions{
  2038  				AllowFullNames: true,
  2039  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2040  			},
  2041  			[]*model.User{},
  2042  		},
  2043  		{
  2044  			"search jim, channel 1",
  2045  			tid,
  2046  			c1.Id,
  2047  			"jim",
  2048  			&model.UserSearchOptions{
  2049  				AllowFullNames: true,
  2050  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2051  			},
  2052  			[]*model.User{u2, u1},
  2053  		},
  2054  		{
  2055  			"search jim, channel 1, limit 1",
  2056  			tid,
  2057  			c1.Id,
  2058  			"jim",
  2059  			&model.UserSearchOptions{
  2060  				AllowFullNames: true,
  2061  				Limit:          1,
  2062  			},
  2063  			[]*model.User{u2},
  2064  		},
  2065  	}
  2066  
  2067  	for _, testCase := range testCases {
  2068  		t.Run(testCase.Description, func(t *testing.T) {
  2069  			result := <-ss.User().SearchNotInChannel(
  2070  				testCase.TeamId,
  2071  				testCase.ChannelId,
  2072  				testCase.Term,
  2073  				testCase.Options,
  2074  			)
  2075  			require.Nil(t, result.Err)
  2076  			assertUsers(t, testCase.Expected, result.Data.([]*model.User))
  2077  		})
  2078  	}
  2079  }
  2080  
  2081  func testUserStoreSearchInChannel(t *testing.T, ss store.Store) {
  2082  	u1 := &model.User{
  2083  		Username:  "jimbo1" + model.NewId(),
  2084  		FirstName: "Tim",
  2085  		LastName:  "Bill",
  2086  		Nickname:  "Rob",
  2087  		Email:     "harold" + model.NewId() + "@simulator.amazonses.com",
  2088  	}
  2089  	store.Must(ss.User().Save(u1))
  2090  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2091  
  2092  	u2 := &model.User{
  2093  		Username: "jim-bobby" + model.NewId(),
  2094  		Email:    MakeEmail(),
  2095  	}
  2096  	store.Must(ss.User().Save(u2))
  2097  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2098  
  2099  	u3 := &model.User{
  2100  		Username: "jimbo3" + model.NewId(),
  2101  		Email:    MakeEmail(),
  2102  		DeleteAt: 1,
  2103  	}
  2104  	store.Must(ss.User().Save(u3))
  2105  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  2106  
  2107  	tid := model.NewId()
  2108  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u1.Id}, -1))
  2109  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u2.Id}, -1))
  2110  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u3.Id}, -1))
  2111  
  2112  	// The users returned from the database will have AuthData as an empty string.
  2113  	nilAuthData := new(string)
  2114  	*nilAuthData = ""
  2115  
  2116  	u1.AuthData = nilAuthData
  2117  	u2.AuthData = nilAuthData
  2118  	u3.AuthData = nilAuthData
  2119  
  2120  	c1 := model.Channel{
  2121  		TeamId:      tid,
  2122  		DisplayName: "NameName",
  2123  		Name:        "zz" + model.NewId() + "b",
  2124  		Type:        model.CHANNEL_OPEN,
  2125  	}
  2126  	c1 = *store.Must(ss.Channel().Save(&c1, -1)).(*model.Channel)
  2127  
  2128  	c2 := model.Channel{
  2129  		TeamId:      tid,
  2130  		DisplayName: "NameName",
  2131  		Name:        "zz" + model.NewId() + "b",
  2132  		Type:        model.CHANNEL_OPEN,
  2133  	}
  2134  	c2 = *store.Must(ss.Channel().Save(&c2, -1)).(*model.Channel)
  2135  
  2136  	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
  2137  		ChannelId:   c1.Id,
  2138  		UserId:      u1.Id,
  2139  		NotifyProps: model.GetDefaultChannelNotifyProps(),
  2140  	}))
  2141  	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
  2142  		ChannelId:   c2.Id,
  2143  		UserId:      u2.Id,
  2144  		NotifyProps: model.GetDefaultChannelNotifyProps(),
  2145  	}))
  2146  	store.Must(ss.Channel().SaveMember(&model.ChannelMember{
  2147  		ChannelId:   c1.Id,
  2148  		UserId:      u3.Id,
  2149  		NotifyProps: model.GetDefaultChannelNotifyProps(),
  2150  	}))
  2151  
  2152  	testCases := []struct {
  2153  		Description string
  2154  		ChannelId   string
  2155  		Term        string
  2156  		Options     *model.UserSearchOptions
  2157  		Expected    []*model.User
  2158  	}{
  2159  		{
  2160  			"search jimb, channel 1",
  2161  			c1.Id,
  2162  			"jimb",
  2163  			&model.UserSearchOptions{
  2164  				AllowFullNames: true,
  2165  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2166  			},
  2167  			[]*model.User{u1},
  2168  		},
  2169  		{
  2170  			"search jimb, allow inactive, channel 1",
  2171  			c1.Id,
  2172  			"jimb",
  2173  			&model.UserSearchOptions{
  2174  				AllowFullNames: true,
  2175  				AllowInactive:  true,
  2176  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2177  			},
  2178  			[]*model.User{u1, u3},
  2179  		},
  2180  		{
  2181  			"search jimb, allow inactive, channel 1, limit 1",
  2182  			c1.Id,
  2183  			"jimb",
  2184  			&model.UserSearchOptions{
  2185  				AllowFullNames: true,
  2186  				AllowInactive:  true,
  2187  				Limit:          1,
  2188  			},
  2189  			[]*model.User{u1},
  2190  		},
  2191  		{
  2192  			"search jimb, channel 2",
  2193  			c2.Id,
  2194  			"jimb",
  2195  			&model.UserSearchOptions{
  2196  				AllowFullNames: true,
  2197  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2198  			},
  2199  			[]*model.User{},
  2200  		},
  2201  		{
  2202  			"search jimb, allow inactive, channel 2",
  2203  			c2.Id,
  2204  			"jimb",
  2205  			&model.UserSearchOptions{
  2206  				AllowFullNames: true,
  2207  				AllowInactive:  true,
  2208  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2209  			},
  2210  			[]*model.User{},
  2211  		},
  2212  	}
  2213  
  2214  	for _, testCase := range testCases {
  2215  		t.Run(testCase.Description, func(t *testing.T) {
  2216  			result := <-ss.User().SearchInChannel(
  2217  				testCase.ChannelId,
  2218  				testCase.Term,
  2219  				testCase.Options,
  2220  			)
  2221  			require.Nil(t, result.Err)
  2222  			assertUsers(t, testCase.Expected, result.Data.([]*model.User))
  2223  		})
  2224  	}
  2225  }
  2226  
  2227  func testUserStoreSearchNotInTeam(t *testing.T, ss store.Store) {
  2228  	u1 := &model.User{
  2229  		Username:  "jimbo1" + model.NewId(),
  2230  		FirstName: "Tim",
  2231  		LastName:  "Bill",
  2232  		Nickname:  "Rob",
  2233  		Email:     "harold" + model.NewId() + "@simulator.amazonses.com",
  2234  	}
  2235  	store.Must(ss.User().Save(u1))
  2236  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2237  
  2238  	u2 := &model.User{
  2239  		Username: "jim-bobby" + model.NewId(),
  2240  		Email:    MakeEmail(),
  2241  	}
  2242  	store.Must(ss.User().Save(u2))
  2243  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2244  
  2245  	u3 := &model.User{
  2246  		Username: "jimbo3" + model.NewId(),
  2247  		Email:    MakeEmail(),
  2248  		DeleteAt: 1,
  2249  	}
  2250  	store.Must(ss.User().Save(u3))
  2251  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  2252  
  2253  	u4 := &model.User{
  2254  		Username: "simon" + model.NewId(),
  2255  		Email:    MakeEmail(),
  2256  		DeleteAt: 0,
  2257  	}
  2258  	store.Must(ss.User().Save(u4))
  2259  	defer func() { store.Must(ss.User().PermanentDelete(u4.Id)) }()
  2260  
  2261  	u5 := &model.User{
  2262  		Username:  "yu" + model.NewId(),
  2263  		FirstName: "En",
  2264  		LastName:  "Yu",
  2265  		Nickname:  "enyu",
  2266  		Email:     MakeEmail(),
  2267  	}
  2268  	store.Must(ss.User().Save(u5))
  2269  	defer func() { store.Must(ss.User().PermanentDelete(u5.Id)) }()
  2270  
  2271  	u6 := &model.User{
  2272  		Username:  "underscore" + model.NewId(),
  2273  		FirstName: "Du_",
  2274  		LastName:  "_DE",
  2275  		Nickname:  "lodash",
  2276  		Email:     MakeEmail(),
  2277  	}
  2278  	store.Must(ss.User().Save(u6))
  2279  	defer func() { store.Must(ss.User().PermanentDelete(u6.Id)) }()
  2280  
  2281  	teamId1 := model.NewId()
  2282  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId1, UserId: u1.Id}, -1))
  2283  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId1, UserId: u2.Id}, -1))
  2284  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId1, UserId: u3.Id}, -1))
  2285  	// u4 is not in team 1
  2286  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId1, UserId: u5.Id}, -1))
  2287  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId1, UserId: u6.Id}, -1))
  2288  
  2289  	teamId2 := model.NewId()
  2290  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId2, UserId: u4.Id}, -1))
  2291  
  2292  	// The users returned from the database will have AuthData as an empty string.
  2293  	nilAuthData := new(string)
  2294  	*nilAuthData = ""
  2295  
  2296  	u1.AuthData = nilAuthData
  2297  	u2.AuthData = nilAuthData
  2298  	u3.AuthData = nilAuthData
  2299  	u4.AuthData = nilAuthData
  2300  	u5.AuthData = nilAuthData
  2301  	u6.AuthData = nilAuthData
  2302  
  2303  	testCases := []struct {
  2304  		Description string
  2305  		TeamId      string
  2306  		Term        string
  2307  		Options     *model.UserSearchOptions
  2308  		Expected    []*model.User
  2309  	}{
  2310  		{
  2311  			"search simo, team 1",
  2312  			teamId1,
  2313  			"simo",
  2314  			&model.UserSearchOptions{
  2315  				AllowFullNames: true,
  2316  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2317  			},
  2318  			[]*model.User{u4},
  2319  		},
  2320  
  2321  		{
  2322  			"search jimb, team 1",
  2323  			teamId1,
  2324  			"jimb",
  2325  			&model.UserSearchOptions{
  2326  				AllowFullNames: true,
  2327  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2328  			},
  2329  			[]*model.User{},
  2330  		},
  2331  		{
  2332  			"search jimb, allow inactive, team 1",
  2333  			teamId1,
  2334  			"jimb",
  2335  			&model.UserSearchOptions{
  2336  				AllowFullNames: true,
  2337  				AllowInactive:  true,
  2338  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2339  			},
  2340  			[]*model.User{},
  2341  		},
  2342  		{
  2343  			"search simo, team 2",
  2344  			teamId2,
  2345  			"simo",
  2346  			&model.UserSearchOptions{
  2347  				AllowFullNames: true,
  2348  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2349  			},
  2350  			[]*model.User{},
  2351  		},
  2352  		{
  2353  			"search jimb, team2",
  2354  			teamId2,
  2355  			"jimb",
  2356  			&model.UserSearchOptions{
  2357  				AllowFullNames: true,
  2358  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2359  			},
  2360  			[]*model.User{u1},
  2361  		},
  2362  		{
  2363  			"search jimb, allow inactive, team 2",
  2364  			teamId2,
  2365  			"jimb",
  2366  			&model.UserSearchOptions{
  2367  				AllowFullNames: true,
  2368  				AllowInactive:  true,
  2369  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2370  			},
  2371  			[]*model.User{u1, u3},
  2372  		},
  2373  		{
  2374  			"search jimb, allow inactive, team 2, limit 1",
  2375  			teamId2,
  2376  			"jimb",
  2377  			&model.UserSearchOptions{
  2378  				AllowFullNames: true,
  2379  				AllowInactive:  true,
  2380  				Limit:          1,
  2381  			},
  2382  			[]*model.User{u1},
  2383  		},
  2384  	}
  2385  
  2386  	for _, testCase := range testCases {
  2387  		t.Run(testCase.Description, func(t *testing.T) {
  2388  			result := <-ss.User().SearchNotInTeam(
  2389  				testCase.TeamId,
  2390  				testCase.Term,
  2391  				testCase.Options,
  2392  			)
  2393  			require.Nil(t, result.Err)
  2394  			assertUsers(t, testCase.Expected, result.Data.([]*model.User))
  2395  		})
  2396  	}
  2397  }
  2398  
  2399  func testUserStoreSearchWithoutTeam(t *testing.T, ss store.Store) {
  2400  	u1 := &model.User{
  2401  		Username:  "jimbo1" + model.NewId(),
  2402  		FirstName: "Tim",
  2403  		LastName:  "Bill",
  2404  		Nickname:  "Rob",
  2405  		Email:     "harold" + model.NewId() + "@simulator.amazonses.com",
  2406  	}
  2407  	store.Must(ss.User().Save(u1))
  2408  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2409  
  2410  	u2 := &model.User{
  2411  		Username: "jim2-bobby" + model.NewId(),
  2412  		Email:    MakeEmail(),
  2413  	}
  2414  	store.Must(ss.User().Save(u2))
  2415  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2416  
  2417  	u3 := &model.User{
  2418  		Username: "jimbo3" + model.NewId(),
  2419  		Email:    MakeEmail(),
  2420  		DeleteAt: 1,
  2421  	}
  2422  	store.Must(ss.User().Save(u3))
  2423  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  2424  
  2425  	tid := model.NewId()
  2426  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: tid, UserId: u3.Id}, -1))
  2427  
  2428  	// The users returned from the database will have AuthData as an empty string.
  2429  	nilAuthData := new(string)
  2430  	*nilAuthData = ""
  2431  
  2432  	u1.AuthData = nilAuthData
  2433  	u2.AuthData = nilAuthData
  2434  	u3.AuthData = nilAuthData
  2435  
  2436  	testCases := []struct {
  2437  		Description string
  2438  		Term        string
  2439  		Options     *model.UserSearchOptions
  2440  		Expected    []*model.User
  2441  	}{
  2442  		{
  2443  			"empty string",
  2444  			"",
  2445  			&model.UserSearchOptions{
  2446  				AllowFullNames: true,
  2447  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2448  			},
  2449  			[]*model.User{u2, u1},
  2450  		},
  2451  		{
  2452  			"jim",
  2453  			"jim",
  2454  			&model.UserSearchOptions{
  2455  				AllowFullNames: true,
  2456  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2457  			},
  2458  			[]*model.User{u2, u1},
  2459  		},
  2460  		{
  2461  			"PLT-8354",
  2462  			"* ",
  2463  			&model.UserSearchOptions{
  2464  				AllowFullNames: true,
  2465  				Limit:          model.USER_SEARCH_DEFAULT_LIMIT,
  2466  			},
  2467  			[]*model.User{u2, u1},
  2468  		},
  2469  		{
  2470  			"jim, limit 1",
  2471  			"jim",
  2472  			&model.UserSearchOptions{
  2473  				AllowFullNames: true,
  2474  				Limit:          1,
  2475  			},
  2476  			[]*model.User{u2},
  2477  		},
  2478  	}
  2479  
  2480  	for _, testCase := range testCases {
  2481  		t.Run(testCase.Description, func(t *testing.T) {
  2482  			result := <-ss.User().SearchWithoutTeam(
  2483  				testCase.Term,
  2484  				testCase.Options,
  2485  			)
  2486  			require.Nil(t, result.Err)
  2487  			assertUsers(t, testCase.Expected, result.Data.([]*model.User))
  2488  		})
  2489  	}
  2490  }
  2491  
  2492  func testUserStoreAnalyticsGetInactiveUsersCount(t *testing.T, ss store.Store) {
  2493  	u1 := &model.User{}
  2494  	u1.Email = MakeEmail()
  2495  	store.Must(ss.User().Save(u1))
  2496  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2497  
  2498  	var count int64
  2499  
  2500  	if result := <-ss.User().AnalyticsGetInactiveUsersCount(); result.Err != nil {
  2501  		t.Fatal(result.Err)
  2502  	} else {
  2503  		count = result.Data.(int64)
  2504  	}
  2505  
  2506  	u2 := &model.User{}
  2507  	u2.Email = MakeEmail()
  2508  	u2.DeleteAt = model.GetMillis()
  2509  	store.Must(ss.User().Save(u2))
  2510  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2511  
  2512  	if result := <-ss.User().AnalyticsGetInactiveUsersCount(); result.Err != nil {
  2513  		t.Fatal(result.Err)
  2514  	} else {
  2515  		newCount := result.Data.(int64)
  2516  		if count != newCount-1 {
  2517  			t.Fatal("Expected 1 more inactive users but found otherwise.", count, newCount)
  2518  		}
  2519  	}
  2520  }
  2521  
  2522  func testUserStoreAnalyticsGetSystemAdminCount(t *testing.T, ss store.Store) {
  2523  	var countBefore int64
  2524  	if result := <-ss.User().AnalyticsGetSystemAdminCount(); result.Err != nil {
  2525  		t.Fatal(result.Err)
  2526  	} else {
  2527  		countBefore = result.Data.(int64)
  2528  	}
  2529  
  2530  	u1 := model.User{}
  2531  	u1.Email = MakeEmail()
  2532  	u1.Username = model.NewId()
  2533  	u1.Roles = "system_user system_admin"
  2534  
  2535  	u2 := model.User{}
  2536  	u2.Email = MakeEmail()
  2537  	u2.Username = model.NewId()
  2538  
  2539  	if err := (<-ss.User().Save(&u1)).Err; err != nil {
  2540  		t.Fatal("couldn't save user", err)
  2541  	}
  2542  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2543  
  2544  	if err := (<-ss.User().Save(&u2)).Err; err != nil {
  2545  		t.Fatal("couldn't save user", err)
  2546  	}
  2547  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2548  
  2549  	if result := <-ss.User().AnalyticsGetSystemAdminCount(); result.Err != nil {
  2550  		t.Fatal(result.Err)
  2551  	} else {
  2552  		// We expect to find 1 more system admin than there was at the start of this test function.
  2553  		if count := result.Data.(int64); count != countBefore+1 {
  2554  			t.Fatal("Did not get the expected number of system admins. Expected, got: ", countBefore+1, count)
  2555  		}
  2556  	}
  2557  }
  2558  
  2559  func testUserStoreGetProfilesNotInTeam(t *testing.T, ss store.Store) {
  2560  	teamId := model.NewId()
  2561  
  2562  	u1 := &model.User{}
  2563  	u1.Email = MakeEmail()
  2564  	store.Must(ss.User().Save(u1))
  2565  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2566  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u1.Id}, -1))
  2567  	store.Must(ss.User().UpdateUpdateAt(u1.Id))
  2568  
  2569  	u2 := &model.User{}
  2570  	u2.Email = MakeEmail()
  2571  	store.Must(ss.User().Save(u2))
  2572  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2573  	store.Must(ss.User().UpdateUpdateAt(u2.Id))
  2574  
  2575  	var initialUsersNotInTeam int
  2576  	var etag1, etag2, etag3 string
  2577  
  2578  	if er1 := <-ss.User().GetEtagForProfilesNotInTeam(teamId); er1.Err != nil {
  2579  		t.Fatal(er1.Err)
  2580  	} else {
  2581  		etag1 = er1.Data.(string)
  2582  	}
  2583  
  2584  	if r1 := <-ss.User().GetProfilesNotInTeam(teamId, 0, 100000); r1.Err != nil {
  2585  		t.Fatal(r1.Err)
  2586  	} else {
  2587  		users := r1.Data.([]*model.User)
  2588  		initialUsersNotInTeam = len(users)
  2589  		if initialUsersNotInTeam < 1 {
  2590  			t.Fatalf("Should be at least 1 user not in the team")
  2591  		}
  2592  
  2593  		found := false
  2594  		for _, u := range users {
  2595  			if u.Id == u2.Id {
  2596  				found = true
  2597  			}
  2598  			if u.Id == u1.Id {
  2599  				t.Fatalf("Should not have found user1")
  2600  			}
  2601  		}
  2602  
  2603  		if !found {
  2604  			t.Fatal("missing user2")
  2605  		}
  2606  	}
  2607  
  2608  	time.Sleep(time.Millisecond * 10)
  2609  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u2.Id}, -1))
  2610  	store.Must(ss.User().UpdateUpdateAt(u2.Id))
  2611  
  2612  	if er2 := <-ss.User().GetEtagForProfilesNotInTeam(teamId); er2.Err != nil {
  2613  		t.Fatal(er2.Err)
  2614  	} else {
  2615  		etag2 = er2.Data.(string)
  2616  		if etag1 == etag2 {
  2617  			t.Fatalf("etag should have changed")
  2618  		}
  2619  	}
  2620  
  2621  	if r2 := <-ss.User().GetProfilesNotInTeam(teamId, 0, 100000); r2.Err != nil {
  2622  		t.Fatal(r2.Err)
  2623  	} else {
  2624  		users := r2.Data.([]*model.User)
  2625  
  2626  		if len(users) != initialUsersNotInTeam-1 {
  2627  			t.Fatalf("Should be one less user not in team")
  2628  		}
  2629  
  2630  		for _, u := range users {
  2631  			if u.Id == u2.Id {
  2632  				t.Fatalf("Should not have found user2")
  2633  			}
  2634  			if u.Id == u1.Id {
  2635  				t.Fatalf("Should not have found user1")
  2636  			}
  2637  		}
  2638  	}
  2639  
  2640  	time.Sleep(time.Millisecond * 10)
  2641  	store.Must(ss.Team().RemoveMember(teamId, u1.Id))
  2642  	store.Must(ss.Team().RemoveMember(teamId, u2.Id))
  2643  	store.Must(ss.User().UpdateUpdateAt(u1.Id))
  2644  	store.Must(ss.User().UpdateUpdateAt(u2.Id))
  2645  
  2646  	if er3 := <-ss.User().GetEtagForProfilesNotInTeam(teamId); er3.Err != nil {
  2647  		t.Fatal(er3.Err)
  2648  	} else {
  2649  		etag3 = er3.Data.(string)
  2650  		t.Log(etag3)
  2651  		if etag1 == etag3 || etag3 == etag2 {
  2652  			t.Fatalf("etag should have changed")
  2653  		}
  2654  	}
  2655  
  2656  	if r3 := <-ss.User().GetProfilesNotInTeam(teamId, 0, 100000); r3.Err != nil {
  2657  		t.Fatal(r3.Err)
  2658  	} else {
  2659  		users := r3.Data.([]*model.User)
  2660  		found1, found2 := false, false
  2661  		for _, u := range users {
  2662  			if u.Id == u2.Id {
  2663  				found2 = true
  2664  			}
  2665  			if u.Id == u1.Id {
  2666  				found1 = true
  2667  			}
  2668  		}
  2669  
  2670  		if !found1 || !found2 {
  2671  			t.Fatal("missing user1 or user2")
  2672  		}
  2673  	}
  2674  
  2675  	time.Sleep(time.Millisecond * 10)
  2676  	u3 := &model.User{}
  2677  	u3.Email = MakeEmail()
  2678  	store.Must(ss.User().Save(u3))
  2679  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  2680  	store.Must(ss.Team().SaveMember(&model.TeamMember{TeamId: teamId, UserId: u3.Id}, -1))
  2681  	store.Must(ss.User().UpdateUpdateAt(u3.Id))
  2682  
  2683  	if er4 := <-ss.User().GetEtagForProfilesNotInTeam(teamId); er4.Err != nil {
  2684  		t.Fatal(er4.Err)
  2685  	} else {
  2686  		etag4 := er4.Data.(string)
  2687  		t.Log(etag4)
  2688  		if etag4 != etag3 {
  2689  			t.Fatalf("etag should be the same")
  2690  		}
  2691  	}
  2692  }
  2693  
  2694  func testUserStoreClearAllCustomRoleAssignments(t *testing.T, ss store.Store) {
  2695  	u1 := model.User{
  2696  		Email:    MakeEmail(),
  2697  		Username: model.NewId(),
  2698  		Roles:    "system_user system_admin system_post_all",
  2699  	}
  2700  	u2 := model.User{
  2701  		Email:    MakeEmail(),
  2702  		Username: model.NewId(),
  2703  		Roles:    "system_user custom_role system_admin another_custom_role",
  2704  	}
  2705  	u3 := model.User{
  2706  		Email:    MakeEmail(),
  2707  		Username: model.NewId(),
  2708  		Roles:    "system_user",
  2709  	}
  2710  	u4 := model.User{
  2711  		Email:    MakeEmail(),
  2712  		Username: model.NewId(),
  2713  		Roles:    "custom_only",
  2714  	}
  2715  
  2716  	store.Must(ss.User().Save(&u1))
  2717  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2718  	store.Must(ss.User().Save(&u2))
  2719  	defer func() { store.Must(ss.User().PermanentDelete(u2.Id)) }()
  2720  	store.Must(ss.User().Save(&u3))
  2721  	defer func() { store.Must(ss.User().PermanentDelete(u3.Id)) }()
  2722  	store.Must(ss.User().Save(&u4))
  2723  	defer func() { store.Must(ss.User().PermanentDelete(u4.Id)) }()
  2724  
  2725  	require.Nil(t, (<-ss.User().ClearAllCustomRoleAssignments()).Err)
  2726  
  2727  	r1 := <-ss.User().GetByUsername(u1.Username)
  2728  	require.Nil(t, r1.Err)
  2729  	assert.Equal(t, u1.Roles, r1.Data.(*model.User).Roles)
  2730  
  2731  	r2 := <-ss.User().GetByUsername(u2.Username)
  2732  	require.Nil(t, r2.Err)
  2733  	assert.Equal(t, "system_user system_admin", r2.Data.(*model.User).Roles)
  2734  
  2735  	r3 := <-ss.User().GetByUsername(u3.Username)
  2736  	require.Nil(t, r3.Err)
  2737  	assert.Equal(t, u3.Roles, r3.Data.(*model.User).Roles)
  2738  
  2739  	r4 := <-ss.User().GetByUsername(u4.Username)
  2740  	require.Nil(t, r4.Err)
  2741  	assert.Equal(t, "", r4.Data.(*model.User).Roles)
  2742  }
  2743  
  2744  func testUserStoreGetAllAfter(t *testing.T, ss store.Store) {
  2745  	u1 := model.User{
  2746  		Email:    MakeEmail(),
  2747  		Username: model.NewId(),
  2748  		Roles:    "system_user system_admin system_post_all",
  2749  	}
  2750  	store.Must(ss.User().Save(&u1))
  2751  	defer func() { store.Must(ss.User().PermanentDelete(u1.Id)) }()
  2752  
  2753  	r1 := <-ss.User().GetAllAfter(10000, strings.Repeat("0", 26))
  2754  	require.Nil(t, r1.Err)
  2755  
  2756  	d1 := r1.Data.([]*model.User)
  2757  
  2758  	found := false
  2759  	for _, u := range d1 {
  2760  
  2761  		if u.Id == u1.Id {
  2762  			found = true
  2763  			assert.Equal(t, u1.Id, u.Id)
  2764  			assert.Equal(t, u1.Email, u.Email)
  2765  		}
  2766  	}
  2767  	assert.True(t, found)
  2768  
  2769  	r2 := <-ss.User().GetAllAfter(10000, u1.Id)
  2770  	require.Nil(t, r2.Err)
  2771  
  2772  	d2 := r2.Data.([]*model.User)
  2773  	for _, u := range d2 {
  2774  		assert.NotEqual(t, u1.Id, u.Id)
  2775  	}
  2776  }