github.com/richardbowden/terraform@v0.6.12-0.20160901200758-30ea22c25211/command/flag_kv_test.go (about)

     1  package command
     2  
     3  import (
     4  	"flag"
     5  	"github.com/davecgh/go-spew/spew"
     6  	"io/ioutil"
     7  	"reflect"
     8  	"testing"
     9  )
    10  
    11  func TestFlagStringKV_impl(t *testing.T) {
    12  	var _ flag.Value = new(FlagStringKV)
    13  }
    14  
    15  func TestFlagStringKV(t *testing.T) {
    16  	cases := []struct {
    17  		Input  string
    18  		Output map[string]string
    19  		Error  bool
    20  	}{
    21  		{
    22  			"key=value",
    23  			map[string]string{"key": "value"},
    24  			false,
    25  		},
    26  
    27  		{
    28  			"key=",
    29  			map[string]string{"key": ""},
    30  			false,
    31  		},
    32  
    33  		{
    34  			"key=foo=bar",
    35  			map[string]string{"key": "foo=bar"},
    36  			false,
    37  		},
    38  
    39  		{
    40  			"map.key=foo",
    41  			map[string]string{"map.key": "foo"},
    42  			false,
    43  		},
    44  
    45  		{
    46  			"key",
    47  			nil,
    48  			true,
    49  		},
    50  	}
    51  
    52  	for _, tc := range cases {
    53  		f := new(FlagStringKV)
    54  		err := f.Set(tc.Input)
    55  		if err != nil != tc.Error {
    56  			t.Fatalf("bad error. Input: %#v\n\nError: %s", tc.Input, err)
    57  		}
    58  
    59  		actual := map[string]string(*f)
    60  		if !reflect.DeepEqual(actual, tc.Output) {
    61  			t.Fatalf("bad: %#v", actual)
    62  		}
    63  	}
    64  }
    65  
    66  func TestFlagTypedKV_impl(t *testing.T) {
    67  	var _ flag.Value = new(FlagTypedKV)
    68  }
    69  
    70  func TestFlagTypedKV(t *testing.T) {
    71  	cases := []struct {
    72  		Input  string
    73  		Output map[string]interface{}
    74  		Error  bool
    75  	}{
    76  		{
    77  			"key=value",
    78  			map[string]interface{}{"key": "value"},
    79  			false,
    80  		},
    81  
    82  		{
    83  			"key=",
    84  			map[string]interface{}{"key": ""},
    85  			false,
    86  		},
    87  
    88  		{
    89  			"key=foo=bar",
    90  			map[string]interface{}{"key": "foo=bar"},
    91  			false,
    92  		},
    93  
    94  		{
    95  			"map.key=foo",
    96  			map[string]interface{}{"map.key": "foo"},
    97  			false,
    98  		},
    99  
   100  		{
   101  			"key",
   102  			nil,
   103  			true,
   104  		},
   105  
   106  		{
   107  			`key=["hello", "world"]`,
   108  			map[string]interface{}{"key": []interface{}{"hello", "world"}},
   109  			false,
   110  		},
   111  
   112  		{
   113  			`key={"hello" = "world", "foo" = "bar"}`,
   114  			map[string]interface{}{
   115  				"key": []map[string]interface{}{
   116  					map[string]interface{}{
   117  						"hello": "world",
   118  						"foo":   "bar",
   119  					},
   120  				},
   121  			},
   122  			false,
   123  		},
   124  
   125  		{
   126  			`key={"hello" = "world", "foo" = "bar"}\nkey2="invalid"`,
   127  			nil,
   128  			true,
   129  		},
   130  	}
   131  
   132  	for _, tc := range cases {
   133  		f := new(FlagTypedKV)
   134  		err := f.Set(tc.Input)
   135  		if err != nil != tc.Error {
   136  			t.Fatalf("bad error. Input: %#v\n\nError: %s", tc.Input, err)
   137  		}
   138  
   139  		actual := map[string]interface{}(*f)
   140  		if !reflect.DeepEqual(actual, tc.Output) {
   141  			t.Fatalf("bad:\nexpected: %s\n\n     got: %s\n", spew.Sdump(tc.Output), spew.Sdump(actual))
   142  		}
   143  	}
   144  }
   145  
   146  func TestFlagKVFile_impl(t *testing.T) {
   147  	var _ flag.Value = new(FlagKVFile)
   148  }
   149  
   150  func TestFlagKVFile(t *testing.T) {
   151  	inputLibucl := `
   152  foo = "bar"
   153  `
   154  
   155  	inputJson := `{
   156  		"foo": "bar"}`
   157  
   158  	cases := []struct {
   159  		Input  string
   160  		Output map[string]interface{}
   161  		Error  bool
   162  	}{
   163  		{
   164  			inputLibucl,
   165  			map[string]interface{}{"foo": "bar"},
   166  			false,
   167  		},
   168  
   169  		{
   170  			inputJson,
   171  			map[string]interface{}{"foo": "bar"},
   172  			false,
   173  		},
   174  
   175  		{
   176  			`map.key = "foo"`,
   177  			map[string]interface{}{"map.key": "foo"},
   178  			false,
   179  		},
   180  	}
   181  
   182  	path := testTempFile(t)
   183  
   184  	for _, tc := range cases {
   185  		if err := ioutil.WriteFile(path, []byte(tc.Input), 0644); err != nil {
   186  			t.Fatalf("err: %s", err)
   187  		}
   188  
   189  		f := new(FlagKVFile)
   190  		err := f.Set(path)
   191  		if err != nil != tc.Error {
   192  			t.Fatalf("bad error. Input: %#v, err: %s", tc.Input, err)
   193  		}
   194  
   195  		actual := map[string]interface{}(*f)
   196  		if !reflect.DeepEqual(actual, tc.Output) {
   197  			t.Fatalf("bad: %#v", actual)
   198  		}
   199  	}
   200  }