IntenseWebs/mattermost
3
0
Fork 0
mirror of https://github.com/mattermost/mattermost.git synced 2025-02-25 18:55:24 -06:00
Code Issues Packages Projects Releases Wiki Activity

Migrate app/team_test.go to use testify (#12215) (#12226)

Browse Source 
* Migrate app/team_test.go to use testify (#12215)

* Add missing message

* Fix suggestions
This commit is contained in:
Esdras Beleza
2019-09-17 14:38:22 +01:00
committed by Miguel de la Cruz
parent b3517eaf2f
commit 46c624f4f8
1 changed files with 154 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

384
app/team_test.go
View File

@@ -26,14 +26,11 @@ func TestCreateTeam(t *testing.T) {
Type: model.TEAM_OPEN,
}
if _, err := th.App.CreateTeam(team); err != nil {
t.Log(err)
t.Fatal("Should create a new team")
}
_, err := th.App.CreateTeam(team)
require.Nil(t, err, "Should create a new team")
if _, err := th.App.CreateTeam(th.BasicTeam); err == nil {
t.Fatal("Should not create a new team - team already exist")
}
_, err = th.App.CreateTeam(th.BasicTeam)
require.NotNil(t, err, "Should not create a new team - team already exist")
}
func TestCreateTeamWithUser(t *testing.T) {
@@ -48,13 +45,11 @@ func TestCreateTeamWithUser(t *testing.T) {
Type: model.TEAM_OPEN,
}
if _, err := th.App.CreateTeamWithUser(team, th.BasicUser.Id); err != nil {
t.Fatal("Should create a new team with existing user", err)
}
_, err := th.App.CreateTeamWithUser(team, th.BasicUser.Id)
require.Nil(t, err, "Should create a new team with existing user")
if _, err := th.App.CreateTeamWithUser(team, model.NewId()); err == nil {
t.Fatal("Should not create a new team - user does not exist")
}
_, err = th.App.CreateTeamWithUser(team, model.NewId())
require.NotNil(t, err, "Should not create a new team - user does not exist")
}
func TestUpdateTeam(t *testing.T) {
@@ -63,14 +58,9 @@ func TestUpdateTeam(t *testing.T) {
th.BasicTeam.DisplayName = "Testing 123"
if updatedTeam, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
} else {
if updatedTeam.DisplayName != "Testing 123" {
t.Fatal("Wrong Team DisplayName")
}
}
updatedTeam, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
require.Equal(t, "Testing 123", updatedTeam.DisplayName, "Wrong Team DisplayName")
}
func TestAddUserToTeam(t *testing.T) {
@@ -82,59 +72,45 @@ func TestAddUserToTeam(t *testing.T) {
ruser, _ := th.App.CreateUser(&user)
defer th.App.PermanentDeleteUser(&user)
if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err != nil {
t.Log(err)
t.Fatal("Should add user to the team")
}
_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.Nil(t, err, "Should add user to the team")
})
t.Run("allow user by domain", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "example.com"
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser, _ := th.App.CreateUser(&user)
defer th.App.PermanentDeleteUser(&user)
if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err != nil {
t.Log(err)
t.Fatal("Should have allowed whitelisted user")
}
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.Nil(t, err, "Should have allowed whitelisted user")
})
t.Run("block user by domain but allow bot", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "example.com"
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser, err := th.App.CreateUser(&user)
if err != nil {
t.Fatalf("Error creating user: %s", err)
}
require.Nil(t, err, "Error creating user: %s", err)
defer th.App.PermanentDeleteUser(&user)
if _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err == nil || err.Where != "JoinUserToTeam" {
t.Log(err)
t.Fatal("Should not add restricted user")
}
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.NotNil(t, err, "Should not add restricted user")
require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
user = model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), AuthService: "notnil", AuthData: model.NewString("notnil")}
ruser, err = th.App.CreateUser(&user)
if err != nil {
t.Fatalf("Error creating authservice user: %s", err)
}
require.Nil(t, err, "Error creating authservice user: %s", err)
defer th.App.PermanentDeleteUser(&user)
if _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err == nil || err.Where != "JoinUserToTeam" {
t.Log(err)
t.Fatal("Should not add authservice user")
}
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.NotNil(t, err, "Should not add authservice user")
require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
bot, err := th.App.CreateBot(&model.Bot{
Username: "somebot",
@@ -149,50 +125,45 @@ func TestAddUserToTeam(t *testing.T) {
t.Run("block user with subdomain", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "example.com"
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser, _ := th.App.CreateUser(&user)
defer th.App.PermanentDeleteUser(&user)
if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, ""); err == nil || err.Where != "JoinUserToTeam" {
t.Log(err)
t.Fatal("Should not add restricted user")
}
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.NotNil(t, err, "Should not add restricted user")
require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
})
t.Run("allow users by multiple domains", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "foo.com, bar.com"
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
user1 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@foo.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser1, _ := th.App.CreateUser(&user1)
user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@bar.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser2, _ := th.App.CreateUser(&user2)
user3 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser3, _ := th.App.CreateUser(&user3)
defer th.App.PermanentDeleteUser(&user1)
defer th.App.PermanentDeleteUser(&user2)
defer th.App.PermanentDeleteUser(&user3)
if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser1.Id, ""); err != nil {
t.Log(err)
t.Fatal("Should have allowed whitelisted user1")
}
if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, ""); err != nil {
t.Log(err)
t.Fatal("Should have allowed whitelisted user2")
}
if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, ""); err == nil || err.Where != "JoinUserToTeam" {
t.Log(err)
t.Fatal("Should not have allowed restricted user3")
}
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser1.Id, "")
require.Nil(t, err, "Should have allowed whitelisted user1")
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, "")
require.Nil(t, err, "Should have allowed whitelisted user2")
_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, "")
require.NotNil(t, err, "Should not have allowed restricted user3")
require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
})
}
@@ -206,9 +177,8 @@ func TestAddUserToTeamByToken(t *testing.T) {
rguest := th.CreateGuest()
t.Run("invalid token", func(t *testing.T) {
if _, err := th.App.AddUserToTeamByToken(ruser.Id, "123"); err == nil {
t.Fatal("Should fail on unexisting token")
}
_, err := th.App.AddUserToTeamByToken(ruser.Id, "123")
require.NotNil(t, err, "Should fail on unexisting token")
})
t.Run("invalid token type", func(t *testing.T) {
@@ -216,11 +186,12 @@ func TestAddUserToTeamByToken(t *testing.T) {
TOKEN_TYPE_VERIFY_EMAIL,
model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
defer th.App.DeleteToken(token)
if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil {
t.Fatal("Should fail on bad token type")
}
_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
require.NotNil(t, err, "Should fail on bad token type")
})
t.Run("expired token", func(t *testing.T) {
@@ -228,12 +199,13 @@ func TestAddUserToTeamByToken(t *testing.T) {
TOKEN_TYPE_TEAM_INVITATION,
model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
)
token.CreateAt = model.GetMillis() - INVITATION_EXPIRY_TIME - 1
require.Nil(t, th.App.Srv.Store.Token().Save(token))
defer th.App.DeleteToken(token)
if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil {
t.Fatal("Should fail on expired token")
}
_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
require.NotNil(t, err, "Should fail on expired token")
})
t.Run("invalid team id", func(t *testing.T) {
@@ -243,9 +215,9 @@ func TestAddUserToTeamByToken(t *testing.T) {
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
defer th.App.DeleteToken(token)
if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil {
t.Fatal("Should fail on bad team id")
}
_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
require.NotNil(t, err, "Should fail on bad team id")
})
t.Run("invalid user id", func(t *testing.T) {
@@ -255,9 +227,9 @@ func TestAddUserToTeamByToken(t *testing.T) {
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
defer th.App.DeleteToken(token)
if _, err := th.App.AddUserToTeamByToken(model.NewId(), token.Token); err == nil {
t.Fatal("Should fail on bad user id")
}
_, err := th.App.AddUserToTeamByToken(model.NewId(), token.Token)
require.NotNil(t, err, "Should fail on bad user id")
})
t.Run("valid request", func(t *testing.T) {
@@ -266,11 +238,10 @@ func TestAddUserToTeamByToken(t *testing.T) {
model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err != nil {
t.Log(err)
t.Fatal("Should add user to the team")
}
_, err := th.App.Srv.Store.Token().GetByToken(token.Token)
_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
require.Nil(t, err, "Should add user to the team")
_, err = th.App.Srv.Store.Token().GetByToken(token.Token)
require.NotNil(t, err, "The token must be deleted after be used")
members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, ruser.Id)
@@ -304,11 +275,11 @@ func TestAddUserToTeamByToken(t *testing.T) {
model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
if _, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token); err != nil {
t.Log(err)
t.Fatal("Should add user to the team")
}
_, err := th.App.Srv.Store.Token().GetByToken(token.Token)
_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
require.Nil(t, err, "Should add user to the team")
_, err = th.App.Srv.Store.Token().GetByToken(token.Token)
require.NotNil(t, err, "The token must be deleted after be used")
members, err := th.App.GetChannelMembersForUser(th.BasicTeam.Id, rguest.Id)
@@ -319,35 +290,28 @@ func TestAddUserToTeamByToken(t *testing.T) {
t.Run("group-constrained team", func(t *testing.T) {
th.BasicTeam.GroupConstrained = model.NewBool(true)
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
token := model.NewToken(
TOKEN_TYPE_TEAM_INVITATION,
model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil {
t.Fatal("Should return an error when trying to join a group-constrained team.")
} else {
require.Equal(t, "app.team.invite_token.group_constrained.error", err.Id)
}
_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
require.NotNil(t, err, "Should return an error when trying to join a group-constrained team.")
require.Equal(t, "app.team.invite_token.group_constrained.error", err.Id)
th.BasicTeam.GroupConstrained = model.NewBool(false)
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err = th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
})
t.Run("block user", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "example.com"
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser, _ := th.App.CreateUser(&user)
@@ -359,10 +323,9 @@ func TestAddUserToTeamByToken(t *testing.T) {
)
require.Nil(t, th.App.Srv.Store.Token().Save(token))
if _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token); err == nil || err.Where != "JoinUserToTeam" {
t.Log(err)
t.Fatal("Should not add restricted user")
}
_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
require.NotNil(t, err, "Should not add restricted user")
require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
})
}
@@ -374,27 +337,22 @@ func TestAddUserToTeamByTeamId(t *testing.T) {
user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser, _ := th.App.CreateUser(&user)
if err := th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser); err != nil {
t.Log(err)
t.Fatal("Should add user to the team")
}
err := th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser)
require.Nil(t, err, "Should add user to the team")
})
t.Run("block user", func(t *testing.T) {
th.BasicTeam.AllowedDomains = "example.com"
if _, err := th.App.UpdateTeam(th.BasicTeam); err != nil {
t.Log(err)
t.Fatal("Should update the team")
}
_, err := th.App.UpdateTeam(th.BasicTeam)
require.Nil(t, err, "Should update the team")
user := model.User{Email: strings.ToLower(model.NewId()) + "test@invalid.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser, _ := th.App.CreateUser(&user)
defer th.App.PermanentDeleteUser(&user)
if err := th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser); err == nil || err.Where != "JoinUserToTeam" {
t.Log(err)
t.Fatal("Should not add restricted user")
}
err = th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser)
require.NotNil(t, err, "Should not add restricted user")
require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
})
}
@@ -409,9 +367,8 @@ func TestPermanentDeleteTeam(t *testing.T) {
Email: "foo@foo.com",
Type: model.TEAM_OPEN,
})
if err != nil {
t.Fatal(err.Error())
}
require.Nil(t, err, "Should create a team")
defer func() {
th.App.PermanentDeleteTeam(team)
}()
@@ -423,21 +380,19 @@ func TestPermanentDeleteTeam(t *testing.T) {
URL: "http://foo",
Method: model.COMMAND_METHOD_POST,
})
if err != nil {
t.Fatal(err.Error())
}
require.Nil(t, err, "Should create a command")
defer th.App.DeleteCommand(command.Id)
if command, err = th.App.GetCommand(command.Id); command == nil || err != nil {
t.Fatal("unable to get new command")
}
command, err = th.App.GetCommand(command.Id)
require.NotNil(t, command, "command should not be nil")
require.Nil(t, err, "unable to get new command")
err = th.App.PermanentDeleteTeam(team)
require.Nil(t, err)
if command, err = th.App.GetCommand(command.Id); command != nil || err == nil {
t.Fatal("command wasn't deleted")
}
command, err = th.App.GetCommand(command.Id)
require.Nil(t, command, "command wasn't deleted")
require.NotNil(t, err, "should not return an error")
// Test deleting a team with no channels.
team = th.CreateTeam()
@@ -445,19 +400,16 @@ func TestPermanentDeleteTeam(t *testing.T) {
th.App.PermanentDeleteTeam(team)
}()
if channels, err := th.App.GetPublicChannelsForTeam(team.Id, 0, 1000); err != nil {
t.Fatal(err)
} else {
for _, channel := range *channels {
if err2 := th.App.PermanentDeleteChannel(channel); err2 != nil {
t.Fatal(err)
}
}
channels, err := th.App.GetPublicChannelsForTeam(team.Id, 0, 1000)
require.Nil(t, err)
for _, channel := range *channels {
err2 := th.App.PermanentDeleteChannel(channel)
require.Nil(t, err2)
}
if err := th.App.PermanentDeleteTeam(team); err != nil {
t.Fatal(err)
}
err = th.App.PermanentDeleteTeam(team)
require.Nil(t, err)
}
func TestSanitizeTeam(t *testing.T) {
@@ -469,6 +421,7 @@ func TestSanitizeTeam(t *testing.T) {
Email: th.MakeEmail(),
AllowedDomains: "example.com",
}
copyTeam := func() *model.Team {
copy := &model.Team{}
*copy = *team
@@ -489,9 +442,7 @@ func TestSanitizeTeam(t *testing.T) {
}
sanitized := th.App.SanitizeTeam(session, copyTeam())
if sanitized.Email != "" {
t.Fatal("should've sanitized team")
}
require.Empty(t, sanitized.Email, "should've sanitized team")
})
t.Run("user of the team", func(t *testing.T) {
@@ -508,9 +459,7 @@ func TestSanitizeTeam(t *testing.T) {
}
sanitized := th.App.SanitizeTeam(session, copyTeam())
if sanitized.Email != "" {
t.Fatal("should've sanitized team")
}
require.Empty(t, sanitized.Email, "should've sanitized team")
})
t.Run("team admin", func(t *testing.T) {
@@ -527,9 +476,7 @@ func TestSanitizeTeam(t *testing.T) {
}
sanitized := th.App.SanitizeTeam(session, copyTeam())
if sanitized.Email == "" {
t.Fatal("shouldn't have sanitized team")
}
require.NotEmpty(t, sanitized.Email, "shouldn't have sanitized team")
})
t.Run("team admin of another team", func(t *testing.T) {
@@ -546,9 +493,7 @@ func TestSanitizeTeam(t *testing.T) {
}
sanitized := th.App.SanitizeTeam(session, copyTeam())
if sanitized.Email != "" {
t.Fatal("should've sanitized team")
}
require.Empty(t, sanitized.Email, "should've sanitized team")
})
t.Run("system admin, not a user of team", func(t *testing.T) {
@@ -565,9 +510,7 @@ func TestSanitizeTeam(t *testing.T) {
}
sanitized := th.App.SanitizeTeam(session, copyTeam())
if sanitized.Email == "" {
t.Fatal("shouldn't have sanitized team")
}
require.NotEmpty(t, sanitized.Email, "shouldn't have sanitized team")
})
t.Run("system admin, user of team", func(t *testing.T) {
@@ -584,9 +527,7 @@ func TestSanitizeTeam(t *testing.T) {
}
sanitized := th.App.SanitizeTeam(session, copyTeam())
if sanitized.Email == "" {
t.Fatal("shouldn't have sanitized team")
}
require.NotEmpty(t, sanitized.Email, "shouldn't have sanitized team")
})
}
@@ -627,13 +568,8 @@ func TestSanitizeTeams(t *testing.T) {
sanitized := th.App.SanitizeTeams(session, teams)
if sanitized[0].Email != "" {
t.Fatal("should've sanitized first team")
}
if sanitized[1].Email == "" {
t.Fatal("shouldn't have sanitized second team")
}
require.Empty(t, sanitized[0].Email, "should've sanitized first team")
require.NotEmpty(t, sanitized[1].Email, "shouldn't have sanitized second team")
})
t.Run("system admin", func(t *testing.T) {
@@ -663,14 +599,8 @@ func TestSanitizeTeams(t *testing.T) {
}
sanitized := th.App.SanitizeTeams(session, teams)
if sanitized[0].Email == "" {
t.Fatal("shouldn't have sanitized first team")
}
if sanitized[1].Email == "" {
t.Fatal("shouldn't have sanitized second team")
}
assert.NotEmpty(t, sanitized[0].Email, "shouldn't have sanitized first team")
assert.NotEmpty(t, sanitized[1].Email, "shouldn't have sanitized second team")
})
}
@@ -686,10 +616,8 @@ func TestJoinUserToTeam(t *testing.T) {
Type: model.TEAM_OPEN,
}
if _, err := th.App.CreateTeam(team); err != nil {
t.Log(err)
t.Fatal("Should create a new team")
}
_, err := th.App.CreateTeam(team)
require.Nil(t, err, "Should create a new team")
maxUsersPerTeam := th.App.Config().TeamSettings.MaxUsersPerTeam
defer func() {
@@ -704,9 +632,9 @@ func TestJoinUserToTeam(t *testing.T) {
ruser, _ := th.App.CreateUser(&user)
defer th.App.PermanentDeleteUser(&user)
if _, alreadyAdded, err := th.App.joinUserToTeam(team, ruser); alreadyAdded || err != nil {
t.Fatal("Should return already added equal to false and no error")
}
_, alreadyAdded, err := th.App.joinUserToTeam(team, ruser)
require.False(t, alreadyAdded, "Should return already added equal to false")
require.Nil(t, err, "Should return no error")
})
t.Run("join when you are a member", func(t *testing.T) {
@@ -715,9 +643,10 @@ func TestJoinUserToTeam(t *testing.T) {
defer th.App.PermanentDeleteUser(&user)
th.App.joinUserToTeam(team, ruser)
if _, alreadyAdded, err := th.App.joinUserToTeam(team, ruser); !alreadyAdded || err != nil {
t.Fatal("Should return already added and no error")
}
_, alreadyAdded, err := th.App.joinUserToTeam(team, ruser)
require.True(t, alreadyAdded, "Should return already added")
require.Nil(t, err, "Should return no error")
})
t.Run("re-join after leaving", func(t *testing.T) {
@@ -727,9 +656,10 @@ func TestJoinUserToTeam(t *testing.T) {
th.App.joinUserToTeam(team, ruser)
th.App.LeaveTeam(team, ruser, ruser.Id)
if _, alreadyAdded, err := th.App.joinUserToTeam(team, ruser); alreadyAdded || err != nil {
t.Fatal("Should return already added equal to false and no error")
}
_, alreadyAdded, err := th.App.joinUserToTeam(team, ruser)
require.False(t, alreadyAdded, "Should return already added equal to false")
require.Nil(t, err, "Should return no error")
})
t.Run("new join with limit problem", func(t *testing.T) {
@@ -737,28 +667,31 @@ func TestJoinUserToTeam(t *testing.T) {
ruser1, _ := th.App.CreateUser(&user1)
user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser2, _ := th.App.CreateUser(&user2)
defer th.App.PermanentDeleteUser(&user1)
defer th.App.PermanentDeleteUser(&user2)
th.App.joinUserToTeam(team, ruser1)
if _, _, err := th.App.joinUserToTeam(team, ruser2); err == nil {
t.Fatal("Should fail")
}
_, _, err := th.App.joinUserToTeam(team, ruser2)
require.NotNil(t, err, "Should fail")
})
t.Run("re-join alfter leaving with limit problem", func(t *testing.T) {
user1 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser1, _ := th.App.CreateUser(&user1)
user2 := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
ruser2, _ := th.App.CreateUser(&user2)
defer th.App.PermanentDeleteUser(&user1)
defer th.App.PermanentDeleteUser(&user2)
th.App.joinUserToTeam(team, ruser1)
th.App.LeaveTeam(team, ruser1, ruser1.Id)
th.App.joinUserToTeam(team, ruser2)
if _, _, err := th.App.joinUserToTeam(team, ruser1); err == nil {
t.Fatal("Should fail")
}
_, _, err := th.App.joinUserToTeam(team, ruser1)
require.NotNil(t, err, "Should fail")
})
}
@@ -771,13 +704,8 @@ func TestAppUpdateTeamScheme(t *testing.T) {
team.SchemeId = mockID
updatedTeam, err := th.App.UpdateTeamScheme(th.BasicTeam)
if err != nil {
t.Fatal(err)
}
if updatedTeam.SchemeId != mockID {
t.Fatal("Wrong Team SchemeId")
}
require.Nil(t, err)
require.Equal(t, mockID, updatedTeam.SchemeId, "Wrong Team SchemeId")
}
func TestGetTeamMembers(t *testing.T) {
@@ -811,6 +739,7 @@ func TestGetTeamMembers(t *testing.T) {
// Fetch team members multipile times
members, err := th.App.GetTeamMembers(th.BasicTeam.Id, 0, 5, nil)
require.Nil(t, err)
// This should return 5 members
members2, err := th.App.GetTeamMembers(th.BasicTeam.Id, 5, 6, nil)
require.Nil(t, err)
@@ -897,9 +826,8 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.Nil(t, err)
if _, err := th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user"); err == nil {
t.Fatal("Should fail when try to modify the guest role")
}
_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user")
require.NotNil(t, err, "Should fail when try to modify the guest role")
})
t.Run("from user to guest", func(t *testing.T) {
@@ -909,9 +837,8 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.Nil(t, err)
if _, err := th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest"); err == nil {
t.Fatal("Should fail when try to modify the guest role")
}
_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest")
require.NotNil(t, err, "Should fail when try to modify the guest role")
})
t.Run("from user to admin", func(t *testing.T) {
@@ -921,9 +848,8 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.Nil(t, err)
if _, err := th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user team_admin"); err != nil {
t.Fatal("Should work when you not modify guest role")
}
_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user team_admin")
require.Nil(t, err, "Should work when you not modify guest role")
})
t.Run("from guest to guest plus custom", func(t *testing.T) {
@@ -936,9 +862,8 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
_, err = th.App.CreateRole(&model.Role{Name: "custom", DisplayName: "custom", Description: "custom"})
require.Nil(t, err)
if _, err := th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest custom"); err != nil {
t.Fatal("Should work when you not modify guest role")
}
_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest custom")
require.Nil(t, err, "Should work when you not modify guest role")
})
t.Run("a guest cant have user role", func(t *testing.T) {
@@ -948,9 +873,8 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
require.Nil(t, err)
if _, err := th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest team_user"); err == nil {
t.Fatal("Should work when you not modify guest role")
}
_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest team_user")
require.NotNil(t, err, "Should work when you not modify guest role")
})
}