github.com/mponton/terratest@v0.44.0/modules/terraform/var-file_test.go (about)

     1  package terraform
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"os"
     7  	"testing"
     8  
     9  	"github.com/mponton/terratest/modules/random"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestGetVariablesFromVarFilesAsString(t *testing.T) {
    14  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
    15  
    16  	testHcl := []byte(`
    17  		aws_region     = "us-east-2"
    18  		aws_account_id = "111111111111"
    19  		number_type = 2
    20  		boolean_type = true
    21  		tags = {
    22  			foo = "bar"
    23  		}
    24  		list = ["item1"]`)
    25  
    26  	WriteFile(t, randomFileName, testHcl)
    27  	defer os.Remove(randomFileName)
    28  
    29  	stringVal := GetVariableAsStringFromVarFile(t, randomFileName, "aws_region")
    30  
    31  	boolString := GetVariableAsStringFromVarFile(t, randomFileName, "boolean_type")
    32  
    33  	numString := GetVariableAsStringFromVarFile(t, randomFileName, "number_type")
    34  
    35  	require.Equal(t, "us-east-2", stringVal)
    36  	require.Equal(t, "true", boolString)
    37  	require.Equal(t, "2", numString)
    38  
    39  }
    40  
    41  func TestGetVariablesFromVarFilesAsStringKeyDoesNotExist(t *testing.T) {
    42  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
    43  
    44  	testHcl := []byte(`
    45  		aws_region     = "us-east-2"
    46  		aws_account_id = "111111111111"
    47  		tags = {
    48  			foo = "bar"
    49  		}
    50  		list = ["item1"]`)
    51  
    52  	WriteFile(t, randomFileName, testHcl)
    53  	defer os.Remove(randomFileName)
    54  
    55  	_, err := GetVariableAsStringFromVarFileE(t, randomFileName, "badkey")
    56  
    57  	require.Error(t, err)
    58  }
    59  
    60  func TestGetVariableAsMapFromVarFile(t *testing.T) {
    61  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
    62  	expected := make(map[string]string)
    63  	expected["foo"] = "bar"
    64  
    65  	testHcl := []byte(`
    66  		aws_region     = "us-east-2"
    67  		aws_account_id = "111111111111"
    68  		tags = {
    69  			foo = "bar"
    70  		}
    71  		list = ["item1"]`)
    72  
    73  	WriteFile(t, randomFileName, testHcl)
    74  	defer os.Remove(randomFileName)
    75  
    76  	val := GetVariableAsMapFromVarFile(t, randomFileName, "tags")
    77  	require.Equal(t, expected, val)
    78  }
    79  
    80  func TestGetVariableAsMapFromVarFileNotMap(t *testing.T) {
    81  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
    82  
    83  	testHcl := []byte(`
    84  		aws_region     = "us-east-2"
    85  		aws_account_id = "111111111111"
    86  		tags = {
    87  			foo = "bar"
    88  		}
    89  		list = ["item1"]`)
    90  
    91  	WriteFile(t, randomFileName, testHcl)
    92  	defer os.Remove(randomFileName)
    93  
    94  	_, err := GetVariableAsMapFromVarFileE(t, randomFileName, "aws_region")
    95  
    96  	require.Error(t, err)
    97  }
    98  
    99  func TestGetVariableAsMapFromVarFileKeyDoesNotExist(t *testing.T) {
   100  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   101  
   102  	testHcl := []byte(`
   103  		aws_region     = "us-east-2"
   104  		aws_account_id = "111111111111"
   105  		tags = {
   106  			foo = "bar"
   107  		}
   108  		list = ["item1"]`)
   109  
   110  	WriteFile(t, randomFileName, testHcl)
   111  	defer os.Remove(randomFileName)
   112  
   113  	_, err := GetVariableAsMapFromVarFileE(t, randomFileName, "badkey")
   114  
   115  	require.Error(t, err)
   116  }
   117  
   118  func TestGetVariableAsListFromVarFile(t *testing.T) {
   119  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   120  	expected := []string{"item1"}
   121  
   122  	testHcl := []byte(`
   123  		aws_region     = "us-east-2"
   124  		aws_account_id = "111111111111"
   125  		tags = {
   126  			foo = "bar"
   127  		}
   128  		list = ["item1"]`)
   129  
   130  	WriteFile(t, randomFileName, testHcl)
   131  	defer os.Remove(randomFileName)
   132  
   133  	val := GetVariableAsListFromVarFile(t, randomFileName, "list")
   134  
   135  	require.Equal(t, expected, val)
   136  }
   137  
   138  func TestGetVariableAsListNotList(t *testing.T) {
   139  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   140  
   141  	testHcl := []byte(`
   142  		aws_region     = "us-east-2"
   143  		aws_account_id = "111111111111"
   144  		tags = {
   145  			foo = "bar"
   146  		}
   147  		list = ["item1"]`)
   148  
   149  	WriteFile(t, randomFileName, testHcl)
   150  	defer os.Remove(randomFileName)
   151  
   152  	_, err := GetVariableAsListFromVarFileE(t, randomFileName, "tags")
   153  
   154  	require.Error(t, err)
   155  }
   156  
   157  func TestGetVariableAsListKeyDoesNotExist(t *testing.T) {
   158  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   159  
   160  	testHcl := []byte(`
   161  		aws_region     = "us-east-2"
   162  		aws_account_id = "111111111111"
   163  		tags = {
   164  			foo = "bar"
   165  		}
   166  		list = ["item1"]`)
   167  
   168  	WriteFile(t, randomFileName, testHcl)
   169  	defer os.Remove(randomFileName)
   170  
   171  	_, err := GetVariableAsListFromVarFileE(t, randomFileName, "badkey")
   172  
   173  	require.Error(t, err)
   174  }
   175  func TestGetAllVariablesFromVarFileEFileDoesNotExist(t *testing.T) {
   176  	var variables map[string]interface{}
   177  	err := GetAllVariablesFromVarFileE(t, "filea", &variables)
   178  	require.Equal(t, "open filea: no such file or directory", err.Error())
   179  }
   180  
   181  func TestGetAllVariablesFromVarFileBadFile(t *testing.T) {
   182  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   183  	testHcl := []byte(`
   184  		thiswillnotwork`)
   185  
   186  	WriteFile(t, randomFileName, testHcl)
   187  	defer os.Remove(randomFileName)
   188  
   189  	var variables map[string]interface{}
   190  	err := GetAllVariablesFromVarFileE(t, randomFileName, &variables)
   191  	require.Error(t, err)
   192  
   193  	// HCL library could change their error string, so we are only testing the error string contains what we add to it
   194  	require.Regexp(t, fmt.Sprintf("^%s:2,3-18: ", randomFileName), err.Error())
   195  }
   196  
   197  func TestGetAllVariablesFromVarFile(t *testing.T) {
   198  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   199  	testHcl := []byte(`
   200  	aws_region     = "us-east-2"
   201  	`)
   202  
   203  	WriteFile(t, randomFileName, testHcl)
   204  	defer os.Remove(randomFileName)
   205  
   206  	var variables map[string]interface{}
   207  	err := GetAllVariablesFromVarFileE(t, randomFileName, &variables)
   208  	require.NoError(t, err)
   209  
   210  	expected := make(map[string]interface{})
   211  	expected["aws_region"] = "us-east-2"
   212  
   213  	require.Equal(t, expected, variables)
   214  }
   215  
   216  func TestGetAllVariablesFromVarFileStructOut(t *testing.T) {
   217  	randomFileName := fmt.Sprintf("./%s.tfvars", random.UniqueId())
   218  	testHcl := []byte(`
   219  	aws_region     = "us-east-2"
   220  	`)
   221  
   222  	WriteFile(t, randomFileName, testHcl)
   223  	defer os.Remove(randomFileName)
   224  
   225  	var region struct {
   226  		AwsRegion string `cty:"aws_region"`
   227  	}
   228  	err := GetAllVariablesFromVarFileE(t, randomFileName, &region)
   229  	require.NoError(t, err)
   230  	require.Equal(t, "us-east-2", region.AwsRegion)
   231  }
   232  
   233  func TestGetVariablesFromVarFilesAsStringJSON(t *testing.T) {
   234  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   235  
   236  	testJSON := []byte(`
   237  		{
   238  			"aws_region": "us-east-2",
   239  			"aws_account_id": "111111111111",
   240  			"number_type": 2,
   241  			"boolean_type": true,
   242  			"tags": {
   243  				"foo": "bar"
   244  			},
   245  			"list": ["item1"]
   246  		}`)
   247  
   248  	WriteFile(t, randomFileName, testJSON)
   249  	defer os.Remove(randomFileName)
   250  
   251  	stringVal := GetVariableAsStringFromVarFile(t, randomFileName, "aws_region")
   252  
   253  	boolString := GetVariableAsStringFromVarFile(t, randomFileName, "boolean_type")
   254  
   255  	numString := GetVariableAsStringFromVarFile(t, randomFileName, "number_type")
   256  
   257  	require.Equal(t, "us-east-2", stringVal)
   258  	require.Equal(t, "true", boolString)
   259  	require.Equal(t, "2", numString)
   260  
   261  }
   262  
   263  func TestGetVariablesFromVarFilesAsStringKeyDoesNotExistJSON(t *testing.T) {
   264  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   265  
   266  	testJSON := []byte(`
   267  		{
   268  			"aws_region": "us-east-2",
   269  			"aws_account_id": "111111111111",
   270  			"tags": {
   271  				"foo": "bar"
   272  			},
   273  			"list": ["item1"]
   274  		}`)
   275  
   276  	WriteFile(t, randomFileName, testJSON)
   277  	defer os.Remove(randomFileName)
   278  
   279  	_, err := GetVariableAsStringFromVarFileE(t, randomFileName, "badkey")
   280  
   281  	require.Error(t, err)
   282  }
   283  
   284  func TestGetVariableAsMapFromVarFileJSON(t *testing.T) {
   285  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   286  	expected := make(map[string]string)
   287  	expected["foo"] = "bar"
   288  
   289  	testJSON := []byte(`
   290  		{
   291  			"aws_region": "us-east-2",
   292  			"aws_account_id": "111111111111",
   293  			"tags": {
   294  				"foo": "bar"
   295  			},
   296  			"list": ["item1"]
   297  		}`)
   298  
   299  	WriteFile(t, randomFileName, testJSON)
   300  	defer os.Remove(randomFileName)
   301  
   302  	val := GetVariableAsMapFromVarFile(t, randomFileName, "tags")
   303  	require.Equal(t, expected, val)
   304  }
   305  
   306  func TestGetVariableAsMapFromVarFileNotMapJSON(t *testing.T) {
   307  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   308  
   309  	testJSON := []byte(`
   310  		{
   311  			"aws_region": "us-east-2",
   312  			"aws_account_id": "111111111111",
   313  			"tags": {
   314  				"foo": "bar"
   315  			},
   316  			"list": ["item1"]
   317  		}`)
   318  
   319  	WriteFile(t, randomFileName, testJSON)
   320  	defer os.Remove(randomFileName)
   321  
   322  	_, err := GetVariableAsMapFromVarFileE(t, randomFileName, "aws_region")
   323  
   324  	require.Error(t, err)
   325  }
   326  
   327  func TestGetVariableAsMapFromVarFileKeyDoesNotExistJSON(t *testing.T) {
   328  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   329  
   330  	testJSON := []byte(`
   331  		{
   332  			"aws_region": "us-east-2",
   333  			"aws_account_id": "111111111111",
   334  			"tags": {
   335  				"foo": "bar"
   336  			},
   337  			"list": ["item1"]
   338  		}`)
   339  
   340  	WriteFile(t, randomFileName, testJSON)
   341  	defer os.Remove(randomFileName)
   342  
   343  	_, err := GetVariableAsMapFromVarFileE(t, randomFileName, "badkey")
   344  
   345  	require.Error(t, err)
   346  }
   347  
   348  func TestGetVariableAsListFromVarFileJSON(t *testing.T) {
   349  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   350  	expected := []string{"item1"}
   351  
   352  	testJSON := []byte(`
   353  		{
   354  			"aws_region": "us-east-2",
   355  			"aws_account_id": "111111111111",
   356  			"tags": {
   357  				"foo": "bar"
   358  			},
   359  			"list": ["item1"]
   360  		}`)
   361  
   362  	WriteFile(t, randomFileName, testJSON)
   363  	defer os.Remove(randomFileName)
   364  
   365  	val := GetVariableAsListFromVarFile(t, randomFileName, "list")
   366  
   367  	require.Equal(t, expected, val)
   368  }
   369  
   370  func TestGetVariableAsListNotListJSON(t *testing.T) {
   371  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   372  
   373  	testJSON := []byte(`
   374  		{
   375  			"aws_region": "us-east-2",
   376  			"aws_account_id": "111111111111",
   377  			"tags": {
   378  				"foo": "bar"
   379  			},
   380  			"list": ["item1"]
   381  		}`)
   382  
   383  	WriteFile(t, randomFileName, testJSON)
   384  	defer os.Remove(randomFileName)
   385  
   386  	_, err := GetVariableAsListFromVarFileE(t, randomFileName, "tags")
   387  
   388  	require.Error(t, err)
   389  }
   390  
   391  func TestGetVariableAsListKeyDoesNotExistJSON(t *testing.T) {
   392  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   393  
   394  	testJSON := []byte(`
   395  		{
   396  			"aws_region": "us-east-2",
   397  			"aws_account_id": "111111111111",
   398  			"tags": {
   399  				"foo": "bar"
   400  			},
   401  			"list": ["item1"]
   402  		}`)
   403  
   404  	WriteFile(t, randomFileName, testJSON)
   405  	defer os.Remove(randomFileName)
   406  
   407  	_, err := GetVariableAsListFromVarFileE(t, randomFileName, "badkey")
   408  
   409  	require.Error(t, err)
   410  }
   411  
   412  func TestGetAllVariablesFromVarFileBadFileJSON(t *testing.T) {
   413  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   414  	testJSON := []byte(`
   415  		{
   416  			thiswillnotwork
   417  		}`)
   418  
   419  	WriteFile(t, randomFileName, testJSON)
   420  	defer os.Remove(randomFileName)
   421  
   422  	var variables map[string]interface{}
   423  	err := GetAllVariablesFromVarFileE(t, randomFileName, &variables)
   424  	require.Error(t, err)
   425  
   426  	// HCL library could change their error string, so we are only testing the error string contains what we add to it
   427  	require.Regexp(t, fmt.Sprintf("^%s:3,7-22: ", randomFileName), err.Error())
   428  }
   429  
   430  func TestGetAllVariablesFromVarFileJSON(t *testing.T) {
   431  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   432  	testJSON := []byte(`
   433  	{
   434  		"aws_region": "us-east-2"
   435  	}
   436  	`)
   437  
   438  	WriteFile(t, randomFileName, testJSON)
   439  	defer os.Remove(randomFileName)
   440  
   441  	var variables map[string]interface{}
   442  	err := GetAllVariablesFromVarFileE(t, randomFileName, &variables)
   443  	require.NoError(t, err)
   444  
   445  	expected := make(map[string]interface{})
   446  	expected["aws_region"] = "us-east-2"
   447  
   448  	require.Equal(t, expected, variables)
   449  }
   450  
   451  func TestGetAllVariablesFromVarFileStructOutJSON(t *testing.T) {
   452  	randomFileName := fmt.Sprintf("./%s.tfvars.json", random.UniqueId())
   453  	testJSON := []byte(`
   454  	{
   455  		"aws_region": "us-east-2"
   456  	}
   457  	`)
   458  
   459  	WriteFile(t, randomFileName, testJSON)
   460  	defer os.Remove(randomFileName)
   461  
   462  	var region struct {
   463  		AwsRegion string `cty:"aws_region"`
   464  	}
   465  	err := GetAllVariablesFromVarFileE(t, randomFileName, &region)
   466  	require.NoError(t, err)
   467  	require.Equal(t, "us-east-2", region.AwsRegion)
   468  }
   469  
   470  // Helper function to write a file to the filesystem
   471  // Will immediately fail the test if it could not write the file
   472  func WriteFile(t *testing.T, fileName string, bytes []byte) {
   473  	err := ioutil.WriteFile(fileName, bytes, 0644)
   474  
   475  	require.NoError(t, err)
   476  }