github.com/jaylevin/jenkins-library@v1.230.4/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 TestRunHelmDependency(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: "dependency", 210 }, 211 methodError: nil, 212 }, 213 { 214 config: helmExecuteOptions{ 215 HelmCommand: "dependency", 216 }, 217 methodError: errors.New("some error"), 218 expectedErrStr: "failed to execute helm dependency: 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("RunHelmDependency").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 dependency: 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("RunHelmDependency").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 }