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  }