2 # Licensed under the Apache License, Version 2.0 (the "License"); you may
3 # not use this file except in compliance with the License. You may obtain
4 # a copy of the License at
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
10 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
11 # License for the specific language governing permissions and limitations
14 # For those usages not covered by the Apache License, Version 2.0 please
15 # contact: alfonso.tiernosepulveda@telefonica.com
21 from asynctest
.mock
import Mock
22 from osm_common
.dbmemory
import DbMemory
23 from osm_common
.fslocal
import FsLocal
24 from n2vc
.k8s_helm_conn
import K8sHelmConnector
26 __author__
= "Isabel Lloret <illoret@indra.es>"
29 class TestK8sHelmConn(asynctest
.TestCase
):
30 logging
.basicConfig(level
=logging
.DEBUG
)
31 logger
= logging
.getLogger(__name__
)
32 logger
.setLevel(logging
.DEBUG
)
34 async def setUp(self
):
35 self
.db
= Mock(DbMemory())
36 self
.fs
= asynctest
.Mock(FsLocal())
37 self
.fs
.path
= "./tmp/"
38 self
.namespace
= "testk8s"
39 self
.service_account
= "osm"
40 self
.cluster_id
= "helm_cluster_id"
41 self
.cluster_uuid
= self
.cluster_id
42 # pass fake kubectl and helm commands to make sure it does not call actual commands
43 K8sHelmConnector
._check
_file
_exists
= asynctest
.Mock(return_value
=True)
44 K8sHelmConnector
._local
_async
_exec
= asynctest
.CoroutineMock(
47 cluster_dir
= self
.fs
.path
+ self
.cluster_id
48 self
.kube_config
= self
.fs
.path
+ self
.cluster_id
+ "/.kube/config"
49 self
.helm_home
= self
.fs
.path
+ self
.cluster_id
+ "/.helm"
51 "HELM_HOME": "{}/.helm".format(cluster_dir
),
52 "KUBECONFIG": "{}/.kube/config".format(cluster_dir
),
54 self
.helm_conn
= K8sHelmConnector(self
.fs
, self
.db
, log
=self
.logger
)
55 self
.logger
.debug("Set up executed")
57 @asynctest.fail_on(active_handles
=True)
58 async def test_init_env(self
):
62 @asynctest.fail_on(active_handles
=True)
63 async def test_repo_add(self
):
65 repo_url
= "https://charts.bitnami.com/bitnami"
66 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
68 await self
.helm_conn
.repo_add(self
.cluster_uuid
, repo_name
, repo_url
)
70 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
71 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
72 from_path
=self
.cluster_id
75 self
.helm_conn
._local
_async
_exec
.call_count
,
77 "local_async_exec expected 2 calls, called {}".format(
78 self
.helm_conn
._local
_async
_exec
.call_count
82 repo_update_command
= (
83 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm repo update {}"
86 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm repo add {} {}"
87 ).format(repo_name
, repo_url
)
88 calls
= self
.helm_conn
._local
_async
_exec
.call_args_list
89 call0_kargs
= calls
[0][1]
91 call0_kargs
.get("command"),
93 "Invalid repo add command: {}".format(call0_kargs
.get("command")),
96 call0_kargs
.get("env"),
98 "Invalid env for add command: {}".format(call0_kargs
.get("env")),
100 call1_kargs
= calls
[1][1]
102 call1_kargs
.get("command"),
104 "Invalid repo update command: {}".format(call1_kargs
.get("command")),
107 call1_kargs
.get("env"),
109 "Invalid env for update command: {}".format(call1_kargs
.get("env")),
112 @asynctest.fail_on(active_handles
=True)
113 async def test_repo_list(self
):
114 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
116 await self
.helm_conn
.repo_list(self
.cluster_uuid
)
118 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
119 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
120 from_path
=self
.cluster_id
122 command
= "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm repo list --output yaml"
123 self
.helm_conn
._local
_async
_exec
.assert_called_with(
124 command
=command
, env
=self
.env
, raise_exception_on_error
=False
127 @asynctest.fail_on(active_handles
=True)
128 async def test_repo_remove(self
):
129 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
130 repo_name
= "bitnami"
131 await self
.helm_conn
.repo_remove(self
.cluster_uuid
, repo_name
)
133 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
134 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
135 from_path
=self
.cluster_id
137 command
= "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm repo remove {}".format(
140 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
141 command
=command
, env
=self
.env
, raise_exception_on_error
=True
144 @asynctest.fail_on(active_handles
=True)
145 async def test_install(self
):
146 kdu_model
= "stable/openldap:1.2.2"
147 kdu_instance
= "stable-openldap-0005399828"
149 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
150 self
.helm_conn
._status
_kdu
= asynctest
.CoroutineMock(return_value
=None)
151 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
152 self
.helm_conn
.generate_kdu_instance_name
= Mock(return_value
=kdu_instance
)
154 await self
.helm_conn
.install(
159 namespace
=self
.namespace
,
163 self
.helm_conn
.fs
.sync
.assert_has_calls(
165 asynctest
.call(from_path
=self
.cluster_id
),
166 asynctest
.call(from_path
=self
.cluster_id
),
169 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
171 asynctest
.call(from_path
=self
.cluster_id
),
172 asynctest
.call(from_path
=self
.cluster_id
),
175 self
.helm_conn
._store
_status
.assert_called_with(
176 cluster_id
=self
.cluster_id
,
177 kdu_instance
=kdu_instance
,
178 namespace
=self
.namespace
,
183 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm install "
184 "--atomic --output yaml --timeout 300 "
185 "--name=stable-openldap-0005399828 --namespace testk8s stable/openldap "
188 self
.helm_conn
._local
_async
_exec
.assert_called_with(
189 command
=command
, env
=self
.env
, raise_exception_on_error
=False
192 @asynctest.fail_on(active_handles
=True)
193 async def test_upgrade_force_true(self
):
194 kdu_model
= "stable/openldap:1.2.3"
195 kdu_instance
= "stable-openldap-0005399828"
198 "chart": "openldap-1.2.2",
199 "name": kdu_instance
,
200 "namespace": self
.namespace
,
202 "status": "DEPLOYED",
204 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
205 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
206 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
207 return_value
=instance_info
209 # TEST-1 (--force true)
210 await self
.helm_conn
.upgrade(
218 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
219 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
221 asynctest
.call(from_path
=self
.cluster_id
),
222 asynctest
.call(from_path
=self
.cluster_id
),
225 self
.helm_conn
._store
_status
.assert_called_with(
226 cluster_id
=self
.cluster_id
,
227 kdu_instance
=kdu_instance
,
228 namespace
=self
.namespace
,
233 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm upgrade --namespace testk8s "
234 "--atomic --output yaml --timeout 300 --force --reuse-values stable-openldap-0005399828 stable/openldap "
237 self
.helm_conn
._local
_async
_exec
.assert_called_with(
238 command
=command
, env
=self
.env
, raise_exception_on_error
=False
240 # TEST-2 (--force false)
241 await self
.helm_conn
.upgrade(
248 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
249 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
251 asynctest
.call(from_path
=self
.cluster_id
),
252 asynctest
.call(from_path
=self
.cluster_id
),
255 self
.helm_conn
._store
_status
.assert_called_with(
256 cluster_id
=self
.cluster_id
,
257 kdu_instance
=kdu_instance
,
258 namespace
=self
.namespace
,
263 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm upgrade --namespace testk8s "
264 "--atomic --output yaml --timeout 300 --reuse-values stable-openldap-0005399828 stable/openldap "
267 self
.helm_conn
._local
_async
_exec
.assert_called_with(
268 command
=command
, env
=self
.env
, raise_exception_on_error
=False
271 @asynctest.fail_on(active_handles
=True)
272 async def test_upgrade_namespace(self
):
273 kdu_model
= "stable/openldap:1.2.3"
274 kdu_instance
= "stable-openldap-0005399828"
277 "chart": "openldap-1.2.2",
278 "name": kdu_instance
,
279 "namespace": self
.namespace
,
281 "status": "DEPLOYED",
283 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
284 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
285 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
286 return_value
=instance_info
289 await self
.helm_conn
.upgrade(
297 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
298 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
300 asynctest
.call(from_path
=self
.cluster_id
),
301 asynctest
.call(from_path
=self
.cluster_id
),
304 self
.helm_conn
._store
_status
.assert_called_with(
305 cluster_id
=self
.cluster_id
,
306 kdu_instance
=kdu_instance
,
312 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm upgrade --namespace default "
313 "--atomic --output yaml --timeout 300 --reuse-values stable-openldap-0005399828 stable/openldap "
316 self
.helm_conn
._local
_async
_exec
.assert_called_with(
317 command
=command
, env
=self
.env
, raise_exception_on_error
=False
320 @asynctest.fail_on(active_handles
=True)
321 async def test_scale(self
):
322 kdu_model
= "stable/openldap:1.2.3"
323 kdu_instance
= "stable-openldap-0005399828"
326 "chart": "openldap-1.2.3",
327 "name": kdu_instance
,
328 "namespace": self
.namespace
,
330 "status": "DEPLOYED",
335 "url": "https://kubernetes-charts.storage.googleapis.com/",
339 # Default values for openldap.
340 # This is a YAML-formatted file.
341 # Declare variables to be passed into your templates.
348 self
.helm_conn
.repo_list
= asynctest
.CoroutineMock(return_value
=repo_list
)
349 self
.helm_conn
.values_kdu
= asynctest
.CoroutineMock(return_value
=kdu_values
)
350 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
351 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
352 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
353 return_value
=instance_info
357 await self
.helm_conn
.scale(
362 cluster_uuid
=self
.cluster_uuid
,
367 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config "
368 "/usr/bin/helm upgrade --namespace testk8s --atomic --output yaml --set replicaCount=2 "
369 "--timeout 1800 --reuse-values stable-openldap-0005399828 stable/openldap "
372 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
373 command
=command
, env
=self
.env
, raise_exception_on_error
=False
377 await self
.helm_conn
.scale(
382 cluster_uuid
=self
.cluster_uuid
,
387 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config "
388 "/usr/bin/helm upgrade --namespace testk8s --atomic --output yaml --set dummy-app.replicas=3 "
389 "--timeout 1800 --reuse-values stable-openldap-0005399828 stable/openldap "
392 self
.helm_conn
._local
_async
_exec
.assert_called_with(
393 command
=command
, env
=self
.env
, raise_exception_on_error
=False
395 self
.helm_conn
.fs
.reverse_sync
.assert_called_with(from_path
=self
.cluster_id
)
396 self
.helm_conn
._store
_status
.assert_called_with(
397 cluster_id
=self
.cluster_id
,
398 kdu_instance
=kdu_instance
,
399 namespace
=self
.namespace
,
404 @asynctest.fail_on(active_handles
=True)
405 async def test_rollback(self
):
406 kdu_instance
= "stable-openldap-0005399828"
409 "chart": "openldap-1.2.3",
410 "name": kdu_instance
,
411 "namespace": self
.namespace
,
413 "status": "DEPLOYED",
415 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
416 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
417 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
418 return_value
=instance_info
421 await self
.helm_conn
.rollback(
422 self
.cluster_uuid
, kdu_instance
=kdu_instance
, revision
=1, db_dict
=db_dict
424 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
425 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
426 from_path
=self
.cluster_id
428 self
.helm_conn
._store
_status
.assert_called_with(
429 cluster_id
=self
.cluster_id
,
430 kdu_instance
=kdu_instance
,
431 namespace
=self
.namespace
,
433 operation
="rollback",
436 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config "
437 "/usr/bin/helm rollback stable-openldap-0005399828 1 --wait"
439 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
440 command
=command
, env
=self
.env
, raise_exception_on_error
=False
443 @asynctest.fail_on(active_handles
=True)
444 async def test_uninstall(self
):
445 kdu_instance
= "stable-openldap-0005399828"
447 "chart": "openldap-1.2.2",
448 "name": kdu_instance
,
449 "namespace": self
.namespace
,
451 "status": "DEPLOYED",
453 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
454 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
455 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
456 return_value
=instance_info
459 await self
.helm_conn
.uninstall(self
.cluster_uuid
, kdu_instance
)
460 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
461 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
462 from_path
=self
.cluster_id
464 command
= "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm delete --purge {}".format(
467 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
468 command
=command
, env
=self
.env
, raise_exception_on_error
=True
471 @asynctest.fail_on(active_handles
=True)
472 async def test_get_services(self
):
473 kdu_instance
= "test_services_1"
474 service
= {"name": "testservice", "type": "LoadBalancer"}
475 self
.helm_conn
._local
_async
_exec
_pipe
= asynctest
.CoroutineMock(
478 self
.helm_conn
._parse
_services
= Mock(return_value
=["testservice"])
479 self
.helm_conn
._get
_service
= asynctest
.CoroutineMock(return_value
=service
)
481 services
= await self
.helm_conn
.get_services(
482 self
.cluster_uuid
, kdu_instance
, self
.namespace
484 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
485 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
486 from_path
=self
.cluster_id
488 self
.helm_conn
._parse
_services
.assert_called_once()
489 command1
= "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm get manifest {} ".format(
492 command2
= "/usr/bin/kubectl get --namespace={} -f -".format(self
.namespace
)
493 self
.helm_conn
._local
_async
_exec
_pipe
.assert_called_once_with(
494 command1
, command2
, env
=self
.env
, raise_exception_on_error
=True
497 services
, [service
], "Invalid service returned from get_service"
500 @asynctest.fail_on(active_handles
=True)
501 async def test_get_service(self
):
502 service_name
= "service1"
504 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
505 await self
.helm_conn
.get_service(
506 self
.cluster_uuid
, service_name
, self
.namespace
509 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
510 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
511 from_path
=self
.cluster_id
514 "/usr/bin/kubectl --kubeconfig=./tmp/helm_cluster_id/.kube/config "
515 "--namespace=testk8s get service service1 -o=yaml"
517 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
518 command
=command
, env
=self
.env
, raise_exception_on_error
=True
521 @asynctest.fail_on(active_handles
=True)
522 async def test_inspect_kdu(self
):
523 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
525 kdu_model
= "stable/openldap:1.2.4"
526 repo_url
= "https://kubernetes-charts.storage.googleapis.com/"
527 await self
.helm_conn
.inspect_kdu(kdu_model
, repo_url
)
530 "/usr/bin/helm inspect openldap --repo "
531 "https://kubernetes-charts.storage.googleapis.com/ "
534 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
536 @asynctest.fail_on(active_handles
=True)
537 async def test_help_kdu(self
):
538 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
540 kdu_model
= "stable/openldap:1.2.4"
541 repo_url
= "https://kubernetes-charts.storage.googleapis.com/"
542 await self
.helm_conn
.help_kdu(kdu_model
, repo_url
)
545 "/usr/bin/helm inspect readme openldap --repo "
546 "https://kubernetes-charts.storage.googleapis.com/ "
549 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
551 @asynctest.fail_on(active_handles
=True)
552 async def test_values_kdu(self
):
553 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
555 kdu_model
= "stable/openldap:1.2.4"
556 repo_url
= "https://kubernetes-charts.storage.googleapis.com/"
557 await self
.helm_conn
.values_kdu(kdu_model
, repo_url
)
560 "/usr/bin/helm inspect values openldap --repo "
561 "https://kubernetes-charts.storage.googleapis.com/ "
564 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
566 @asynctest.fail_on(active_handles
=True)
567 async def test_get_values_kdu(self
):
568 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
570 kdu_instance
= "stable-openldap-0005399828"
571 await self
.helm_conn
.get_values_kdu(
572 kdu_instance
, self
.namespace
, self
.env
["KUBECONFIG"]
576 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm get values "
577 "stable-openldap-0005399828 --output yaml"
579 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
581 @asynctest.fail_on(active_handles
=True)
582 async def test_instances_list(self
):
583 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
585 await self
.helm_conn
.instances_list(self
.cluster_uuid
)
586 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
587 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
588 from_path
=self
.cluster_id
590 command
= "/usr/bin/helm list --output yaml"
591 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
592 command
=command
, env
=self
.env
, raise_exception_on_error
=True
595 @asynctest.fail_on(active_handles
=True)
596 async def test_status_kdu(self
):
597 kdu_instance
= "stable-openldap-0005399828"
598 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
600 await self
.helm_conn
._status
_kdu
(
601 self
.cluster_id
, kdu_instance
, self
.namespace
, yaml_format
=True
604 "env KUBECONFIG=./tmp/helm_cluster_id/.kube/config /usr/bin/helm status {} --output yaml"
605 ).format(kdu_instance
)
606 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
609 raise_exception_on_error
=True,
610 show_error_log
=False,
613 @asynctest.fail_on(active_handles
=True)
614 async def test_store_status(self
):
615 kdu_instance
= "stable-openldap-0005399828"
619 "description": "Install complete",
622 "notes": "The openldap helm chart has been installed",
626 self
.helm_conn
._status
_kdu
= asynctest
.CoroutineMock(return_value
=status
)
627 self
.helm_conn
.write_app_status_to_db
= asynctest
.CoroutineMock(
631 await self
.helm_conn
._store
_status
(
632 cluster_id
=self
.cluster_id
,
633 kdu_instance
=kdu_instance
,
634 namespace
=self
.namespace
,
638 self
.helm_conn
._status
_kdu
.assert_called_once_with(
639 cluster_id
=self
.cluster_id
,
640 kdu_instance
=kdu_instance
,
641 namespace
=self
.namespace
,
644 self
.helm_conn
.write_app_status_to_db
.assert_called_once_with(
646 status
="Install complete",
647 detailed_status
=str(status
),
651 @asynctest.fail_on(active_handles
=True)
652 async def test_reset_uninstall_false(self
):
653 self
.helm_conn
._uninstall
_sw
= asynctest
.CoroutineMock()
655 await self
.helm_conn
.reset(self
.cluster_uuid
, force
=False, uninstall_sw
=False)
656 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
657 self
.helm_conn
.fs
.file_delete
.assert_called_once_with(
658 self
.cluster_id
, ignore_non_exist
=True
660 self
.helm_conn
._uninstall
_sw
.assert_not_called()
662 @asynctest.fail_on(active_handles
=True)
663 async def test_reset_uninstall(self
):
664 kdu_instance
= "stable-openldap-0021099429"
667 "app_version": "2.4.48",
668 "chart": "openldap-1.2.3",
669 "name": kdu_instance
,
670 "namespace": self
.namespace
,
672 "status": "deployed",
673 "updated": "2020-10-30 11:11:20.376744191 +0000 UTC",
676 self
.helm_conn
._get
_namespace
= Mock(return_value
=self
.namespace
)
677 self
.helm_conn
._uninstall
_sw
= asynctest
.CoroutineMock()
678 self
.helm_conn
.instances_list
= asynctest
.CoroutineMock(return_value
=instances
)
679 self
.helm_conn
.uninstall
= asynctest
.CoroutineMock()
681 await self
.helm_conn
.reset(self
.cluster_uuid
, force
=True, uninstall_sw
=True)
682 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
683 self
.helm_conn
.fs
.file_delete
.assert_called_once_with(
684 self
.cluster_id
, ignore_non_exist
=True
686 self
.helm_conn
._get
_namespace
.assert_called_once_with(
687 cluster_uuid
=self
.cluster_uuid
689 self
.helm_conn
.instances_list
.assert_called_once_with(
690 cluster_uuid
=self
.cluster_uuid
692 self
.helm_conn
.uninstall
.assert_called_once_with(
693 cluster_uuid
=self
.cluster_uuid
, kdu_instance
=kdu_instance
695 self
.helm_conn
._uninstall
_sw
.assert_called_once_with(
696 cluster_id
=self
.cluster_id
, namespace
=self
.namespace
699 @asynctest.fail_on(active_handles
=True)
700 async def test_uninstall_sw_namespace(self
):
701 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
703 await self
.helm_conn
._uninstall
_sw
(self
.cluster_id
, self
.namespace
)
704 calls
= self
.helm_conn
._local
_async
_exec
.call_args_list
706 len(calls
), 3, "To uninstall should have executed three commands"
708 call0_kargs
= calls
[0][1]
709 command_0
= "/usr/bin/helm --kubeconfig={} --home={} reset".format(
710 self
.kube_config
, self
.helm_home
714 {"command": command_0
, "raise_exception_on_error": True, "env": self
.env
},
715 "Invalid args for first call to local_exec",
717 call1_kargs
= calls
[1][1]
719 "/usr/bin/kubectl --kubeconfig={} delete "
720 "clusterrolebinding.rbac.authorization.k8s.io/osm-tiller-cluster-rule".format(
726 {"command": command_1
, "raise_exception_on_error": False, "env": self
.env
},
727 "Invalid args for second call to local_exec",
729 call2_kargs
= calls
[2][1]
731 "/usr/bin/kubectl --kubeconfig={} --namespace {} delete "
732 "serviceaccount/{}".format(
733 self
.kube_config
, self
.namespace
, self
.service_account
738 {"command": command_2
, "raise_exception_on_error": False, "env": self
.env
},
739 "Invalid args for third call to local_exec",