444 строки
15 KiB
Go
444 строки
15 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package commands
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/mattermost/mattermost-server/v5/model"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestCreateCommand(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
config := th.Config()
|
|
*config.ServiceSettings.EnableCommands = true
|
|
th.SetConfig(config)
|
|
|
|
team := th.BasicTeam
|
|
adminUser := th.TeamAdminUser
|
|
user := th.BasicUser
|
|
|
|
testCases := []struct {
|
|
Description string
|
|
Args []string
|
|
ExpectedErr string
|
|
}{
|
|
{
|
|
"nil error",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"",
|
|
},
|
|
{
|
|
"Team not specified",
|
|
[]string{"command", "create", "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Error: requires at least 1 arg(s), only received 0",
|
|
},
|
|
{
|
|
"Team not found",
|
|
[]string{"command", "create", "fakeTeam", "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Error: unable to find team",
|
|
},
|
|
{
|
|
"Creator not specified",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler"},
|
|
`Error: required flag(s) "creator" not set`,
|
|
},
|
|
{
|
|
"Creator not found",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", "fakeuser"},
|
|
"unable to find user",
|
|
},
|
|
{
|
|
"Creator not team admin",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", user.Username},
|
|
"the creator must be a user who has permissions to manage slash commands",
|
|
},
|
|
{
|
|
"Command not specified",
|
|
[]string{"command", "", team.Name, "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Error: unknown flag: --trigger-word",
|
|
},
|
|
{
|
|
"Trigger not specified",
|
|
[]string{"command", "create", team.Name, "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
`Error: required flag(s) "trigger-word" not set`,
|
|
},
|
|
{
|
|
"Blank trigger",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Invalid trigger",
|
|
},
|
|
{
|
|
"Trigger with space",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "test cmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Error: a trigger word must not contain spaces",
|
|
},
|
|
{
|
|
"Trigger starting with /",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "/testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Error: a trigger word cannot begin with a /",
|
|
},
|
|
{
|
|
"URL not specified",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd", "--creator", adminUser.Username},
|
|
`Error: required flag(s) "url" not set`,
|
|
},
|
|
{
|
|
"Blank URL",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd2", "--url", "", "--creator", adminUser.Username},
|
|
"Invalid URL",
|
|
},
|
|
{
|
|
"Invalid URL",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd2", "--url", "localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Invalid URL",
|
|
},
|
|
{
|
|
"Duplicate Command",
|
|
[]string{"command", "create", team.Name, "--trigger-word", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"This trigger word is already in use",
|
|
},
|
|
{
|
|
"Misspelled flag",
|
|
[]string{"command", "create", team.Name, "--trigger-wor", "testcmd", "--url", "http://localhost:8000/my-slash-handler", "--creator", adminUser.Username},
|
|
"Error: unknown flag:",
|
|
},
|
|
}
|
|
|
|
for _, testCase := range testCases {
|
|
t.Run(testCase.Description, func(t *testing.T) {
|
|
actual, _ := th.RunCommandWithOutput(t, testCase.Args...)
|
|
|
|
cmds, response := th.SystemAdminClient.ListCommands(team.Id, true)
|
|
|
|
require.Nil(t, response.Error, "Failed to list commands")
|
|
|
|
if testCase.ExpectedErr == "" {
|
|
assert.NotZero(t, len(cmds), "Failed to create command")
|
|
assert.Equal(t, cmds[0].Trigger, "testcmd", "Failed to create command")
|
|
assert.Contains(t, actual, "PASS")
|
|
} else {
|
|
assert.LessOrEqual(t, len(cmds), 1, "Created command that shouldn't have been created")
|
|
assert.Contains(t, actual, testCase.ExpectedErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestShowCommand(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
url := "http://localhost:8000/test-command"
|
|
team := th.BasicTeam
|
|
user := th.BasicUser
|
|
th.LinkUserToTeam(user, team)
|
|
trigger := "trigger_" + model.NewId()
|
|
displayName := "dn_" + model.NewId()
|
|
|
|
c := &model.Command{
|
|
DisplayName: displayName,
|
|
Method: "G",
|
|
TeamId: team.Id,
|
|
Username: user.Username,
|
|
CreatorId: user.Id,
|
|
URL: url,
|
|
Trigger: trigger,
|
|
}
|
|
|
|
t.Run("existing command", func(t *testing.T) {
|
|
command, err := th.App.CreateCommand(c)
|
|
require.Nil(t, err)
|
|
commands, err := th.App.ListTeamCommands(team.Id)
|
|
require.Nil(t, err)
|
|
assert.Equal(t, len(commands), 1)
|
|
|
|
output := th.CheckCommand(t, "command", "show", command.Id)
|
|
assert.Contains(t, output, command.Id)
|
|
assert.Contains(t, output, command.TeamId)
|
|
assert.Contains(t, output, trigger)
|
|
assert.Contains(t, output, displayName)
|
|
assert.Contains(t, output, user.Username)
|
|
})
|
|
|
|
t.Run("not existing command", func(t *testing.T) {
|
|
assert.Error(t, th.RunCommand(t, "command", "show", "invalid"))
|
|
})
|
|
|
|
t.Run("no commandID", func(t *testing.T) {
|
|
assert.Error(t, th.RunCommand(t, "command", "show"))
|
|
})
|
|
}
|
|
|
|
func TestDeleteCommand(t *testing.T) {
|
|
// Skipped due to v5.6 RC build issues.
|
|
t.Skip()
|
|
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
url := "http://localhost:8000/test-command"
|
|
team := th.BasicTeam
|
|
user := th.BasicUser
|
|
th.LinkUserToTeam(user, team)
|
|
|
|
c := &model.Command{
|
|
DisplayName: "dn_" + model.NewId(),
|
|
Method: "G",
|
|
TeamId: team.Id,
|
|
Username: user.Username,
|
|
CreatorId: user.Id,
|
|
URL: url,
|
|
Trigger: "trigger_" + model.NewId(),
|
|
}
|
|
|
|
t.Run("existing command", func(t *testing.T) {
|
|
command, err := th.App.CreateCommand(c)
|
|
require.Nil(t, err)
|
|
commands, err := th.App.ListTeamCommands(team.Id)
|
|
require.Nil(t, err)
|
|
assert.Equal(t, len(commands), 1)
|
|
|
|
th.CheckCommand(t, "command", "delete", command.Id)
|
|
commands, err = th.App.ListTeamCommands(team.Id)
|
|
require.Nil(t, err)
|
|
assert.Equal(t, len(commands), 0)
|
|
})
|
|
|
|
t.Run("not existing command", func(t *testing.T) {
|
|
assert.Error(t, th.RunCommand(t, "command", "delete", "invalid"))
|
|
})
|
|
}
|
|
|
|
func TestModifyCommand(t *testing.T) {
|
|
th := Setup(t).InitBasic()
|
|
defer th.TearDown()
|
|
|
|
// set config
|
|
config := th.Config()
|
|
*config.ServiceSettings.EnableCommands = true
|
|
th.SetConfig(config)
|
|
|
|
// set team and users
|
|
team := th.BasicTeam
|
|
adminUser := th.TeamAdminUser
|
|
user := th.BasicUser
|
|
|
|
// create test command to modify
|
|
url := "http://localhost:8000/test-command"
|
|
th.LinkUserToTeam(user, team)
|
|
trigger := "trigger_" + model.NewId()
|
|
displayName := "dn_" + model.NewId()
|
|
|
|
c := &model.Command{
|
|
DisplayName: displayName,
|
|
Method: "G",
|
|
TeamId: team.Id,
|
|
Username: user.Username,
|
|
CreatorId: user.Id,
|
|
URL: url,
|
|
Trigger: trigger,
|
|
}
|
|
|
|
command, err := th.App.CreateCommand(c)
|
|
require.Nil(t, err)
|
|
commands, err := th.App.ListTeamCommands(team.Id)
|
|
require.Nil(t, err)
|
|
assert.Equal(t, len(commands), 1)
|
|
|
|
t.Run("command not specified", func(t *testing.T) {
|
|
args := []string{"command", "", command.Id, "--trigger-word", "sometrigger"}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
assert.Contains(t, output, "Error: unknown flag: --trigger-word")
|
|
})
|
|
|
|
t.Run("modify command unchanged", func(t *testing.T) {
|
|
args := []string{"command", "modify", command.Id}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.DisplayName, command.DisplayName)
|
|
assert.Equal(t, cmd.Method, command.Method)
|
|
assert.Equal(t, cmd.TeamId, command.TeamId)
|
|
assert.Equal(t, cmd.Username, command.Username)
|
|
assert.Equal(t, cmd.CreatorId, command.CreatorId)
|
|
assert.Equal(t, cmd.URL, command.URL)
|
|
assert.Equal(t, cmd.Trigger, command.Trigger)
|
|
assert.Equal(t, cmd.AutoComplete, command.AutoComplete)
|
|
assert.Equal(t, cmd.AutoCompleteDesc, command.AutoCompleteDesc)
|
|
assert.Equal(t, cmd.AutoCompleteHint, command.AutoCompleteHint)
|
|
assert.Equal(t, cmd.IconURL, command.IconURL)
|
|
})
|
|
|
|
t.Run("misspelled flag", func(t *testing.T) {
|
|
args := []string{"command", "", command.Id, "--trigger-wor", "sometrigger"}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
assert.Contains(t, output, "Error: unknown flag:")
|
|
})
|
|
|
|
t.Run("multiple flags nil error", func(t *testing.T) {
|
|
testName := "multitrigger"
|
|
testURL := "http://localhost:8000/test-modify"
|
|
testDescription := "multiple field test"
|
|
args := []string{"command", "modify", command.Id, "--trigger-word", testName, "--url", testURL, "--description", testDescription}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.Trigger, testName)
|
|
assert.Equal(t, cmd.URL, testURL)
|
|
assert.Equal(t, cmd.Description, testDescription)
|
|
})
|
|
|
|
t.Run("displayname nil error", func(t *testing.T) {
|
|
testVal := "newName"
|
|
args := []string{"command", "modify", command.Id, "--title", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.DisplayName, testVal)
|
|
})
|
|
|
|
t.Run("description nil error", func(t *testing.T) {
|
|
testVal := "test description"
|
|
args := []string{"command", "modify", command.Id, "--description", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.Description, testVal)
|
|
})
|
|
|
|
t.Run("trigger nil error", func(t *testing.T) {
|
|
testVal := "testtrigger"
|
|
args := []string{"command", "modify", command.Id, "--trigger-word", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.Trigger, testVal)
|
|
})
|
|
|
|
t.Run("trigger with space", func(t *testing.T) {
|
|
testVal := "bad trigger"
|
|
args := []string{"command", "modify", command.Id, "--trigger-word", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
assert.Contains(t, output, "Error: a trigger word must not contain spaces")
|
|
})
|
|
|
|
t.Run("trigger with leading /", func(t *testing.T) {
|
|
testVal := "/bad-trigger"
|
|
args := []string{"command", "modify", command.Id, "--trigger-word", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
assert.Contains(t, output, "Error: a trigger word cannot begin with a /")
|
|
})
|
|
|
|
t.Run("blank trigger", func(t *testing.T) {
|
|
cmd_unmodified, _ := th.App.GetCommand(command.Id)
|
|
args := []string{"command", "modify", command.Id, "--trigger-word", ""}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd_modified, _ := th.App.GetCommand(command.Id)
|
|
|
|
// assert trigger remains unchanged
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd_unmodified.Trigger, cmd_modified.Trigger)
|
|
})
|
|
|
|
//url case
|
|
t.Run("url nil error", func(t *testing.T) {
|
|
testVal := "http://localhost:8000/modify-command"
|
|
args := []string{"command", "modify", command.Id, "--url", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.URL, testVal)
|
|
})
|
|
|
|
t.Run("blank url", func(t *testing.T) {
|
|
cmd_unmodified, _ := th.App.GetCommand(command.Id)
|
|
args := []string{"command", "modify", command.Id, "--url", ""}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd_modified, _ := th.App.GetCommand(command.Id)
|
|
|
|
//assert URL remains unchanged
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd_unmodified.URL, cmd_modified.URL)
|
|
})
|
|
|
|
t.Run("icon url nil error", func(t *testing.T) {
|
|
testVal := "http://localhost:8000/testicon.png"
|
|
args := []string{"command", "modify", command.Id, "--icon", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.IconURL, testVal)
|
|
})
|
|
|
|
t.Run("creator nil error", func(t *testing.T) {
|
|
testVal := adminUser
|
|
args := []string{"command", "modify", command.Id, "--creator", testVal.Username}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.CreatorId, testVal.Id)
|
|
})
|
|
|
|
t.Run("creator not found", func(t *testing.T) {
|
|
testVal := "fakeuser"
|
|
args := []string{"command", "modify", command.Id, "--creator", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
assert.Contains(t, output, "unable to find user")
|
|
})
|
|
|
|
t.Run("creator not admin user", func(t *testing.T) {
|
|
testVal := user.Username
|
|
args := []string{"command", "modify", command.Id, "--creator", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
assert.Contains(t, output, "the creator must be a user who has permissions to manage slash commands")
|
|
})
|
|
|
|
t.Run("response username nil error", func(t *testing.T) {
|
|
testVal := "response-test"
|
|
args := []string{"command", "modify", command.Id, "--response-username", testVal}
|
|
output, _ := th.RunCommandWithOutput(t, args...)
|
|
cmd, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output, "PASS")
|
|
assert.Equal(t, cmd.Username, testVal)
|
|
})
|
|
|
|
t.Run("post set and unset", func(t *testing.T) {
|
|
args_set := []string{"command", "modify", command.Id, "--post", ""}
|
|
args_unset := []string{"command", "modify", command.Id, "", ""}
|
|
|
|
// set post and check
|
|
output_set, _ := th.RunCommandWithOutput(t, args_set...)
|
|
cmd_set, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output_set, "PASS")
|
|
assert.Equal(t, cmd_set.Method, "P")
|
|
|
|
// unset post and check
|
|
output_unset, _ := th.RunCommandWithOutput(t, args_unset...)
|
|
cmd_unset, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output_unset, "PASS")
|
|
assert.Equal(t, cmd_unset.Method, "G")
|
|
})
|
|
|
|
t.Run("autocomplete set and unset", func(t *testing.T) {
|
|
args_set := []string{"command", "modify", command.Id, "--autocomplete", ""}
|
|
args_unset := []string{"command", "modify", command.Id, "", ""}
|
|
|
|
// set autocomplete and check
|
|
output_set, _ := th.RunCommandWithOutput(t, args_set...)
|
|
cmd_set, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output_set, "PASS")
|
|
assert.Equal(t, cmd_set.AutoComplete, true)
|
|
|
|
// unset autocomplete and check
|
|
output_unset, _ := th.RunCommandWithOutput(t, args_unset...)
|
|
cmd_unset, _ := th.App.GetCommand(command.Id)
|
|
assert.Contains(t, output_unset, "PASS")
|
|
assert.Equal(t, cmd_unset.AutoComplete, false)
|
|
})
|
|
}
|