github.com/lamielle/terraform@v0.3.2-0.20141121070651-81f008ba53d5/config/expr_parse_test.go (about)

     1  package config
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  )
     7  
     8  func TestExprParse(t *testing.T) {
     9  	cases := []struct {
    10  		Input  string
    11  		Result Interpolation
    12  		Error  bool
    13  	}{
    14  		{
    15  			"foo",
    16  			nil,
    17  			true,
    18  		},
    19  
    20  		{
    21  			`"foo"`,
    22  			&LiteralInterpolation{Literal: "foo"},
    23  			false,
    24  		},
    25  
    26  		{
    27  			"var.foo",
    28  			&VariableInterpolation{
    29  				Variable: &UserVariable{
    30  					Name: "foo",
    31  					key:  "var.foo",
    32  				},
    33  			},
    34  			false,
    35  		},
    36  
    37  		{
    38  			"module.foo.bar",
    39  			&VariableInterpolation{
    40  				Variable: &ModuleVariable{
    41  					Name:  "foo",
    42  					Field: "bar",
    43  					key:   "module.foo.bar",
    44  				},
    45  			},
    46  			false,
    47  		},
    48  
    49  		{
    50  			"lookup(var.foo, var.bar)",
    51  			&FunctionInterpolation{
    52  				Func: nil, // Funcs["lookup"]
    53  				Args: []Interpolation{
    54  					&VariableInterpolation{
    55  						Variable: &UserVariable{
    56  							Name: "foo",
    57  							key:  "var.foo",
    58  						},
    59  					},
    60  					&VariableInterpolation{
    61  						Variable: &UserVariable{
    62  							Name: "bar",
    63  							key:  "var.bar",
    64  						},
    65  					},
    66  				},
    67  			},
    68  			false,
    69  		},
    70  
    71  		{
    72  			"lookup(var.foo, lookup(var.baz, var.bar))",
    73  			&FunctionInterpolation{
    74  				Func: nil, // Funcs["lookup"]
    75  				Args: []Interpolation{
    76  					&VariableInterpolation{
    77  						Variable: &UserVariable{
    78  							Name: "foo",
    79  							key:  "var.foo",
    80  						},
    81  					},
    82  					&FunctionInterpolation{
    83  						Func: nil, // Funcs["lookup"]
    84  						Args: []Interpolation{
    85  							&VariableInterpolation{
    86  								Variable: &UserVariable{
    87  									Name: "baz",
    88  									key:  "var.baz",
    89  								},
    90  							},
    91  							&VariableInterpolation{
    92  								Variable: &UserVariable{
    93  									Name: "bar",
    94  									key:  "var.bar",
    95  								},
    96  							},
    97  						},
    98  					},
    99  				},
   100  			},
   101  			false,
   102  		},
   103  
   104  		{
   105  			`concat("foo","-","0.0/16")`,
   106  			&FunctionInterpolation{
   107  				Func: nil, // Funcs["lookup"]
   108  				Args: []Interpolation{
   109  					&LiteralInterpolation{Literal: "foo"},
   110  					&LiteralInterpolation{Literal: "-"},
   111  					&LiteralInterpolation{Literal: "0.0/16"},
   112  				},
   113  			},
   114  			false,
   115  		},
   116  	}
   117  
   118  	for i, tc := range cases {
   119  		actual, err := ExprParse(tc.Input)
   120  		if (err != nil) != tc.Error {
   121  			t.Fatalf("%d. Error: %s", i, err)
   122  		}
   123  
   124  		// This is jank, but reflect.DeepEqual never has functions
   125  		// being the same.
   126  		f, ok := actual.(*FunctionInterpolation)
   127  		if ok {
   128  			fs := make([]*FunctionInterpolation, 1)
   129  			fs[0] = f
   130  			for len(fs) > 0 {
   131  				f := fs[0]
   132  				fs = fs[1:]
   133  
   134  				f.Func = nil
   135  				for _, a := range f.Args {
   136  					f, ok := a.(*FunctionInterpolation)
   137  					if ok {
   138  						fs = append(fs, f)
   139  					}
   140  				}
   141  			}
   142  		}
   143  
   144  		if !reflect.DeepEqual(actual, tc.Result) {
   145  			t.Fatalf("%d bad: %#v", i, actual)
   146  		}
   147  	}
   148  }