github.com/felipejfc/helm@v2.1.2+incompatible/cmd/helm/strvals/parser_test.go (about) 1 /* 2 Copyright 2016 The Kubernetes Authors All rights reserved. 3 Licensed under the Apache License, Version 2.0 (the "License"); 4 you may not use this file except in compliance with the License. 5 You may obtain a copy of the License at 6 7 http://www.apache.org/licenses/LICENSE-2.0 8 9 Unless required by applicable law or agreed to in writing, software 10 distributed under the License is distributed on an "AS IS" BASIS, 11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 See the License for the specific language governing permissions and 13 limitations under the License. 14 */ 15 16 package strvals 17 18 import ( 19 "testing" 20 21 "github.com/ghodss/yaml" 22 ) 23 24 func TestParseSet(t *testing.T) { 25 tests := []struct { 26 str string 27 expect map[string]interface{} 28 err bool 29 }{ 30 { 31 "name1=value1", 32 map[string]interface{}{"name1": "value1"}, 33 false, 34 }, 35 { 36 "name1=value1,name2=value2", 37 map[string]interface{}{"name1": "value1", "name2": "value2"}, 38 false, 39 }, 40 { 41 "name1=value1,name2=value2,", 42 map[string]interface{}{"name1": "value1", "name2": "value2"}, 43 false, 44 }, 45 { 46 str: "name1=value1,,,,name2=value2,", 47 err: true, 48 }, 49 { 50 str: "name1=,name2=value2", 51 expect: map[string]interface{}{"name1": "", "name2": "value2"}, 52 }, 53 { 54 str: "name1,name2=", 55 err: true, 56 }, 57 { 58 str: "name1,name2=value2", 59 err: true, 60 }, 61 { 62 str: "name1,name2=value2\\", 63 err: true, 64 }, 65 { 66 str: "name1,name2", 67 err: true, 68 }, 69 { 70 "name1=one\\,two,name2=three\\,four", 71 map[string]interface{}{"name1": "one,two", "name2": "three,four"}, 72 false, 73 }, 74 { 75 "name1=one\\=two,name2=three\\=four", 76 map[string]interface{}{"name1": "one=two", "name2": "three=four"}, 77 false, 78 }, 79 { 80 "name1=one two three,name2=three two one", 81 map[string]interface{}{"name1": "one two three", "name2": "three two one"}, 82 false, 83 }, 84 { 85 "outer.inner=value", 86 map[string]interface{}{"outer": map[string]interface{}{"inner": "value"}}, 87 false, 88 }, 89 { 90 "outer.middle.inner=value", 91 map[string]interface{}{"outer": map[string]interface{}{"middle": map[string]interface{}{"inner": "value"}}}, 92 false, 93 }, 94 { 95 "outer.inner1=value,outer.inner2=value2", 96 map[string]interface{}{"outer": map[string]interface{}{"inner1": "value", "inner2": "value2"}}, 97 false, 98 }, 99 { 100 "outer.inner1=value,outer.middle.inner=value", 101 map[string]interface{}{ 102 "outer": map[string]interface{}{ 103 "inner1": "value", 104 "middle": map[string]interface{}{ 105 "inner": "value", 106 }, 107 }, 108 }, 109 false, 110 }, 111 { 112 str: "name1.name2", 113 err: true, 114 }, 115 { 116 str: "name1.name2,name1.name3", 117 err: true, 118 }, 119 { 120 str: "name1.name2=", 121 expect: map[string]interface{}{"name1": map[string]interface{}{"name2": ""}}, 122 }, 123 { 124 str: "name1.=name2", 125 err: true, 126 }, 127 { 128 str: "name1.,name2", 129 err: true, 130 }, 131 { 132 "name1={value1,value2}", 133 map[string]interface{}{"name1": []string{"value1", "value2"}}, 134 false, 135 }, 136 { 137 "name1={value1,value2},name2={value1,value2}", 138 map[string]interface{}{ 139 "name1": []string{"value1", "value2"}, 140 "name2": []string{"value1", "value2"}, 141 }, 142 false, 143 }, 144 { 145 "name1={1021,902}", 146 map[string]interface{}{"name1": []int{1021, 902}}, 147 false, 148 }, 149 { 150 "name1.name2={value1,value2}", 151 map[string]interface{}{"name1": map[string]interface{}{"name2": []string{"value1", "value2"}}}, 152 false, 153 }, 154 { 155 str: "name1={1021,902", 156 err: true, 157 }, 158 } 159 160 for _, tt := range tests { 161 got, err := Parse(tt.str) 162 if err != nil { 163 if tt.err { 164 continue 165 } 166 t.Fatalf("%s: %s", tt.str, err) 167 } 168 if tt.err { 169 t.Errorf("%s: Expected error. Got nil", tt.str) 170 } 171 172 y1, err := yaml.Marshal(tt.expect) 173 if err != nil { 174 t.Fatal(err) 175 } 176 y2, err := yaml.Marshal(got) 177 if err != nil { 178 t.Fatalf("Error serializing parsed value: %s", err) 179 } 180 181 if string(y1) != string(y2) { 182 t.Errorf("%s: Expected:\n%s\nGot:\n%s", tt.str, y1, y2) 183 } 184 } 185 } 186 187 func TestParseInto(t *testing.T) { 188 got := map[string]interface{}{ 189 "outer": map[string]interface{}{ 190 "inner1": "overwrite", 191 "inner2": "value2", 192 }, 193 } 194 input := "outer.inner1=value1,outer.inner3=value3" 195 expect := map[string]interface{}{ 196 "outer": map[string]interface{}{ 197 "inner1": "value1", 198 "inner2": "value2", 199 "inner3": "value3", 200 }, 201 } 202 203 if err := ParseInto(input, got); err != nil { 204 t.Fatal(err) 205 } 206 207 y1, err := yaml.Marshal(expect) 208 if err != nil { 209 t.Fatal(err) 210 } 211 y2, err := yaml.Marshal(got) 212 if err != nil { 213 t.Fatalf("Error serializing parsed value: %s", err) 214 } 215 216 if string(y1) != string(y2) { 217 t.Errorf("%s: Expected:\n%s\nGot:\n%s", input, y1, y2) 218 } 219 } 220 221 func TestToYAML(t *testing.T) { 222 // The TestParse does the hard part. We just verify that YAML formatting is 223 // happening. 224 o, err := ToYAML("name=value") 225 if err != nil { 226 t.Fatal(err) 227 } 228 expect := "name: value\n" 229 if o != expect { 230 t.Errorf("Expected %q, got %q", expect, o) 231 } 232 }