fix /test command (#14169)

Automatic Merge

app/auto_channels.go

@@ -32,7 +32,7 @@ func NewAutoChannelCreator(client *model.Client4, team *model.Team) *AutoChannel
 	}
 }
 
-func (cfg *AutoChannelCreator) createRandomChannel() (*model.Channel, bool) {
+func (cfg *AutoChannelCreator) createRandomChannel() (*model.Channel, error) {
 	var displayName string
 	if cfg.Fuzzy {
 		displayName = utils.FuzzName()
@@ -50,24 +50,22 @@ func (cfg *AutoChannelCreator) createRandomChannel() (*model.Channel, bool) {
 	println(cfg.client.GetTeamRoute(cfg.team.Id))
 	channel, resp := cfg.client.CreateChannel(channel)
 	if resp.Error != nil {
-		println(resp.Error.Error())
+		return nil, resp.Error
-		println(resp.Error.DetailedError)
-		return nil, false
 	}
-	return channel, true
+	return channel, nil
 }
 
-func (cfg *AutoChannelCreator) CreateTestChannels(num utils.Range) ([]*model.Channel, bool) {
+func (cfg *AutoChannelCreator) CreateTestChannels(num utils.Range) ([]*model.Channel, error) {
 	numChannels := utils.RandIntFromRange(num)
 	channels := make([]*model.Channel, numChannels)
 
 	for i := 0; i < numChannels; i++ {
-		var err bool
+		var err error
 		channels[i], err = cfg.createRandomChannel()
-		if !err {
+		if err != nil {
-			return channels, false
+			return nil, err
 		}
 	}
 
-	return channels, true
+	return channels, nil
 }

app/auto_environment.go

@@ -16,14 +16,14 @@ type TestEnvironment struct {
 	Environments []TeamEnvironment
 }
 
-func CreateTestEnvironmentWithTeams(a *App, client *model.Client4, rangeTeams utils.Range, rangeChannels utils.Range, rangeUsers utils.Range, rangePosts utils.Range, fuzzy bool) (TestEnvironment, bool) {
+func CreateTestEnvironmentWithTeams(a *App, client *model.Client4, rangeTeams utils.Range, rangeChannels utils.Range, rangeUsers utils.Range, rangePosts utils.Range, fuzzy bool) (TestEnvironment, error) {
 	rand.Seed(time.Now().UTC().UnixNano())
 
 	teamCreator := NewAutoTeamCreator(client)
 	teamCreator.Fuzzy = fuzzy
 	teams, err := teamCreator.CreateTestTeams(rangeTeams)
-	if !err {
+	if err != nil {
-		return TestEnvironment{}, false
+		return TestEnvironment{}, err
 	}
 
 	environment := TestEnvironment{teams, make([]TeamEnvironment, len(teams))}
@@ -32,21 +32,21 @@ func CreateTestEnvironmentWithTeams(a *App, client *model.Client4, rangeTeams ut
 		userCreator := NewAutoUserCreator(a, client, team)
 		userCreator.Fuzzy = fuzzy
 		randomUser, err := userCreator.createRandomUser()
-		if !err {
+		if err != nil {
-			return TestEnvironment{}, false
+			return TestEnvironment{}, err
 		}
 		client.LoginById(randomUser.Id, USER_PASSWORD)
 		teamEnvironment, err := CreateTestEnvironmentInTeam(a, client, team, rangeChannels, rangeUsers, rangePosts, fuzzy)
-		if !err {
+		if err != nil {
-			return TestEnvironment{}, false
+			return TestEnvironment{}, err
 		}
 		environment.Environments[i] = teamEnvironment
 	}
 
-	return environment, true
+	return environment, nil
 }
 
-func CreateTestEnvironmentInTeam(a *App, client *model.Client4, team *model.Team, rangeChannels utils.Range, rangeUsers utils.Range, rangePosts utils.Range, fuzzy bool) (TeamEnvironment, bool) {
+func CreateTestEnvironmentInTeam(a *App, client *model.Client4, team *model.Team, rangeChannels utils.Range, rangeUsers utils.Range, rangePosts utils.Range, fuzzy bool) (TeamEnvironment, error) {
 	rand.Seed(time.Now().UTC().UnixNano())
 
 	// We need to create at least one user
@@ -57,8 +57,8 @@ func CreateTestEnvironmentInTeam(a *App, client *model.Client4, team *model.Team
 	userCreator := NewAutoUserCreator(a, client, team)
 	userCreator.Fuzzy = fuzzy
 	users, err := userCreator.CreateTestUsers(rangeUsers)
-	if !err {
+	if err != nil {
-		return TeamEnvironment{}, false
+		return TeamEnvironment{}, nil
 	}
 	usernames := make([]string, len(users))
 	for i, user := range users {
@@ -68,32 +68,45 @@ func CreateTestEnvironmentInTeam(a *App, client *model.Client4, team *model.Team
 	channelCreator := NewAutoChannelCreator(client, team)
 	channelCreator.Fuzzy = fuzzy
 	channels, err := channelCreator.CreateTestChannels(rangeChannels)
+	if err != nil {
+		return TeamEnvironment{}, nil
+	}
 
 	// Have every user join every channel
 	for _, user := range users {
 		for _, channel := range channels {
-			client.LoginById(user.Id, USER_PASSWORD)
+			_, resp := client.LoginById(user.Id, USER_PASSWORD)
-			client.AddChannelMember(channel.Id, user.Id)
+			if resp.Error != nil {
-		}
+				return TeamEnvironment{}, resp.Error
 			}
 
-	if !err {
+			_, resp = client.AddChannelMember(channel.Id, user.Id)
-		return TeamEnvironment{}, false
+			if resp.Error != nil {
+				return TeamEnvironment{}, resp.Error
+			}
+		}
 	}
 
 	numPosts := utils.RandIntFromRange(rangePosts)
 	numImages := utils.RandIntFromRange(rangePosts) / 4
 	for j := 0; j < numPosts; j++ {
 		user := users[utils.RandIntFromRange(utils.Range{Begin: 0, End: len(users) - 1})]
-		client.LoginById(user.Id, USER_PASSWORD)
+		_, resp := client.LoginById(user.Id, USER_PASSWORD)
+		if resp.Error != nil {
+			return TeamEnvironment{}, resp.Error
+		}
+
 		for i, channel := range channels {
 			postCreator := NewAutoPostCreator(client, channel.Id)
 			postCreator.HasImage = i < numImages
 			postCreator.Users = usernames
 			postCreator.Fuzzy = fuzzy
-			postCreator.CreateRandomPost()
+			_, err := postCreator.CreateRandomPost()
+			if err != nil {
+				return TeamEnvironment{}, err
+			}
 		}
 	}
 
-	return TeamEnvironment{users, channels}, true
+	return TeamEnvironment{users, channels}, nil
 }

app/auto_posts.go

@@ -41,41 +41,41 @@ func NewAutoPostCreator(client *model.Client4, channelid string) *AutoPostCreato
 	}
 }
 
-func (cfg *AutoPostCreator) UploadTestFile() ([]string, bool) {
+func (cfg *AutoPostCreator) UploadTestFile() ([]string, error) {
 	filename := cfg.ImageFilenames[utils.RandIntFromRange(utils.Range{Begin: 0, End: len(cfg.ImageFilenames) - 1})]
 
-	path, _ := fileutils.FindDir("web/static/images")
+	path, _ := fileutils.FindDir("tests")
 	file, err := os.Open(filepath.Join(path, filename))
 	if err != nil {
-		return nil, false
+		return nil, err
 	}
 	defer file.Close()
 
 	data := &bytes.Buffer{}
 	_, err = io.Copy(data, file)
 	if err != nil {
-		return nil, false
+		return nil, err
 	}
 
-	resp, appErr := cfg.client.UploadFile(data.Bytes(), cfg.channelid, filename)
+	fileResp, resp := cfg.client.UploadFile(data.Bytes(), cfg.channelid, filename)
-	if appErr != nil {
+	if resp.Error != nil {
-		return nil, false
+		return nil, resp.Error
 	}
 
-	return []string{resp.FileInfos[0].Id}, true
+	return []string{fileResp.FileInfos[0].Id}, nil
 }
 
-func (cfg *AutoPostCreator) CreateRandomPost() (*model.Post, bool) {
+func (cfg *AutoPostCreator) CreateRandomPost() (*model.Post, error) {
 	return cfg.CreateRandomPostNested("", "")
 }
 
-func (cfg *AutoPostCreator) CreateRandomPostNested(parentId, rootId string) (*model.Post, bool) {
+func (cfg *AutoPostCreator) CreateRandomPostNested(parentId, rootId string) (*model.Post, error) {
 	var fileIds []string
 	if cfg.HasImage {
-		var err1 bool
+		var err error
-		fileIds, err1 = cfg.UploadTestFile()
+		fileIds, err = cfg.UploadTestFile()
-		if !err1 {
+		if err != nil {
-			return nil, false
+			return nil, err
 		}
 	}
 
@@ -93,8 +93,8 @@ func (cfg *AutoPostCreator) CreateRandomPostNested(parentId, rootId string) (*mo
 		Message:   postText,
 		FileIds:   fileIds}
 	rpost, resp := cfg.client.CreatePost(post)
-	if resp != nil && resp.Error != nil {
+	if resp.Error != nil {
-		return nil, false
+		return nil, resp.Error
 	}
-	return rpost, true
+	return rpost, nil
 }

app/auto_teams.go

@@ -37,14 +37,14 @@ func NewAutoTeamCreator(client *model.Client4) *AutoTeamCreator {
 	}
 }
 
-func (cfg *AutoTeamCreator) createRandomTeam() (*model.Team, bool) {
+func (cfg *AutoTeamCreator) createRandomTeam() (*model.Team, error) {
 	var teamEmail string
 	var teamDisplayName string
 	var teamName string
 	if cfg.Fuzzy {
 		teamEmail = "success+" + model.NewId() + "simulator.amazonses.com"
 		teamDisplayName = utils.FuzzName()
-		teamName = utils.FuzzName()
+		teamName = model.NewRandomTeamName()
 	} else {
 		teamEmail = "success+" + model.NewId() + "simulator.amazonses.com"
 		teamDisplayName = utils.RandomName(cfg.NameLength, cfg.NameCharset)
@@ -57,24 +57,24 @@ func (cfg *AutoTeamCreator) createRandomTeam() (*model.Team, bool) {
 		Type:        model.TEAM_OPEN,
 	}
 
-	createdTeam, err := cfg.client.CreateTeam(team)
+	createdTeam, resp := cfg.client.CreateTeam(team)
-	if err != nil {
+	if resp.Error != nil {
-		return nil, false
+		return nil, resp.Error
 	}
-	return createdTeam, true
+	return createdTeam, nil
 }
 
-func (cfg *AutoTeamCreator) CreateTestTeams(num utils.Range) ([]*model.Team, bool) {
+func (cfg *AutoTeamCreator) CreateTestTeams(num utils.Range) ([]*model.Team, error) {
 	numTeams := utils.RandIntFromRange(num)
 	teams := make([]*model.Team, numTeams)
 
 	for i := 0; i < numTeams; i++ {
-		var err bool
+		var err error
 		teams[i], err = cfg.createRandomTeam()
-		if !err {
+		if err != nil {
-			return teams, false
+			return nil, err
 		}
 	}
 
-	return teams, true
+	return teams, nil
 }

app/auto_users.go

@@ -4,7 +4,6 @@
 package app
 
 import (
-	"github.com/mattermost/mattermost-server/v5/mlog"
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/mattermost/mattermost-server/v5/utils"
 )
@@ -36,7 +35,10 @@ func NewAutoUserCreator(a *App, client *model.Client4, team *model.Team) *AutoUs
 // Basic test team and user so you always know one
 func (a *App) CreateBasicUser(client *model.Client4) *model.AppError {
 	found, _ := client.TeamExists(BTEST_TEAM_NAME, "")
-	if !found {
+	if found {
+		return nil
+	}
+
 	newteam := &model.Team{DisplayName: BTEST_TEAM_DISPLAY_NAME, Name: BTEST_TEAM_NAME, Email: BTEST_TEAM_EMAIL, Type: BTEST_TEAM_TYPE}
 	basicteam, resp := client.CreateTeam(newteam)
 	if resp.Error != nil {
@@ -54,11 +56,11 @@ func (a *App) CreateBasicUser(client *model.Client4) *model.AppError {
 	if _, err = a.Srv().Store.Team().SaveMember(&model.TeamMember{TeamId: basicteam.Id, UserId: ruser.Id}, *a.Config().TeamSettings.MaxUsersPerTeam); err != nil {
 		return err
 	}
-	}
+
 	return nil
 }
 
-func (cfg *AutoUserCreator) createRandomUser() (*model.User, bool) {
+func (cfg *AutoUserCreator) createRandomUser() (*model.User, error) {
 	var userEmail string
 	var userName string
 	if cfg.Fuzzy {
@@ -76,36 +78,34 @@ func (cfg *AutoUserCreator) createRandomUser() (*model.User, bool) {
 
 	ruser, resp := cfg.client.CreateUserWithInviteId(user, cfg.team.InviteId)
 	if resp.Error != nil {
-		mlog.Error(resp.Error.Error())
+		return nil, resp.Error
-		return nil, false
 	}
 
 	status := &model.Status{UserId: ruser.Id, Status: model.STATUS_ONLINE, Manual: false, LastActivityAt: model.GetMillis(), ActiveChannel: ""}
 	if err := cfg.app.Srv().Store.Status().SaveOrUpdate(status); err != nil {
-		mlog.Error(err.Error())
+		return nil, err
-		return nil, false
 	}
 
 	// We need to cheat to verify the user's email
 	_, err := cfg.app.Srv().Store.User().VerifyEmail(ruser.Id, ruser.Email)
 	if err != nil {
-		return nil, false
+		return nil, err
 	}
 
-	return ruser, true
+	return ruser, nil
 }
 
-func (cfg *AutoUserCreator) CreateTestUsers(num utils.Range) ([]*model.User, bool) {
+func (cfg *AutoUserCreator) CreateTestUsers(num utils.Range) ([]*model.User, error) {
 	numUsers := utils.RandIntFromRange(num)
 	users := make([]*model.User, numUsers)
 
 	for i := 0; i < numUsers; i++ {
-		var err bool
+		var err error
 		users[i], err = cfg.createRandomUser()
-		if !err {
+		if err != nil {
-			return users, false
+			return nil, err
 		}
 	}
 
-	return users, true
+	return users, nil
 }

app/command_loadtest.go

@@ -15,6 +15,7 @@ import (
 	"github.com/mattermost/mattermost-server/v5/mlog"
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/mattermost/mattermost-server/v5/utils"
+	"github.com/pkg/errors"
 )
 
 var usage = `Mattermost testing commands to help configure the system
@@ -105,9 +106,18 @@ func (me *LoadTestProvider) GetCommand(a *App, T goi18n.TranslateFunc) *model.Co
 }
 
 func (me *LoadTestProvider) DoCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+	commandResponse, err := me.doCommand(a, args, message)
+	if err != nil {
+		mlog.Error("failed command /"+CMD_TEST, mlog.Err(err))
+	}
+
+	return commandResponse
+}
+
+func (me *LoadTestProvider) doCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	//This command is only available when EnableTesting is true
 	if !*a.Config().ServiceSettings.EnableTesting {
-		return &model.CommandResponse{}
+		return &model.CommandResponse{}, nil
 	}
 
 	if strings.HasPrefix(message, "setup") {
@@ -145,17 +155,19 @@ func (me *LoadTestProvider) DoCommand(a *App, args *model.CommandArgs, message s
 	if strings.HasPrefix(message, "url") {
 		return me.UrlCommand(a, args, message)
 	}
+
 	if strings.HasPrefix(message, "json") {
 		return me.JsonCommand(a, args, message)
 	}
-	return me.HelpCommand(args, message)
+
+	return me.HelpCommand(args, message), nil
 }
 
 func (me *LoadTestProvider) HelpCommand(args *model.CommandArgs, message string) *model.CommandResponse {
 	return &model.CommandResponse{Text: usage, ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
 }
 
-func (me *LoadTestProvider) SetupCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) SetupCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	tokens := strings.Fields(strings.TrimPrefix(message, "setup"))
 	doTeams := contains(tokens, "teams")
 	doFuzz := contains(tokens, "fuzz")
@@ -194,12 +206,16 @@ func (me *LoadTestProvider) SetupCommand(a *App, args *model.CommandArgs, messag
 		}
 	}
 	client := model.NewAPIv4Client(args.SiteURL)
+	client.SetToken(args.Session.Token)
 
 	if doTeams {
 		if err := a.CreateBasicUser(client); err != nil {
-			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
+		}
+		_, resp := client.Login(BTEST_USER_EMAIL, BTEST_USER_PASSWORD)
+		if resp.Error != nil {
+			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, resp.Error
 		}
-		client.Login(BTEST_USER_EMAIL, BTEST_USER_PASSWORD)
 		environment, err := CreateTestEnvironmentWithTeams(
 			a,
 			client,
@@ -208,22 +224,21 @@ func (me *LoadTestProvider) SetupCommand(a *App, args *model.CommandArgs, messag
 			utils.Range{Begin: numUsers, End: numUsers},
 			utils.Range{Begin: numPosts, End: numPosts},
 			doFuzz)
-		if !err {
+		if err != nil {
-			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
-		} else {
+		}
+
 		mlog.Info("Testing environment created")
 		for i := 0; i < len(environment.Teams); i++ {
 			mlog.Info("Team Created: " + environment.Teams[i].Name)
 			mlog.Info("\t User to login: " + environment.Environments[i].Users[0].Email + ", " + USER_PASSWORD)
 		}
-		}
 	} else {
 		team, err := a.Srv().Store.Team().Get(args.TeamId)
 		if err != nil {
-			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 		}
 
-		client.SetToken(args.Session.Token)
 		CreateTestEnvironmentInTeam(
 			a,
 			client,
@@ -234,26 +249,28 @@ func (me *LoadTestProvider) SetupCommand(a *App, args *model.CommandArgs, messag
 			doFuzz)
 	}
 
-	return &model.CommandResponse{Text: "Created environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	return &model.CommandResponse{Text: "Created environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) ActivateUserCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) ActivateUserCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	user_id := strings.TrimSpace(strings.TrimPrefix(message, "activate_user"))
 	if err := a.UpdateUserActive(user_id, true); err != nil {
-		return &model.CommandResponse{Text: "Failed to activate user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to activate user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
-	return &model.CommandResponse{Text: "Activated user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+
+	return &model.CommandResponse{Text: "Activated user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) DeActivateUserCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) DeActivateUserCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	user_id := strings.TrimSpace(strings.TrimPrefix(message, "deactivate_user"))
 	if err := a.UpdateUserActive(user_id, false); err != nil {
-		return &model.CommandResponse{Text: "Failed to deactivate user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to deactivate user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
-	return &model.CommandResponse{Text: "DeActivated user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+
+	return &model.CommandResponse{Text: "DeActivated user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) UsersCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) UsersCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	cmd := strings.TrimSpace(strings.TrimPrefix(message, "users"))
 
 	doFuzz := false
@@ -269,7 +286,7 @@ func (me *LoadTestProvider) UsersCommand(a *App, args *model.CommandArgs, messag
 
 	team, err := a.Srv().Store.Team().Get(args.TeamId)
 	if err != nil {
-		return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to add users", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
 
 	client := model.NewAPIv4Client(args.SiteURL)
@@ -277,10 +294,10 @@ func (me *LoadTestProvider) UsersCommand(a *App, args *model.CommandArgs, messag
 	userCreator.Fuzzy = doFuzz
 	userCreator.CreateTestUsers(usersr)
 
-	return &model.CommandResponse{Text: "Added users", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	return &model.CommandResponse{Text: "Added users", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) ChannelsCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) ChannelsCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	cmd := strings.TrimSpace(strings.TrimPrefix(message, "channels"))
 
 	doFuzz := false
@@ -296,7 +313,7 @@ func (me *LoadTestProvider) ChannelsCommand(a *App, args *model.CommandArgs, mes
 
 	team, err := a.Srv().Store.Team().Get(args.TeamId)
 	if err != nil {
-		return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to add channels", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
 
 	client := model.NewAPIv4Client(args.SiteURL)
@@ -305,10 +322,10 @@ func (me *LoadTestProvider) ChannelsCommand(a *App, args *model.CommandArgs, mes
 	channelCreator.Fuzzy = doFuzz
 	channelCreator.CreateTestChannels(channelsr)
 
-	return &model.CommandResponse{Text: "Added channels", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	return &model.CommandResponse{Text: "Added channels", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) ThreadedPostCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) ThreadedPostCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	var usernames []string
 	options := &model.UserGetOptions{InTeamId: args.TeamId, Page: 0, PerPage: 1000}
 	if profileUsers, err := a.Srv().Store.User().GetProfiles(options); err == nil {
@@ -325,18 +342,18 @@ func (me *LoadTestProvider) ThreadedPostCommand(a *App, args *model.CommandArgs,
 	testPoster := NewAutoPostCreator(client, args.ChannelId)
 	testPoster.Fuzzy = true
 	testPoster.Users = usernames
-	rpost, ok := testPoster.CreateRandomPost()
+	rpost, err := testPoster.CreateRandomPost()
-	if !ok {
+	if err != nil {
-		return &model.CommandResponse{Text: "Cannot create a post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to create a post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
 	for i := 0; i < 1000; i++ {
 		testPoster.CreateRandomPostNested(rpost.Id, rpost.Id)
 	}
 
-	return &model.CommandResponse{Text: "Added threaded post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	return &model.CommandResponse{Text: "Added threaded post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) PostsCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) PostsCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	cmd := strings.TrimSpace(strings.TrimPrefix(message, "posts"))
 
 	doFuzz := false
@@ -379,10 +396,14 @@ func (me *LoadTestProvider) PostsCommand(a *App, args *model.CommandArgs, messag
 	numPosts := utils.RandIntFromRange(postsr)
 	for i := 0; i < numPosts; i++ {
 		testPoster.HasImage = (i < numImages)
-		testPoster.CreateRandomPost()
+		_, err := testPoster.CreateRandomPost()
+		if err != nil {
+			return &model.CommandResponse{Text: "Failed to add posts", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 		}
 
-	return &model.CommandResponse{Text: "Added posts", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	}
+
+	return &model.CommandResponse{Text: "Added posts", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
 func getMatch(re *regexp.Regexp, text string) string {
@@ -393,35 +414,35 @@ func getMatch(re *regexp.Regexp, text string) string {
 	return ""
 }
 
-func (me *LoadTestProvider) PostCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) PostCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	textMessage := getMatch(messageRE, message)
 	if textMessage == "" {
-		return &model.CommandResponse{Text: "No message to post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "No message to post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 	}
 
 	teamName := getMatch(teamRE, message)
 	team, err := a.GetTeamByName(teamName)
 	if err != nil {
-		return &model.CommandResponse{Text: "Failed to get a team", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to get a team", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
 
 	channelName := getMatch(channelRE, message)
 	channel, err := a.GetChannelByName(channelName, team.Id, true)
 	if err != nil {
-		return &model.CommandResponse{Text: "Failed to get a channel", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to get a channel", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
 
 	passwd := getMatch(passwdRE, message)
 	username := getMatch(userRE, message)
 	user, err := a.GetUserByUsername(username)
 	if err != nil {
-		return &model.CommandResponse{Text: "Failed to get a user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to get a user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
 
 	client := model.NewAPIv4Client(args.SiteURL)
 	_, resp := client.LoginById(user.Id, passwd)
-	if resp != nil && resp.Error != nil {
+	if resp.Error != nil {
-		return &model.CommandResponse{Text: "Failed to login a user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to login a user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, resp.Error
 	}
 
 	post := &model.Post{
@@ -429,17 +450,17 @@ func (me *LoadTestProvider) PostCommand(a *App, args *model.CommandArgs, message
 		Message:   textMessage,
 	}
 	_, resp = client.CreatePost(post)
-	if resp != nil && resp.Error != nil {
+	if resp.Error != nil {
-		return &model.CommandResponse{Text: "Failed to create a post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Failed to create a post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, resp.Error
 	}
 
-	return &model.CommandResponse{Text: "Added a post to " + channel.DisplayName, ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	return &model.CommandResponse{Text: "Added a post to " + channel.DisplayName, ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) UrlCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) UrlCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	url := strings.TrimSpace(strings.TrimPrefix(message, "url"))
 	if len(url) == 0 {
-		return &model.CommandResponse{Text: "Command must contain a url", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Command must contain a url", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 	}
 
 	// provide a shortcut to easily access tests stored in doc/developer/tests
@@ -453,9 +474,9 @@ func (me *LoadTestProvider) UrlCommand(a *App, args *model.CommandArgs, message
 
 	var contents io.ReadCloser
 	if r, err := http.Get(url); err != nil {
-		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	} else if r.StatusCode > 400 {
-		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, errors.Errorf("unexpected status code %d", r.StatusCode)
 	} else {
 		contents = r.Body
 	}
@@ -466,7 +487,7 @@ func (me *LoadTestProvider) UrlCommand(a *App, args *model.CommandArgs, message
 	for {
 		length, err := contents.Read(bytes)
 		if err != nil && err != io.EOF {
-			return &model.CommandResponse{Text: "Encountered error reading file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			return &model.CommandResponse{Text: "Encountered error reading file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 		}
 
 		if length == 0 {
@@ -479,17 +500,17 @@ func (me *LoadTestProvider) UrlCommand(a *App, args *model.CommandArgs, message
 		post.UserId = args.UserId
 
 		if _, err := a.CreatePostMissingChannel(post, false); err != nil {
-			return &model.CommandResponse{Text: "Unable to create post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+			return &model.CommandResponse{Text: "Unable to create post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 		}
 	}
 
-	return &model.CommandResponse{Text: "Loaded data", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+	return &model.CommandResponse{Text: "Loaded data", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
-func (me *LoadTestProvider) JsonCommand(a *App, args *model.CommandArgs, message string) *model.CommandResponse {
+func (me *LoadTestProvider) JsonCommand(a *App, args *model.CommandArgs, message string) (*model.CommandResponse, error) {
 	url := strings.TrimSpace(strings.TrimPrefix(message, "json"))
 	if len(url) == 0 {
-		return &model.CommandResponse{Text: "Command must contain a url", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Command must contain a url", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 	}
 
 	// provide a shortcut to easily access tests stored in doc/developer/tests
@@ -503,9 +524,9 @@ func (me *LoadTestProvider) JsonCommand(a *App, args *model.CommandArgs, message
 
 	var contents io.ReadCloser
 	if r, err := http.Get(url); err != nil {
-		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	} else if r.StatusCode > 400 {
-		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Unable to get file", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, errors.Errorf("unexpected status code %d", r.StatusCode)
 	} else {
 		contents = r.Body
 	}
@@ -518,9 +539,10 @@ func (me *LoadTestProvider) JsonCommand(a *App, args *model.CommandArgs, message
 	}
 
 	if _, err := a.CreatePostMissingChannel(post, false); err != nil {
-		return &model.CommandResponse{Text: "Unable to create post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+		return &model.CommandResponse{Text: "Unable to create post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
 	}
-	return &model.CommandResponse{Text: "Loaded data", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
+
+	return &model.CommandResponse{Text: "Loaded data", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, nil
 }
 
 func parseRange(command string, cmd string) (utils.Range, bool) {