github.com/pengwynn/gh@v1.0.1-0.20140118055701-14327ca3942e/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  }