657 lines
20 KiB
Go
657 lines
20 KiB
Go
package complete_test
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/spf13/pflag"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/go-task/task/v3"
|
|
"github.com/go-task/task/v3/internal/complete"
|
|
"github.com/go-task/task/v3/internal/slicesext"
|
|
)
|
|
|
|
func newTestFlagSet() *pflag.FlagSet {
|
|
fs := pflag.NewFlagSet("test", pflag.ContinueOnError)
|
|
var b bool
|
|
var s string
|
|
fs.BoolVarP(&b, "list-all", "a", false, "Lists all tasks")
|
|
fs.BoolVarP(&b, "list", "l", false, "Lists tasks with descriptions")
|
|
fs.BoolVarP(&b, "verbose", "v", false, "Verbose mode")
|
|
fs.StringVarP(&s, "taskfile", "t", "", "Taskfile path")
|
|
fs.StringVarP(&s, "dir", "d", "", "Run dir")
|
|
fs.StringVar(&s, "temp-dir", "", "Temp dir")
|
|
fs.StringVarP(&s, "output", "o", "", "Output style")
|
|
fs.StringVar(&s, "sort", "", "Sort order")
|
|
fs.StringVar(&s, "cacert", "", "CA cert path")
|
|
fs.StringVar(&s, "completion", "", "Generate a completion script")
|
|
return fs
|
|
}
|
|
|
|
const testTaskfile = `version: '3'
|
|
|
|
vars:
|
|
ALLOWED_ENVS:
|
|
- dev
|
|
- staging
|
|
- prod
|
|
|
|
tasks:
|
|
deploy:
|
|
desc: Deploy the application
|
|
aliases: [dep, ship]
|
|
requires:
|
|
vars:
|
|
- name: ENV
|
|
enum:
|
|
- dev
|
|
- staging
|
|
- prod
|
|
- REGION
|
|
cmds:
|
|
- 'echo {{.ENV}} {{.REGION}}'
|
|
|
|
build:
|
|
desc: Build it
|
|
cmds:
|
|
- 'echo build'
|
|
|
|
dynenum:
|
|
desc: Dynamic enum
|
|
requires:
|
|
vars:
|
|
- name: ENV
|
|
enum:
|
|
ref: .ALLOWED_ENVS
|
|
cmds:
|
|
- 'echo {{.ENV}}'
|
|
|
|
docs:serve:
|
|
desc: Serve docs locally
|
|
requires:
|
|
vars:
|
|
- PORT
|
|
cmds:
|
|
- 'echo serving'
|
|
|
|
`
|
|
|
|
const wildcardTaskfile = `version: '3'
|
|
|
|
tasks:
|
|
wildcard-*:
|
|
cmds:
|
|
- 'echo {{index .MATCH 0}}'
|
|
|
|
wildcard-*-*:
|
|
cmds:
|
|
- 'echo {{index .MATCH 0}}'
|
|
|
|
'*-wildcard-*':
|
|
cmds:
|
|
- 'echo {{index .MATCH 0}}'
|
|
|
|
matches-exactly-*:
|
|
cmds:
|
|
- 'echo {{.MATCH}}'
|
|
|
|
start-*:
|
|
desc: Start a service
|
|
aliases: [s-*]
|
|
cmds:
|
|
- 'echo {{index .MATCH 0}}'
|
|
|
|
release-*:
|
|
desc: Release a component
|
|
requires:
|
|
vars:
|
|
- name: CHANNEL
|
|
enum:
|
|
- beta
|
|
- stable
|
|
cmds:
|
|
- 'echo {{index .MATCH 0}}'
|
|
|
|
build:
|
|
desc: Build it
|
|
cmds:
|
|
- 'echo build'
|
|
`
|
|
|
|
func setupExecutor(t *testing.T) *task.Executor {
|
|
t.Helper()
|
|
return setupExecutorWith(t, testTaskfile)
|
|
}
|
|
|
|
func setupExecutorWith(tb testing.TB, taskfile string) *task.Executor {
|
|
tb.Helper()
|
|
dir := tb.TempDir()
|
|
require.NoError(tb, os.WriteFile(filepath.Join(dir, "Taskfile.yml"), []byte(taskfile), 0o644))
|
|
|
|
e := task.NewExecutor(
|
|
task.WithDir(dir),
|
|
task.WithStdout(io.Discard),
|
|
task.WithStderr(io.Discard),
|
|
task.WithVersionCheck(false),
|
|
)
|
|
require.NoError(tb, e.Setup())
|
|
return e
|
|
}
|
|
|
|
func TestComplete_TaskNames(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{""}, complete.Options{})
|
|
|
|
require.ElementsMatch(t,
|
|
[]string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"},
|
|
values(suggs),
|
|
)
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
require.Contains(t, descriptions(suggs), "Deploy the application")
|
|
}
|
|
|
|
func TestComplete_WildcardTaskNames(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutorWith(t, wildcardTaskfile)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{""}, complete.Options{})
|
|
|
|
// Patterns are cut at their first `*`: `wildcard-*` and `wildcard-*-*`
|
|
// collapse into one candidate, and `*-wildcard-*` leaves nothing to insert.
|
|
require.Equal(t, []string{"build", "matches-exactly-", "release-", "start-", "s-", "wildcard-"}, values(suggs))
|
|
// A truncated prefix costs the whole response its trailing space, so task
|
|
// names keep theirs and the wildcard prefix gets one it does not want.
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
// Without a desc, the pattern says what the prefix stands for.
|
|
require.Contains(t, descriptions(suggs), "wildcard-*")
|
|
|
|
suggs, _ = complete.Complete(e, newTestFlagSet(), []string{""}, complete.Options{NoDescriptions: true})
|
|
require.Equal(t, []string{"", "", "", "", "", ""}, descriptions(suggs))
|
|
}
|
|
|
|
func TestComplete_AliasResolvesToTaskVars(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"dep", ""}, complete.Options{})
|
|
require.Equal(t, []string{"ENV=dev", "ENV=staging", "ENV=prod", "REGION="}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoSpace|complete.DirectiveNoFileComp|complete.DirectiveKeepOrder, dir)
|
|
}
|
|
|
|
func TestComplete_StaticEnum(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"deploy", ""}, complete.Options{})
|
|
|
|
require.Equal(t, []string{"ENV=dev", "ENV=staging", "ENV=prod", "REGION="}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoSpace|complete.DirectiveNoFileComp|complete.DirectiveKeepOrder, dir)
|
|
}
|
|
|
|
func TestComplete_EnumRef(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, _ := complete.Complete(e, newTestFlagSet(), []string{"dynenum", ""}, complete.Options{})
|
|
require.Equal(t, []string{"ENV=dev", "ENV=staging", "ENV=prod"}, values(suggs))
|
|
}
|
|
|
|
func TestComplete_FlagValueNotConfusedWithTaskName(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"--dir", "deploy", ""}, complete.Options{})
|
|
require.ElementsMatch(t,
|
|
[]string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"},
|
|
values(suggs),
|
|
)
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_NamespacedTaskName(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"docs:serve", ""}, complete.Options{})
|
|
require.Equal(t, []string{"PORT="}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoSpace|complete.DirectiveNoFileComp|complete.DirectiveKeepOrder, dir)
|
|
}
|
|
|
|
func TestComplete_FlagValueInlineEquals(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"--output="}, complete.Options{})
|
|
// The inline form returns full `--output=value` tokens.
|
|
require.Equal(t, []string{"--output=interleaved", "--output=group", "--output=prefixed"}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_AfterDash(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"deploy", "--", ""}, complete.Options{})
|
|
require.Empty(t, suggs)
|
|
require.Equal(t, complete.DirectiveDefault, dir)
|
|
}
|
|
|
|
func TestComplete_FlagNames(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"-"}, complete.Options{})
|
|
require.NotEmpty(t, suggs)
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
|
|
vals := values(suggs)
|
|
require.Contains(t, vals, "--list-all")
|
|
require.Contains(t, vals, "--taskfile")
|
|
require.Contains(t, vals, "-a")
|
|
}
|
|
|
|
func TestComplete_EnumFlagValue_Output(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"--output", ""}, complete.Options{})
|
|
require.Equal(t, []string{"interleaved", "group", "prefixed"}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_EnumFlagValue_Sort(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, _ := complete.Complete(e, newTestFlagSet(), []string{"--sort", ""}, complete.Options{})
|
|
require.Equal(t, []string{"default", "alphanumeric", "none"}, values(suggs))
|
|
}
|
|
|
|
func TestComplete_PathFlag_Taskfile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"--taskfile", ""}, complete.Options{})
|
|
require.Equal(t, []string{"yml", "yaml"}, values(suggs))
|
|
require.Equal(t, complete.DirectiveFilterFileExt, dir)
|
|
}
|
|
|
|
func TestComplete_PathFlag_Dir(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"--dir", ""}, complete.Options{})
|
|
require.Empty(t, suggs)
|
|
require.Equal(t, complete.DirectiveFilterDirs, dir)
|
|
}
|
|
|
|
func TestComplete_PathFlag_TempDir(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
suggs, dir := complete.Complete(setupExecutor(t), newTestFlagSet(), []string{"--temp-dir", ""}, complete.Options{})
|
|
require.Empty(t, suggs)
|
|
require.Equal(t, complete.DirectiveFilterDirs, dir)
|
|
}
|
|
|
|
func TestComplete_PathFlag_Cacert(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"--cacert", ""}, complete.Options{})
|
|
require.Empty(t, suggs)
|
|
require.Equal(t, complete.DirectiveDefault, dir)
|
|
}
|
|
|
|
func TestComplete_NilExecutor(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
suggs, dir := complete.Complete(nil, newTestFlagSet(), []string{"-"}, complete.Options{})
|
|
require.NotEmpty(t, suggs)
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_NoAliases(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
opts := complete.Options{NoAliases: true}
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{""}, opts)
|
|
|
|
require.ElementsMatch(t,
|
|
[]string{"build", "deploy", "dynenum", "docs:serve"},
|
|
values(suggs),
|
|
)
|
|
require.NotContains(t, values(suggs), "dep")
|
|
require.NotContains(t, values(suggs), "ship")
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_NoDescriptions(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
opts := complete.Options{NoDescriptions: true}
|
|
suggs, _ := complete.Complete(e, newTestFlagSet(), []string{""}, opts)
|
|
|
|
require.ElementsMatch(t,
|
|
[]string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"},
|
|
values(suggs),
|
|
)
|
|
for _, d := range descriptions(suggs) {
|
|
require.Empty(t, d)
|
|
}
|
|
}
|
|
|
|
func TestParseOptions(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("defaults", func(t *testing.T) {
|
|
t.Parallel()
|
|
opts, rest := complete.ParseOptions([]string{"deploy", ""})
|
|
require.Equal(t, complete.Options{}, opts)
|
|
require.Equal(t, []string{"deploy", ""}, rest)
|
|
})
|
|
|
|
t.Run("both flags", func(t *testing.T) {
|
|
t.Parallel()
|
|
opts, rest := complete.ParseOptions([]string{"--no-aliases", "--no-descriptions", "deploy", ""})
|
|
require.True(t, opts.NoAliases)
|
|
require.True(t, opts.NoDescriptions)
|
|
require.Equal(t, []string{"deploy", ""}, rest)
|
|
})
|
|
|
|
t.Run("only leading flags consumed", func(t *testing.T) {
|
|
t.Parallel()
|
|
// A flag appearing after the user's words is left in the command line.
|
|
opts, rest := complete.ParseOptions([]string{"deploy", "--no-aliases"})
|
|
require.False(t, opts.NoAliases)
|
|
require.Equal(t, []string{"deploy", "--no-aliases"}, rest)
|
|
})
|
|
}
|
|
|
|
func TestNeedsTaskfile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := map[string]struct {
|
|
args []string
|
|
want bool
|
|
}{
|
|
"task name": {[]string{""}, true},
|
|
"partial task name": {[]string{"bui"}, true},
|
|
"task var": {[]string{"deploy", ""}, true},
|
|
"value flag then name": {[]string{"--dir", "/tmp", ""}, true},
|
|
"flag name": {[]string{"-"}, false},
|
|
"long flag name": {[]string{"--li"}, false},
|
|
"inline flag value": {[]string{"--output="}, false},
|
|
"flag value": {[]string{"--output", ""}, false},
|
|
"path flag value": {[]string{"--taskfile", ""}, false},
|
|
"after dash": {[]string{"deploy", "--", ""}, false},
|
|
}
|
|
|
|
for name, tt := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Parallel()
|
|
require.Equal(t, tt.want, complete.NeedsTaskfile(tt.args, newTestFlagSet()))
|
|
})
|
|
}
|
|
}
|
|
|
|
// Reading the Taskfile from standard input would block until EOF, freezing the
|
|
// shell on a keystroke.
|
|
func TestNeedsTaskfile_StdinEntrypoint(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fs := newTestFlagSet()
|
|
require.NoError(t, fs.Set("taskfile", "-"))
|
|
require.False(t, complete.NeedsTaskfile([]string{""}, fs))
|
|
require.False(t, complete.NeedsTaskfile([]string{"deploy", ""}, fs))
|
|
}
|
|
|
|
// Keeps the shells the engine offers in step with the scripts the root package
|
|
// can actually serve.
|
|
func TestCompletionShells(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
suggs, dir := complete.Complete(nil, newTestFlagSet(), []string{"--completion", ""}, complete.Options{})
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
require.NotEmpty(t, suggs)
|
|
|
|
for _, shell := range values(suggs) {
|
|
_, err := task.Completion(shell)
|
|
require.NoErrorf(t, err, "--completion offers %q", shell)
|
|
}
|
|
}
|
|
|
|
func TestWrite_Format(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var buf bytes.Buffer
|
|
complete.Write(&buf, []complete.Suggestion{
|
|
{Value: "deploy", Description: "Deploy the app"},
|
|
{Value: "build"},
|
|
}, complete.DirectiveNoSpace|complete.DirectiveNoFileComp)
|
|
require.Equal(t, "deploy\tDeploy the app\nbuild\n:6\n", buf.String())
|
|
}
|
|
|
|
func TestWrite_EmptyWithDirective(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var buf bytes.Buffer
|
|
complete.Write(&buf, nil, complete.DirectiveFilterDirs)
|
|
require.Equal(t, ":16\n", buf.String())
|
|
}
|
|
|
|
// CLI variables are global to the invocation, so once every requirement on the
|
|
// line is met the engine goes back to offering task names.
|
|
func TestComplete_TaskNamesAfterTaskWithoutRequires(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
suggs, dir := complete.Complete(setupExecutor(t), newTestFlagSet(), []string{"build", ""}, complete.Options{})
|
|
|
|
require.Subset(t, values(suggs), []string{"build", "deploy", "docs:serve"})
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_RequiredVarsThenTaskNames(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
fs := newTestFlagSet()
|
|
|
|
suggs, dir := complete.Complete(e, fs, []string{"deploy", ""}, complete.Options{})
|
|
require.Equal(t, []string{"ENV=dev", "ENV=staging", "ENV=prod", "REGION="}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoSpace|complete.DirectiveNoFileComp|complete.DirectiveKeepOrder, dir)
|
|
|
|
suggs, dir = complete.Complete(e, fs, []string{"deploy", "ENV=dev", ""}, complete.Options{})
|
|
require.Equal(t, []string{"REGION="}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoSpace|complete.DirectiveNoFileComp|complete.DirectiveKeepOrder, dir)
|
|
|
|
suggs, dir = complete.Complete(e, fs, []string{"deploy", "ENV=dev", "REGION=eu", ""}, complete.Options{})
|
|
require.Subset(t, values(suggs), []string{"build", "deploy"})
|
|
require.Equal(t, complete.DirectiveNoFileComp, dir)
|
|
}
|
|
|
|
func TestComplete_RequiredVarsUnionAcrossTasks(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
suggs, _ := complete.Complete(e, newTestFlagSet(), []string{"dynenum", "deploy", ""}, complete.Options{})
|
|
|
|
// ENV is required by both and appears once, in the order the line names them.
|
|
require.Equal(t, []string{"ENV=dev", "ENV=staging", "ENV=prod", "REGION="}, values(suggs))
|
|
}
|
|
|
|
func TestComplete_WildcardTaskRequiredVars(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutorWith(t, wildcardTaskfile)
|
|
suggs, dir := complete.Complete(e, newTestFlagSet(), []string{"release-cli", ""}, complete.Options{})
|
|
|
|
require.Equal(t, []string{"CHANNEL=beta", "CHANNEL=stable"}, values(suggs))
|
|
require.Equal(t, complete.DirectiveNoSpace|complete.DirectiveNoFileComp|complete.DirectiveKeepOrder, dir)
|
|
}
|
|
|
|
// flags.WithFlags() applies WithTaskSorter after NewExecutor set its default, so
|
|
// the engine must not assume a sorter is present.
|
|
func TestComplete_DefaultSorterFallback(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutorWith(t, testTaskfile)
|
|
e.Options(task.WithTaskSorter(nil))
|
|
|
|
suggs, _ := complete.Complete(e, newTestFlagSet(), []string{""}, complete.Options{})
|
|
require.Equal(t, []string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"}, values(suggs))
|
|
}
|
|
|
|
func values(suggs []complete.Suggestion) []string {
|
|
return slicesext.Convert(suggs, func(s complete.Suggestion) string { return s.Value })
|
|
}
|
|
|
|
func descriptions(suggs []complete.Suggestion) []string {
|
|
return slicesext.Convert(suggs, func(s complete.Suggestion) string { return s.Description })
|
|
}
|
|
|
|
func TestComplete_StaticRequirementsDoNotCompileTasks(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutorWith(t, `version: '3'
|
|
tasks:
|
|
build:
|
|
cmds:
|
|
- for:
|
|
matrix:
|
|
item: {ref: .MISSING}
|
|
cmd: 'echo {{.ITEM}}'
|
|
deploy:
|
|
aliases: [dep]
|
|
requires:
|
|
vars:
|
|
- name: ENV
|
|
enum: [dev, prod]
|
|
cmds:
|
|
- for:
|
|
matrix:
|
|
env: {ref: 'splitList "," .ENV'}
|
|
cmd: 'echo {{.ITEM.env}}'
|
|
`)
|
|
// Static suggestions must not even need a compiler, regardless of the
|
|
// commands, loops, variables or dotenv files attached to the named task.
|
|
e.Compiler = nil
|
|
fs := newTestFlagSet()
|
|
suggs, _ := complete.Complete(e, fs, []string{"build", ""}, complete.Options{})
|
|
require.Equal(t, []string{"build", "deploy", "dep"}, values(suggs))
|
|
suggs, _ = complete.Complete(e, fs, []string{"dep", ""}, complete.Options{})
|
|
require.Equal(t, []string{"ENV=dev", "ENV=prod"}, values(suggs))
|
|
}
|
|
|
|
func TestComplete_EnumRefUsesCLIGlobals(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutorWith(t, `version: '3'
|
|
vars:
|
|
TARGETS: default
|
|
ENVS: {ref: 'splitList "," .TARGETS'}
|
|
tasks:
|
|
deploy:
|
|
requires:
|
|
vars:
|
|
- name: ENV
|
|
enum: {ref: .ENVS}
|
|
local:
|
|
vars:
|
|
TARGETS: local
|
|
ENVS: {ref: 'splitList "," .TARGETS'}
|
|
requires:
|
|
vars:
|
|
- name: ENV
|
|
enum: {ref: .ENVS}
|
|
'release-*':
|
|
vars:
|
|
ENVS: {ref: 'splitList "," (index .MATCH 0)'}
|
|
requires:
|
|
vars:
|
|
- name: ENV
|
|
enum: {ref: .ENVS}
|
|
`)
|
|
fs := newTestFlagSet()
|
|
for _, tt := range []struct {
|
|
words []string
|
|
want []string
|
|
}{
|
|
{[]string{"TARGETS=ignored", "deploy", "TARGETS=dev,prod", ""}, []string{"ENV=dev", "ENV=prod"}},
|
|
{[]string{"deploy", ""}, []string{"ENV=default"}}, // No mutation between requests.
|
|
{[]string{"TARGETS=dev,prod", "local", ""}, []string{"ENV=local"}},
|
|
{[]string{"release-beta,stable", ""}, []string{"ENV=beta", "ENV=stable"}},
|
|
} {
|
|
suggs, _ := complete.Complete(e, fs, tt.words, complete.Options{})
|
|
require.Equal(t, tt.want, values(suggs))
|
|
}
|
|
}
|
|
|
|
func TestComplete_DescriptionsResolveIndependently(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutorWith(t, `version: '3'
|
|
vars:
|
|
TITLE: default
|
|
DYNAMIC:
|
|
sh: 'exit 1'
|
|
tasks:
|
|
build:
|
|
desc: 'Build {{.TITLE}}'
|
|
aliases: [b]
|
|
cmds:
|
|
- for:
|
|
matrix:
|
|
item: {ref: .MISSING}
|
|
cmd: 'echo {{.ITEM}}'
|
|
broken:
|
|
desc: '{{index .MISSING 0}}'
|
|
static:
|
|
desc: Static
|
|
dir: '{{index .MISSING 0}}'
|
|
`)
|
|
suggs, _ := complete.Complete(e, newTestFlagSet(), []string{"TITLE=custom", ""}, complete.Options{})
|
|
descs := make(map[string]string, len(suggs))
|
|
for _, s := range suggs {
|
|
descs[s.Value] = s.Description
|
|
}
|
|
require.Equal(t, "Build custom", descs["build"])
|
|
require.Equal(t, "Build custom", descs["b"])
|
|
require.Equal(t, "{{index .MISSING 0}}", descs["broken"])
|
|
require.Equal(t, "Static", descs["static"])
|
|
}
|
|
|
|
func TestComplete_FlagContext(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
e := setupExecutor(t)
|
|
fs := newTestFlagSet()
|
|
for _, tt := range []struct {
|
|
name string
|
|
words []string
|
|
want []string
|
|
load bool
|
|
}{
|
|
{"grouped value flag", []string{"-vo", ""}, []string{"interleaved", "group", "prefixed"}, false},
|
|
{"grouped inline value", []string{"-vo=g"}, []string{"-vo=interleaved", "-vo=group", "-vo=prefixed"}, false},
|
|
{"flag-like value", []string{"--dir", "--output", ""}, []string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"}, true},
|
|
{"dash value", []string{"--dir", "--", ""}, []string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"}, true},
|
|
{"grouped prior value", []string{"-vd", "deploy", "build", ""}, []string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"}, true},
|
|
{"attached prior value", []string{"-vddeploy", "build", ""}, []string{"build", "deploy", "dep", "ship", "dynenum", "docs:serve"}, true},
|
|
{"boolean assignment", []string{"-v=false", "deploy", ""}, []string{"ENV=dev", "ENV=staging", "ENV=prod", "REGION="}, true},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
require.Equal(t, tt.load, complete.NeedsTaskfile(tt.words, fs))
|
|
suggs, _ := complete.Complete(e, fs, tt.words, complete.Options{})
|
|
require.Equal(t, tt.want, values(suggs))
|
|
})
|
|
}
|
|
}
|