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 }