github.com/trevoraustin/hub@v2.2.0-preview1.0.20141105230840-96d8bfc654cc+incompatible/commands/commands_test.go (about) 1 package commands 2 3 import ( 4 "github.com/bmizerany/assert" 5 "testing" 6 ) 7 8 func TestCommandUseSelf(t *testing.T) { 9 c := &Command{Usage: "foo"} 10 11 args := NewArgs([]string{"foo"}) 12 13 run, err := lookupCommand(c, args) 14 15 assert.Equal(t, nil, err) 16 assert.Equal(t, c, run) 17 } 18 19 func TestCommandUseSubcommand(t *testing.T) { 20 c := &Command{Usage: "foo"} 21 s := &Command{Usage: "bar"} 22 c.Use(s) 23 24 args := NewArgs([]string{"foo", "bar"}) 25 26 run, err := lookupCommand(c, args) 27 28 assert.Equal(t, nil, err) 29 assert.Equal(t, s, run) 30 } 31 32 func TestCommandUseErrorWhenMissingSubcommand(t *testing.T) { 33 c := &Command{Usage: "foo"} 34 s := &Command{Usage: "bar"} 35 c.Use(s) 36 37 args := NewArgs([]string{"foo", "baz"}) 38 39 _, err := lookupCommand(c, args) 40 41 assert.NotEqual(t, nil, err) 42 } 43 44 func TestArgsForCommand(t *testing.T) { 45 c := &Command{Usage: "foo"} 46 47 args := NewArgs([]string{"foo", "bar", "baz"}) 48 49 lookupCommand(c, args) 50 51 assert.Equal(t, 2, len(args.Params)) 52 } 53 54 func TestArgsForSubCommand(t *testing.T) { 55 c := &Command{Usage: "foo"} 56 s := &Command{Usage: "bar"} 57 c.Use(s) 58 59 args := NewArgs([]string{"foo", "bar", "baz"}) 60 61 lookupCommand(c, args) 62 63 assert.Equal(t, 1, len(args.Params)) 64 } 65 66 func TestFlagsAfterArguments(t *testing.T) { 67 c := &Command{Usage: "foo -m MESSAGE ARG1"} 68 69 var flag string 70 c.Flag.StringVarP(&flag, "message", "m", "", "MESSAGE") 71 72 args := NewArgs([]string{"foo", "bar", "-m", "baz"}) 73 74 c.parseArguments(args) 75 assert.Equal(t, "baz", flag) 76 77 assert.Equal(t, 1, len(args.Params)) 78 assert.Equal(t, "bar", args.LastParam()) 79 } 80 81 func TestCommandUsageSubCommands(t *testing.T) { 82 f1 := func(c *Command, args *Args) {} 83 f2 := func(c *Command, args *Args) {} 84 85 c := &Command{Usage: "foo", Run: f1} 86 s := &Command{Key: "bar", Usage: "foo bar", Run: f2} 87 c.Use(s) 88 89 usage := c.subCommandsUsage() 90 91 expected := `usage: git foo 92 or: git foo bar 93 ` 94 assert.Equal(t, expected, usage) 95 } 96 97 func TestCommandUsageSubCommandsPrintOnlyRunnables(t *testing.T) { 98 f1 := func(c *Command, args *Args) {} 99 100 c := &Command{Usage: "foo"} 101 s := &Command{Key: "bar", Usage: "foo bar", Run: f1} 102 c.Use(s) 103 104 usage := c.subCommandsUsage() 105 106 expected := `usage: git foo bar 107 ` 108 assert.Equal(t, expected, usage) 109 } 110 111 func TestCommandNameTakeUsage(t *testing.T) { 112 c := &Command{Usage: "foo -t -v --foo"} 113 assert.Equal(t, "foo", c.Name()) 114 } 115 116 func TestCommandNameTakeKey(t *testing.T) { 117 c := &Command{Key: "bar", Usage: "foo -t -v --foo"} 118 assert.Equal(t, "bar", c.Name()) 119 } 120 121 func TestCommandCall(t *testing.T) { 122 var result string 123 f := func(c *Command, args *Args) { result = args.FirstParam() } 124 125 c := &Command{Usage: "foo", Run: f} 126 args := NewArgs([]string{"foo", "bar"}) 127 128 c.Call(args) 129 assert.Equal(t, "bar", result) 130 } 131 132 func TestCommandHelp(t *testing.T) { 133 var result string 134 f := func(c *Command, args *Args) { result = args.FirstParam() } 135 c := &Command{Usage: "foo", Run: f} 136 args := NewArgs([]string{"foo", "-h"}) 137 138 c.Call(args) 139 assert.Equal(t, "", result) 140 } 141 142 func TestSubCommandCall(t *testing.T) { 143 var result string 144 f1 := func(c *Command, args *Args) { result = "noop" } 145 f2 := func(c *Command, args *Args) { result = args.LastParam() } 146 147 c := &Command{Usage: "foo", Run: f1} 148 s := &Command{Key: "bar", Usage: "foo bar", Run: f2} 149 c.Use(s) 150 151 args := NewArgs([]string{"foo", "bar", "baz"}) 152 153 c.Call(args) 154 assert.Equal(t, "baz", result) 155 } 156 157 func TestSubCommandsUsage(t *testing.T) { 158 // with subcommand 159 f1 := func(c *Command, args *Args) {} 160 f2 := func(c *Command, args *Args) {} 161 162 c := &Command{Usage: "foo", Run: f1} 163 s := &Command{Key: "bar", Usage: "foo bar", Run: f2} 164 c.Use(s) 165 166 usage := c.subCommandsUsage() 167 assert.Equal(t, "usage: git foo\n or: git foo bar\n", usage) 168 169 // no subcommand 170 cc := &Command{Usage: "foo", Run: f1} 171 172 usage = cc.subCommandsUsage() 173 assert.Equal(t, "usage: git foo\n", usage) 174 }