github.phpd.cn/hashicorp/packer@v1.3.2/template/interpolate/render_test.go (about)

     1  package interpolate
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  func TestRenderInterface(t *testing.T) {
     9  	type Test struct {
    10  		Foo string
    11  	}
    12  
    13  	cases := map[string]struct {
    14  		Input  interface{}
    15  		Output interface{}
    16  	}{
    17  		"basic": {
    18  			map[string]interface{}{
    19  				"foo": "{{upper `bar`}}",
    20  			},
    21  			map[string]interface{}{
    22  				"foo": "BAR",
    23  			},
    24  		},
    25  
    26  		"struct": {
    27  			&Test{
    28  				Foo: "{{upper `bar`}}",
    29  			},
    30  			&Test{
    31  				Foo: "BAR",
    32  			},
    33  		},
    34  	}
    35  
    36  	ctx := &Context{}
    37  	for k, tc := range cases {
    38  		actual, err := RenderInterface(tc.Input, ctx)
    39  		if err != nil {
    40  			t.Fatalf("err: %s\n\n%s", k, err)
    41  		}
    42  
    43  		if !reflect.DeepEqual(actual, tc.Output) {
    44  			t.Fatalf("err: %s\n\n%#v\n\n%#v", k, actual, tc.Output)
    45  		}
    46  	}
    47  }
    48  
    49  func TestRenderMap(t *testing.T) {
    50  	cases := map[string]struct {
    51  		Input  interface{}
    52  		Output interface{}
    53  		Filter *RenderFilter
    54  	}{
    55  		"basic": {
    56  			map[string]interface{}{
    57  				"foo": "{{upper `bar`}}",
    58  			},
    59  			map[string]interface{}{
    60  				"foo": "BAR",
    61  			},
    62  			nil,
    63  		},
    64  
    65  		"map keys shouldn't be interpolated": {
    66  			map[string]interface{}{
    67  				"{{foo}}": "{{upper `bar`}}",
    68  			},
    69  			map[string]interface{}{
    70  				"{{foo}}": "BAR",
    71  			},
    72  			nil,
    73  		},
    74  
    75  		"nested values": {
    76  			map[string]interface{}{
    77  				"foo": map[string]string{
    78  					"bar": "{{upper `baz`}}",
    79  				},
    80  			},
    81  			map[string]interface{}{
    82  				"foo": map[string]string{
    83  					"bar": "BAZ",
    84  				},
    85  			},
    86  			nil,
    87  		},
    88  
    89  		"nested value keys": {
    90  			map[string]interface{}{
    91  				"foo": map[string]string{
    92  					"{{upper `bar`}}": "{{upper `baz`}}",
    93  				},
    94  			},
    95  			map[string]interface{}{
    96  				"foo": map[string]string{
    97  					"BAR": "BAZ",
    98  				},
    99  			},
   100  			nil,
   101  		},
   102  
   103  		"filter": {
   104  			map[string]interface{}{
   105  				"bar": "{{upper `baz`}}",
   106  				"foo": map[string]string{
   107  					"{{upper `bar`}}": "{{upper `baz`}}",
   108  				},
   109  			},
   110  			map[string]interface{}{
   111  				"bar": "BAZ",
   112  				"foo": map[string]string{
   113  					"{{upper `bar`}}": "{{upper `baz`}}",
   114  				},
   115  			},
   116  			&RenderFilter{
   117  				Include: []string{"bar"},
   118  			},
   119  		},
   120  
   121  		"filter case-insensitive": {
   122  			map[string]interface{}{
   123  				"bar": "{{upper `baz`}}",
   124  				"foo": map[string]string{
   125  					"{{upper `bar`}}": "{{upper `baz`}}",
   126  				},
   127  			},
   128  			map[string]interface{}{
   129  				"bar": "BAZ",
   130  				"foo": map[string]string{
   131  					"{{upper `bar`}}": "{{upper `baz`}}",
   132  				},
   133  			},
   134  			&RenderFilter{
   135  				Include: []string{"baR"},
   136  			},
   137  		},
   138  	}
   139  
   140  	ctx := &Context{}
   141  	for k, tc := range cases {
   142  		actual, err := RenderMap(tc.Input, ctx, tc.Filter)
   143  		if err != nil {
   144  			t.Fatalf("err: %s\n\n%s", k, err)
   145  		}
   146  
   147  		if !reflect.DeepEqual(actual, tc.Output) {
   148  			t.Fatalf("err: %s\n\n%#v\n\n%#v", k, actual, tc.Output)
   149  		}
   150  	}
   151  }