goutil/cliutil/cmdline/builder_test.go at master · gookit/goutil · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package cmdline_test

import (
	"fmt"
	"strconv"
	"testing"

	"github.com/gookit/goutil/cliutil/cmdline"
	"github.com/gookit/goutil/testutil/assert"
)

func TestQuote(t *testing.T) {
	tests := []struct {
		in   string
		want string
	}{
		{"", `""`},
		{" ", `" "`},
		{"one", `one`},
		{"one'", `one'`},
		{"one ", `"one "`},
		{" one ", `" one "`},
		{"one two", `"one two"`},
		{"one two three four", `"one two three four"`},
		{`the "val0" of option`, `'the "val0" of option'`},
		{`--pretty=format:'one two three'`, `--pretty=format:'one two three'`},
		{`--pretty=format:"one two three"`, `--pretty=format:"one two three"`},
	}

	for _, tt := range tests {
		assert.Eq(t, tt.want, cmdline.Quote(tt.in))
	}

	fmt.Println(strconv.Quote(`one`))
	fmt.Println(strconv.Quote(`one two`))
	fmt.Println(strconv.Quote(`"one two" three four`))
	fmt.Println(strconv.Quote(`'one two' three four`))
}

func TestLineBuild(t *testing.T) {
	s := cmdline.LineBuild("myapp", []string{"-a", "val0", "arg0"})
	assert.Eq(t, "myapp -a val0 arg0", s)

	// case: empty string
	b := cmdline.NewBuilder("myapp", "-a", "")
	assert.Eq(t, 11, b.Len())
	assert.Eq(t, `myapp -a ""`, b.String())

	b.Reset()
	assert.Eq(t, 0, b.Len())

	// case: add first
	b.AddArg("myapp")
	assert.Eq(t, `myapp`, b.String())
	b.AddArgs("-a", "val0")
	assert.Eq(t, "myapp -a val0", b.String())

	// addAny
	b.Reset()
	b.AddAny("myapp", "-a", "val0")
	assert.Eq(t, `myapp -a val0`, b.String())

	// case: contains `"`
	b.Reset()
	b.AddArgs("myapp", "-a", `"val0"`)
	assert.Eq(t, `myapp -a "val0"`, b.String())
	b.Reset()
	b.AddArgs("myapp", "-a", `the "val0" of option`)
	assert.Eq(t, `myapp -a 'the "val0" of option'`, b.String())

	// case: contains `'`
	b.Reset()
	b.AddArgs("myapp", "-a", `'val0'`)
	assert.Eq(t, `myapp -a 'val0'`, b.ResetGet())

	b.AddArgs("myapp", "-a", `the 'val0' of option`)
	assert.Eq(t, `myapp -a "the 'val0' of option"`, b.String())
	b.Reset()
}

func TestLineBuild_special(t *testing.T) {
	var b = cmdline.LineBuilder{}

	tests := []struct {
		args []string
		want string
	}{
		{
			[]string{"myapp", `one "two three"`},
			`myapp 'one "two three"'`,
		},
		{
			[]string{"myapp", `"one two" three`},
			`myapp '"one two" three'`,
		},
	}

	for _, tt := range tests {
		b.AddArray(tt.args)
		assert.Eq(t, tt.want, b.ResetGet())
	}
}

func TestLineBuild_complex(t *testing.T) {
	var b = cmdline.LineBuilder{}

	t.Run("case01", func(t *testing.T) {
		b.AddArgs("git", "log", `--pretty=format:"one two three"`)
		assert.Eq(t, `git log --pretty=format:"one two three"`, b.ResetGet())
	})

	t.Run("case02", func(t *testing.T) {
		b.AddArgs("git", "log", `--pretty`, `format:"one two three"`)
		assert.Eq(t, `git log --pretty format:"one two three"`, b.ResetGet())
	})
}

func TestLineBuild_hasQuote(t *testing.T) {
	line := "git log --pretty=format:'one two three'"
	args := cmdline.ParseLine(line)
	// dump.P(args)
	assert.Len(t, args, 3)
	assert.Eq(t, line, cmdline.LineBuild("", args))
}