github.com/ouraigua/jenkins-library@v0.0.0-20231028010029-fbeaf2f3aa9b/cmd/kubernetesDeploy_test.go (about) 1 //go:build unit 2 // +build unit 3 4 package cmd 5 6 import ( 7 "bytes" 8 "fmt" 9 "testing" 10 11 "github.com/SAP/jenkins-library/pkg/mock" 12 "github.com/SAP/jenkins-library/pkg/telemetry" 13 14 "github.com/stretchr/testify/assert" 15 "github.com/stretchr/testify/require" 16 ) 17 18 type kubernetesDeployMockUtils struct { 19 shouldFail bool 20 *mock.FilesMock 21 *mock.ExecMockRunner 22 *mock.HttpClientMock 23 } 24 25 func newKubernetesDeployMockUtils() kubernetesDeployMockUtils { 26 utils := kubernetesDeployMockUtils{ 27 shouldFail: false, 28 FilesMock: &mock.FilesMock{}, 29 ExecMockRunner: &mock.ExecMockRunner{}, 30 } 31 return utils 32 } 33 34 func TestRunKubernetesDeploy(t *testing.T) { 35 36 t.Run("test helm", func(t *testing.T) { 37 opts := kubernetesDeployOptions{ 38 ContainerRegistryURL: "https://my.registry:55555", 39 ContainerRegistryUser: "registryUser", 40 ContainerRegistryPassword: "dummy", 41 ContainerRegistrySecret: "testSecret", 42 ChartPath: "path/to/chart", 43 DeploymentName: "deploymentName", 44 DeployTool: "helm", 45 ForceUpdates: true, 46 RenderSubchartNotes: true, 47 HelmDeployWaitSeconds: 400, 48 IngressHosts: []string{"ingress.host1", "ingress.host2"}, 49 Image: "path/to/Image:latest", 50 AdditionalParameters: []string{"--testParam", "testValue"}, 51 KubeContext: "testCluster", 52 Namespace: "deploymentNamespace", 53 DockerConfigJSON: ".pipeline/docker/config.json", 54 } 55 56 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 57 58 mockUtils := newKubernetesDeployMockUtils() 59 mockUtils.StdoutReturn = map[string]string{ 60 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 61 } 62 63 var stdout bytes.Buffer 64 65 telemetryData := &telemetry.CustomData{} 66 67 runKubernetesDeploy(opts, telemetryData, mockUtils, &stdout) 68 69 assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command") 70 assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters") 71 72 assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command") 73 assert.Equal(t, []string{"create", "secret", "generic", "testSecret", "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 74 "--type=kubernetes.io/dockerconfigjson", "--insecure-skip-tls-verify=true", "--dry-run=client", "--output=json"}, 75 mockUtils.Calls[1].Params, "Wrong secret creation parameters") 76 77 assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command") 78 assert.Equal(t, []string{ 79 "upgrade", 80 "deploymentName", 81 "path/to/chart", 82 "--install", 83 "--namespace", 84 "deploymentNamespace", 85 "--set", 86 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret,ingress.hosts[0]=ingress.host1,ingress.hosts[1]=ingress.host2", 87 "--force", 88 "--wait", 89 "--timeout", 90 "400", 91 "--atomic", 92 "--kube-context", 93 "testCluster", 94 "--render-subchart-notes", 95 "--testParam", 96 "testValue", 97 }, mockUtils.Calls[2].Params, "Wrong upgrade parameters") 98 99 assert.Equal(t, &telemetry.CustomData{ 100 Custom1Label: "deployTool", 101 Custom1: "helm", 102 }, telemetryData) 103 }) 104 105 t.Run("test helm - with containerImageName and containerImageTag instead of image", func(t *testing.T) { 106 opts := kubernetesDeployOptions{ 107 ContainerRegistryURL: "https://my.registry:55555", 108 ContainerRegistryUser: "registryUser", 109 ContainerRegistryPassword: "dummy", 110 ContainerRegistrySecret: "testSecret", 111 ChartPath: "path/to/chart", 112 DeploymentName: "deploymentName", 113 DeployTool: "helm", 114 ForceUpdates: true, 115 HelmDeployWaitSeconds: 400, 116 IngressHosts: []string{"ingress.host1", "ingress.host2"}, 117 ContainerImageTag: "latest", 118 ContainerImageName: "path/to/Image", 119 AdditionalParameters: []string{"--testParam", "testValue"}, 120 KubeContext: "testCluster", 121 Namespace: "deploymentNamespace", 122 DockerConfigJSON: ".pipeline/docker/config.json", 123 } 124 125 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 126 127 mockUtils := newKubernetesDeployMockUtils() 128 mockUtils.StdoutReturn = map[string]string{ 129 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 130 } 131 132 var stdout bytes.Buffer 133 134 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 135 136 assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command") 137 assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters") 138 139 assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command") 140 assert.Equal(t, []string{ 141 "create", 142 "secret", 143 "generic", 144 "testSecret", 145 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 146 "--type=kubernetes.io/dockerconfigjson", 147 "--insecure-skip-tls-verify=true", 148 "--dry-run=client", 149 "--output=json"}, 150 mockUtils.Calls[1].Params, "Wrong secret creation parameters") 151 152 assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command") 153 154 assert.Contains(t, mockUtils.Calls[2].Params, "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret,ingress.hosts[0]=ingress.host1,ingress.hosts[1]=ingress.host2", "Wrong upgrade parameters") 155 }) 156 157 t.Run("test helm - docker config.json path passed as parameter", func(t *testing.T) { 158 opts := kubernetesDeployOptions{ 159 ContainerRegistryURL: "https://my.registry:55555", 160 DockerConfigJSON: "/path/to/.docker/config.json", 161 ContainerRegistryUser: "registryUser", 162 ContainerRegistryPassword: "dummy", 163 ContainerRegistrySecret: "testSecret", 164 ChartPath: "path/to/chart", 165 DeploymentName: "deploymentName", 166 DeployTool: "helm", 167 ForceUpdates: true, 168 HelmDeployWaitSeconds: 400, 169 IngressHosts: []string{"ingress.host1", "ingress.host2"}, 170 Image: "path/to/Image:latest", 171 AdditionalParameters: []string{"--testParam", "testValue"}, 172 KubeContext: "testCluster", 173 Namespace: "deploymentNamespace", 174 } 175 176 k8sSecretSpec := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 177 178 mockUtils := newKubernetesDeployMockUtils() 179 mockUtils.AddFile("/path/to/.docker/config.json", []byte(`{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}`)) 180 mockUtils.StdoutReturn = map[string]string{ 181 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=/path/to/.docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: k8sSecretSpec, 182 } 183 184 var stdout bytes.Buffer 185 186 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 187 assert.NoError(t, err) 188 189 assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command") 190 assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters") 191 192 assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command") 193 assert.Equal(t, []string{ 194 "create", 195 "secret", 196 "generic", 197 "testSecret", 198 "--from-file=.dockerconfigjson=/path/to/.docker/config.json", 199 "--type=kubernetes.io/dockerconfigjson", 200 "--insecure-skip-tls-verify=true", 201 "--dry-run=client", 202 "--output=json"}, 203 mockUtils.Calls[1].Params, "Wrong secret creation parameters") 204 205 assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command") 206 assert.Equal(t, []string{ 207 "upgrade", 208 "deploymentName", 209 "path/to/chart", 210 "--install", 211 "--namespace", 212 "deploymentNamespace", 213 "--set", 214 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret,ingress.hosts[0]=ingress.host1,ingress.hosts[1]=ingress.host2", 215 "--force", 216 "--wait", 217 "--timeout", 218 "400", 219 "--atomic", 220 "--kube-context", 221 "testCluster", 222 "--testParam", 223 "testValue", 224 }, mockUtils.Calls[2].Params, "Wrong upgrade parameters") 225 }) 226 227 t.Run("test helm -- keep failed deployment", func(t *testing.T) { 228 opts := kubernetesDeployOptions{ 229 ContainerRegistryURL: "https://my.registry:55555", 230 ContainerRegistryUser: "registryUser", 231 ContainerRegistryPassword: "dummy", 232 ContainerRegistrySecret: "testSecret", 233 ChartPath: "path/to/chart", 234 DeploymentName: "deploymentName", 235 DeployTool: "helm", 236 ForceUpdates: true, 237 HelmDeployWaitSeconds: 400, 238 IngressHosts: []string{"ingress.host1", "ingress.host2"}, 239 Image: "path/to/Image:latest", 240 AdditionalParameters: []string{"--testParam", "testValue"}, 241 KubeContext: "testCluster", 242 Namespace: "deploymentNamespace", 243 KeepFailedDeployments: true, 244 DockerConfigJSON: ".pipeline/docker/config.json", 245 } 246 247 k8sSecretSpec := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 248 249 mockUtils := newKubernetesDeployMockUtils() 250 mockUtils.StdoutReturn = map[string]string{ 251 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: k8sSecretSpec, 252 } 253 254 var stdout bytes.Buffer 255 256 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 257 258 assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong init command") 259 assert.Equal(t, []string{"init", "--client-only"}, mockUtils.Calls[0].Params, "Wrong init parameters") 260 261 assert.Equal(t, "kubectl", mockUtils.Calls[1].Exec, "Wrong secret creation command") 262 assert.Equal(t, []string{ 263 "create", 264 "secret", 265 "generic", 266 "testSecret", 267 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 268 "--type=kubernetes.io/dockerconfigjson", 269 "--insecure-skip-tls-verify=true", 270 "--dry-run=client", 271 "--output=json"}, 272 mockUtils.Calls[1].Params, "Wrong secret creation parameters") 273 274 assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong upgrade command") 275 assert.Equal(t, []string{ 276 "upgrade", 277 "deploymentName", 278 "path/to/chart", 279 "--install", 280 "--namespace", 281 "deploymentNamespace", 282 "--set", 283 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret,ingress.hosts[0]=ingress.host1,ingress.hosts[1]=ingress.host2", 284 "--force", 285 "--wait", 286 "--timeout", 287 "400", 288 "--kube-context", 289 "testCluster", 290 "--testParam", 291 "testValue", 292 }, mockUtils.Calls[2].Params, "Wrong upgrade parameters") 293 }) 294 295 t.Run("test helm - fails without image information", func(t *testing.T) { 296 opts := kubernetesDeployOptions{ 297 ContainerRegistryURL: "https://my.registry:55555", 298 ContainerRegistrySecret: "testSecret", 299 ChartPath: "path/to/chart", 300 DeploymentName: "deploymentName", 301 DeployTool: "helm", 302 ForceUpdates: true, 303 HelmDeployWaitSeconds: 400, 304 IngressHosts: []string{}, 305 AdditionalParameters: []string{"--testParam", "testValue"}, 306 KubeContext: "testCluster", 307 Namespace: "deploymentNamespace", 308 } 309 mockUtils := newKubernetesDeployMockUtils() 310 311 var stdout bytes.Buffer 312 313 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 314 assert.EqualError(t, err, "failed to process deployment values: image information not given - please either set image or containerImageName and containerImageTag") 315 }) 316 317 t.Run("test helm v3", func(t *testing.T) { 318 opts := kubernetesDeployOptions{ 319 ContainerRegistryURL: "https://my.registry:55555", 320 ContainerRegistryUser: "registryUser", 321 ContainerRegistryPassword: "dummy", 322 ContainerRegistrySecret: "testSecret", 323 ChartPath: "path/to/chart", 324 DeploymentName: "deploymentName", 325 DeployTool: "helm3", 326 ForceUpdates: true, 327 HelmDeployWaitSeconds: 400, 328 HelmValues: []string{"values1.yaml", "values2.yaml"}, 329 Image: "path/to/Image:latest", 330 AdditionalParameters: []string{"--testParam", "testValue"}, 331 KubeContext: "testCluster", 332 Namespace: "deploymentNamespace", 333 DockerConfigJSON: ".pipeline/docker/config.json", 334 } 335 336 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 337 338 mockUtils := newKubernetesDeployMockUtils() 339 mockUtils.StdoutReturn = map[string]string{ 340 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 341 } 342 343 var stdout bytes.Buffer 344 345 telemetryData := &telemetry.CustomData{} 346 runKubernetesDeploy(opts, telemetryData, mockUtils, &stdout) 347 348 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 349 assert.Equal(t, []string{ 350 "create", 351 "secret", 352 "generic", 353 "testSecret", 354 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 355 "--type=kubernetes.io/dockerconfigjson", 356 "--insecure-skip-tls-verify=true", 357 "--dry-run=client", 358 "--output=json"}, 359 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 360 361 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 362 assert.Equal(t, []string{ 363 "upgrade", 364 "deploymentName", 365 "path/to/chart", 366 "--values", 367 "values1.yaml", 368 "--values", 369 "values2.yaml", 370 "--install", 371 "--namespace", 372 "deploymentNamespace", 373 "--set", 374 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", 375 "--force", 376 "--wait", 377 "--timeout", 378 "400s", 379 "--atomic", 380 "--kube-context", 381 "testCluster", 382 "--testParam", 383 "testValue", 384 }, mockUtils.Calls[1].Params, "Wrong upgrade parameters") 385 386 assert.Equal(t, &telemetry.CustomData{ 387 Custom1Label: "deployTool", 388 Custom1: "helm3", 389 }, telemetryData) 390 }) 391 392 t.Run("test helm v3 - runs helm tests", func(t *testing.T) { 393 opts := kubernetesDeployOptions{ 394 ContainerRegistryURL: "https://my.registry:55555", 395 ContainerRegistryUser: "registryUser", 396 ContainerRegistryPassword: "dummy", 397 ContainerRegistrySecret: "testSecret", 398 ChartPath: "path/to/chart", 399 DeploymentName: "deploymentName", 400 DeployTool: "helm3", 401 ForceUpdates: true, 402 HelmDeployWaitSeconds: 400, 403 HelmValues: []string{"values1.yaml", "values2.yaml"}, 404 Image: "path/to/Image:latest", 405 AdditionalParameters: []string{"--testParam", "testValue"}, 406 KubeContext: "testCluster", 407 Namespace: "deploymentNamespace", 408 DockerConfigJSON: ".pipeline/docker/config.json", 409 RunHelmTests: true, 410 HelmTestWaitSeconds: 400, 411 } 412 413 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 414 415 mockUtils := newKubernetesDeployMockUtils() 416 mockUtils.StdoutReturn = map[string]string{ 417 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 418 } 419 420 var stdout bytes.Buffer 421 422 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 423 424 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 425 assert.Equal(t, []string{ 426 "create", 427 "secret", 428 "generic", 429 "testSecret", 430 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 431 "--type=kubernetes.io/dockerconfigjson", 432 "--insecure-skip-tls-verify=true", 433 "--dry-run=client", 434 "--output=json"}, 435 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 436 437 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 438 assert.Equal(t, []string{ 439 "upgrade", 440 "deploymentName", 441 "path/to/chart", 442 "--values", 443 "values1.yaml", 444 "--values", 445 "values2.yaml", 446 "--install", 447 "--namespace", 448 "deploymentNamespace", 449 "--set", 450 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", 451 "--force", 452 "--wait", 453 "--timeout", 454 "400s", 455 "--atomic", 456 "--kube-context", 457 "testCluster", 458 "--testParam", 459 "testValue", 460 }, mockUtils.Calls[1].Params, "Wrong upgrade parameters") 461 462 assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong test command") 463 assert.Equal(t, []string{ 464 "test", 465 "deploymentName", 466 "--namespace", 467 "deploymentNamespace", 468 "--kube-context", 469 "testCluster", 470 "--timeout", 471 "400s", 472 }, mockUtils.Calls[2].Params, "Wrong test parameters") 473 }) 474 475 t.Run("test helm v3 - runs helm tests with logs", func(t *testing.T) { 476 opts := kubernetesDeployOptions{ 477 ContainerRegistryURL: "https://my.registry:55555", 478 ContainerRegistryUser: "registryUser", 479 ContainerRegistryPassword: "dummy", 480 ContainerRegistrySecret: "testSecret", 481 ChartPath: "path/to/chart", 482 DeploymentName: "deploymentName", 483 DeployTool: "helm3", 484 ForceUpdates: true, 485 HelmDeployWaitSeconds: 400, 486 HelmValues: []string{"values1.yaml", "values2.yaml"}, 487 Image: "path/to/Image:latest", 488 AdditionalParameters: []string{"--testParam", "testValue"}, 489 KubeContext: "testCluster", 490 Namespace: "deploymentNamespace", 491 DockerConfigJSON: ".pipeline/docker/config.json", 492 RunHelmTests: true, 493 ShowTestLogs: true, 494 HelmTestWaitSeconds: 400, 495 } 496 497 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 498 499 mockUtils := newKubernetesDeployMockUtils() 500 mockUtils.StdoutReturn = map[string]string{ 501 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 502 } 503 504 var stdout bytes.Buffer 505 506 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 507 508 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 509 assert.Equal(t, []string{ 510 "create", 511 "secret", 512 "generic", 513 "testSecret", 514 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 515 "--type=kubernetes.io/dockerconfigjson", 516 "--insecure-skip-tls-verify=true", 517 "--dry-run=client", 518 "--output=json"}, 519 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 520 521 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 522 assert.Equal(t, []string{ 523 "upgrade", 524 "deploymentName", 525 "path/to/chart", 526 "--values", 527 "values1.yaml", 528 "--values", 529 "values2.yaml", 530 "--install", 531 "--namespace", 532 "deploymentNamespace", 533 "--set", 534 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", 535 "--force", 536 "--wait", 537 "--timeout", 538 "400s", 539 "--atomic", 540 "--kube-context", 541 "testCluster", 542 "--testParam", 543 "testValue", 544 }, mockUtils.Calls[1].Params, "Wrong upgrade parameters") 545 546 assert.Equal(t, "helm", mockUtils.Calls[2].Exec, "Wrong test command") 547 assert.Equal(t, []string{ 548 "test", 549 "deploymentName", 550 "--namespace", 551 "deploymentNamespace", 552 "--kube-context", 553 "testCluster", 554 "--timeout", 555 "400s", 556 "--logs", 557 }, mockUtils.Calls[2].Params, "Wrong test parameters") 558 }) 559 560 t.Run("test helm v3 - should not run helm tests", func(t *testing.T) { 561 opts := kubernetesDeployOptions{ 562 ContainerRegistryURL: "https://my.registry:55555", 563 ContainerRegistryUser: "registryUser", 564 ContainerRegistryPassword: "dummy", 565 ContainerRegistrySecret: "testSecret", 566 ChartPath: "path/to/chart", 567 DeploymentName: "deploymentName", 568 DeployTool: "helm3", 569 ForceUpdates: true, 570 HelmDeployWaitSeconds: 400, 571 HelmValues: []string{"values1.yaml", "values2.yaml"}, 572 Image: "path/to/Image:latest", 573 AdditionalParameters: []string{"--testParam", "testValue"}, 574 KubeContext: "testCluster", 575 Namespace: "deploymentNamespace", 576 DockerConfigJSON: ".pipeline/docker/config.json", 577 RunHelmTests: false, 578 ShowTestLogs: true, 579 } 580 581 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 582 583 mockUtils := newKubernetesDeployMockUtils() 584 mockUtils.StdoutReturn = map[string]string{ 585 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 586 } 587 588 var stdout bytes.Buffer 589 590 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 591 592 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 593 assert.Equal(t, []string{ 594 "create", 595 "secret", 596 "generic", 597 "testSecret", 598 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 599 "--type=kubernetes.io/dockerconfigjson", 600 "--insecure-skip-tls-verify=true", 601 "--dry-run=client", 602 "--output=json"}, 603 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 604 605 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 606 assert.Equal(t, []string{ 607 "upgrade", 608 "deploymentName", 609 "path/to/chart", 610 "--values", 611 "values1.yaml", 612 "--values", 613 "values2.yaml", 614 "--install", 615 "--namespace", 616 "deploymentNamespace", 617 "--set", 618 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", 619 "--force", 620 "--wait", 621 "--timeout", 622 "400s", 623 "--atomic", 624 "--kube-context", 625 "testCluster", 626 "--testParam", 627 "testValue", 628 }, mockUtils.Calls[1].Params, "Wrong upgrade parameters") 629 630 assert.Equal(t, 2, len(mockUtils.Calls), "Too many helm calls") 631 }) 632 633 t.Run("test helm v3 - with containerImageName and containerImageTag instead of image", func(t *testing.T) { 634 opts := kubernetesDeployOptions{ 635 ContainerRegistryURL: "https://my.registry:55555", 636 ContainerRegistryUser: "registryUser", 637 ContainerRegistryPassword: "dummy", 638 ContainerRegistrySecret: "testSecret", 639 ChartPath: "path/to/chart", 640 DeploymentName: "deploymentName", 641 DeployTool: "helm3", 642 ForceUpdates: true, 643 HelmDeployWaitSeconds: 400, 644 HelmValues: []string{"values1.yaml", "values2.yaml"}, 645 ContainerImageName: "path/to/Image", 646 ContainerImageTag: "latest", 647 AdditionalParameters: []string{"--testParam", "testValue"}, 648 KubeContext: "testCluster", 649 Namespace: "deploymentNamespace", 650 DockerConfigJSON: ".pipeline/docker/config.json", 651 } 652 653 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 654 655 mockUtils := newKubernetesDeployMockUtils() 656 mockUtils.StdoutReturn = map[string]string{ 657 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 658 } 659 660 var stdout bytes.Buffer 661 662 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 663 664 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 665 assert.Equal(t, []string{ 666 "create", 667 "secret", 668 "generic", 669 "testSecret", 670 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 671 "--type=kubernetes.io/dockerconfigjson", 672 "--insecure-skip-tls-verify=true", 673 "--dry-run=client", 674 "--output=json"}, 675 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 676 677 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 678 679 assert.Contains(t, mockUtils.Calls[1].Params, "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", "Wrong upgrade parameters") 680 681 }) 682 683 t.Run("test helm v3 - with multiple images", func(t *testing.T) { 684 opts := kubernetesDeployOptions{ 685 ContainerRegistryURL: "https://my.registry:55555", 686 ContainerRegistryUser: "registryUser", 687 ContainerRegistryPassword: "dummy", 688 ContainerRegistrySecret: "testSecret", 689 ChartPath: "path/to/chart", 690 DeploymentName: "deploymentName", 691 DeployTool: "helm3", 692 ForceUpdates: true, 693 HelmDeployWaitSeconds: 400, 694 HelmValues: []string{"values1.yaml", "values2.yaml"}, 695 ImageNames: []string{"myImage", "myImage.sub1", "myImage.sub2"}, 696 ImageNameTags: []string{"myImage:myTag", "myImage-sub1:myTag", "myImage-sub2:myTag"}, 697 AdditionalParameters: []string{"--testParam", "testValue"}, 698 KubeContext: "testCluster", 699 Namespace: "deploymentNamespace", 700 DockerConfigJSON: ".pipeline/docker/config.json", 701 } 702 703 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 704 705 mockUtils := newKubernetesDeployMockUtils() 706 mockUtils.StdoutReturn = map[string]string{ 707 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 708 } 709 710 var stdout bytes.Buffer 711 712 require.NoError(t, runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout)) 713 714 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 715 assert.Equal(t, []string{ 716 "create", 717 "secret", 718 "generic", 719 "testSecret", 720 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 721 "--type=kubernetes.io/dockerconfigjson", 722 "--insecure-skip-tls-verify=true", 723 "--dry-run=client", 724 "--output=json"}, 725 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 726 727 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 728 729 assert.Contains(t, mockUtils.Calls[1].Params, `image.myImage.repository=my.registry:55555/myImage,image.myImage.tag=myTag,image.myImage_sub1.repository=my.registry:55555/myImage-sub1,image.myImage_sub1.tag=myTag,image.myImage_sub2.repository=my.registry:55555/myImage-sub2,image.myImage_sub2.tag=myTag,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret`, "Wrong upgrade parameters") 730 731 }) 732 733 t.Run("test helm v3 - with one image in multiple images array", func(t *testing.T) { 734 opts := kubernetesDeployOptions{ 735 ContainerRegistryURL: "https://my.registry:55555", 736 ContainerRegistryUser: "registryUser", 737 ContainerRegistryPassword: "dummy", 738 ContainerRegistrySecret: "testSecret", 739 ChartPath: "path/to/chart", 740 DeploymentName: "deploymentName", 741 DeployTool: "helm3", 742 ForceUpdates: true, 743 HelmDeployWaitSeconds: 400, 744 HelmValues: []string{"values1.yaml", "values2.yaml"}, 745 ImageNames: []string{"myImage"}, 746 ImageNameTags: []string{"myImage:myTag"}, 747 AdditionalParameters: []string{"--testParam", "testValue"}, 748 KubeContext: "testCluster", 749 Namespace: "deploymentNamespace", 750 DockerConfigJSON: ".pipeline/docker/config.json", 751 } 752 753 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 754 755 mockUtils := newKubernetesDeployMockUtils() 756 mockUtils.StdoutReturn = map[string]string{ 757 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 758 } 759 760 var stdout bytes.Buffer 761 762 require.NoError(t, runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout)) 763 764 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 765 assert.Equal(t, []string{ 766 "create", 767 "secret", 768 "generic", 769 "testSecret", 770 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 771 "--type=kubernetes.io/dockerconfigjson", 772 "--insecure-skip-tls-verify=true", 773 "--dry-run=client", 774 "--output=json"}, 775 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 776 777 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 778 779 assert.Contains(t, mockUtils.Calls[1].Params, `image.myImage.repository=my.registry:55555/myImage,image.myImage.tag=myTag,image.repository=my.registry:55555/myImage,image.tag=myTag,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret`, "Wrong upgrade parameters") 780 781 }) 782 783 t.Run("test helm v3 - with multiple images - missing ImageNameTags", func(t *testing.T) { 784 opts := kubernetesDeployOptions{ 785 ContainerRegistryURL: "https://my.registry:55555", 786 ContainerRegistryUser: "registryUser", 787 ContainerRegistryPassword: "dummy", 788 ContainerRegistrySecret: "testSecret", 789 ChartPath: "path/to/chart", 790 DeploymentName: "deploymentName", 791 DeployTool: "helm3", 792 ForceUpdates: true, 793 HelmDeployWaitSeconds: 400, 794 HelmValues: []string{"values1.yaml", "values2.yaml"}, 795 ImageNames: []string{"myImage", "myImage.sub1", "myImage.sub2"}, 796 ImageNameTags: []string{"myImage:myTag"}, 797 AdditionalParameters: []string{"--testParam", "testValue"}, 798 KubeContext: "testCluster", 799 Namespace: "deploymentNamespace", 800 DockerConfigJSON: ".pipeline/docker/config.json", 801 } 802 803 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 804 805 mockUtils := newKubernetesDeployMockUtils() 806 mockUtils.StdoutReturn = map[string]string{ 807 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 808 } 809 810 var stdout bytes.Buffer 811 812 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 813 assert.EqualError(t, err, "failed to process deployment values: number of imageNames and imageNameTags must be equal") 814 }) 815 816 t.Run("test helm v3 - with multiple images and valuesMapping", func(t *testing.T) { 817 opts := kubernetesDeployOptions{ 818 ContainerRegistryURL: "https://my.registry:55555", 819 ContainerRegistryUser: "registryUser", 820 ContainerRegistryPassword: "dummy", 821 ContainerRegistrySecret: "testSecret", 822 ChartPath: "path/to/chart", 823 DeploymentName: "deploymentName", 824 DeployTool: "helm3", 825 ForceUpdates: true, 826 HelmDeployWaitSeconds: 400, 827 HelmValues: []string{"values1.yaml", "values2.yaml"}, 828 ValuesMapping: map[string]interface{}{ 829 "subchart.image.registry": "image.myImage.repository", 830 "subchart.image.tag": "image.myImage.tag", 831 }, 832 ImageNames: []string{"myImage", "myImage.sub1", "myImage.sub2"}, 833 ImageNameTags: []string{"myImage:myTag", "myImage-sub1:myTag", "myImage-sub2:myTag"}, 834 AdditionalParameters: []string{"--testParam", "testValue"}, 835 KubeContext: "testCluster", 836 Namespace: "deploymentNamespace", 837 DockerConfigJSON: ".pipeline/docker/config.json", 838 } 839 840 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 841 842 mockUtils := newKubernetesDeployMockUtils() 843 mockUtils.StdoutReturn = map[string]string{ 844 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 845 } 846 847 var stdout bytes.Buffer 848 849 require.NoError(t, runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout)) 850 851 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 852 assert.Equal(t, []string{ 853 "create", 854 "secret", 855 "generic", 856 "testSecret", 857 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 858 "--type=kubernetes.io/dockerconfigjson", 859 "--insecure-skip-tls-verify=true", 860 "--dry-run=client", 861 "--output=json"}, 862 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 863 864 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 865 assert.Equal(t, len(mockUtils.Calls[1].Params), 21, "Unexpected upgrade command") 866 pos := 11 867 assert.Contains(t, mockUtils.Calls[1].Params[pos], "image.myImage.repository=my.registry:55555/myImage", "Missing update parameter") 868 assert.Contains(t, mockUtils.Calls[1].Params[pos], "image.myImage.tag=myTag", "Wrong upgrade parameters") 869 assert.Contains(t, mockUtils.Calls[1].Params[pos], "image.myImage_sub1.repository=my.registry:55555/myImage-sub1", "Missing update parameter") 870 assert.Contains(t, mockUtils.Calls[1].Params[pos], "image.myImage_sub1.tag=myTag", "Missing update parameter") 871 assert.Contains(t, mockUtils.Calls[1].Params[pos], "image.myImage_sub2.repository=my.registry:55555/myImage-sub2", "Missing update parameter") 872 assert.Contains(t, mockUtils.Calls[1].Params[pos], "image.myImage_sub2.tag=myTag,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==", "Missing update parameter") 873 assert.Contains(t, mockUtils.Calls[1].Params[pos], "imagePullSecrets[0].name=testSecret", "Missing update parameter") 874 assert.Contains(t, mockUtils.Calls[1].Params[pos], "subchart.image.registry=my.registry:55555/myImage", "Missing update parameter") 875 assert.Contains(t, mockUtils.Calls[1].Params[pos], "subchart.image.tag=myTag", "Missing update parameter") 876 }) 877 878 t.Run("test helm v3 - with multiple images and incorrect valuesMapping", func(t *testing.T) { 879 opts := kubernetesDeployOptions{ 880 ContainerRegistryURL: "https://my.registry:55555", 881 ContainerRegistryUser: "registryUser", 882 ContainerRegistryPassword: "dummy", 883 ContainerRegistrySecret: "testSecret", 884 ChartPath: "path/to/chart", 885 DeploymentName: "deploymentName", 886 DeployTool: "helm3", 887 ForceUpdates: true, 888 HelmDeployWaitSeconds: 400, 889 HelmValues: []string{"values1.yaml", "values2.yaml"}, 890 ValuesMapping: map[string]interface{}{ 891 "subchart.image.registry": false, 892 }, 893 ImageNames: []string{"myImage", "myImage.sub1", "myImage.sub2"}, 894 ImageNameTags: []string{"myImage:myTag", "myImage-sub1:myTag", "myImage-sub2:myTag"}, 895 AdditionalParameters: []string{"--testParam", "testValue"}, 896 KubeContext: "testCluster", 897 Namespace: "deploymentNamespace", 898 DockerConfigJSON: ".pipeline/docker/config.json", 899 } 900 901 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 902 903 mockUtils := newKubernetesDeployMockUtils() 904 mockUtils.StdoutReturn = map[string]string{ 905 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 906 } 907 908 var stdout bytes.Buffer 909 910 require.Error(t, runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout), "invalid path 'false' is used for valueMapping, only strings are supported") 911 912 }) 913 914 t.Run("test helm3 - fails without image information", func(t *testing.T) { 915 opts := kubernetesDeployOptions{ 916 ContainerRegistryURL: "https://my.registry:55555", 917 ContainerRegistrySecret: "testSecret", 918 ChartPath: "path/to/chart", 919 DeploymentName: "deploymentName", 920 DeployTool: "helm3", 921 ForceUpdates: true, 922 HelmDeployWaitSeconds: 400, 923 IngressHosts: []string{}, 924 AdditionalParameters: []string{"--testParam", "testValue"}, 925 KubeContext: "testCluster", 926 Namespace: "deploymentNamespace", 927 } 928 mockUtils := newKubernetesDeployMockUtils() 929 930 var stdout bytes.Buffer 931 932 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 933 assert.EqualError(t, err, "failed to process deployment values: image information not given - please either set image or containerImageName and containerImageTag") 934 }) 935 936 t.Run("test helm v3 - keep failed deployments", func(t *testing.T) { 937 opts := kubernetesDeployOptions{ 938 ContainerRegistryURL: "https://my.registry:55555", 939 ContainerRegistryUser: "registryUser", 940 ContainerRegistryPassword: "dummy", 941 ContainerRegistrySecret: "testSecret", 942 ChartPath: "path/to/chart", 943 DeploymentName: "deploymentName", 944 DeployTool: "helm3", 945 ForceUpdates: true, 946 HelmDeployWaitSeconds: 400, 947 HelmValues: []string{"values1.yaml", "values2.yaml"}, 948 Image: "path/to/Image:latest", 949 AdditionalParameters: []string{"--testParam", "testValue"}, 950 KubeContext: "testCluster", 951 Namespace: "deploymentNamespace", 952 KeepFailedDeployments: true, 953 DockerConfigJSON: ".pipeline/docker/config.json", 954 } 955 956 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 957 958 mockUtils := newKubernetesDeployMockUtils() 959 mockUtils.StdoutReturn = map[string]string{ 960 `kubectl create secret generic testSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json`: dockerConfigJSON, 961 } 962 963 var stdout bytes.Buffer 964 965 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 966 967 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong secret creation command") 968 assert.Equal(t, []string{ 969 "create", 970 "secret", 971 "generic", 972 "testSecret", 973 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 974 "--type=kubernetes.io/dockerconfigjson", 975 "--insecure-skip-tls-verify=true", 976 "--dry-run=client", 977 "--output=json"}, 978 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 979 980 assert.Equal(t, "helm", mockUtils.Calls[1].Exec, "Wrong upgrade command") 981 assert.Equal(t, []string{ 982 "upgrade", 983 "deploymentName", 984 "path/to/chart", 985 "--values", 986 "values1.yaml", 987 "--values", 988 "values2.yaml", 989 "--install", 990 "--namespace", 991 "deploymentNamespace", 992 "--set", 993 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,secret.name=testSecret,secret.dockerconfigjson=ThisIsOurBase64EncodedSecret==,imagePullSecrets[0].name=testSecret", 994 "--force", 995 "--wait", 996 "--timeout", 997 "400s", 998 "--kube-context", 999 "testCluster", 1000 "--testParam", 1001 "testValue", 1002 }, mockUtils.Calls[1].Params, "Wrong upgrade parameters") 1003 }) 1004 1005 t.Run("test helm v3 - no container credentials", func(t *testing.T) { 1006 opts := kubernetesDeployOptions{ 1007 ContainerRegistryURL: "https://my.registry:55555", 1008 ChartPath: "path/to/chart", 1009 ContainerRegistrySecret: "testSecret", 1010 DeploymentName: "deploymentName", 1011 DeployTool: "helm3", 1012 ForceUpdates: true, 1013 HelmDeployWaitSeconds: 400, 1014 IngressHosts: []string{}, 1015 Image: "path/to/Image:latest", 1016 AdditionalParameters: []string{"--testParam", "testValue"}, 1017 KubeContext: "testCluster", 1018 Namespace: "deploymentNamespace", 1019 } 1020 mockUtils := newKubernetesDeployMockUtils() 1021 1022 var stdout bytes.Buffer 1023 1024 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1025 1026 assert.Equal(t, 1, len(mockUtils.Calls), "Wrong number of upgrade commands") 1027 assert.Equal(t, "helm", mockUtils.Calls[0].Exec, "Wrong upgrade command") 1028 assert.Equal(t, []string{ 1029 "upgrade", 1030 "deploymentName", 1031 "path/to/chart", 1032 "--install", 1033 "--namespace", 1034 "deploymentNamespace", 1035 "--set", 1036 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,imagePullSecrets[0].name=testSecret", 1037 "--force", 1038 "--wait", 1039 "--timeout", 1040 "400s", 1041 "--atomic", 1042 "--kube-context", 1043 "testCluster", 1044 "--testParam", 1045 "testValue", 1046 }, mockUtils.Calls[0].Params, "Wrong upgrade parameters") 1047 }) 1048 1049 t.Run("test helm - use extensions", func(t *testing.T) { 1050 opts := kubernetesDeployOptions{ 1051 ContainerRegistryURL: "https://my.registry:55555", 1052 ChartPath: "path/to/chart", 1053 ContainerRegistrySecret: "testSecret", 1054 DeploymentName: "deploymentName", 1055 DeployTool: "helm3", 1056 IngressHosts: []string{}, 1057 Image: "path/to/Image:latest", 1058 KubeContext: "testCluster", 1059 Namespace: "deploymentNamespace", 1060 GithubToken: "testGHToken", 1061 SetupScript: "https://github.com/my/test/setup_script.sh", 1062 VerificationScript: "https://github.com/my/test/verification_script.sh", 1063 TeardownScript: "https://github.com/my/test/teardown_script.sh", 1064 } 1065 mockUtils := newKubernetesDeployMockUtils() 1066 mockUtils.HttpClientMock = &mock.HttpClientMock{HTTPFileUtils: mockUtils.FilesMock} 1067 1068 var stdout bytes.Buffer 1069 1070 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1071 1072 assert.Equal(t, 4, len(mockUtils.Calls)) 1073 assert.Equal(t, ".pipeline/setup_script.sh", mockUtils.Calls[0].Exec) 1074 assert.Equal(t, ".pipeline/verification_script.sh", mockUtils.Calls[2].Exec) 1075 assert.Equal(t, ".pipeline/teardown_script.sh", mockUtils.Calls[3].Exec) 1076 }) 1077 1078 t.Run("test helm v3 - fails without chart path", func(t *testing.T) { 1079 opts := kubernetesDeployOptions{ 1080 ContainerRegistryURL: "https://my.registry:55555", 1081 ContainerRegistrySecret: "testSecret", 1082 DeploymentName: "deploymentName", 1083 DeployTool: "helm3", 1084 ForceUpdates: true, 1085 HelmDeployWaitSeconds: 400, 1086 IngressHosts: []string{}, 1087 Image: "path/to/Image:latest", 1088 AdditionalParameters: []string{"--testParam", "testValue"}, 1089 KubeContext: "testCluster", 1090 Namespace: "deploymentNamespace", 1091 } 1092 mockUtils := newKubernetesDeployMockUtils() 1093 1094 var stdout bytes.Buffer 1095 1096 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1097 assert.EqualError(t, err, "chart path has not been set, please configure chartPath parameter") 1098 }) 1099 1100 t.Run("test helm v3 - fails without deployment name", func(t *testing.T) { 1101 opts := kubernetesDeployOptions{ 1102 ContainerRegistryURL: "https://my.registry:55555", 1103 ContainerRegistrySecret: "testSecret", 1104 ChartPath: "path/to/chart", 1105 DeployTool: "helm3", 1106 ForceUpdates: true, 1107 HelmDeployWaitSeconds: 400, 1108 IngressHosts: []string{}, 1109 Image: "path/to/Image:latest", 1110 AdditionalParameters: []string{"--testParam", "testValue"}, 1111 KubeContext: "testCluster", 1112 Namespace: "deploymentNamespace", 1113 } 1114 mockUtils := newKubernetesDeployMockUtils() 1115 1116 var stdout bytes.Buffer 1117 1118 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1119 assert.EqualError(t, err, "deployment name has not been set, please configure deploymentName parameter") 1120 }) 1121 1122 t.Run("test helm v3 - no force", func(t *testing.T) { 1123 opts := kubernetesDeployOptions{ 1124 ContainerRegistryURL: "https://my.registry:55555", 1125 ChartPath: "path/to/chart", 1126 ContainerRegistrySecret: "testSecret", 1127 DeploymentName: "deploymentName", 1128 DeployTool: "helm3", 1129 HelmDeployWaitSeconds: 400, 1130 IngressHosts: []string{}, 1131 Image: "path/to/Image:latest", 1132 AdditionalParameters: []string{"--testParam", "testValue"}, 1133 KubeContext: "testCluster", 1134 Namespace: "deploymentNamespace", 1135 } 1136 mockUtils := newKubernetesDeployMockUtils() 1137 1138 var stdout bytes.Buffer 1139 1140 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1141 assert.Equal(t, []string{ 1142 "upgrade", 1143 "deploymentName", 1144 "path/to/chart", 1145 "--install", 1146 "--namespace", 1147 "deploymentNamespace", 1148 "--set", 1149 "image.repository=my.registry:55555/path/to/Image,image.tag=latest,image.path/to/Image.repository=my.registry:55555/path/to/Image,image.path/to/Image.tag=latest,imagePullSecrets[0].name=testSecret", 1150 "--wait", 1151 "--timeout", 1152 "400s", 1153 "--atomic", 1154 "--kube-context", 1155 "testCluster", 1156 "--testParam", 1157 "testValue", 1158 }, mockUtils.Calls[0].Params, "Wrong upgrade parameters") 1159 }) 1160 1161 t.Run("test kubectl - create secret from docker config.json", func(t *testing.T) { 1162 1163 opts := kubernetesDeployOptions{ 1164 AppTemplate: "path/to/test.yaml", 1165 ContainerRegistryURL: "https://my.registry:55555", 1166 ContainerRegistryUser: "registryUser", 1167 ContainerRegistryPassword: "dummy", 1168 ContainerRegistrySecret: "regSecret", 1169 CreateDockerRegistrySecret: true, 1170 DeployTool: "kubectl", 1171 Image: "path/to/Image:latest", 1172 AdditionalParameters: []string{"--testParam", "testValue"}, 1173 KubeConfig: "This is my kubeconfig", 1174 KubeContext: "testCluster", 1175 Namespace: "deploymentNamespace", 1176 DeployCommand: "apply", 1177 DockerConfigJSON: ".pipeline/docker/config.json", 1178 } 1179 1180 kubeYaml := `kind: Deployment 1181 metadata: 1182 spec: 1183 spec: 1184 image: <image-name>` 1185 1186 dockerConfigJSON := `{"kind": "Secret","data":{".dockerconfigjson": "ThisIsOurBase64EncodedSecret=="}}` 1187 1188 mockUtils := newKubernetesDeployMockUtils() 1189 mockUtils.AddFile(opts.AppTemplate, []byte(kubeYaml)) 1190 1191 mockUtils.StdoutReturn = map[string]string{ 1192 `kubectl create secret generic regSecret --from-file=.dockerconfigjson=.pipeline/docker/config.json --type=kubernetes.io/dockerconfigjson --insecure-skip-tls-verify=true --dry-run=client --output=json --insecure-skip-tls-verify=true --namespace=deploymentNamespace --context=testCluster`: dockerConfigJSON, 1193 } 1194 var stdout bytes.Buffer 1195 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1196 1197 assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"}) 1198 1199 assert.Equal(t, []string{ 1200 "create", 1201 "secret", 1202 "generic", 1203 "regSecret", 1204 "--from-file=.dockerconfigjson=.pipeline/docker/config.json", 1205 "--type=kubernetes.io/dockerconfigjson", 1206 "--insecure-skip-tls-verify=true", 1207 "--dry-run=client", 1208 "--output=json", 1209 "--insecure-skip-tls-verify=true", 1210 "--namespace=deploymentNamespace", 1211 "--context=testCluster", 1212 }, 1213 mockUtils.Calls[0].Params, "Wrong secret creation parameters") 1214 1215 assert.Containsf(t, mockUtils.Calls[1].Params, "apply", "Wrong secret creation parameters") 1216 assert.Containsf(t, mockUtils.Calls[1].Params, "-f", "Wrong secret creation parameters") 1217 }) 1218 1219 t.Run("test kubectl - token only", func(t *testing.T) { 1220 1221 opts := kubernetesDeployOptions{ 1222 APIServer: "https://my.api.server", 1223 AppTemplate: "path/to/test.yaml", 1224 ContainerRegistryURL: "https://my.registry:55555", 1225 ContainerRegistrySecret: "regSecret", 1226 DeployTool: "kubectl", 1227 Image: "path/to/Image:latest", 1228 KubeToken: "testToken", 1229 Namespace: "deploymentNamespace", 1230 DeployCommand: "apply", 1231 } 1232 1233 mockUtils := newKubernetesDeployMockUtils() 1234 mockUtils.AddFile(opts.AppTemplate, []byte("testYaml")) 1235 mockUtils.ShouldFailOnCommand = map[string]error{} 1236 1237 var stdout bytes.Buffer 1238 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1239 1240 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command") 1241 assert.Equal(t, []string{ 1242 "--insecure-skip-tls-verify=true", 1243 fmt.Sprintf("--namespace=%v", opts.Namespace), 1244 fmt.Sprintf("--server=%v", opts.APIServer), 1245 fmt.Sprintf("--token=%v", opts.KubeToken), 1246 "apply", 1247 "--filename", 1248 opts.AppTemplate, 1249 }, mockUtils.Calls[0].Params, "kubectl parameters incorrect") 1250 }) 1251 1252 t.Run("test kubectl - with containerImageName and containerImageTag instead of image", func(t *testing.T) { 1253 opts := kubernetesDeployOptions{ 1254 APIServer: "https://my.api.server", 1255 AppTemplate: "test.yaml", 1256 ContainerRegistryURL: "https://my.registry:55555", 1257 ContainerRegistrySecret: "regSecret", 1258 DeployTool: "kubectl", 1259 ContainerImageTag: "latest", 1260 ContainerImageName: "path/to/Image", 1261 KubeConfig: "This is my kubeconfig", 1262 Namespace: "deploymentNamespace", 1263 DeployCommand: "apply", 1264 } 1265 1266 mockUtils := newKubernetesDeployMockUtils() 1267 mockUtils.AddFile("test.yaml", []byte("image: <image-name>")) 1268 1269 var stdout bytes.Buffer 1270 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1271 1272 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command") 1273 1274 appTemplateFileContents, err := mockUtils.FileRead(opts.AppTemplate) 1275 assert.NoError(t, err) 1276 assert.Contains(t, string(appTemplateFileContents), "image: my.registry:55555/path/to/Image:latest", "kubectl parameters incorrect") 1277 }) 1278 1279 t.Run("test kubectl - with containerImageName and containerImageTag instead of image using go template", func(t *testing.T) { 1280 opts := kubernetesDeployOptions{ 1281 APIServer: "https://my.api.server", 1282 AppTemplate: "test.yaml", 1283 ContainerRegistryURL: "https://my.registry:55555", 1284 ContainerRegistrySecret: "regSecret", 1285 DeployTool: "kubectl", 1286 ContainerImageTag: "latest", 1287 ContainerImageName: "path/to/Image", 1288 KubeConfig: "This is my kubeconfig", 1289 Namespace: "deploymentNamespace", 1290 DeployCommand: "apply", 1291 } 1292 1293 mockUtils := newKubernetesDeployMockUtils() 1294 mockUtils.AddFile("test.yaml", []byte("image: {{ .Values.image.repository }}:{{ .Values.image.tag }}")) 1295 1296 var stdout bytes.Buffer 1297 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1298 1299 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command") 1300 1301 appTemplateFileContents, err := mockUtils.FileRead(opts.AppTemplate) 1302 assert.NoError(t, err) 1303 assert.Contains(t, string(appTemplateFileContents), "image: my.registry:55555/path/to/Image:latest", "kubectl parameters incorrect") 1304 }) 1305 1306 t.Run("test kubectl - with multiple images using go template", func(t *testing.T) { 1307 opts := kubernetesDeployOptions{ 1308 APIServer: "https://my.api.server", 1309 AppTemplate: "test.yaml", 1310 ContainerRegistryURL: "https://my.registry:55555", 1311 ContainerRegistrySecret: "regSecret", 1312 DeployTool: "kubectl", 1313 KubeConfig: "This is my kubeconfig", 1314 Namespace: "deploymentNamespace", 1315 DeployCommand: "apply", 1316 ValuesMapping: map[string]interface{}{ 1317 "subchart.image.repository": "image.myImage.repository", 1318 "subchart.image.tag": "image.myImage.tag", 1319 }, 1320 ImageNames: []string{"myImage", "myImage-sub1", "myImage-sub2"}, 1321 ImageNameTags: []string{"myImage:myTag", "myImage-sub1:myTag", "myImage-sub2:myTag"}, 1322 } 1323 1324 mockUtils := newKubernetesDeployMockUtils() 1325 mockUtils.AddFile("test.yaml", []byte(`image: {{ .Values.image.myImage.repository }}:{{ .Values.image.myImage.tag }} 1326 image2: {{ .Values.subchart.image.repository }}:{{ .Values.subchart.image.tag }} 1327 image3: {{ .Values.image.myImage_sub1.repository }}:{{ .Values.image.myImage_sub1.tag }}`)) 1328 1329 var stdout bytes.Buffer 1330 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1331 1332 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command") 1333 1334 appTemplateFileContents, err := mockUtils.FileRead(opts.AppTemplate) 1335 assert.NoError(t, err) 1336 assert.Contains(t, string(appTemplateFileContents), "image: my.registry:55555/myImage:myTag\nimage2: my.registry:55555/myImage:myTag\nimage3: my.registry:55555/myImage-sub1:myTag", "kubectl parameters incorrect") 1337 }) 1338 1339 t.Run("test kubectl - with multiple images and digests", func(t *testing.T) { 1340 opts := kubernetesDeployOptions{ 1341 APIServer: "https://my.api.server", 1342 AppTemplate: "test.yaml", 1343 ContainerRegistryURL: "https://my.registry:55555", 1344 ContainerRegistrySecret: "regSecret", 1345 DeployTool: "kubectl", 1346 KubeConfig: "This is my kubeconfig", 1347 Namespace: "deploymentNamespace", 1348 DeployCommand: "apply", 1349 ValuesMapping: map[string]interface{}{ 1350 "subchart.image.repository": "image.myImage.repository", 1351 "subchart.image.tag": "image.myImage.tag", 1352 }, 1353 ImageNames: []string{"myImage", "myImage-sub1", "myImage-sub2"}, 1354 ImageNameTags: []string{"myImage:myTag", "myImage-sub1:myTag", "myImage-sub2:myTag"}, 1355 ImageDigests: []string{"sha256:111", "sha256:222", "sha256:333"}, 1356 } 1357 1358 mockUtils := newKubernetesDeployMockUtils() 1359 mockUtils.AddFile("test.yaml", []byte(`image: {{ .Values.image.myImage.repository }}:{{ .Values.image.myImage.tag }} 1360 image2: {{ .Values.subchart.image.repository }}:{{ .Values.subchart.image.tag }} 1361 image3: {{ .Values.image.myImage_sub1.repository }}:{{ .Values.image.myImage_sub1.tag }} 1362 image4: {{ .Values.image.myImage_sub2.repository }}:{{ .Values.image.myImage_sub2.tag }}`)) 1363 1364 var stdout bytes.Buffer 1365 runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1366 1367 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong apply command") 1368 1369 appTemplateFileContents, err := mockUtils.FileRead(opts.AppTemplate) 1370 assert.NoError(t, err) 1371 assert.Contains(t, string(appTemplateFileContents), `image: my.registry:55555/myImage:myTag@sha256:111 1372 image2: my.registry:55555/myImage:myTag@sha256:111 1373 image3: my.registry:55555/myImage-sub1:myTag@sha256:222 1374 image4: my.registry:55555/myImage-sub2:myTag@sha256:333`, "kubectl parameters incorrect") 1375 }) 1376 1377 t.Run("test kubectl - fail with multiple images using placeholder", func(t *testing.T) { 1378 opts := kubernetesDeployOptions{ 1379 APIServer: "https://my.api.server", 1380 AppTemplate: "test.yaml", 1381 ContainerRegistryURL: "https://my.registry:55555", 1382 ContainerRegistrySecret: "regSecret", 1383 DeployTool: "kubectl", 1384 KubeConfig: "This is my kubeconfig", 1385 Namespace: "deploymentNamespace", 1386 DeployCommand: "apply", 1387 ImageNames: []string{"myImage", "myImage-sub1", "myImage-sub2"}, 1388 ImageNameTags: []string{"myImage:myTag", "myImage-sub1:myTag", "myImage-sub2:myTag"}, 1389 } 1390 1391 mockUtils := newKubernetesDeployMockUtils() 1392 mockUtils.AddFile("test.yaml", []byte("image: <image-name>")) 1393 1394 var stdout bytes.Buffer 1395 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1396 assert.EqualError(t, err, "multi-image replacement not supported for single image placeholder") 1397 }) 1398 1399 t.Run("test kubectl - fails without image information", func(t *testing.T) { 1400 opts := kubernetesDeployOptions{ 1401 APIServer: "https://my.api.server", 1402 AppTemplate: "test.yaml", 1403 ContainerRegistryURL: "https://my.registry:55555", 1404 ContainerRegistrySecret: "regSecret", 1405 DeployTool: "kubectl", 1406 KubeConfig: "This is my kubeconfig", 1407 Namespace: "deploymentNamespace", 1408 DeployCommand: "apply", 1409 } 1410 1411 mockUtils := newKubernetesDeployMockUtils() 1412 mockUtils.AddFile("test.yaml", []byte("testYaml")) 1413 1414 var stdout bytes.Buffer 1415 1416 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1417 assert.EqualError(t, err, "failed to process deployment values: image information not given - please either set image or containerImageName and containerImageTag") 1418 }) 1419 1420 t.Run("test kubectl - use replace deploy command", func(t *testing.T) { 1421 opts := kubernetesDeployOptions{ 1422 AppTemplate: "test.yaml", 1423 ContainerRegistryURL: "https://my.registry:55555", 1424 ContainerRegistrySecret: "regSecret", 1425 CreateDockerRegistrySecret: true, 1426 DeployTool: "kubectl", 1427 Image: "path/to/Image:latest", 1428 AdditionalParameters: []string{"--testParam", "testValue"}, 1429 KubeConfig: "This is my kubeconfig", 1430 KubeContext: "testCluster", 1431 Namespace: "deploymentNamespace", 1432 DeployCommand: "replace", 1433 } 1434 1435 kubeYaml := `kind: Deployment 1436 metadata: 1437 spec: 1438 spec: 1439 image: <image-name>` 1440 1441 mockUtils := newKubernetesDeployMockUtils() 1442 mockUtils.AddFile("test.yaml", []byte(kubeYaml)) 1443 1444 var stdout bytes.Buffer 1445 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1446 assert.NoError(t, err, "Command should not fail") 1447 1448 assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"}) 1449 1450 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong replace command") 1451 assert.Equal(t, []string{ 1452 "--insecure-skip-tls-verify=true", 1453 fmt.Sprintf("--namespace=%v", opts.Namespace), 1454 fmt.Sprintf("--context=%v", opts.KubeContext), 1455 "replace", 1456 "--filename", 1457 opts.AppTemplate, 1458 "--testParam", 1459 "testValue", 1460 }, mockUtils.Calls[0].Params, "kubectl parameters incorrect") 1461 1462 appTemplate, err := mockUtils.FileRead(opts.AppTemplate) 1463 assert.Contains(t, string(appTemplate), "my.registry:55555/path/to/Image:latest") 1464 }) 1465 1466 t.Run("test kubectl - use replace --force deploy command", func(t *testing.T) { 1467 opts := kubernetesDeployOptions{ 1468 AppTemplate: "test.yaml", 1469 ContainerRegistryURL: "https://my.registry:55555", 1470 ContainerRegistrySecret: "regSecret", 1471 CreateDockerRegistrySecret: true, 1472 DeployTool: "kubectl", 1473 Image: "path/to/Image:latest", 1474 AdditionalParameters: []string{"--testParam", "testValue"}, 1475 KubeConfig: "This is my kubeconfig", 1476 KubeContext: "testCluster", 1477 Namespace: "deploymentNamespace", 1478 DeployCommand: "replace", 1479 ForceUpdates: true, 1480 } 1481 1482 kubeYaml := `kind: Deployment 1483 metadata: 1484 spec: 1485 spec: 1486 image: <image-name>` 1487 1488 mockUtils := newKubernetesDeployMockUtils() 1489 mockUtils.AddFile("test.yaml", []byte(kubeYaml)) 1490 1491 var stdout bytes.Buffer 1492 err := runKubernetesDeploy(opts, &telemetry.CustomData{}, mockUtils, &stdout) 1493 assert.NoError(t, err, "Command should not fail") 1494 1495 assert.Equal(t, mockUtils.Env, []string{"KUBECONFIG=This is my kubeconfig"}) 1496 1497 assert.Equal(t, "kubectl", mockUtils.Calls[0].Exec, "Wrong replace command") 1498 assert.Equal(t, []string{ 1499 "--insecure-skip-tls-verify=true", 1500 fmt.Sprintf("--namespace=%v", opts.Namespace), 1501 fmt.Sprintf("--context=%v", opts.KubeContext), 1502 "replace", 1503 "--filename", 1504 opts.AppTemplate, 1505 "--force", 1506 "--testParam", 1507 "testValue", 1508 }, mockUtils.Calls[0].Params, "kubectl parameters incorrect") 1509 1510 appTemplate, err := mockUtils.FileRead(opts.AppTemplate) 1511 assert.Contains(t, string(appTemplate), "my.registry:55555/path/to/Image:latest") 1512 }) 1513 1514 } 1515 1516 func TestSplitRegistryURL(t *testing.T) { 1517 tt := []struct { 1518 in string 1519 outProtocol string 1520 outRegistry string 1521 outError error 1522 }{ 1523 {in: "https://my.registry.com", outProtocol: "https", outRegistry: "my.registry.com", outError: nil}, 1524 {in: "https://", outProtocol: "", outRegistry: "", outError: fmt.Errorf("Failed to split registry url 'https://'")}, 1525 {in: "my.registry.com", outProtocol: "", outRegistry: "", outError: fmt.Errorf("Failed to split registry url 'my.registry.com'")}, 1526 {in: "", outProtocol: "", outRegistry: "", outError: fmt.Errorf("Failed to split registry url ''")}, 1527 {in: "https://https://my.registry.com", outProtocol: "", outRegistry: "", outError: fmt.Errorf("Failed to split registry url 'https://https://my.registry.com'")}, 1528 } 1529 1530 for _, test := range tt { 1531 p, r, err := splitRegistryURL(test.in) 1532 assert.Equal(t, test.outProtocol, p, "Protocol value unexpected") 1533 assert.Equal(t, test.outRegistry, r, "Registry value unexpected") 1534 assert.Equal(t, test.outError, err, "Error value not as expected") 1535 } 1536 1537 } 1538 1539 func TestSplitImageName(t *testing.T) { 1540 tt := []struct { 1541 in string 1542 outImage string 1543 outTag string 1544 outError error 1545 }{ 1546 {in: "", outImage: "", outTag: "", outError: fmt.Errorf("Failed to split image name ''")}, 1547 {in: "path/to/image", outImage: "path/to/image", outTag: "", outError: nil}, 1548 {in: "path/to/image:tag", outImage: "path/to/image", outTag: "tag", outError: nil}, 1549 {in: "https://my.registry.com/path/to/image:tag", outImage: "", outTag: "", outError: fmt.Errorf("Failed to split image name 'https://my.registry.com/path/to/image:tag'")}, 1550 } 1551 for _, test := range tt { 1552 i, tag, err := splitFullImageName(test.in) 1553 assert.Equal(t, test.outImage, i, "Image value unexpected") 1554 assert.Equal(t, test.outTag, tag, "Tag value unexpected") 1555 assert.Equal(t, test.outError, err, "Error value not as expected") 1556 } 1557 }