github.com/adacta-ru/mattermost-server@v5.11.1+incompatible/app/team_test.go (about) 1 // Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved. 2 // See License.txt for license information. 3 4 package app 5 6 import ( 7 "fmt" 8 "sort" 9 "strings" 10 "testing" 11 12 "github.com/mattermost/mattermost-server/model" 13 "github.com/stretchr/testify/assert" 14 "github.com/stretchr/testify/require" 15 ) 16 17 func TestCreateTeam(t *testing.T) { 18 th := Setup(t).InitBasic() 19 defer th.TearDown() 20 21 id := model.NewId() 22 team := &model.Team{ 23 DisplayName: "dn_" + id, 24 Name: "name" + id, 25 Email: "success+" + id + "@simulator.amazonses.com", 26 Type: model.TEAM_OPEN, 27 } 28 29 if _, err := th.App.CreateTeam(team); err != nil { 30 t.Log(err) 31 t.Fatal("Should create a new team") 32 } 33 34 if _, err := th.App.CreateTeam(th.BasicTeam); err == nil { 35 t.Fatal("Should not create a new team - team already exist") 36 } 37 } 38 39 func TestCreateTeamWithUser(t *testing.T) { 40 th := Setup(t).InitBasic() 41 defer th.TearDown() 42 43 id := model.NewId() 44 team := &model.Team{ 45 DisplayName: "dn_" + id, 46 Name: "name" + id, 47 Email: "success+" + id + "@simulator.amazonses.com", 48 Type: model.TEAM_OPEN, 49 } 50 51 if _, err := th.App.CreateTeamWithUser(team, th.BasicUser.Id); err != nil { 52 t.Fatal("Should create a new team with existing user", err) 53 } 54 55 if _, err := th.App.CreateTeamWithUser(team, model.NewId()); err == nil { 56 t.Fatal("Should not create a new team - user does not exist") 57 } 58 } 59 60 func TestUpdateTeam(t *testing.T) { 61 th := Setup(t).InitBasic() 62 defer th.TearDown() 63 64 th.BasicTeam.DisplayName = "Testing 123" 65 66 if updatedTeam, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 67 t.Log(err) 68 t.Fatal("Should update the team") 69 } else { 70 if updatedTeam.DisplayName != "Testing 123" { 71 t.Fatal("Wrong Team DisplayName") 72 } 73 } 74 } 75 76 func TestAddUserToTeam(t *testing.T) { 77 th := Setup(t).InitBasic() 78 defer th.TearDown() 79 80 t.Run("add user", func(t *testing.T) { 81 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 82 ruser, _ := th.App.CreateUser(&user) 83 defer th.App.PermanentDeleteUser(&user) 84 85 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err != nil { 86 t.Log(err) 87 t.Fatal("Should add user to the team") 88 } 89 }) 90 91 t.Run("allow user by domain", func(t *testing.T) { 92 th.BasicTeam.AllowedDomains = "example.com" 93 if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 94 t.Log(err) 95 t.Fatal("Should update the team") 96 } 97 98 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 99 ruser, _ := th.App.CreateUser(&user) 100 defer th.App.PermanentDeleteUser(&user) 101 102 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err != nil { 103 t.Log(err) 104 t.Fatal("Should have allowed whitelisted user") 105 } 106 }) 107 108 t.Run("block user by domain", func(t *testing.T) { 109 th.BasicTeam.AllowedDomains = "example.com" 110 if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 111 t.Log(err) 112 t.Fatal("Should update the team") 113 } 114 115 user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 116 ruser, err := th.App.CreateUser(&user) 117 if err != nil { 118 t.Fatalf("Error creating user: %s", err) 119 } 120 defer th.App.PermanentDeleteUser(&user) 121 122 if _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err == nil || err.Where != "JoinUserToTeam" { 123 t.Log(err) 124 t.Fatal("Should not add restricted user") 125 } 126 127 user = model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), AuthService: "notnil", AuthData: model.NewString("notnil")} 128 ruser, err = th.App.CreateUser(&user) 129 if err != nil { 130 t.Fatalf("Error creating authservice user: %s", err) 131 } 132 defer th.App.PermanentDeleteUser(&user) 133 134 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err == nil || err.Where != "JoinUserToTeam" { 135 t.Log(err) 136 t.Fatal("Should not add authservice user") 137 } 138 }) 139 140 t.Run("block user with subdomain", func(t *testing.T) { 141 th.BasicTeam.AllowedDomains = "example.com" 142 if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 143 t.Log(err) 144 t.Fatal("Should update the team") 145 } 146 147 user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 148 ruser, _ := th.App.CreateUser(&user) 149 defer th.App.PermanentDeleteUser(&user) 150 151 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err == nil || err.Where != "JoinUserToTeam" { 152 t.Log(err) 153 t.Fatal("Should not add restricted user") 154 } 155 }) 156 157 t.Run("allow users by multiple domains", func(t *testing.T) { 158 th.BasicTeam.AllowedDomains = "foo.com, bar.com" 159 if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 160 t.Log(err) 161 t.Fatal("Should update the team") 162 } 163 164 user1 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@foo.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 165 ruser1, _ := th.App.CreateUser(&user1) 166 user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@bar.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 167 ruser2, _ := th.App.CreateUser(&user2) 168 user3 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 169 ruser3, _ := th.App.CreateUser(&user3) 170 defer th.App.PermanentDeleteUser(&user1) 171 defer th.App.PermanentDeleteUser(&user2) 172 defer th.App.PermanentDeleteUser(&user3) 173 174 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser1.Id, ""); err != nil { 175 t.Log(err) 176 t.Fatal("Should have allowed whitelisted user1") 177 } 178 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, ""); err != nil { 179 t.Log(err) 180 t.Fatal("Should have allowed whitelisted user2") 181 } 182 if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, ""); err == nil || err.Where != "JoinUserToTeam" { 183 t.Log(err) 184 t.Fatal("Should not have allowed restricted user3") 185 } 186 187 }) 188 } 189 190 func TestAddUserToTeamByToken(t *testing.T) { 191 th := Setup(t).InitBasic() 192 defer th.TearDown() 193 194 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 195 ruser, _ := th.App.CreateUser(&user) 196 197 t.Run("invalid token", func(t *testing.T) { 198 if _, err := th.App.AddUserToTeamByToken(ruser.Id, "123"); err == nil { 199 t.Fatal("Should fail on unexisting token") 200 } 201 }) 202 203 t.Run("invalid token type", func(t *testing.T) { 204 token := model.NewToken( 205 TOKEN_TYPE_VERIFY_EMAIL, 206 model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}), 207 ) 208 <-th.App.Srv.Store.Token().Save(token) 209 defer th.App.DeleteToken(token) 210 if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil { 211 t.Fatal("Should fail on bad token type") 212 } 213 }) 214 215 t.Run("expired token", func(t *testing.T) { 216 token := model.NewToken( 217 TOKEN_TYPE_TEAM_INVITATION, 218 model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}), 219 ) 220 token.CreateAt = model.GetMillis() - TEAM_INVITATION_EXPIRY_TIME - 1 221 <-th.App.Srv.Store.Token().Save(token) 222 defer th.App.DeleteToken(token) 223 if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil { 224 t.Fatal("Should fail on expired token") 225 } 226 }) 227 228 t.Run("invalid team id", func(t *testing.T) { 229 token := model.NewToken( 230 TOKEN_TYPE_TEAM_INVITATION, 231 model.MapToJson(map[string]string{"teamId": model.NewId()}), 232 ) 233 <-th.App.Srv.Store.Token().Save(token) 234 defer th.App.DeleteToken(token) 235 if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil { 236 t.Fatal("Should fail on bad team id") 237 } 238 }) 239 240 t.Run("invalid user id", func(t *testing.T) { 241 token := model.NewToken( 242 TOKEN_TYPE_TEAM_INVITATION, 243 model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}), 244 ) 245 <-th.App.Srv.Store.Token().Save(token) 246 defer th.App.DeleteToken(token) 247 if _, err := th.App.AddUserToTeamByToken(model.NewId(), token.Token); err == nil { 248 t.Fatal("Should fail on bad user id") 249 } 250 }) 251 252 t.Run("valid request", func(t *testing.T) { 253 token := model.NewToken( 254 TOKEN_TYPE_TEAM_INVITATION, 255 model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}), 256 ) 257 <-th.App.Srv.Store.Token().Save(token) 258 if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err != nil { 259 t.Log(err) 260 t.Fatal("Should add user to the team") 261 } 262 if result := <-th.App.Srv.Store.Token().GetByToken(token.Token); result.Err == nil { 263 t.Fatal("The token must be deleted after be used") 264 } 265 }) 266 267 t.Run("block user", func(t *testing.T) { 268 th.BasicTeam.AllowedDomains = "example.com" 269 if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 270 t.Log(err) 271 t.Fatal("Should update the team") 272 } 273 274 user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 275 ruser, _ := th.App.CreateUser(&user) 276 defer th.App.PermanentDeleteUser(&user) 277 278 token := model.NewToken( 279 TOKEN_TYPE_TEAM_INVITATION, 280 model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}), 281 ) 282 <-th.App.Srv.Store.Token().Save(token) 283 284 if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil || err.Where != "JoinUserToTeam" { 285 t.Log(err) 286 t.Fatal("Should not add restricted user") 287 } 288 }) 289 } 290 291 func TestAddUserToTeamByTeamId(t *testing.T) { 292 th := Setup(t).InitBasic() 293 defer th.TearDown() 294 295 t.Run("add user", func(t *testing.T) { 296 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 297 ruser, _ := th.App.CreateUser(&user) 298 299 if err := th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser); err != nil { 300 t.Log(err) 301 t.Fatal("Should add user to the team") 302 } 303 }) 304 305 t.Run("block user", func(t *testing.T) { 306 th.BasicTeam.AllowedDomains = "example.com" 307 if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil { 308 t.Log(err) 309 t.Fatal("Should update the team") 310 } 311 312 user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 313 ruser, _ := th.App.CreateUser(&user) 314 defer th.App.PermanentDeleteUser(&user) 315 316 if err := th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser); err == nil || err.Where != "JoinUserToTeam" { 317 t.Log(err) 318 t.Fatal("Should not add restricted user") 319 } 320 }) 321 322 } 323 324 func TestPermanentDeleteTeam(t *testing.T) { 325 th := Setup(t).InitBasic() 326 defer th.TearDown() 327 328 team, err := th.App.CreateTeam(&model.Team{ 329 DisplayName: "deletion-test", 330 Name: "deletion-test", 331 Email: "foo@foo.com", 332 Type: model.TEAM_OPEN, 333 }) 334 if err != nil { 335 t.Fatal(err.Error()) 336 } 337 defer func() { 338 th.App.PermanentDeleteTeam(team) 339 }() 340 341 command, err := th.App.CreateCommand(&model.Command{ 342 CreatorId: th.BasicUser.Id, 343 TeamId: team.Id, 344 Trigger: "foo", 345 URL: "http://foo", 346 Method: model.COMMAND_METHOD_POST, 347 }) 348 if err != nil { 349 t.Fatal(err.Error()) 350 } 351 defer th.App.DeleteCommand(command.Id) 352 353 if command, err = th.App.GetCommand(command.Id); command == nil || err != nil { 354 t.Fatal("unable to get new command") 355 } 356 357 err = th.App.PermanentDeleteTeam(team) 358 require.Nil(t, err) 359 360 if command, err = th.App.GetCommand(command.Id); command != nil || err == nil { 361 t.Fatal("command wasn't deleted") 362 } 363 364 // Test deleting a team with no channels. 365 team = th.CreateTeam() 366 defer func() { 367 th.App.PermanentDeleteTeam(team) 368 }() 369 370 if channels, err := th.App.GetPublicChannelsForTeam(team.Id, 0, 1000); err != nil { 371 t.Fatal(err) 372 } else { 373 for _, channel := range *channels { 374 if err2 := th.App.PermanentDeleteChannel(channel); err2 != nil { 375 t.Fatal(err) 376 } 377 } 378 } 379 380 if err := th.App.PermanentDeleteTeam(team); err != nil { 381 t.Fatal(err) 382 } 383 } 384 385 func TestSanitizeTeam(t *testing.T) { 386 th := Setup(t) 387 defer th.TearDown() 388 389 team := &model.Team{ 390 Id: model.NewId(), 391 Email: th.MakeEmail(), 392 AllowedDomains: "example.com", 393 } 394 copyTeam := func() *model.Team { 395 copy := &model.Team{} 396 *copy = *team 397 return copy 398 } 399 400 t.Run("not a user of the team", func(t *testing.T) { 401 userId := model.NewId() 402 session := model.Session{ 403 Roles: model.SYSTEM_USER_ROLE_ID, 404 TeamMembers: []*model.TeamMember{ 405 { 406 UserId: userId, 407 TeamId: model.NewId(), 408 Roles: model.TEAM_USER_ROLE_ID, 409 }, 410 }, 411 } 412 413 sanitized := th.App.SanitizeTeam(session, copyTeam()) 414 if sanitized.Email != "" { 415 t.Fatal("should've sanitized team") 416 } 417 }) 418 419 t.Run("user of the team", func(t *testing.T) { 420 userId := model.NewId() 421 session := model.Session{ 422 Roles: model.SYSTEM_USER_ROLE_ID, 423 TeamMembers: []*model.TeamMember{ 424 { 425 UserId: userId, 426 TeamId: team.Id, 427 Roles: model.TEAM_USER_ROLE_ID, 428 }, 429 }, 430 } 431 432 sanitized := th.App.SanitizeTeam(session, copyTeam()) 433 if sanitized.Email != "" { 434 t.Fatal("should've sanitized team") 435 } 436 }) 437 438 t.Run("team admin", func(t *testing.T) { 439 userId := model.NewId() 440 session := model.Session{ 441 Roles: model.SYSTEM_USER_ROLE_ID, 442 TeamMembers: []*model.TeamMember{ 443 { 444 UserId: userId, 445 TeamId: team.Id, 446 Roles: model.TEAM_USER_ROLE_ID + " " + model.TEAM_ADMIN_ROLE_ID, 447 }, 448 }, 449 } 450 451 sanitized := th.App.SanitizeTeam(session, copyTeam()) 452 if sanitized.Email == "" { 453 t.Fatal("shouldn't have sanitized team") 454 } 455 }) 456 457 t.Run("team admin of another team", func(t *testing.T) { 458 userId := model.NewId() 459 session := model.Session{ 460 Roles: model.SYSTEM_USER_ROLE_ID, 461 TeamMembers: []*model.TeamMember{ 462 { 463 UserId: userId, 464 TeamId: model.NewId(), 465 Roles: model.TEAM_USER_ROLE_ID + " " + model.TEAM_ADMIN_ROLE_ID, 466 }, 467 }, 468 } 469 470 sanitized := th.App.SanitizeTeam(session, copyTeam()) 471 if sanitized.Email != "" { 472 t.Fatal("should've sanitized team") 473 } 474 }) 475 476 t.Run("system admin, not a user of team", func(t *testing.T) { 477 userId := model.NewId() 478 session := model.Session{ 479 Roles: model.SYSTEM_USER_ROLE_ID + " " + model.SYSTEM_ADMIN_ROLE_ID, 480 TeamMembers: []*model.TeamMember{ 481 { 482 UserId: userId, 483 TeamId: model.NewId(), 484 Roles: model.TEAM_USER_ROLE_ID, 485 }, 486 }, 487 } 488 489 sanitized := th.App.SanitizeTeam(session, copyTeam()) 490 if sanitized.Email == "" { 491 t.Fatal("shouldn't have sanitized team") 492 } 493 }) 494 495 t.Run("system admin, user of team", func(t *testing.T) { 496 userId := model.NewId() 497 session := model.Session{ 498 Roles: model.SYSTEM_USER_ROLE_ID + " " + model.SYSTEM_ADMIN_ROLE_ID, 499 TeamMembers: []*model.TeamMember{ 500 { 501 UserId: userId, 502 TeamId: team.Id, 503 Roles: model.TEAM_USER_ROLE_ID, 504 }, 505 }, 506 } 507 508 sanitized := th.App.SanitizeTeam(session, copyTeam()) 509 if sanitized.Email == "" { 510 t.Fatal("shouldn't have sanitized team") 511 } 512 }) 513 } 514 515 func TestSanitizeTeams(t *testing.T) { 516 th := Setup(t) 517 defer th.TearDown() 518 519 t.Run("not a system admin", func(t *testing.T) { 520 teams := []*model.Team{ 521 { 522 Id: model.NewId(), 523 Email: th.MakeEmail(), 524 AllowedDomains: "example.com", 525 }, 526 { 527 Id: model.NewId(), 528 Email: th.MakeEmail(), 529 AllowedDomains: "example.com", 530 }, 531 } 532 533 userId := model.NewId() 534 session := model.Session{ 535 Roles: model.SYSTEM_USER_ROLE_ID, 536 TeamMembers: []*model.TeamMember{ 537 { 538 UserId: userId, 539 TeamId: teams[0].Id, 540 Roles: model.TEAM_USER_ROLE_ID, 541 }, 542 { 543 UserId: userId, 544 TeamId: teams[1].Id, 545 Roles: model.TEAM_USER_ROLE_ID + " " + model.TEAM_ADMIN_ROLE_ID, 546 }, 547 }, 548 } 549 550 sanitized := th.App.SanitizeTeams(session, teams) 551 552 if sanitized[0].Email != "" { 553 t.Fatal("should've sanitized first team") 554 } 555 556 if sanitized[1].Email == "" { 557 t.Fatal("shouldn't have sanitized second team") 558 } 559 }) 560 561 t.Run("system admin", func(t *testing.T) { 562 teams := []*model.Team{ 563 { 564 Id: model.NewId(), 565 Email: th.MakeEmail(), 566 AllowedDomains: "example.com", 567 }, 568 { 569 Id: model.NewId(), 570 Email: th.MakeEmail(), 571 AllowedDomains: "example.com", 572 }, 573 } 574 575 userId := model.NewId() 576 session := model.Session{ 577 Roles: model.SYSTEM_USER_ROLE_ID + " " + model.SYSTEM_ADMIN_ROLE_ID, 578 TeamMembers: []*model.TeamMember{ 579 { 580 UserId: userId, 581 TeamId: teams[0].Id, 582 Roles: model.TEAM_USER_ROLE_ID, 583 }, 584 }, 585 } 586 587 sanitized := th.App.SanitizeTeams(session, teams) 588 589 if sanitized[0].Email == "" { 590 t.Fatal("shouldn't have sanitized first team") 591 } 592 593 if sanitized[1].Email == "" { 594 t.Fatal("shouldn't have sanitized second team") 595 } 596 }) 597 } 598 599 func TestJoinUserToTeam(t *testing.T) { 600 th := Setup(t).InitBasic() 601 defer th.TearDown() 602 603 id := model.NewId() 604 team := &model.Team{ 605 DisplayName: "dn_" + id, 606 Name: "name" + id, 607 Email: "success+" + id + "@simulator.amazonses.com", 608 Type: model.TEAM_OPEN, 609 } 610 611 if _, err := th.App.CreateTeam(team); err != nil { 612 t.Log(err) 613 t.Fatal("Should create a new team") 614 } 615 616 maxUsersPerTeam := th.App.Config().TeamSettings.MaxUsersPerTeam 617 defer func() { 618 th.App.UpdateConfig(func(cfg *model.Config) { cfg.TeamSettings.MaxUsersPerTeam = maxUsersPerTeam }) 619 th.App.PermanentDeleteTeam(team) 620 }() 621 one := 1 622 th.App.UpdateConfig(func(cfg *model.Config) { cfg.TeamSettings.MaxUsersPerTeam = &one }) 623 624 t.Run("new join", func(t *testing.T) { 625 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 626 ruser, _ := th.App.CreateUser(&user) 627 defer th.App.PermanentDeleteUser(&user) 628 629 if _, alreadyAdded, err := th.App.joinUserToTeam(team, ruser); alreadyAdded || err != nil { 630 t.Fatal("Should return already added equal to false and no error") 631 } 632 }) 633 634 t.Run("join when you are a member", func(t *testing.T) { 635 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 636 ruser, _ := th.App.CreateUser(&user) 637 defer th.App.PermanentDeleteUser(&user) 638 639 th.App.joinUserToTeam(team, ruser) 640 if _, alreadyAdded, err := th.App.joinUserToTeam(team, ruser); !alreadyAdded || err != nil { 641 t.Fatal("Should return already added and no error") 642 } 643 }) 644 645 t.Run("re-join after leaving", func(t *testing.T) { 646 user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 647 ruser, _ := th.App.CreateUser(&user) 648 defer th.App.PermanentDeleteUser(&user) 649 650 th.App.joinUserToTeam(team, ruser) 651 th.App.LeaveTeam(team, ruser, ruser.Id) 652 if _, alreadyAdded, err := th.App.joinUserToTeam(team, ruser); alreadyAdded || err != nil { 653 t.Fatal("Should return already added equal to false and no error") 654 } 655 }) 656 657 t.Run("new join with limit problem", func(t *testing.T) { 658 user1 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 659 ruser1, _ := th.App.CreateUser(&user1) 660 user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 661 ruser2, _ := th.App.CreateUser(&user2) 662 defer th.App.PermanentDeleteUser(&user1) 663 defer th.App.PermanentDeleteUser(&user2) 664 th.App.joinUserToTeam(team, ruser1) 665 if _, _, err := th.App.joinUserToTeam(team, ruser2); err == nil { 666 t.Fatal("Should fail") 667 } 668 }) 669 670 t.Run("re-join alfter leaving with limit problem", func(t *testing.T) { 671 user1 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 672 ruser1, _ := th.App.CreateUser(&user1) 673 user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""} 674 ruser2, _ := th.App.CreateUser(&user2) 675 defer th.App.PermanentDeleteUser(&user1) 676 defer th.App.PermanentDeleteUser(&user2) 677 678 th.App.joinUserToTeam(team, ruser1) 679 th.App.LeaveTeam(team, ruser1, ruser1.Id) 680 th.App.joinUserToTeam(team, ruser2) 681 if _, _, err := th.App.joinUserToTeam(team, ruser1); err == nil { 682 t.Fatal("Should fail") 683 } 684 }) 685 } 686 687 func TestAppUpdateTeamScheme(t *testing.T) { 688 th := Setup(t).InitBasic() 689 defer th.TearDown() 690 691 team := th.BasicTeam 692 mockID := model.NewString("x") 693 team.SchemeId = mockID 694 695 updatedTeam, err := th.App.UpdateTeamScheme(th.BasicTeam) 696 if err != nil { 697 t.Fatal(err) 698 } 699 700 if updatedTeam.SchemeId != mockID { 701 t.Fatal("Wrong Team SchemeId") 702 } 703 } 704 705 func TestGetTeamMembers(t *testing.T) { 706 th := Setup(t).InitBasic() 707 defer th.TearDown() 708 709 var userIDs sort.StringSlice 710 userIDs = append(userIDs, th.BasicUser.Id) 711 userIDs = append(userIDs, th.BasicUser2.Id) 712 713 for i := 0; i < 8; i++ { 714 user := model.User{ 715 Email: strings.ToLower(model.NewId()) + "success+test@example.com", 716 Username: fmt.Sprintf("user%v", i), 717 Password: "passwd1", 718 } 719 ruser, err := th.App.CreateUser(&user) 720 require.Nil(t, err) 721 require.NotNil(t, ruser) 722 defer th.App.PermanentDeleteUser(&user) 723 724 _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "") 725 require.Nil(t, err) 726 727 // Store the user ids for comparison later 728 userIDs = append(userIDs, ruser.Id) 729 } 730 // Sort them because the result of GetTeamMembers() is also sorted 731 sort.Sort(userIDs) 732 733 // Fetch team members multipile times 734 members, err := th.App.GetTeamMembers(th.BasicTeam.Id, 0, 5) 735 require.Nil(t, err) 736 // This should return 5 members 737 members2, err := th.App.GetTeamMembers(th.BasicTeam.Id, 5, 6) 738 require.Nil(t, err) 739 members = append(members, members2...) 740 741 require.Equal(t, len(userIDs), len(members)) 742 for i, member := range members { 743 assert.Equal(t, userIDs[i], member.UserId) 744 } 745 } 746 747 func TestGetTeamStats(t *testing.T) { 748 th := Setup(t).InitBasic() 749 defer th.TearDown() 750 751 teamStats, err := th.App.GetTeamStats(th.BasicTeam.Id) 752 require.Nil(t, err) 753 require.NotNil(t, teamStats) 754 members, err := th.App.GetTeamMembers(th.BasicTeam.Id, 0, 5) 755 require.Nil(t, err) 756 assert.Equal(t, int64(len(members)), teamStats.TotalMemberCount) 757 }