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

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

* Add missing message

* Fix suggestions

app/team_test.go

@@ -26,14 +26,11 @@ func TestCreateTeam(t *testing.T) {
 		Type:        model.TEAM_OPEN,
 	}
 
-	if _, err := th.App.CreateTeam(team); err != nil {
+	_, err := th.App.CreateTeam(team)
-		t.Log(err)
+	require.Nil(t, err, "Should create a new team")
-		t.Fatal("Should create a new team")
-	}
 
-	if _, err := th.App.CreateTeam(th.BasicTeam); err == nil {
+	_, err = th.App.CreateTeam(th.BasicTeam)
-		t.Fatal("Should not create a new team - team already exist")
+	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 {
+	_, err := th.App.CreateTeamWithUser(team, th.BasicUser.Id)
-		t.Fatal("Should create a new team with existing user", err)
+	require.Nil(t, err, "Should create a new team with existing user")
-	}
 
-	if _, err := th.App.CreateTeamWithUser(team, model.NewId()); err == nil {
+	_, err = th.App.CreateTeamWithUser(team, model.NewId())
-		t.Fatal("Should not create a new team - user does not exist")
+	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 {
+	updatedTeam, err := th.App.UpdateTeam(th.BasicTeam)
-		t.Log(err)
+	require.Nil(t, err, "Should update the team")
-		t.Fatal("Should update the team")
+	require.Equal(t, "Testing 123", updatedTeam.DisplayName, "Wrong Team DisplayName")
-	} else {
-		if updatedTeam.DisplayName != "Testing 123" {
-			t.Fatal("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 {
+		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
-			t.Log(err)
+		require.Nil(t, err, "Should add user to the team")
-			t.Fatal("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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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 {
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
-			t.Log(err)
+		require.Nil(t, err, "Should have allowed whitelisted user")
-			t.Fatal("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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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 {
+		require.Nil(t, err, "Error creating user: %s", err)
-			t.Fatalf("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" {
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
-			t.Log(err)
+		require.NotNil(t, err, "Should not add restricted user")
-			t.Fatal("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 {
+		require.Nil(t, err, "Error creating authservice user: %s", err)
-			t.Fatalf("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" {
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
-			t.Log(err)
+		require.NotNil(t, err, "Should not add authservice user")
-			t.Fatal("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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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" {
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
-			t.Log(err)
+		require.NotNil(t, err, "Should not add restricted user")
-			t.Fatal("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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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 {
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser1.Id, "")
-			t.Log(err)
+		require.Nil(t, err, "Should have allowed whitelisted user1")
-			t.Fatal("Should have allowed whitelisted user1")
+
-		}
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, "")
-		if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, ""); err != nil {
+		require.Nil(t, err, "Should have allowed whitelisted user2")
-			t.Log(err)
+
-			t.Fatal("Should have allowed whitelisted user2")
+		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, "")
-		}
+		require.NotNil(t, err, "Should not have allowed restricted user3")
-		if _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, ""); err == nil || err.Where != "JoinUserToTeam" {
+		require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
-			t.Log(err)
-			t.Fatal("Should not have allowed restricted user3")
-		}
 
 	})
 }
@@ -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 {
+		_, err := th.App.AddUserToTeamByToken(ruser.Id, "123")
-			t.Fatal("Should fail on unexisting token")
+		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 {
+		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
-			t.Log(err)
+		require.Nil(t, err, "Should add user to the team")
-			t.Fatal("Should add user to the team")
+
-		}
+		_, err = th.App.Srv.Store.Token().GetByToken(token.Token)
-		_, 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)
+		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
-			t.Fatal("Should add user to the team")
+		require.Nil(t, err, "Should add user to the team")
-		}
+
-		_, err := th.App.Srv.Store.Token().GetByToken(token.Token)
+		_, 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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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.")
+		_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
-		} else {
+		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)
+		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 {
+		_, err = th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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" {
+		_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
-			t.Log(err)
+		require.NotNil(t, err, "Should not add restricted user")
-			t.Fatal("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 {
+		err := th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser)
-			t.Log(err)
+		require.Nil(t, err, "Should add user to the team")
-			t.Fatal("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 {
+		_, err := th.App.UpdateTeam(th.BasicTeam)
-			t.Log(err)
+		require.Nil(t, err, "Should update the team")
-			t.Fatal("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" {
+		err = th.App.AddUserToTeamByTeamId(th.BasicTeam.Id, ruser)
-			t.Log(err)
+		require.NotNil(t, err, "Should not add restricted user")
-			t.Fatal("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 {
+	require.Nil(t, err, "Should create a team")
-		t.Fatal(err.Error())
+
-	}
 	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 {
+	require.Nil(t, err, "Should create a command")
-		t.Fatal(err.Error())
-	}
 	defer th.App.DeleteCommand(command.Id)
 
-	if command, err = th.App.GetCommand(command.Id); command == nil || err != nil {
+	command, err = th.App.GetCommand(command.Id)
-		t.Fatal("unable to get new command")
+	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 {
+	command, err = th.App.GetCommand(command.Id)
-		t.Fatal("command wasn't deleted")
+	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 {
+	channels, err := th.App.GetPublicChannelsForTeam(team.Id, 0, 1000)
-		t.Fatal(err)
+	require.Nil(t, err)
-	} else {
+
-		for _, channel := range *channels {
+	for _, channel := range *channels {
-			if err2 := th.App.PermanentDeleteChannel(channel); err2 != nil {
+		err2 := th.App.PermanentDeleteChannel(channel)
-				t.Fatal(err)
+		require.Nil(t, err2)
-			}
-		}
 	}
 
-	if err := th.App.PermanentDeleteTeam(team); err != nil {
+	err = th.App.PermanentDeleteTeam(team)
-		t.Fatal(err)
+	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 != "" {
+		require.Empty(t, sanitized.Email, "should've sanitized team")
-			t.Fatal("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 != "" {
+		require.Empty(t, sanitized.Email, "should've sanitized team")
-			t.Fatal("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 == "" {
+		require.NotEmpty(t, sanitized.Email, "shouldn't have sanitized team")
-			t.Fatal("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 != "" {
+		require.Empty(t, sanitized.Email, "should've sanitized team")
-			t.Fatal("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 == "" {
+		require.NotEmpty(t, sanitized.Email, "shouldn't have sanitized team")
-			t.Fatal("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 == "" {
+		require.NotEmpty(t, sanitized.Email, "shouldn't have sanitized team")
-			t.Fatal("shouldn't have sanitized team")
-		}
 	})
 }
 
@@ -627,13 +568,8 @@ func TestSanitizeTeams(t *testing.T) {
 
 		sanitized := th.App.SanitizeTeams(session, teams)
 
-		if sanitized[0].Email != "" {
+		require.Empty(t, sanitized[0].Email, "should've sanitized first team")
-			t.Fatal("should've sanitized first team")
+		require.NotEmpty(t, sanitized[1].Email, "shouldn't have sanitized second team")
-		}
-
-		if sanitized[1].Email == "" {
-			t.Fatal("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)
-
+		assert.NotEmpty(t, sanitized[0].Email, "shouldn't have sanitized first team")
-		if sanitized[0].Email == "" {
+		assert.NotEmpty(t, sanitized[1].Email, "shouldn't have sanitized second team")
-			t.Fatal("shouldn't have sanitized first team")
-		}
-
-		if sanitized[1].Email == "" {
-			t.Fatal("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 {
+	_, err := th.App.CreateTeam(team)
-		t.Log(err)
+	require.Nil(t, err, "Should create a new team")
-		t.Fatal("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 {
+		_, alreadyAdded, err := th.App.joinUserToTeam(team, ruser)
-			t.Fatal("Should return already added equal to false and no error")
+		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 {
+	require.Nil(t, err)
-		t.Fatal(err)
+	require.Equal(t, mockID, updatedTeam.SchemeId, "Wrong Team SchemeId")
-	}
-
-	if updatedTeam.SchemeId != mockID {
-		t.Fatal("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 {
+		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user")
-			t.Fatal("Should fail when try to modify the guest role")
+		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 {
+		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest")
-			t.Fatal("Should fail when try to modify the guest role")
+		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 {
+		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user team_admin")
-			t.Fatal("Should work when you not modify guest role")
+		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 {
+		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest custom")
-			t.Fatal("Should work when you not modify guest role")
+		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 {
+		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest team_user")
-			t.Fatal("Should work when you not modify guest role")
+		require.NotNil(t, err, "Should work when you not modify guest role")
-		}
 	})
 }