github.com/jaylevin/jenkins-library@v1.230.4/cmd/terraformExecute_test.go (about)

     1  package cmd
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/SAP/jenkins-library/pkg/mock"
     6  	"github.com/stretchr/testify/assert"
     7  	"testing"
     8  )
     9  
    10  type terraformExecuteMockUtils struct {
    11  	*mock.ExecMockRunner
    12  	*mock.FilesMock
    13  }
    14  
    15  func newTerraformExecuteTestsUtils() terraformExecuteMockUtils {
    16  	utils := terraformExecuteMockUtils{
    17  		ExecMockRunner: &mock.ExecMockRunner{},
    18  		FilesMock:      &mock.FilesMock{},
    19  	}
    20  	return utils
    21  }
    22  
    23  func TestRunTerraformExecute(t *testing.T) {
    24  	t.Parallel()
    25  
    26  	tt := []struct {
    27  		terraformExecuteOptions
    28  		expectedArgs    []string
    29  		expectedEnvVars []string
    30  	}{
    31  		{
    32  			terraformExecuteOptions{
    33  				Command: "apply",
    34  			}, []string{"apply", "-auto-approve", "-no-color"}, []string{},
    35  		},
    36  		{
    37  			terraformExecuteOptions{
    38  				Command:          "apply",
    39  				TerraformSecrets: "/tmp/test",
    40  			}, []string{"apply", "-auto-approve", "-var-file=/tmp/test", "-no-color"}, []string{},
    41  		},
    42  		{
    43  			terraformExecuteOptions{
    44  				Command: "plan",
    45  			}, []string{"plan", "-no-color"}, []string{},
    46  		},
    47  		{
    48  			terraformExecuteOptions{
    49  				Command:          "plan",
    50  				TerraformSecrets: "/tmp/test",
    51  			}, []string{"plan", "-var-file=/tmp/test", "-no-color"}, []string{},
    52  		},
    53  		{
    54  			terraformExecuteOptions{
    55  				Command:          "plan",
    56  				TerraformSecrets: "/tmp/test",
    57  				AdditionalArgs:   []string{"-arg1"},
    58  			}, []string{"plan", "-var-file=/tmp/test", "-no-color", "-arg1"}, []string{},
    59  		},
    60  		{
    61  			terraformExecuteOptions{
    62  				Command:          "apply",
    63  				TerraformSecrets: "/tmp/test",
    64  				AdditionalArgs:   []string{"-arg1"},
    65  			}, []string{"apply", "-auto-approve", "-var-file=/tmp/test", "-no-color", "-arg1"}, []string{},
    66  		},
    67  		{
    68  			terraformExecuteOptions{
    69  				Command:          "apply",
    70  				TerraformSecrets: "/tmp/test",
    71  				AdditionalArgs:   []string{"-arg1"},
    72  				GlobalOptions:    []string{"-chgdir=src"},
    73  			}, []string{"-chgdir=src", "apply", "-auto-approve", "-var-file=/tmp/test", "-no-color", "-arg1"}, []string{},
    74  		},
    75  		{
    76  			terraformExecuteOptions{
    77  				Command: "apply",
    78  				Init:    true,
    79  			}, []string{"apply", "-auto-approve", "-no-color"}, []string{},
    80  		},
    81  		{
    82  			terraformExecuteOptions{
    83  				Command:       "apply",
    84  				GlobalOptions: []string{"-chgdir=src"},
    85  				Init:          true,
    86  			}, []string{"-chgdir=src", "apply", "-auto-approve", "-no-color"}, []string{},
    87  		},
    88  		{
    89  			terraformExecuteOptions{
    90  				Command:       "apply",
    91  				CliConfigFile: ".pipeline/.terraformrc",
    92  			}, []string{"apply", "-auto-approve", "-no-color"}, []string{"TF_CLI_CONFIG_FILE=.pipeline/.terraformrc"},
    93  		},
    94  		{
    95  			terraformExecuteOptions{
    96  				Command:   "plan",
    97  				Workspace: "any-workspace",
    98  			}, []string{"plan", "-no-color"}, []string{"TF_WORKSPACE=any-workspace"},
    99  		},
   100  	}
   101  
   102  	for i, test := range tt {
   103  		t.Run(fmt.Sprintf("That arguments are correct %d", i), func(t *testing.T) {
   104  			t.Parallel()
   105  			// init
   106  			config := test.terraformExecuteOptions
   107  			utils := newTerraformExecuteTestsUtils()
   108  			utils.StdoutReturn = map[string]string{}
   109  			utils.StdoutReturn["terraform output -json"] = "{}"
   110  			utils.StdoutReturn["terraform -chgdir=src output -json"] = "{}"
   111  
   112  			runner := utils.ExecMockRunner
   113  
   114  			// test
   115  			err := runTerraformExecute(&config, nil, utils, &terraformExecuteCommonPipelineEnvironment{})
   116  
   117  			// assert
   118  			assert.NoError(t, err)
   119  
   120  			if config.Init {
   121  				assert.Equal(t, mock.ExecCall{Exec: "terraform", Params: append(config.GlobalOptions, "init", "-no-color")}, utils.Calls[0])
   122  				assert.Equal(t, mock.ExecCall{Exec: "terraform", Params: test.expectedArgs}, utils.Calls[1])
   123  			} else {
   124  				assert.Equal(t, mock.ExecCall{Exec: "terraform", Params: test.expectedArgs}, utils.Calls[0])
   125  			}
   126  
   127  			assert.Subset(t, runner.Env, test.expectedEnvVars)
   128  		})
   129  	}
   130  
   131  	t.Run("Outputs get injected into CPE", func(t *testing.T) {
   132  		t.Parallel()
   133  
   134  		cpe := terraformExecuteCommonPipelineEnvironment{}
   135  
   136  		config := terraformExecuteOptions{
   137  			Command: "plan",
   138  		}
   139  		utils := newTerraformExecuteTestsUtils()
   140  		utils.StdoutReturn = map[string]string{}
   141  		utils.StdoutReturn["terraform output -json"] = `{
   142  			"sample_var": {
   143  				"sensitive": true,
   144  				"value": "a secret value",
   145  				"type": "string"
   146  			}
   147  }
   148  		`
   149  
   150  		// test
   151  		err := runTerraformExecute(&config, nil, utils, &cpe)
   152  
   153  		// assert
   154  		assert.NoError(t, err)
   155  		assert.Equal(t, 1, len(cpe.custom.terraformOutputs))
   156  		assert.Equal(t, "a secret value", cpe.custom.terraformOutputs["sample_var"])
   157  	})
   158  }