github.com/xgoffin/jenkins-library@v1.154.0/cmd/helmExecute_test.go (about)

     1  package cmd
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/SAP/jenkins-library/pkg/kubernetes/mocks"
     8  	"github.com/pkg/errors"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestRunHelmUpgrade(t *testing.T) {
    13  	t.Parallel()
    14  
    15  	testTable := []struct {
    16  		config         helmExecuteOptions
    17  		methodError    error
    18  		expectedErrStr string
    19  	}{
    20  		{
    21  			config: helmExecuteOptions{
    22  				HelmCommand: "upgrade",
    23  			},
    24  			methodError: nil,
    25  		},
    26  		{
    27  			config: helmExecuteOptions{
    28  				HelmCommand: "upgrade",
    29  			},
    30  			methodError:    errors.New("some error"),
    31  			expectedErrStr: "failed to execute upgrade: some error",
    32  		},
    33  	}
    34  
    35  	for i, testCase := range testTable {
    36  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
    37  			helmExecute := &mocks.HelmExecutor{}
    38  			helmExecute.On("RunHelmUpgrade").Return(testCase.methodError)
    39  
    40  			err := runHelmExecute(testCase.config, helmExecute)
    41  			if err != nil {
    42  				assert.Equal(t, testCase.expectedErrStr, err.Error())
    43  			}
    44  		})
    45  
    46  	}
    47  }
    48  
    49  func TestRunHelmLint(t *testing.T) {
    50  	t.Parallel()
    51  
    52  	testTable := []struct {
    53  		config         helmExecuteOptions
    54  		expectedConfig []string
    55  		methodError    error
    56  		expectedErrStr string
    57  	}{
    58  		{
    59  			config: helmExecuteOptions{
    60  				HelmCommand: "lint",
    61  			},
    62  			methodError: nil,
    63  		},
    64  		{
    65  			config: helmExecuteOptions{
    66  				HelmCommand: "lint",
    67  			},
    68  			methodError:    errors.New("some error"),
    69  			expectedErrStr: "failed to execute helm lint: some error",
    70  		},
    71  	}
    72  
    73  	for i, testCase := range testTable {
    74  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
    75  			helmExecute := &mocks.HelmExecutor{}
    76  			helmExecute.On("RunHelmLint").Return(testCase.methodError)
    77  
    78  			err := runHelmExecute(testCase.config, helmExecute)
    79  			if err != nil {
    80  				assert.Equal(t, testCase.expectedErrStr, err.Error())
    81  			}
    82  		})
    83  
    84  	}
    85  }
    86  
    87  func TestRunHelmInstall(t *testing.T) {
    88  	t.Parallel()
    89  
    90  	testTable := []struct {
    91  		config         helmExecuteOptions
    92  		expectedConfig []string
    93  		methodError    error
    94  		expectedErrStr string
    95  	}{
    96  		{
    97  			config: helmExecuteOptions{
    98  				HelmCommand: "install",
    99  			},
   100  			methodError: nil,
   101  		},
   102  		{
   103  			config: helmExecuteOptions{
   104  				HelmCommand: "install",
   105  			},
   106  			methodError:    errors.New("some error"),
   107  			expectedErrStr: "failed to execute helm install: some error",
   108  		},
   109  	}
   110  
   111  	for i, testCase := range testTable {
   112  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
   113  			helmExecute := &mocks.HelmExecutor{}
   114  			helmExecute.On("RunHelmInstall").Return(testCase.methodError)
   115  
   116  			err := runHelmExecute(testCase.config, helmExecute)
   117  			if err != nil {
   118  				assert.Equal(t, testCase.expectedErrStr, err.Error())
   119  			}
   120  		})
   121  
   122  	}
   123  }
   124  
   125  func TestRunHelmTest(t *testing.T) {
   126  	t.Parallel()
   127  
   128  	testTable := []struct {
   129  		config         helmExecuteOptions
   130  		methodError    error
   131  		expectedErrStr string
   132  	}{
   133  		{
   134  			config: helmExecuteOptions{
   135  				HelmCommand: "test",
   136  			},
   137  			methodError: nil,
   138  		},
   139  		{
   140  			config: helmExecuteOptions{
   141  				HelmCommand: "test",
   142  			},
   143  			methodError:    errors.New("some error"),
   144  			expectedErrStr: "failed to execute helm test: some error",
   145  		},
   146  	}
   147  
   148  	for i, testCase := range testTable {
   149  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
   150  			helmExecute := &mocks.HelmExecutor{}
   151  			helmExecute.On("RunHelmTest").Return(testCase.methodError)
   152  
   153  			err := runHelmExecute(testCase.config, helmExecute)
   154  			if err != nil {
   155  				assert.Equal(t, testCase.expectedErrStr, err.Error())
   156  			}
   157  		})
   158  
   159  	}
   160  }
   161  
   162  func TestRunHelmUninstall(t *testing.T) {
   163  	t.Parallel()
   164  
   165  	testTable := []struct {
   166  		config         helmExecuteOptions
   167  		methodError    error
   168  		expectedErrStr string
   169  	}{
   170  		{
   171  			config: helmExecuteOptions{
   172  				HelmCommand: "uninstall",
   173  			},
   174  			methodError: nil,
   175  		},
   176  		{
   177  			config: helmExecuteOptions{
   178  				HelmCommand: "uninstall",
   179  			},
   180  			methodError:    errors.New("some error"),
   181  			expectedErrStr: "failed to execute helm uninstall: some error",
   182  		},
   183  	}
   184  
   185  	for i, testCase := range testTable {
   186  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
   187  			helmExecute := &mocks.HelmExecutor{}
   188  			helmExecute.On("RunHelmUninstall").Return(testCase.methodError)
   189  
   190  			err := runHelmExecute(testCase.config, helmExecute)
   191  			if err != nil {
   192  				assert.Equal(t, testCase.expectedErrStr, err.Error())
   193  			}
   194  		})
   195  
   196  	}
   197  }
   198  
   199  func TestRunHelmPackage(t *testing.T) {
   200  	t.Parallel()
   201  
   202  	testTable := []struct {
   203  		config         helmExecuteOptions
   204  		methodError    error
   205  		expectedErrStr string
   206  	}{
   207  		{
   208  			config: helmExecuteOptions{
   209  				HelmCommand: "package",
   210  			},
   211  			methodError: nil,
   212  		},
   213  		{
   214  			config: helmExecuteOptions{
   215  				HelmCommand: "package",
   216  			},
   217  			methodError:    errors.New("some error"),
   218  			expectedErrStr: "failed to execute helm package: some error",
   219  		},
   220  	}
   221  
   222  	for i, testCase := range testTable {
   223  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
   224  			helmExecute := &mocks.HelmExecutor{}
   225  			helmExecute.On("RunHelmPackage").Return(testCase.methodError)
   226  
   227  			err := runHelmExecute(testCase.config, helmExecute)
   228  			if err != nil {
   229  				assert.Equal(t, testCase.expectedErrStr, err.Error())
   230  			}
   231  		})
   232  
   233  	}
   234  }
   235  
   236  func TestRunHelmPush(t *testing.T) {
   237  	t.Parallel()
   238  
   239  	testTable := []struct {
   240  		config         helmExecuteOptions
   241  		methodError    error
   242  		expectedErrStr string
   243  	}{
   244  		{
   245  			config: helmExecuteOptions{
   246  				HelmCommand: "publish",
   247  			},
   248  			methodError: nil,
   249  		},
   250  		{
   251  			config: helmExecuteOptions{
   252  				HelmCommand: "publish",
   253  			},
   254  			methodError:    errors.New("some error"),
   255  			expectedErrStr: "failed to execute helm publish: some error",
   256  		},
   257  	}
   258  
   259  	for i, testCase := range testTable {
   260  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
   261  			helmExecute := &mocks.HelmExecutor{}
   262  			helmExecute.On("RunHelmPublish").Return(testCase.methodError)
   263  
   264  			err := runHelmExecute(testCase.config, helmExecute)
   265  			if err != nil {
   266  				assert.Equal(t, testCase.expectedErrStr, err.Error())
   267  			}
   268  		})
   269  
   270  	}
   271  }
   272  
   273  func TestRunHelmDefaultCommand(t *testing.T) {
   274  	t.Parallel()
   275  
   276  	testTable := []struct {
   277  		config             helmExecuteOptions
   278  		methodLintError    error
   279  		methodPackageError error
   280  		methodPublishError error
   281  		expectedErrStr     string
   282  	}{
   283  		{
   284  			config: helmExecuteOptions{
   285  				HelmCommand: "",
   286  			},
   287  			methodLintError:    nil,
   288  			methodPackageError: nil,
   289  			methodPublishError: nil,
   290  		},
   291  		{
   292  			config: helmExecuteOptions{
   293  				HelmCommand: "",
   294  			},
   295  			methodLintError: errors.New("some error"),
   296  			expectedErrStr:  "failed to execute helm lint: some error",
   297  		},
   298  		{
   299  			config: helmExecuteOptions{
   300  				HelmCommand: "",
   301  			},
   302  			methodPackageError: errors.New("some error"),
   303  			expectedErrStr:     "failed to execute helm package: some error",
   304  		},
   305  		{
   306  			config: helmExecuteOptions{
   307  				HelmCommand: "",
   308  			},
   309  			methodPublishError: errors.New("some error"),
   310  			expectedErrStr:     "failed to execute helm publish: some error",
   311  		},
   312  	}
   313  
   314  	for i, testCase := range testTable {
   315  		t.Run(fmt.Sprint("case ", i), func(t *testing.T) {
   316  			helmExecute := &mocks.HelmExecutor{}
   317  			helmExecute.On("RunHelmLint").Return(testCase.methodLintError)
   318  			helmExecute.On("RunHelmPackage").Return(testCase.methodPackageError)
   319  			helmExecute.On("RunHelmPublish").Return(testCase.methodPublishError)
   320  
   321  			err := runHelmExecute(testCase.config, helmExecute)
   322  			if err != nil {
   323  				assert.Equal(t, testCase.expectedErrStr, err.Error())
   324  			}
   325  
   326  		})
   327  	}
   328  
   329  }