mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

fix /test command (#14169)

Просмотр исходного кода 
Automatic Merge
Этот коммит содержится в:
Jesse Hallam
2020-04-18 04:08:57 -03:00
коммит произвёл GitHub
родитель e88ba85d60
Коммит 4582823f87
7 изменённых файлов: 181 добавлений и 148 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

18
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())
println(resp.Error.DetailedError)
return nil, false
return nil, resp.Error
}
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 {
return channels, false
if err != nil {
return nil, err
}
}
return channels, true
return channels, nil
}

53
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 {
return TestEnvironment{}, false
if err != nil {
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 {
return TestEnvironment{}, false
if err != nil {
return TestEnvironment{}, err
}
client.LoginById(randomUser.Id, USER_PASSWORD)
teamEnvironment, err := CreateTestEnvironmentInTeam(a, client, team, rangeChannels, rangeUsers, rangePosts, fuzzy)
if !err {
return TestEnvironment{}, false
if err != nil {
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 {
return TeamEnvironment{}, false
if err != nil {
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)
client.AddChannelMember(channel.Id, user.Id)
}
}
_, resp := client.LoginById(user.Id, USER_PASSWORD)
if resp.Error != nil {
return TeamEnvironment{}, resp.Error
}
if !err {
return TeamEnvironment{}, false
_, resp = client.AddChannelMember(channel.Id, user.Id)
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
}

34
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)
if appErr != nil {
return nil, false
fileResp, resp := cfg.client.UploadFile(data.Bytes(), cfg.channelid, filename)
if resp.Error != nil {
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
fileIds, err1 = cfg.UploadTestFile()
if !err1 {
return nil, false
var err error
fileIds, err = cfg.UploadTestFile()
if err != nil {
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 {
return nil, false
if resp.Error != nil {
return nil, resp.Error
}
return rpost, true
return rpost, nil
}

22
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)
if err != nil {
return nil, false
createdTeam, resp := cfg.client.CreateTeam(team)
if resp.Error != nil {
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 {
return teams, false
if err != nil {
return nil, err
}
}
return teams, true
return teams, nil
}

62
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,29 +35,32 @@ 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 {
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 {
return resp.Error
}
newuser := &model.User{Email: BTEST_USER_EMAIL, Nickname: BTEST_USER_NAME, Password: BTEST_USER_PASSWORD}
ruser, resp := client.CreateUser(newuser)
if resp.Error != nil {
return resp.Error
}
_, err := a.Srv().Store.User().VerifyEmail(ruser.Id, ruser.Email)
if err != nil {
return err
}
if _, err = a.Srv().Store.Team().SaveMember(&model.TeamMember{TeamId: basicteam.Id, UserId: ruser.Id}, *a.Config().TeamSettings.MaxUsersPerTeam); err != nil {
return err
}
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 {
return resp.Error
}
newuser := &model.User{Email: BTEST_USER_EMAIL, Nickname: BTEST_USER_NAME, Password: BTEST_USER_PASSWORD}
ruser, resp := client.CreateUser(newuser)
if resp.Error != nil {
return resp.Error
}
_, err := a.Srv().Store.User().VerifyEmail(ruser.Id, ruser.Email)
if err != nil {
return err
}
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, false
return nil, resp.Error
}
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, false
return nil, err
}
// 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 {
return users, false
if err != nil {
return nil, err
}
}
return users, true
return users, nil
}

140
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 {
return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
} 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)
}
if err != nil {
return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}, err
}
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()
if !ok {
return &model.CommandResponse{Text: "Cannot create a post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
rpost, err := testPoster.CreateRandomPost()
if err != nil {
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 {
return &model.CommandResponse{Text: "Failed to login a user", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
if resp.Error != nil {
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 {
return &model.CommandResponse{Text: "Failed to create a post", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL}
if resp.Error != nil {
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) {

Двоичные данные
tests/testjpg.jpg Обычный файл
Просмотреть файл

Двоичный файл не отображается.
Режим "рядом"

После

Ширина:  |  Высота:  |  Размер: 40 KiB