TUN-813: Clean up cloudflared dependencies

vendor/gopkg.in/urfave/cli.v2/altsrc/flag_test.go

@@ -1,352 +0,0 @@
-package altsrc
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"gopkg.in/urfave/cli.v2"
-)
-
-type testApplyInputSource struct {
-	Flag               FlagInputSourceExtension
-	FlagName           string
-	FlagSetName        string
-	Expected           string
-	ContextValueString string
-	ContextValue       flag.Value
-	EnvVarValue        string
-	EnvVarName         string
-	SourcePath         string
-	MapValue           interface{}
-}
-
-func TestGenericApplyInputSourceValue(t *testing.T) {
-	v := &Parser{"abc", "def"}
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewGenericFlag(&cli.GenericFlag{Name: "test", Value: &Parser{}}),
-		FlagName: "test",
-		MapValue: v,
-	})
-	expect(t, v, c.Generic("test"))
-}
-
-func TestGenericApplyInputSourceMethodContextSet(t *testing.T) {
-	p := &Parser{"abc", "def"}
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewGenericFlag(&cli.GenericFlag{Name: "test", Value: &Parser{}}),
-		FlagName:           "test",
-		MapValue:           &Parser{"efg", "hig"},
-		ContextValueString: p.String(),
-	})
-	expect(t, p, c.Generic("test"))
-}
-
-func TestGenericApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag: NewGenericFlag(&cli.GenericFlag{
-			Name:    "test",
-			Value:   &Parser{},
-			EnvVars: []string{"TEST"},
-		}),
-		FlagName:    "test",
-		MapValue:    &Parser{"efg", "hij"},
-		EnvVarName:  "TEST",
-		EnvVarValue: "abc,def",
-	})
-	expect(t, &Parser{"abc", "def"}, c.Generic("test"))
-}
-
-func TestStringSliceApplyInputSourceValue(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewStringSliceFlag(&cli.StringSliceFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: []interface{}{"hello", "world"},
-	})
-	expect(t, c.StringSlice("test"), []string{"hello", "world"})
-}
-
-func TestStringSliceApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewStringSliceFlag(&cli.StringSliceFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           []interface{}{"hello", "world"},
-		ContextValueString: "ohno",
-	})
-	expect(t, c.StringSlice("test"), []string{"ohno"})
-}
-
-func TestStringSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewStringSliceFlag(&cli.StringSliceFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    []interface{}{"hello", "world"},
-		EnvVarName:  "TEST",
-		EnvVarValue: "oh,no",
-	})
-	expect(t, c.StringSlice("test"), []string{"oh", "no"})
-}
-
-func TestIntSliceApplyInputSourceValue(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewIntSliceFlag(&cli.IntSliceFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: []interface{}{1, 2},
-	})
-	expect(t, c.IntSlice("test"), []int{1, 2})
-}
-
-func TestIntSliceApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewIntSliceFlag(&cli.IntSliceFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           []interface{}{1, 2},
-		ContextValueString: "3",
-	})
-	expect(t, c.IntSlice("test"), []int{3})
-}
-
-func TestIntSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewIntSliceFlag(&cli.IntSliceFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    []interface{}{1, 2},
-		EnvVarName:  "TEST",
-		EnvVarValue: "3,4",
-	})
-	expect(t, c.IntSlice("test"), []int{3, 4})
-}
-
-func TestBoolApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewBoolFlag(&cli.BoolFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: true,
-	})
-	expect(t, true, c.Bool("test"))
-}
-
-func TestBoolApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewBoolFlag(&cli.BoolFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           false,
-		ContextValueString: "true",
-	})
-	expect(t, true, c.Bool("test"))
-}
-
-func TestBoolApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewBoolFlag(&cli.BoolFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    false,
-		EnvVarName:  "TEST",
-		EnvVarValue: "true",
-	})
-	expect(t, true, c.Bool("test"))
-}
-
-func TestStringApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewStringFlag(&cli.StringFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: "hello",
-	})
-	expect(t, "hello", c.String("test"))
-}
-
-func TestStringApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewStringFlag(&cli.StringFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           "hello",
-		ContextValueString: "goodbye",
-	})
-	expect(t, "goodbye", c.String("test"))
-}
-
-func TestStringApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewStringFlag(&cli.StringFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    "hello",
-		EnvVarName:  "TEST",
-		EnvVarValue: "goodbye",
-	})
-	expect(t, "goodbye", c.String("test"))
-}
-func TestPathApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:       NewPathFlag(&cli.PathFlag{Name: "test"}),
-		FlagName:   "test",
-		MapValue:   "hello",
-		SourcePath: "/path/to/source/file",
-	})
-
-	expected := "/path/to/source/hello"
-	if runtime.GOOS == "windows" {
-		expected = `C:\path\to\source\hello`
-	}
-	expect(t, expected, c.String("test"))
-}
-
-func TestPathApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewPathFlag(&cli.PathFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           "hello",
-		ContextValueString: "goodbye",
-		SourcePath:         "/path/to/source/file",
-	})
-	expect(t, "goodbye", c.String("test"))
-}
-
-func TestPathApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewPathFlag(&cli.PathFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    "hello",
-		EnvVarName:  "TEST",
-		EnvVarValue: "goodbye",
-		SourcePath:  "/path/to/source/file",
-	})
-	expect(t, "goodbye", c.String("test"))
-}
-
-func TestIntApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewIntFlag(&cli.IntFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: 15,
-	})
-	expect(t, 15, c.Int("test"))
-}
-
-func TestIntApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewIntFlag(&cli.IntFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           15,
-		ContextValueString: "7",
-	})
-	expect(t, 7, c.Int("test"))
-}
-
-func TestIntApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewIntFlag(&cli.IntFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    15,
-		EnvVarName:  "TEST",
-		EnvVarValue: "12",
-	})
-	expect(t, 12, c.Int("test"))
-}
-
-func TestDurationApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewDurationFlag(&cli.DurationFlag{Name: "test"}),
-		FlagName: "test",
-		MapValue: time.Duration(30 * time.Second),
-	})
-	expect(t, time.Duration(30*time.Second), c.Duration("test"))
-}
-
-func TestDurationApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewDurationFlag(&cli.DurationFlag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           time.Duration(30 * time.Second),
-		ContextValueString: time.Duration(15 * time.Second).String(),
-	})
-	expect(t, time.Duration(15*time.Second), c.Duration("test"))
-}
-
-func TestDurationApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewDurationFlag(&cli.DurationFlag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    time.Duration(30 * time.Second),
-		EnvVarName:  "TEST",
-		EnvVarValue: time.Duration(15 * time.Second).String(),
-	})
-	expect(t, time.Duration(15*time.Second), c.Duration("test"))
-}
-
-func TestFloat64ApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:     NewFloat64Flag(&cli.Float64Flag{Name: "test"}),
-		FlagName: "test",
-		MapValue: 1.3,
-	})
-	expect(t, 1.3, c.Float64("test"))
-}
-
-func TestFloat64ApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:               NewFloat64Flag(&cli.Float64Flag{Name: "test"}),
-		FlagName:           "test",
-		MapValue:           1.3,
-		ContextValueString: fmt.Sprintf("%v", 1.4),
-	})
-	expect(t, 1.4, c.Float64("test"))
-}
-
-func TestFloat64ApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
-		Flag:        NewFloat64Flag(&cli.Float64Flag{Name: "test", EnvVars: []string{"TEST"}}),
-		FlagName:    "test",
-		MapValue:    1.3,
-		EnvVarName:  "TEST",
-		EnvVarValue: fmt.Sprintf("%v", 1.4),
-	})
-	expect(t, 1.4, c.Float64("test"))
-}
-
-func runTest(t *testing.T, test testApplyInputSource) *cli.Context {
-	inputSource := &MapInputSource{
-		file:     test.SourcePath,
-		valueMap: map[interface{}]interface{}{test.FlagName: test.MapValue},
-	}
-	set := flag.NewFlagSet(test.FlagSetName, flag.ContinueOnError)
-	c := cli.NewContext(nil, set, nil)
-	if test.EnvVarName != "" && test.EnvVarValue != "" {
-		os.Setenv(test.EnvVarName, test.EnvVarValue)
-		defer os.Setenv(test.EnvVarName, "")
-	}
-
-	test.Flag.Apply(set)
-	if test.ContextValue != nil {
-		flag := set.Lookup(test.FlagName)
-		flag.Value = test.ContextValue
-	}
-	if test.ContextValueString != "" {
-		set.Set(test.FlagName, test.ContextValueString)
-	}
-	test.Flag.ApplyInputSourceValue(c, inputSource)
-
-	return c
-}
-
-type Parser [2]string
-
-func (p *Parser) Set(value string) error {
-	parts := strings.Split(value, ",")
-	if len(parts) != 2 {
-		return fmt.Errorf("invalid format")
-	}
-
-	(*p)[0] = parts[0]
-	(*p)[1] = parts[1]
-
-	return nil
-}
-
-func (p *Parser) String() string {
-	return fmt.Sprintf("%s,%s", p[0], p[1])
-}

vendor/gopkg.in/urfave/cli.v2/altsrc/helpers_test.go

@@ -1,28 +0,0 @@
-package altsrc
-
-import (
-	"os"
-	"reflect"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-var (
-	wd, _ = os.Getwd()
-)
-
-func expect(t *testing.T, a interface{}, b interface{}) {
-	_, fn, line, _ := runtime.Caller(1)
-	fn = strings.Replace(fn, wd+"/", "", -1)
-
-	if !reflect.DeepEqual(a, b) {
-		t.Errorf("(%s:%d) Expected %v (type %v) - Got %v (type %v)", fn, line, b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if a == b {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}

vendor/gopkg.in/urfave/cli.v2/altsrc/json_command_test.go

@@ -1,324 +0,0 @@
-package altsrc
-
-import (
-	"flag"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"gopkg.in/urfave/cli.v2"
-)
-
-const (
-	fileName   = "current.json"
-	simpleJSON = `{"test": 15}`
-	nestedJSON = `{"top": {"test": 15}}`
-)
-
-func TestCommandJSONFileTest(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, simpleJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileTestGlobalEnvVarWins(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, simpleJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileTestGlobalEnvVarWinsNested(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, nestedJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileTestSpecifiedFlagWins(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, simpleJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"test-cmd", "--load", fileName, "--test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileTestSpecifiedFlagWinsNested(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, nestedJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"test-cmd", "--load", fileName, "--top.test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileTestDefaultValueFileWins(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, simpleJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", Value: 7}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileTestDefaultValueFileWinsNested(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, nestedJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", Value: 7}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileFlagHasDefaultGlobalEnvJSONSetGlobalEnvWins(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, simpleJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", Value: 7, EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandJSONFileFlagHasDefaultGlobalEnvJSONSetGlobalEnvWinsNested(t *testing.T) {
-	cleanup := writeTempFile(t, fileName, nestedJSON)
-	defer cleanup()
-
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", fileName}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", Value: 7, EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewJSONSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func writeTempFile(t *testing.T, name string, content string) func() {
-	if err := ioutil.WriteFile(name, []byte(content), 0666); err != nil {
-		t.Fatalf("cannot write %q: %v", name, err)
-	}
-	return func() {
-		if err := os.Remove(name); err != nil {
-			t.Errorf("cannot remove %q: %v", name, err)
-		}
-	}
-}

vendor/gopkg.in/urfave/cli.v2/altsrc/map_input_source_test.go

@@ -1,25 +0,0 @@
-package altsrc
-
-import (
-	"testing"
-	"time"
-)
-
-func TestMapDuration(t *testing.T) {
-	inputSource := &MapInputSource{
-		file: "test",
-		valueMap: map[interface{}]interface{}{
-			"duration_of_duration_type": time.Minute,
-			"duration_of_string_type":   "1m",
-			"duration_of_int_type":      1000,
-		},
-	}
-	d, err := inputSource.Duration("duration_of_duration_type")
-	expect(t, time.Minute, d)
-	expect(t, nil, err)
-	d, err = inputSource.Duration("duration_of_string_type")
-	expect(t, time.Minute, d)
-	expect(t, nil, err)
-	d, err = inputSource.Duration("duration_of_int_type")
-	refute(t, nil, err)
-}

vendor/gopkg.in/urfave/cli.v2/altsrc/toml_command_test.go

@@ -1,310 +0,0 @@
-// Disabling building of toml support in cases where golang is 1.0 or 1.1
-// as the encoding library is not implemented or supported.
-
-// +build go1.2
-
-package altsrc
-
-import (
-	"flag"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"gopkg.in/urfave/cli.v2"
-)
-
-func TestCommandTomFileTest(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestGlobalEnvVarWins(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestGlobalEnvVarWinsNested(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestSpecifiedFlagWins(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml", "--test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestSpecifiedFlagWinsNested(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte(`[top]
-  test = 15`), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml", "--top.test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestDefaultValueFileWins(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", Value: 7}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileTestDefaultValueFileWinsNested(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", Value: 7}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWins(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("test = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", Value: 7, EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWinsNested(t *testing.T) {
-	app := (&cli.App{})
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666)
-	defer os.Remove("current.toml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.toml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", Value: 7, EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewTomlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}

vendor/gopkg.in/urfave/cli.v2/altsrc/yaml_command_test.go

@@ -1,313 +0,0 @@
-// Disabling building of yaml support in cases where golang is 1.0 or 1.1
-// as the encoding library is not implemented or supported.
-
-// +build go1.2
-
-package altsrc
-
-import (
-	"flag"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"gopkg.in/urfave/cli.v2"
-)
-
-func TestCommandYamlFileTest(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestGlobalEnvVarWins(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestGlobalEnvVarWinsNested(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "10")
-	defer os.Setenv("THE_TEST", "")
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 10)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestSpecifiedFlagWins(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml", "--test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestSpecifiedFlagWinsNested(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml", "--top.test", "7"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 7)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test"}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestDefaultValueFileWins(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", Value: 7}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileTestDefaultValueFileWinsNested(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 15)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", Value: 7}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWins(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "test", Value: 7, EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}
-
-func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWinsNested(t *testing.T) {
-	app := &cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	ioutil.WriteFile("current.yaml", []byte(`top:
-  test: 15`), 0666)
-	defer os.Remove("current.yaml")
-
-	os.Setenv("THE_TEST", "11")
-	defer os.Setenv("THE_TEST", "")
-
-	test := []string{"test-cmd", "--load", "current.yaml"}
-	set.Parse(test)
-
-	c := cli.NewContext(app, set, nil)
-
-	command := &cli.Command{
-		Name:        "test-cmd",
-		Aliases:     []string{"tc"},
-		Usage:       "this is for testing",
-		Description: "testing",
-		Action: func(c *cli.Context) error {
-			val := c.Int("top.test")
-			expect(t, val, 11)
-			return nil
-		},
-		Flags: []cli.Flag{
-			NewIntFlag(&cli.IntFlag{Name: "top.test", Value: 7, EnvVars: []string{"THE_TEST"}}),
-			&cli.StringFlag{Name: "load"}},
-	}
-	command.Before = InitInputSourceWithContext(command.Flags, NewYamlSourceFromFlagFunc("load"))
-	err := command.Run(c)
-
-	expect(t, err, nil)
-}

vendor/gopkg.in/urfave/cli.v2/autocomplete/bash_autocomplete

@@ -1,16 +0,0 @@
-#! /bin/bash
-
-: ${PROG:=$(basename ${BASH_SOURCE})}
-
-_cli_bash_autocomplete() {
-    local cur opts base
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-    return 0
-}
-
-complete -F _cli_bash_autocomplete $PROG
-
-unset PROG

vendor/gopkg.in/urfave/cli.v2/autocomplete/zsh_autocomplete

@@ -1,5 +0,0 @@
-autoload -U compinit && compinit
-autoload -U bashcompinit && bashcompinit
-
-script_dir=$(dirname $0)
-source ${script_dir}/bash_autocomplete

vendor/gopkg.in/urfave/cli.v2/command_test.go

@@ -1,240 +0,0 @@
-package cli
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"strings"
-	"testing"
-)
-
-func TestCommandFlagParsing(t *testing.T) {
-	cases := []struct {
-		testArgs        []string
-		skipFlagParsing bool
-		expectedErr     error
-	}{
-		// Test normal "not ignoring flags" flow
-		{[]string{"test-cmd", "-break", "blah", "blah"}, false, errors.New("flag provided but not defined: -break")},
-
-		{[]string{"test-cmd", "blah", "blah"}, true, nil},   // Test SkipFlagParsing without any args that look like flags
-		{[]string{"test-cmd", "blah", "-break"}, true, nil}, // Test SkipFlagParsing with random flag arg
-		{[]string{"test-cmd", "blah", "-help"}, true, nil},  // Test SkipFlagParsing with "special" help flag arg
-	}
-
-	for _, c := range cases {
-		app := &App{Writer: ioutil.Discard}
-		set := flag.NewFlagSet("test", 0)
-		set.Parse(c.testArgs)
-
-		context := NewContext(app, set, nil)
-
-		command := Command{
-			Name:            "test-cmd",
-			Aliases:         []string{"tc"},
-			Usage:           "this is for testing",
-			Description:     "testing",
-			Action:          func(_ *Context) error { return nil },
-			SkipFlagParsing: c.skipFlagParsing,
-		}
-
-		err := command.Run(context)
-
-		expect(t, err, c.expectedErr)
-		expect(t, context.Args().Slice(), c.testArgs)
-	}
-}
-
-func TestCommand_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "bar",
-				Before: func(c *Context) error {
-					return fmt.Errorf("before error")
-				},
-				After: func(c *Context) error {
-					return fmt.Errorf("after error")
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar"})
-	if err == nil {
-		t.Fatalf("expected to receive error from Run, got none")
-	}
-
-	if !strings.Contains(err.Error(), "before error") {
-		t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
-	}
-	if !strings.Contains(err.Error(), "after error") {
-		t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
-	}
-}
-
-func TestCommand_Run_BeforeSavesMetadata(t *testing.T) {
-	var receivedMsgFromAction string
-	var receivedMsgFromAfter string
-
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "bar",
-				Before: func(c *Context) error {
-					c.App.Metadata["msg"] = "hello world"
-					return nil
-				},
-				Action: func(c *Context) error {
-					msg, ok := c.App.Metadata["msg"]
-					if !ok {
-						return errors.New("msg not found")
-					}
-					receivedMsgFromAction = msg.(string)
-					return nil
-				},
-				After: func(c *Context) error {
-					msg, ok := c.App.Metadata["msg"]
-					if !ok {
-						return errors.New("msg not found")
-					}
-					receivedMsgFromAfter = msg.(string)
-					return nil
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar"})
-	if err != nil {
-		t.Fatalf("expected no error from Run, got %s", err)
-	}
-
-	expectedMsg := "hello world"
-
-	if receivedMsgFromAction != expectedMsg {
-		t.Fatalf("expected msg from Action to match. Given: %q\nExpected: %q",
-			receivedMsgFromAction, expectedMsg)
-	}
-	if receivedMsgFromAfter != expectedMsg {
-		t.Fatalf("expected msg from After to match. Given: %q\nExpected: %q",
-			receivedMsgFromAction, expectedMsg)
-	}
-}
-
-func TestCommand_OnUsageError_hasCommandContext(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "bar",
-				Flags: []Flag{
-					&IntFlag{Name: "flag"},
-				},
-				OnUsageError: func(c *Context, err error, _ bool) error {
-					return fmt.Errorf("intercepted in %s: %s", c.Command.Name, err.Error())
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar", "--flag=wrong"})
-	if err == nil {
-		t.Fatalf("expected to receive error from Run, got none")
-	}
-
-	if !strings.HasPrefix(err.Error(), "intercepted in bar") {
-		t.Errorf("Expect an intercepted error, but got \"%v\"", err)
-	}
-}
-
-func TestCommand_OnUsageError_WithWrongFlagValue(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "bar",
-				Flags: []Flag{
-					&IntFlag{Name: "flag"},
-				},
-				OnUsageError: func(c *Context, err error, _ bool) error {
-					if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
-						t.Errorf("Expect an invalid value error, but got \"%v\"", err)
-					}
-					return errors.New("intercepted: " + err.Error())
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar", "--flag=wrong"})
-	if err == nil {
-		t.Fatalf("expected to receive error from Run, got none")
-	}
-
-	if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
-		t.Errorf("Expect an intercepted error, but got \"%v\"", err)
-	}
-}
-
-func TestCommand_OnUsageError_WithSubcommand(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "bar",
-				Subcommands: []*Command{
-					{
-						Name: "baz",
-					},
-				},
-				Flags: []Flag{
-					&IntFlag{Name: "flag"},
-				},
-				OnUsageError: func(c *Context, err error, _ bool) error {
-					if !strings.HasPrefix(err.Error(), "invalid value \"wrong\"") {
-						t.Errorf("Expect an invalid value error, but got \"%v\"", err)
-					}
-					return errors.New("intercepted: " + err.Error())
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar", "--flag=wrong"})
-	if err == nil {
-		t.Fatalf("expected to receive error from Run, got none")
-	}
-
-	if !strings.HasPrefix(err.Error(), "intercepted: invalid value") {
-		t.Errorf("Expect an intercepted error, but got \"%v\"", err)
-	}
-}
-
-func TestCommand_Run_SubcommandsCanUseErrWriter(t *testing.T) {
-	app := &App{
-		ErrWriter: ioutil.Discard,
-		Commands: []*Command{
-			{
-				Name:  "bar",
-				Usage: "this is for testing",
-				Subcommands: []*Command{
-					{
-						Name:  "baz",
-						Usage: "this is for testing",
-						Action: func(c *Context) error {
-							if c.App.ErrWriter != ioutil.Discard {
-								return fmt.Errorf("ErrWriter not passed")
-							}
-
-							return nil
-						},
-					},
-				},
-			},
-		},
-	}
-
-	err := app.Run([]string{"foo", "bar", "baz"})
-	if err != nil {
-		t.Fatal(err)
-	}
-}

vendor/gopkg.in/urfave/cli.v2/context_test.go

@@ -1,264 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"sort"
-	"testing"
-	"time"
-)
-
-func TestNewContext(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	set.Int64("myflagInt64", int64(12), "doc")
-	set.Uint("myflagUint", uint(93), "doc")
-	set.Uint64("myflagUint64", uint64(93), "doc")
-	set.Float64("myflag64", float64(17), "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Int("myflag", 42, "doc")
-	globalSet.Int64("myflagInt64", int64(42), "doc")
-	globalSet.Uint("myflagUint", uint(33), "doc")
-	globalSet.Uint64("myflagUint64", uint64(33), "doc")
-	globalSet.Float64("myflag64", float64(47), "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-	command := &Command{Name: "mycommand"}
-	c := NewContext(nil, set, globalCtx)
-	c.Command = command
-	expect(t, c.Int("myflag"), 12)
-	expect(t, c.Int64("myflagInt64"), int64(12))
-	expect(t, c.Uint("myflagUint"), uint(93))
-	expect(t, c.Uint64("myflagUint64"), uint64(93))
-	expect(t, c.Float64("myflag64"), float64(17))
-	expect(t, c.Command.Name, "mycommand")
-}
-
-func TestContext_Int(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("myflag", 12, "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Int("top-flag", 13, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Int("myflag"), 12)
-	expect(t, c.Int("top-flag"), 13)
-}
-
-func TestContext_Int64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int64("myflagInt64", 12, "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Int64("top-flag", 13, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Int64("myflagInt64"), int64(12))
-	expect(t, c.Int64("top-flag"), int64(13))
-}
-
-func TestContext_Uint(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Uint("myflagUint", uint(13), "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Uint("top-flag", uint(14), "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Uint("myflagUint"), uint(13))
-	expect(t, c.Uint("top-flag"), uint(14))
-}
-
-func TestContext_Uint64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Uint64("myflagUint64", uint64(9), "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Uint64("top-flag", uint64(10), "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Uint64("myflagUint64"), uint64(9))
-	expect(t, c.Uint64("top-flag"), uint64(10))
-}
-
-func TestContext_Float64(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Float64("myflag", float64(17), "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Float64("top-flag", float64(18), "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Float64("myflag"), float64(17))
-	expect(t, c.Float64("top-flag"), float64(18))
-}
-
-func TestContext_Duration(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Duration("myflag", 12*time.Second, "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Duration("top-flag", 13*time.Second, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Duration("myflag"), 12*time.Second)
-	expect(t, c.Duration("top-flag"), 13*time.Second)
-}
-
-func TestContext_String(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.String("myflag", "hello world", "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.String("top-flag", "hai veld", "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.String("myflag"), "hello world")
-	expect(t, c.String("top-flag"), "hai veld")
-}
-
-func TestContext_Path(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.String("path", "path/to/file", "path to file")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.String("top-path", "path/to/top/file", "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Path("path"), "path/to/file")
-	expect(t, c.Path("top-path"), "path/to/top/file")
-}
-
-func TestContext_Bool(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Bool("top-flag", true, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	c := NewContext(nil, set, parentCtx)
-	expect(t, c.Bool("myflag"), false)
-	expect(t, c.Bool("top-flag"), true)
-}
-
-func TestContext_Args(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := NewContext(nil, set, nil)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	expect(t, c.Args().Len(), 2)
-	expect(t, c.Bool("myflag"), true)
-}
-
-func TestContext_NArg(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	c := NewContext(nil, set, nil)
-	set.Parse([]string{"--myflag", "bat", "baz"})
-	expect(t, c.NArg(), 2)
-}
-
-func TestContext_IsSet(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("one-flag", false, "doc")
-	set.Bool("two-flag", false, "doc")
-	set.String("three-flag", "hello world", "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Bool("top-flag", true, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	ctx := NewContext(nil, set, parentCtx)
-
-	set.Parse([]string{"--one-flag", "--two-flag", "--three-flag", "frob"})
-	parentSet.Parse([]string{"--top-flag"})
-
-	expect(t, ctx.IsSet("one-flag"), true)
-	expect(t, ctx.IsSet("two-flag"), true)
-	expect(t, ctx.IsSet("three-flag"), true)
-	expect(t, ctx.IsSet("top-flag"), true)
-	expect(t, ctx.IsSet("bogus"), false)
-}
-
-func TestContext_NumFlags(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("myflag", false, "doc")
-	set.String("otherflag", "hello world", "doc")
-	globalSet := flag.NewFlagSet("test", 0)
-	globalSet.Bool("myflagGlobal", true, "doc")
-	globalCtx := NewContext(nil, globalSet, nil)
-	c := NewContext(nil, set, globalCtx)
-	set.Parse([]string{"--myflag", "--otherflag=foo"})
-	globalSet.Parse([]string{"--myflagGlobal"})
-	expect(t, c.NumFlags(), 2)
-}
-
-func TestContext_Set(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Int("int", 5, "an int")
-	c := NewContext(nil, set, nil)
-
-	expect(t, c.IsSet("int"), false)
-	c.Set("int", "1")
-	expect(t, c.Int("int"), 1)
-	expect(t, c.IsSet("int"), true)
-}
-
-func TestContext_LocalFlagNames(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("one-flag", false, "doc")
-	set.String("two-flag", "hello world", "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Bool("top-flag", true, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	ctx := NewContext(nil, set, parentCtx)
-	set.Parse([]string{"--one-flag", "--two-flag=foo"})
-	parentSet.Parse([]string{"--top-flag"})
-
-	actualFlags := ctx.LocalFlagNames()
-	sort.Strings(actualFlags)
-
-	expect(t, actualFlags, []string{"one-flag", "two-flag"})
-}
-
-func TestContext_FlagNames(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("one-flag", false, "doc")
-	set.String("two-flag", "hello world", "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Bool("top-flag", true, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	ctx := NewContext(nil, set, parentCtx)
-	set.Parse([]string{"--one-flag", "--two-flag=foo"})
-	parentSet.Parse([]string{"--top-flag"})
-
-	actualFlags := ctx.FlagNames()
-	sort.Strings(actualFlags)
-
-	expect(t, actualFlags, []string{"one-flag", "top-flag", "two-flag"})
-}
-
-func TestContext_Lineage(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("local-flag", false, "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Bool("top-flag", true, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	ctx := NewContext(nil, set, parentCtx)
-	set.Parse([]string{"--local-flag"})
-	parentSet.Parse([]string{"--top-flag"})
-
-	lineage := ctx.Lineage()
-	expect(t, len(lineage), 2)
-	expect(t, lineage[0], ctx)
-	expect(t, lineage[1], parentCtx)
-}
-
-func TestContext_lookupFlagSet(t *testing.T) {
-	set := flag.NewFlagSet("test", 0)
-	set.Bool("local-flag", false, "doc")
-	parentSet := flag.NewFlagSet("test", 0)
-	parentSet.Bool("top-flag", true, "doc")
-	parentCtx := NewContext(nil, parentSet, nil)
-	ctx := NewContext(nil, set, parentCtx)
-	set.Parse([]string{"--local-flag"})
-	parentSet.Parse([]string{"--top-flag"})
-
-	fs := lookupFlagSet("top-flag", ctx)
-	expect(t, fs, parentCtx.flagSet)
-
-	fs = lookupFlagSet("local-flag", ctx)
-	expect(t, fs, ctx.flagSet)
-
-	if fs := lookupFlagSet("frob", ctx); fs != nil {
-		t.Fail()
-	}
-}

vendor/gopkg.in/urfave/cli.v2/errors_test.go

@@ -1,122 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"testing"
-)
-
-func TestHandleExitCoder_nil(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	HandleExitCoder(nil)
-
-	expect(t, exitCode, 0)
-	expect(t, called, false)
-}
-
-func TestHandleExitCoder_ExitCoder(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	HandleExitCoder(Exit("galactic perimeter breach", 9))
-
-	expect(t, exitCode, 9)
-	expect(t, called, true)
-}
-
-func TestHandleExitCoder_MultiErrorWithExitCoder(t *testing.T) {
-	exitCode := 0
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			exitCode = rc
-			called = true
-		}
-	}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	exitErr := Exit("galactic perimeter breach", 9)
-	exitErr2 := Exit("last ExitCoder", 11)
-	err := newMultiError(errors.New("wowsa"), errors.New("egad"), exitErr, exitErr2)
-	HandleExitCoder(err)
-
-	expect(t, exitCode, 11)
-	expect(t, called, true)
-}
-
-// make a stub to not import pkg/errors
-type ErrorWithFormat struct {
-	error
-}
-
-func NewErrorWithFormat(m string) *ErrorWithFormat {
-	return &ErrorWithFormat{error: errors.New(m)}
-}
-
-func (f *ErrorWithFormat) Format(s fmt.State, verb rune) {
-	fmt.Fprintf(s, "This the format: %v", f.error)
-}
-
-func TestHandleExitCoder_ErrorWithFormat(t *testing.T) {
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			called = true
-		}
-	}
-	ErrWriter = &bytes.Buffer{}
-
-	defer func() {
-		OsExiter = fakeOsExiter
-		ErrWriter = fakeErrWriter
-	}()
-
-	err := Exit(NewErrorWithFormat("I am formatted"), 1)
-	HandleExitCoder(err)
-
-	expect(t, called, true)
-	expect(t, ErrWriter.(*bytes.Buffer).String(), "This the format: I am formatted\n")
-}
-
-func TestHandleExitCoder_MultiErrorWithFormat(t *testing.T) {
-	called := false
-
-	OsExiter = func(rc int) {
-		if !called {
-			called = true
-		}
-	}
-	ErrWriter = &bytes.Buffer{}
-
-	defer func() { OsExiter = fakeOsExiter }()
-
-	err := newMultiError(NewErrorWithFormat("err1"), NewErrorWithFormat("err2"))
-	HandleExitCoder(err)
-
-	expect(t, called, true)
-	expect(t, ErrWriter.(*bytes.Buffer).String(), "This the format: err1\nThis the format: err2\n")
-}

vendor/gopkg.in/urfave/cli.v2/help_test.go

@@ -1,451 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func Test_ShowAppHelp_NoAuthor(t *testing.T) {
-	output := new(bytes.Buffer)
-	app := &App{Writer: output}
-
-	c := NewContext(app, nil, nil)
-
-	ShowAppHelp(c)
-
-	if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 {
-		t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):")
-	}
-}
-
-func Test_ShowAppHelp_NoVersion(t *testing.T) {
-	output := new(bytes.Buffer)
-	app := &App{Writer: output}
-
-	app.Version = ""
-
-	c := NewContext(app, nil, nil)
-
-	ShowAppHelp(c)
-
-	if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
-		t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
-	}
-}
-
-func Test_ShowAppHelp_HideVersion(t *testing.T) {
-	output := new(bytes.Buffer)
-	app := &App{Writer: output}
-
-	app.HideVersion = true
-
-	c := NewContext(app, nil, nil)
-
-	ShowAppHelp(c)
-
-	if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
-		t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
-	}
-}
-
-func Test_Help_Custom_Flags(t *testing.T) {
-	oldFlag := HelpFlag
-	defer func() {
-		HelpFlag = oldFlag
-	}()
-
-	HelpFlag = &BoolFlag{
-		Name:    "help",
-		Aliases: []string{"x"},
-		Usage:   "show help",
-	}
-
-	app := App{
-		Flags: []Flag{
-			&BoolFlag{Name: "foo", Aliases: []string{"h"}},
-		},
-		Action: func(ctx *Context) error {
-			if ctx.Bool("h") != true {
-				t.Errorf("custom help flag not set")
-			}
-			return nil
-		},
-	}
-	output := new(bytes.Buffer)
-	app.Writer = output
-	app.Run([]string{"test", "-h"})
-	if output.Len() > 0 {
-		t.Errorf("unexpected output: %s", output.String())
-	}
-}
-
-func Test_Version_Custom_Flags(t *testing.T) {
-	oldFlag := VersionFlag
-	defer func() {
-		VersionFlag = oldFlag
-	}()
-
-	VersionFlag = &BoolFlag{
-		Name:    "version",
-		Aliases: []string{"V"},
-		Usage:   "show version",
-	}
-
-	app := App{
-		Flags: []Flag{
-			&BoolFlag{Name: "foo", Aliases: []string{"v"}},
-		},
-		Action: func(ctx *Context) error {
-			if ctx.Bool("v") != true {
-				t.Errorf("custom version flag not set")
-			}
-			return nil
-		},
-	}
-	output := new(bytes.Buffer)
-	app.Writer = output
-	app.Run([]string{"test", "-v"})
-	if output.Len() > 0 {
-		t.Errorf("unexpected output: %s", output.String())
-	}
-}
-
-func Test_helpCommand_Action_ErrorIfNoTopic(t *testing.T) {
-	app := &App{}
-
-	set := flag.NewFlagSet("test", 0)
-	set.Parse([]string{"foo"})
-
-	c := NewContext(app, set, nil)
-
-	err := helpCommand.Action(c)
-
-	if err == nil {
-		t.Fatalf("expected error from helpCommand.Action(), but got nil")
-	}
-
-	exitErr, ok := err.(*exitError)
-	if !ok {
-		t.Fatalf("expected *exitError from helpCommand.Action(), but instead got: %v", err.Error())
-	}
-
-	if !strings.HasPrefix(exitErr.Error(), "No help topic for") {
-		t.Fatalf("expected an unknown help topic error, but got: %v", exitErr.Error())
-	}
-
-	if exitErr.exitCode != 3 {
-		t.Fatalf("expected exit value = 3, got %d instead", exitErr.exitCode)
-	}
-}
-
-func Test_helpCommand_InHelpOutput(t *testing.T) {
-	app := &App{}
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"test", "--help"})
-
-	s := output.String()
-
-	if strings.Contains(s, "\nCOMMANDS:\nGLOBAL OPTIONS:\n") {
-		t.Fatalf("empty COMMANDS section detected: %q", s)
-	}
-
-	if !strings.Contains(s, "help, h") {
-		t.Fatalf("missing \"help, h\": %q", s)
-	}
-}
-
-func Test_helpSubcommand_Action_ErrorIfNoTopic(t *testing.T) {
-	app := &App{}
-
-	set := flag.NewFlagSet("test", 0)
-	set.Parse([]string{"foo"})
-
-	c := NewContext(app, set, nil)
-
-	err := helpSubcommand.Action(c)
-
-	if err == nil {
-		t.Fatalf("expected error from helpCommand.Action(), but got nil")
-	}
-
-	exitErr, ok := err.(*exitError)
-	if !ok {
-		t.Fatalf("expected *exitError from helpCommand.Action(), but instead got: %v", err.Error())
-	}
-
-	if !strings.HasPrefix(exitErr.Error(), "No help topic for") {
-		t.Fatalf("expected an unknown help topic error, but got: %v", exitErr.Error())
-	}
-
-	if exitErr.exitCode != 3 {
-		t.Fatalf("expected exit value = 3, got %d instead", exitErr.exitCode)
-	}
-}
-
-func TestShowAppHelp_CommandAliases(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name:    "frobbly",
-				Aliases: []string{"fr", "frob"},
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "--help"})
-
-	if !strings.Contains(output.String(), "frobbly, fr, frob") {
-		t.Errorf("expected output to include all command aliases; got: %q", output.String())
-	}
-}
-
-func TestShowCommandHelp_CommandAliases(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name:    "frobbly",
-				Aliases: []string{"fr", "frob", "bork"},
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "help", "fr"})
-
-	if !strings.Contains(output.String(), "frobbly") {
-		t.Errorf("expected output to include command name; got: %q", output.String())
-	}
-
-	if strings.Contains(output.String(), "bork") {
-		t.Errorf("expected output to exclude command aliases; got: %q", output.String())
-	}
-}
-
-func TestShowSubcommandHelp_CommandAliases(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name:    "frobbly",
-				Aliases: []string{"fr", "frob", "bork"},
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "help"})
-
-	if !strings.Contains(output.String(), "frobbly, fr, frob, bork") {
-		t.Errorf("expected output to include all command aliases; got: %q", output.String())
-	}
-}
-
-func TestShowCommandHelp_Customtemplate(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "frobbly",
-				Action: func(ctx *Context) error {
-					return nil
-				},
-				HelpName: "foo frobbly",
-				CustomHelpTemplate: `NAME:
-   {{.HelpName}} - {{.Usage}}
-
-USAGE:
-   {{.HelpName}} [FLAGS] TARGET [TARGET ...]
-
-FLAGS:
-  {{range .VisibleFlags}}{{.}}
-  {{end}}
-EXAMPLES:
-   1. Frobbly runs with this param locally.
-      $ {{.HelpName}} wobbly
-`,
-			},
-		},
-	}
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "help", "frobbly"})
-
-	if strings.Contains(output.String(), "2. Frobbly runs without this param locally.") {
-		t.Errorf("expected output to exclude \"2. Frobbly runs without this param locally.\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "1. Frobbly runs with this param locally.") {
-		t.Errorf("expected output to include \"1. Frobbly runs with this param locally.\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "$ foo frobbly wobbly") {
-		t.Errorf("expected output to include \"$ foo frobbly wobbly\"; got: %q", output.String())
-	}
-}
-
-func TestShowSubcommandHelp_CommandUsageText(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name:      "frobbly",
-				UsageText: "this is usage text",
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-
-	app.Run([]string{"foo", "frobbly", "--help"})
-
-	if !strings.Contains(output.String(), "this is usage text") {
-		t.Errorf("expected output to include usage text; got: %q", output.String())
-	}
-}
-
-func TestShowSubcommandHelp_SubcommandUsageText(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "frobbly",
-				Subcommands: []*Command{
-					{
-						Name:      "bobbly",
-						UsageText: "this is usage text",
-					},
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"foo", "frobbly", "bobbly", "--help"})
-
-	if !strings.Contains(output.String(), "this is usage text") {
-		t.Errorf("expected output to include usage text; got: %q", output.String())
-	}
-}
-
-func TestShowAppHelp_HiddenCommand(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "frobbly",
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-			{
-				Name:   "secretfrob",
-				Hidden: true,
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"app", "--help"})
-
-	if strings.Contains(output.String(), "secretfrob") {
-		t.Errorf("expected output to exclude \"secretfrob\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "frobbly") {
-		t.Errorf("expected output to include \"frobbly\"; got: %q", output.String())
-	}
-}
-
-func TestShowAppHelp_CustomAppTemplate(t *testing.T) {
-	app := &App{
-		Commands: []*Command{
-			{
-				Name: "frobbly",
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-			{
-				Name:   "secretfrob",
-				Hidden: true,
-				Action: func(ctx *Context) error {
-					return nil
-				},
-			},
-		},
-		ExtraInfo: func() map[string]string {
-			platform := fmt.Sprintf("OS: %s | Arch: %s", runtime.GOOS, runtime.GOARCH)
-			goruntime := fmt.Sprintf("Version: %s | CPUs: %d", runtime.Version(), runtime.NumCPU())
-			return map[string]string{
-				"PLATFORM": platform,
-				"RUNTIME":  goruntime,
-			}
-		},
-		CustomAppHelpTemplate: `NAME:
-  {{.Name}} - {{.Usage}}
-
-USAGE:
-  {{.Name}} {{if .VisibleFlags}}[FLAGS] {{end}}COMMAND{{if .VisibleFlags}} [COMMAND FLAGS | -h]{{end}} [ARGUMENTS...]
-
-COMMANDS:
-  {{range .VisibleCommands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-  {{end}}{{if .VisibleFlags}}
-GLOBAL FLAGS:
-  {{range .VisibleFlags}}{{.}}
-  {{end}}{{end}}
-VERSION:
-  2.0.0
-{{"\n"}}{{range $key, $value := ExtraInfo}}
-{{$key}}:
-  {{$value}}
-{{end}}`,
-	}
-
-	output := &bytes.Buffer{}
-	app.Writer = output
-	app.Run([]string{"app", "--help"})
-
-	if strings.Contains(output.String(), "secretfrob") {
-		t.Errorf("expected output to exclude \"secretfrob\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "frobbly") {
-		t.Errorf("expected output to include \"frobbly\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "PLATFORM:") ||
-		!strings.Contains(output.String(), "OS:") ||
-		!strings.Contains(output.String(), "Arch:") {
-		t.Errorf("expected output to include \"PLATFORM:, OS: and Arch:\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "RUNTIME:") ||
-		!strings.Contains(output.String(), "Version:") ||
-		!strings.Contains(output.String(), "CPUs:") {
-		t.Errorf("expected output to include \"RUNTIME:, Version: and CPUs:\"; got: %q", output.String())
-	}
-
-	if !strings.Contains(output.String(), "VERSION:") ||
-		!strings.Contains(output.String(), "2.0.0") {
-		t.Errorf("expected output to include \"VERSION:, 2.0.0\"; got: %q", output.String())
-	}
-}

vendor/gopkg.in/urfave/cli.v2/helpers_test.go

@@ -1,32 +0,0 @@
-package cli
-
-import (
-	"os"
-	"reflect"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-var (
-	wd, _ = os.Getwd()
-)
-
-func init() {
-	os.Setenv("CLI_TEMPLATE_REPANIC", "1")
-}
-
-func expect(t *testing.T, a interface{}, b interface{}) {
-	_, fn, line, _ := runtime.Caller(1)
-	fn = strings.Replace(fn, wd+"/", "", -1)
-
-	if !reflect.DeepEqual(a, b) {
-		t.Errorf("(%s:%d) Expected %v (type %v) - Got %v (type %v)", fn, line, b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}
-
-func refute(t *testing.T, a interface{}, b interface{}) {
-	if reflect.DeepEqual(a, b) {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
-	}
-}

vendor/gopkg.in/urfave/cli.v2/helpers_unix_test.go

@@ -1,9 +0,0 @@
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package cli
-
-import "os"
-
-func clearenv() {
-	os.Clearenv()
-}

vendor/gopkg.in/urfave/cli.v2/helpers_windows_test.go

@@ -1,20 +0,0 @@
-package cli
-
-import (
-	"os"
-	"syscall"
-)
-
-// os.Clearenv() doesn't actually unset variables on Windows
-// See: https://github.com/golang/go/issues/17902
-func clearenv() {
-	for _, s := range os.Environ() {
-		for j := 1; j < len(s); j++ {
-			if s[j] == '=' {
-				keyp, _ := syscall.UTF16PtrFromString(s[0:j])
-				syscall.SetEnvironmentVariable(keyp, nil)
-				break
-			}
-		}
-	}
-}