root
/
helm
mirror of https://github.com/helm/helm.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

add test case 

Signed-off-by: zwwhdls <zwwhdls@hotmail.com>
This commit is contained in:
zwwhdls 2019-12-08 11:30:11 +08:00
parent 4532485fd0
commit 1b39857ac3
2 changed files with 109 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pkg/strvals/parser.go
View File

@ -308,8 +308,11 @@ func (t *parser) listItem(list []interface{}, i int) ([]interface{}, error) {
var crtList []interface{}
if len(list) > i {
// If nested list already exists, take the value of list to next cycle.
existed := list[i]
if existed != nil {
crtList = list[i].([]interface{})
}
}
// Now we need to get the value after the ].
<<<<<<< HEAD
list2, err := t.listItem(crtList, i)

97
pkg/strvals/parser_test.go
View File

@ -421,49 +421,118 @@ func TestParseSet(t *testing.T) {
}
func TestParseInto(t *testing.T) {
got := map[string]interface{}{
tests := []struct {
input string
input2 string
got map[string]interface{}
expect map[string]interface{}
err bool
}{
{
input: "outer.inner1=value1,outer.inner3=value3,outer.inner4=4",
got: map[string]interface{}{
"outer": map[string]interface{}{
"inner1": "overwrite",
"inner2": "value2",
},
}
input := "outer.inner1=value1,outer.inner3=value3,outer.inner4=4,listOuter[0][0].type=listValue"
expect := map[string]interface{}{
},
expect: map[string]interface{}{
"outer": map[string]interface{}{
"inner1": "value1",
"inner2": "value2",
"inner3": "value3",
"inner4": 4,
}},
err: false,
},
{
input: "listOuter[0][0].type=listValue",
input2: "listOuter[0][0].status=alive",
got: map[string]interface{}{},
expect: map[string]interface{}{
"listOuter": [][]interface{}{{map[string]string{
"type": "listValue",
"status": "alive",
}},
}}},
},
err: false,
},
{
input: "listOuter[0][0].type=listValue",
input2: "listOuter[1][0].status=alive",
got: map[string]interface{}{},
expect: map[string]interface{}{
"listOuter": [][]interface{}{
{
map[string]string{"type": "listValue"},
},
{
map[string]string{"status": "alive"},
},
},
},
err: false,
},
{
input: "listOuter[0][1][0].type=listValue",
input2: "listOuter[0][0][1].status=alive",
got: map[string]interface{}{
"listOuter": []interface{}{
[]interface{}{
[]interface{}{
map[string]string{"exited": "old"},
},
},
},
},
expect: map[string]interface{}{
"listOuter": [][][]interface{}{
{
{
map[string]string{"exited": "old"},
map[string]string{"status": "alive"},
},
{
map[string]string{"type": "listValue"},
},
},
},
},
err: false,
},
}
if err := ParseInto(input, got); err != nil {
for _, tt := range tests {
if err := ParseInto(tt.input, tt.got); err != nil {
t.Fatal(err)
}
input2 := "listOuter[0][0].status=alive"
if err := ParseInto(input2, got); err != nil {
t.Fatal(err)
if tt.err {
t.Errorf("%s: Expected error. Got nil", tt.input)
}
y1, err := yaml.Marshal(expect)
if tt.input2 != "" {
if err := ParseInto(tt.input2, tt.got); err != nil {
t.Fatal(err)
}
if tt.err {
t.Errorf("%s: Expected error. Got nil", tt.input2)
}
}
y1, err := yaml.Marshal(tt.expect)
if err != nil {
t.Fatal(err)
}
y2, err := yaml.Marshal(got)
y2, err := yaml.Marshal(tt.got)
if err != nil {
t.Fatalf("Error serializing parsed value: %s", err)
}
if string(y1) != string(y2) {
t.Errorf("%s: Expected:\n%s\nGot:\n%s", input, y1, y2)
t.Errorf("%s: Expected:\n%s\nGot:\n%s", tt.input, y1, y2)
}
}
}
func TestParseIntoString(t *testing.T) {
got := map[string]interface{}{
"outer": map[string]interface{}{