1package commands
2
3import (
4	"io/ioutil"
5	"os"
6	"regexp"
7	"testing"
8
9	"github.com/bmizerany/assert"
10	"github.com/github/hub/ui"
11)
12
13func TestMain(m *testing.M) {
14	ui.Default = ui.Console{Stdout: ioutil.Discard, Stderr: ioutil.Discard}
15	os.Exit(m.Run())
16}
17
18func TestCommandUseSelf(t *testing.T) {
19	c := &Command{Usage: "foo"}
20
21	args := NewArgs([]string{"foo"})
22
23	run, err := c.lookupSubCommand(args)
24
25	assert.Equal(t, nil, err)
26	assert.Equal(t, c, run)
27}
28
29func TestCommandUseSubcommand(t *testing.T) {
30	c := &Command{Usage: "foo"}
31	s := &Command{Usage: "bar"}
32	c.Use(s)
33
34	args := NewArgs([]string{"foo", "bar"})
35
36	run, err := c.lookupSubCommand(args)
37
38	assert.Equal(t, nil, err)
39	assert.Equal(t, s, run)
40}
41
42func TestCommandUseErrorWhenMissingSubcommand(t *testing.T) {
43	c := &Command{Usage: "foo"}
44	s := &Command{Usage: "bar"}
45	c.Use(s)
46
47	args := NewArgs([]string{"foo", "baz"})
48
49	_, err := c.lookupSubCommand(args)
50
51	assert.NotEqual(t, nil, err)
52}
53
54func TestArgsForCommand(t *testing.T) {
55	c := &Command{Usage: "foo"}
56
57	args := NewArgs([]string{"foo", "bar", "baz"})
58
59	c.lookupSubCommand(args)
60
61	assert.Equal(t, 2, len(args.Params))
62}
63
64func TestArgsForSubCommand(t *testing.T) {
65	c := &Command{Usage: "foo"}
66	s := &Command{Usage: "bar"}
67	c.Use(s)
68
69	args := NewArgs([]string{"foo", "bar", "baz"})
70
71	c.lookupSubCommand(args)
72
73	assert.Equal(t, 1, len(args.Params))
74}
75
76func TestFlagsAfterArguments(t *testing.T) {
77	c := &Command{Long: "-m, --message MSG"}
78
79	args := NewArgs([]string{"foo", "bar", "-m", "baz"})
80	err := c.parseArguments(args)
81	assert.Equal(t, nil, err)
82	assert.Equal(t, "baz", args.Flag.Value("--message"))
83	assert.Equal(t, 1, len(args.Params))
84	assert.Equal(t, "bar", args.LastParam())
85}
86
87func TestCommandNameTakeKey(t *testing.T) {
88	c := &Command{Key: "bar", Usage: "foo -t -v --foo"}
89	assert.Equal(t, "bar", c.Name())
90}
91
92func TestCommandCall(t *testing.T) {
93	var result string
94	f := func(c *Command, args *Args) { result = args.FirstParam() }
95
96	c := &Command{Usage: "foo", Run: f}
97	args := NewArgs([]string{"foo", "bar"})
98
99	c.Call(args)
100	assert.Equal(t, "bar", result)
101}
102
103func TestCommandHelp(t *testing.T) {
104	var result string
105	f := func(c *Command, args *Args) { result = args.FirstParam() }
106	c := &Command{Usage: "foo", Run: f}
107	args := NewArgs([]string{"foo", "-h"})
108
109	c.Call(args)
110	assert.Equal(t, "", result)
111}
112
113func TestSubCommandCall(t *testing.T) {
114	var result string
115	f1 := func(c *Command, args *Args) { result = "noop" }
116	f2 := func(c *Command, args *Args) { result = args.LastParam() }
117
118	c := &Command{Usage: "foo", Run: f1}
119	s := &Command{Key: "bar", Usage: "foo bar", Run: f2}
120	c.Use(s)
121
122	args := NewArgs([]string{"foo", "bar", "baz"})
123
124	c.Call(args)
125	assert.Equal(t, "baz", result)
126}
127
128func Test_NameWithOwnerRe(t *testing.T) {
129	re := regexp.MustCompile(NameWithOwnerRe)
130
131	assert.Equal(t, true, re.MatchString("o/n"))
132	assert.Equal(t, true, re.MatchString("own-er/my-project.git"))
133	assert.Equal(t, true, re.MatchString("my-project.git"))
134	assert.Equal(t, true, re.MatchString("my_project"))
135	assert.Equal(t, true, re.MatchString("-dash"))
136	assert.Equal(t, true, re.MatchString(".dotfiles"))
137
138	assert.Equal(t, false, re.MatchString(""))
139	assert.Equal(t, false, re.MatchString("/"))
140	assert.Equal(t, false, re.MatchString(" "))
141	assert.Equal(t, false, re.MatchString("owner/na me"))
142	assert.Equal(t, false, re.MatchString("owner/na/me"))
143	assert.Equal(t, false, re.MatchString("own.er/name"))
144	assert.Equal(t, false, re.MatchString("own_er/name"))
145	assert.Equal(t, false, re.MatchString("-owner/name"))
146}
147