// Copyright 2013-2023 The Cobra Authors

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

package cobra

import (

"bytes"

"context"

"fmt"

"os"

"strings"

"sync"

"testing"

)

func validArgsFunc(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {

if len(args) != 0 {

return nil, ShellCompDirectiveNoFileComp

}

var completions []string

for _, comp := range []string{"one\tThe first", "two\tThe second"} {

if strings.HasPrefix(comp, toComplete) {

completions = append(completions, comp)

}

}

return completions, ShellCompDirectiveDefault

}

func validArgsFunc2(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {

if len(args) != 0 {

return nil, ShellCompDirectiveNoFileComp

}

var completions []string

for _, comp := range []string{"three\tThe third", "four\tThe fourth"} {

if strings.HasPrefix(comp, toComplete) {

completions = append(completions, comp)

}

}

return completions, ShellCompDirectiveDefault

}

func TestCmdNameCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

Run: emptyRun,

}

childCmd1 := &Command{

Use: "firstChild",

Short: "First command",

Run: emptyRun,

}

childCmd2 := &Command{

Use: "secondChild",

Run: emptyRun,

}

hiddenCmd := &Command{

Use: "testHidden",

Hidden: true, // Not completed

Run: emptyRun,

}

deprecatedCmd := &Command{

Use: "testDeprecated",

Deprecated: "deprecated", // Not completed

Run: emptyRun,

}

aliasedCmd := &Command{

Use: "aliased",

Short: "A command with aliases",

Aliases: []string{"testAlias", "testSynonym"}, // Not completed

Run: emptyRun,

}

rootCmd.AddCommand(childCmd1, childCmd2, hiddenCmd, deprecatedCmd, aliasedCmd)

// Test that sub-command names are completed

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"aliased",

"completion",

"firstChild",

"help",

"secondChild",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are completed with prefix

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "s")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"secondChild",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that even with no valid sub-command matches, hidden, deprecated and

// aliases are not completed

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "test")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are completed with description

output, err = executeCommand(rootCmd, ShellCompRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"aliased\tA command with aliases",

"completion\tGenerate the autocompletion script for the specified shell",

"firstChild\tFirst command",

"help\tHelp about any command",

"secondChild",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestNoCmdNameCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

Run: emptyRun,

}

rootCmd.Flags().String("localroot", "", "local root flag")

childCmd1 := &Command{

Use: "childCmd1",

Short: "First command",

Args: MinimumNArgs(0),

Run: emptyRun,

}

rootCmd.AddCommand(childCmd1)

childCmd1.PersistentFlags().StringP("persistent", "p", "", "persistent flag")

persistentFlag := childCmd1.PersistentFlags().Lookup("persistent")

childCmd1.Flags().StringP("nonPersistent", "n", "", "non-persistent flag")

nonPersistentFlag := childCmd1.Flags().Lookup("nonPersistent")

childCmd2 := &Command{

Use: "childCmd2",

Run: emptyRun,

}

childCmd1.AddCommand(childCmd2)

// Test that sub-command names are not completed if there is an argument already

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd1", "arg1", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are not completed if a local non-persistent flag is present

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd1", "--nonPersistent", "value", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

nonPersistentFlag.Changed = false

expected = strings.Join([]string{

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are completed if a local non-persistent flag is present and TraverseChildren is set to true

// set TraverseChildren to true on the root cmd

rootCmd.TraverseChildren = true

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--localroot", "value", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset TraverseChildren for next command

rootCmd.TraverseChildren = false

expected = strings.Join([]string{

"childCmd1",

"completion",

"help",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names from a child cmd are completed if a local non-persistent flag is present

// and TraverseChildren is set to true on the root cmd

rootCmd.TraverseChildren = true

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--localroot", "value", "childCmd1", "--nonPersistent", "value", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset TraverseChildren for next command

rootCmd.TraverseChildren = false

// Reset the flag for the next command

nonPersistentFlag.Changed = false

expected = strings.Join([]string{

"childCmd2",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that we don't use Traverse when we shouldn't.

// This command should not return a completion since the command line is invalid without TraverseChildren.

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--localroot", "value", "childCmd1", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are not completed if a local non-persistent short flag is present

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd1", "-n", "value", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

nonPersistentFlag.Changed = false

expected = strings.Join([]string{

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are completed with a persistent flag

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd1", "--persistent", "value", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

persistentFlag.Changed = false

expected = strings.Join([]string{

"childCmd2",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that sub-command names are completed with a persistent short flag

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd1", "-p", "value", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

persistentFlag.Changed = false

expected = strings.Join([]string{

"childCmd2",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestValidArgsCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

ValidArgs: []string{"one", "two", "three"},

Args: MinimumNArgs(1),

}

// Test that validArgs are completed

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"one",

"two",

"three",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that validArgs are completed with prefix

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "o")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"one",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that validArgs don't repeat

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "one", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestValidArgsAndCmdCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

ValidArgs: []string{"one", "two"},

Run: emptyRun,

}

childCmd := &Command{

Use: "thechild",

Run: emptyRun,

}

rootCmd.AddCommand(childCmd)

// Test that both sub-commands and validArgs are completed

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"completion",

"help",

"thechild",

"one",

"two",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that both sub-commands and validArgs are completed with prefix

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "t")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"thechild",

"two",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestValidArgsFuncAndCmdCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

ValidArgsFunction: validArgsFunc,

Run: emptyRun,

}

childCmd := &Command{

Use: "thechild",

Short: "The child command",

Run: emptyRun,

}

rootCmd.AddCommand(childCmd)

// Test that both sub-commands and validArgsFunction are completed

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"completion",

"help",

"thechild",

"one",

"two",

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that both sub-commands and validArgs are completed with prefix

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "t")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"thechild",

"two",

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that both sub-commands and validArgs are completed with description

output, err = executeCommand(rootCmd, ShellCompRequestCmd, "t")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"thechild\tThe child command",

"two\tThe second",

":0",

"Completion ended with directive: ShellCompDirectiveDefault", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestFlagNameCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

Run: emptyRun,

}

childCmd := &Command{

Use: "childCmd",

Version: "1.2.3",

Run: emptyRun,

}

rootCmd.AddCommand(childCmd)

rootCmd.Flags().IntP("first", "f", -1, "first flag")

rootCmd.PersistentFlags().BoolP("second", "s", false, "second flag")

childCmd.Flags().String("subFlag", "", "sub flag")

// Test that flag names are not shown if the user has not given the '-' prefix

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"childCmd",

"completion",

"help",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are completed

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--first",

"-f",

"--help",

"-h",

"--second",

"-s",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are completed when a prefix is given

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--f")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--first",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are completed in a sub-cmd

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd", "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--second",

"-s",

"--help",

"-h",

"--subFlag",

"--version",

"-v",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestFlagNameCompletionInGoWithDesc(t *testing.T) {

rootCmd := &Command{

Use: "root",

Run: emptyRun,

}

childCmd := &Command{

Use: "childCmd",

Short: "first command",

Version: "1.2.3",

Run: emptyRun,

}

rootCmd.AddCommand(childCmd)

rootCmd.Flags().IntP("first", "f", -1, "first flag\nlonger description for flag")

rootCmd.PersistentFlags().BoolP("second", "s", false, "second flag")

childCmd.Flags().String("subFlag", "", "sub flag")

// Test that flag names are not shown if the user has not given the '-' prefix

output, err := executeCommand(rootCmd, ShellCompRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"childCmd\tfirst command",

"completion\tGenerate the autocompletion script for the specified shell",

"help\tHelp about any command",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are completed

output, err = executeCommand(rootCmd, ShellCompRequestCmd, "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--first\tfirst flag",

"-f\tfirst flag",

"--help\thelp for root",

"-h\thelp for root",

"--second\tsecond flag",

"-s\tsecond flag",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are completed when a prefix is given

output, err = executeCommand(rootCmd, ShellCompRequestCmd, "--f")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--first\tfirst flag",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are completed in a sub-cmd

output, err = executeCommand(rootCmd, ShellCompRequestCmd, "childCmd", "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--second\tsecond flag",

"-s\tsecond flag",

"--help\thelp for childCmd",

"-h\thelp for childCmd",

"--subFlag\tsub flag",

"--version\tversion for childCmd",

"-v\tversion for childCmd",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

// customMultiString is a custom Value type that accepts multiple values,

// but does not include "Slice" or "Array" in its "Type" string.

type customMultiString []string

var _ SliceValue = (*customMultiString)(nil)

func (s *customMultiString) String() string {

return fmt.Sprintf("%v", *s)

}

func (s *customMultiString) Set(v string) error {

*s = append(*s, v)

return nil

}

func (s *customMultiString) Type() string {

return "multi string"

}

func (s *customMultiString) GetSlice() []string {

return *s

}

func TestFlagNameCompletionRepeat(t *testing.T) {

rootCmd := &Command{

Use: "root",

Run: emptyRun,

}

childCmd := &Command{

Use: "childCmd",

Short: "first command",

Run: emptyRun,

}

rootCmd.AddCommand(childCmd)

rootCmd.Flags().IntP("first", "f", -1, "first flag")

firstFlag := rootCmd.Flags().Lookup("first")

rootCmd.Flags().BoolP("second", "s", false, "second flag")

secondFlag := rootCmd.Flags().Lookup("second")

rootCmd.Flags().StringArrayP("array", "a", nil, "array flag")

arrayFlag := rootCmd.Flags().Lookup("array")

rootCmd.Flags().IntSliceP("slice", "l", nil, "slice flag")

sliceFlag := rootCmd.Flags().Lookup("slice")

rootCmd.Flags().BoolSliceP("bslice", "b", nil, "bool slice flag")

bsliceFlag := rootCmd.Flags().Lookup("bslice")

rootCmd.Flags().VarP(&customMultiString{}, "multi", "m", "multi string flag")

multiFlag := rootCmd.Flags().Lookup("multi")

// Test that flag names are not repeated unless they are an array or slice

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--first", "1", "--")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

firstFlag.Changed = false

expected := strings.Join([]string{

"--array",

"--bslice",

"--help",

"--multi",

"--second",

"--slice",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are not repeated unless they are an array or slice

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--first", "1", "--second=false", "--")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

firstFlag.Changed = false

secondFlag.Changed = false

expected = strings.Join([]string{

"--array",

"--bslice",

"--help",

"--multi",

"--slice",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are not repeated unless they are an array or slice

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--slice", "1", "--slice=2", "--array", "val", "--bslice", "true", "--multi", "val", "--")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

sliceFlag.Changed = false

arrayFlag.Changed = false

bsliceFlag.Changed = false

multiFlag.Changed = false

expected = strings.Join([]string{

"--array",

"--bslice",

"--first",

"--help",

"--multi",

"--second",

"--slice",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are not repeated unless they are an array or slice, using shortname

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "-l", "1", "-l=2", "-a", "val", "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

sliceFlag.Changed = false

arrayFlag.Changed = false

multiFlag.Changed = false

expected = strings.Join([]string{

"--array",

"-a",

"--bslice",

"-b",

"--first",

"-f",

"--help",

"-h",

"--multi",

"-m",

"--second",

"-s",

"--slice",

"-l",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that flag names are not repeated unless they are an array or slice, using shortname with prefix

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "-l", "1", "-l=2", "-a", "val", "-a")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

sliceFlag.Changed = false

arrayFlag.Changed = false

multiFlag.Changed = false

expected = strings.Join([]string{

"-a",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

}

func TestRequiredFlagNameCompletionInGo(t *testing.T) {

rootCmd := &Command{

Use: "root",

ValidArgs: []string{"realArg"},

Run: emptyRun,

}

childCmd := &Command{

Use: "childCmd",

ValidArgsFunction: func(cmd *Command, args []string, toComplete string) ([]string, ShellCompDirective) {

return []string{"subArg"}, ShellCompDirectiveNoFileComp

},

Run: emptyRun,

}

rootCmd.AddCommand(childCmd)

rootCmd.Flags().IntP("requiredFlag", "r", -1, "required flag")

assertNoErr(t, rootCmd.MarkFlagRequired("requiredFlag"))

requiredFlag := rootCmd.Flags().Lookup("requiredFlag")

rootCmd.PersistentFlags().IntP("requiredPersistent", "p", -1, "required persistent")

assertNoErr(t, rootCmd.MarkPersistentFlagRequired("requiredPersistent"))

requiredPersistent := rootCmd.PersistentFlags().Lookup("requiredPersistent")

rootCmd.Flags().StringP("release", "R", "", "Release name")

childCmd.Flags().BoolP("subRequired", "s", false, "sub required flag")

assertNoErr(t, childCmd.MarkFlagRequired("subRequired"))

childCmd.Flags().BoolP("subNotRequired", "n", false, "sub not required flag")

// Test that a required flag is suggested even without the - prefix

output, err := executeCommand(rootCmd, ShellCompNoDescRequestCmd, "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected := strings.Join([]string{

"childCmd",

"completion",

"help",

"--requiredFlag",

"-r",

"--requiredPersistent",

"-p",

"realArg",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that a required flag is suggested without other flags when using the '-' prefix

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--requiredFlag",

"-r",

"--requiredPersistent",

"-p",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that if no required flag matches, the normal flags are suggested

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--relea")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--release",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test required flags for sub-commands

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--requiredPersistent",

"-p",

"--subRequired",

"-s",

"subArg",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd", "-")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--requiredPersistent",

"-p",

"--subRequired",

"-s",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "childCmd", "--subNot")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

expected = strings.Join([]string{

"--subNotRequired",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that when a required flag is present, it is not suggested anymore

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--requiredFlag", "1", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)

}

// Reset the flag for the next command

requiredFlag.Changed = false

expected = strings.Join([]string{

"--requiredPersistent",

"-p",

"realArg",

":4",

"Completion ended with directive: ShellCompDirectiveNoFileComp", ""}, "\n")

if output != expected {

t.Errorf("expected: %q, got: %q", expected, output)

}

// Test that when a persistent required flag is present, it is not suggested anymore

output, err = executeCommand(rootCmd, ShellCompNoDescRequestCmd, "--requiredPersistent", "1", "")

if err != nil {

t.Errorf("Unexpected error: %v", err)