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
, patch
22 from osm_common
.dbmemory
import DbMemory
23 from osm_common
.fslocal
import FsLocal
24 from n2vc
.k8s_helm3_conn
import K8sHelm3Connector
, K8sException
26 __author__
= "Isabel Lloret <illoret@indra.es>"
29 class TestK8sHelm3Conn(asynctest
.TestCase
):
30 logging
.basicConfig(level
=logging
.DEBUG
)
31 logger
= logging
.getLogger(__name__
)
32 logger
.setLevel(logging
.DEBUG
)
34 @patch("n2vc.k8s_helm_base_conn.EnvironConfig")
35 async def setUp(self
, mock_env
):
36 mock_env
.return_value
= {"stablerepourl": "https://charts.helm.sh/stable"}
37 self
.db
= Mock(DbMemory())
38 self
.fs
= asynctest
.Mock(FsLocal())
39 self
.fs
.path
= "./tmp/"
40 self
.namespace
= "testk8s"
41 self
.cluster_id
= "helm3_cluster_id"
42 self
.cluster_uuid
= self
.cluster_id
43 # pass fake kubectl and helm commands to make sure it does not call actual commands
44 K8sHelm3Connector
._check
_file
_exists
= asynctest
.Mock(return_value
=True)
45 cluster_dir
= self
.fs
.path
+ self
.cluster_id
47 "HELM_CACHE_HOME": "{}/.cache/helm".format(cluster_dir
),
48 "HELM_CONFIG_HOME": "{}/.config/helm".format(cluster_dir
),
49 "HELM_DATA_HOME": "{}/.local/share/helm".format(cluster_dir
),
50 "KUBECONFIG": "{}/.kube/config".format(cluster_dir
),
52 self
.helm_conn
= K8sHelm3Connector(self
.fs
, self
.db
, log
=self
.logger
)
53 self
.logger
.debug("Set up executed")
55 @asynctest.fail_on(active_handles
=True)
56 async def test_init_env(self
):
57 k8s_creds
= "false_credentials_string"
58 self
.helm_conn
._get
_namespaces
= asynctest
.CoroutineMock(return_value
=[])
59 self
.helm_conn
._create
_namespace
= asynctest
.CoroutineMock()
60 self
.helm_conn
.repo_list
= asynctest
.CoroutineMock(return_value
=[])
61 self
.helm_conn
.repo_add
= asynctest
.CoroutineMock()
63 k8scluster_uuid
, installed
= await self
.helm_conn
.init_env(
64 k8s_creds
, namespace
=self
.namespace
, reuse_cluster_uuid
=self
.cluster_id
72 self
.helm_conn
._get
_namespaces
.assert_called_once_with(self
.cluster_id
)
73 self
.helm_conn
._create
_namespace
.assert_called_once_with(
74 self
.cluster_id
, self
.namespace
76 self
.helm_conn
.repo_list
.assert_called_once_with(k8scluster_uuid
)
77 self
.helm_conn
.repo_add
.assert_called_once_with(
78 k8scluster_uuid
, "stable", "https://charts.helm.sh/stable"
80 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
81 from_path
=self
.cluster_id
83 self
.logger
.debug(f
"cluster_uuid: {k8scluster_uuid}")
85 @asynctest.fail_on(active_handles
=True)
86 async def test_repo_add(self
):
88 repo_url
= "https://charts.bitnami.com/bitnami"
89 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=(0, ""))
91 await self
.helm_conn
.repo_add(self
.cluster_uuid
, repo_name
, repo_url
)
93 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
94 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
95 from_path
=self
.cluster_id
98 self
.helm_conn
._local
_async
_exec
.call_count
,
100 "local_async_exec expected 2 calls, called {}".format(
101 self
.helm_conn
._local
_async
_exec
.call_count
105 repo_update_command
= (
106 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 repo update {}"
109 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 repo add {} {}"
110 ).format(repo_name
, repo_url
)
111 calls
= self
.helm_conn
._local
_async
_exec
.call_args_list
112 call0_kargs
= calls
[0][1]
114 call0_kargs
.get("command"),
116 "Invalid repo add command: {}".format(call0_kargs
.get("command")),
119 call0_kargs
.get("env"),
121 "Invalid env for add command: {}".format(call0_kargs
.get("env")),
123 call1_kargs
= calls
[1][1]
125 call1_kargs
.get("command"),
127 "Invalid repo update command: {}".format(call1_kargs
.get("command")),
130 call1_kargs
.get("env"),
132 "Invalid env for update command: {}".format(call1_kargs
.get("env")),
135 @asynctest.fail_on(active_handles
=True)
136 async def test_repo_list(self
):
138 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
140 await self
.helm_conn
.repo_list(self
.cluster_uuid
)
142 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
143 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
144 from_path
=self
.cluster_id
146 command
= "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 repo list --output yaml"
147 self
.helm_conn
._local
_async
_exec
.assert_called_with(
148 command
=command
, env
=self
.env
, raise_exception_on_error
=False
151 @asynctest.fail_on(active_handles
=True)
152 async def test_repo_remove(self
):
154 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
155 repo_name
= "bitnami"
156 await self
.helm_conn
.repo_remove(self
.cluster_uuid
, repo_name
)
158 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
159 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
160 from_path
=self
.cluster_id
162 command
= "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 repo remove {}".format(
165 self
.helm_conn
._local
_async
_exec
.assert_called_with(
166 command
=command
, env
=self
.env
, raise_exception_on_error
=True
169 @asynctest.fail_on(active_handles
=True)
170 async def test_install(self
):
171 kdu_model
= "stable/openldap:1.2.2"
172 kdu_instance
= "stable-openldap-0005399828"
174 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
175 self
.helm_conn
._status
_kdu
= asynctest
.CoroutineMock(return_value
=None)
176 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
177 self
.kdu_instance
= "stable-openldap-0005399828"
178 self
.helm_conn
.generate_kdu_instance_name
= Mock(return_value
=self
.kdu_instance
)
179 self
.helm_conn
._get
_namespaces
= asynctest
.CoroutineMock(return_value
=[])
180 self
.helm_conn
._namespace
_exists
= asynctest
.CoroutineMock(
181 side_effect
=self
.helm_conn
._namespace
_exists
183 self
.helm_conn
._create
_namespace
= asynctest
.CoroutineMock()
185 await self
.helm_conn
.install(
190 namespace
=self
.namespace
,
194 self
.helm_conn
._namespace
_exists
.assert_called_once()
195 self
.helm_conn
._get
_namespaces
.assert_called_once()
196 self
.helm_conn
._create
_namespace
.assert_called_once_with(
197 self
.cluster_id
, self
.namespace
199 self
.helm_conn
.fs
.sync
.assert_has_calls(
201 asynctest
.call(from_path
=self
.cluster_id
),
202 asynctest
.call(from_path
=self
.cluster_id
),
205 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
207 asynctest
.call(from_path
=self
.cluster_id
),
208 asynctest
.call(from_path
=self
.cluster_id
),
211 self
.helm_conn
._store
_status
.assert_called_with(
212 cluster_id
=self
.cluster_id
,
213 kdu_instance
=kdu_instance
,
214 namespace
=self
.namespace
,
219 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 "
220 "install stable-openldap-0005399828 --atomic --output yaml "
221 "--timeout 300s --namespace testk8s stable/openldap --version 1.2.2"
223 self
.helm_conn
._local
_async
_exec
.assert_called_with(
224 command
=command
, env
=self
.env
, raise_exception_on_error
=False
227 # Exception test if namespace could not being created for some reason
228 self
.helm_conn
._namespace
_exists
.return_value
= False
229 self
.helm_conn
._create
_namespace
.side_effect
= Exception()
231 with self
.assertRaises(K8sException
):
232 await self
.helm_conn
.install(
237 namespace
=self
.namespace
,
241 @asynctest.fail_on(active_handles
=True)
242 async def test_namespace_exists(self
):
243 self
.helm_conn
._get
_namespaces
= asynctest
.CoroutineMock()
245 self
.helm_conn
._get
_namespaces
.return_value
= ["testk8s", "kube-system"]
246 result
= await self
.helm_conn
._namespace
_exists
(self
.cluster_id
, self
.namespace
)
247 self
.helm_conn
._get
_namespaces
.assert_called_once()
248 self
.assertEqual(result
, True)
250 self
.helm_conn
._get
_namespaces
.reset_mock()
251 result
= await self
.helm_conn
._namespace
_exists
(
252 self
.cluster_id
, "none-exists-namespace"
254 self
.helm_conn
._get
_namespaces
.assert_called_once()
255 self
.assertEqual(result
, False)
257 @asynctest.fail_on(active_handles
=True)
258 async def test_upgrade(self
):
259 kdu_model
= "stable/openldap:1.2.3"
260 kdu_instance
= "stable-openldap-0005399828"
263 "chart": "openldap-1.2.2",
264 "name": kdu_instance
,
265 "namespace": self
.namespace
,
267 "status": "DEPLOYED",
269 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
270 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
271 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
272 return_value
=instance_info
274 # TEST-1 (--force true)
275 await self
.helm_conn
.upgrade(
283 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
284 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
286 asynctest
.call(from_path
=self
.cluster_id
),
287 asynctest
.call(from_path
=self
.cluster_id
),
290 self
.helm_conn
._store
_status
.assert_called_with(
291 cluster_id
=self
.cluster_id
,
292 kdu_instance
=kdu_instance
,
293 namespace
=self
.namespace
,
298 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config "
299 "/usr/bin/helm3 upgrade stable-openldap-0005399828 stable/openldap "
300 "--namespace testk8s --atomic --force --output yaml --timeout 300s "
301 "--reuse-values --version 1.2.3"
303 self
.helm_conn
._local
_async
_exec
.assert_called_with(
304 command
=command
, env
=self
.env
, raise_exception_on_error
=False
307 # TEST-2 (--force false)
308 await self
.helm_conn
.upgrade(
315 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
316 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
318 asynctest
.call(from_path
=self
.cluster_id
),
319 asynctest
.call(from_path
=self
.cluster_id
),
322 self
.helm_conn
._store
_status
.assert_called_with(
323 cluster_id
=self
.cluster_id
,
324 kdu_instance
=kdu_instance
,
325 namespace
=self
.namespace
,
330 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config "
331 "/usr/bin/helm3 upgrade stable-openldap-0005399828 stable/openldap "
332 "--namespace testk8s --atomic --output yaml --timeout 300s "
333 "--reuse-values --version 1.2.3"
335 self
.helm_conn
._local
_async
_exec
.assert_called_with(
336 command
=command
, env
=self
.env
, raise_exception_on_error
=False
339 @asynctest.fail_on(active_handles
=True)
340 async def test_upgrade_namespace(self
):
341 kdu_model
= "stable/openldap:1.2.3"
342 kdu_instance
= "stable-openldap-0005399828"
345 "chart": "openldap-1.2.2",
346 "name": kdu_instance
,
347 "namespace": self
.namespace
,
349 "status": "DEPLOYED",
351 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
352 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
353 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
354 return_value
=instance_info
357 await self
.helm_conn
.upgrade(
365 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
366 self
.helm_conn
.fs
.reverse_sync
.assert_has_calls(
368 asynctest
.call(from_path
=self
.cluster_id
),
369 asynctest
.call(from_path
=self
.cluster_id
),
372 self
.helm_conn
._store
_status
.assert_called_with(
373 cluster_id
=self
.cluster_id
,
374 kdu_instance
=kdu_instance
,
380 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config "
381 "/usr/bin/helm3 upgrade stable-openldap-0005399828 stable/openldap "
382 "--namespace default --atomic --output yaml --timeout 300s "
383 "--reuse-values --version 1.2.3"
385 self
.helm_conn
._local
_async
_exec
.assert_called_with(
386 command
=command
, env
=self
.env
, raise_exception_on_error
=False
389 @asynctest.fail_on(active_handles
=True)
390 async def test_scale(self
):
391 kdu_model
= "stable/openldap:1.2.3"
392 kdu_instance
= "stable-openldap-0005399828"
395 "chart": "openldap-1.2.3",
396 "name": kdu_instance
,
397 "namespace": self
.namespace
,
399 "status": "DEPLOYED",
404 "url": "https://kubernetes-charts.storage.googleapis.com/",
408 # Default values for openldap.
409 # This is a YAML-formatted file.
410 # Declare variables to be passed into your templates.
417 self
.helm_conn
.repo_list
= asynctest
.CoroutineMock(return_value
=repo_list
)
418 self
.helm_conn
.values_kdu
= asynctest
.CoroutineMock(return_value
=kdu_values
)
419 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
420 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
421 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
422 return_value
=instance_info
426 await self
.helm_conn
.scale(
431 cluster_uuid
=self
.cluster_uuid
,
436 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config "
437 "/usr/bin/helm3 upgrade stable-openldap-0005399828 stable/openldap "
438 "--namespace testk8s --atomic --output yaml --set replicaCount=2 --timeout 1800s "
439 "--reuse-values --version 1.2.3"
441 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
442 command
=command
, env
=self
.env
, raise_exception_on_error
=False
445 await self
.helm_conn
.scale(
450 cluster_uuid
=self
.cluster_uuid
,
455 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config "
456 "/usr/bin/helm3 upgrade stable-openldap-0005399828 stable/openldap "
457 "--namespace testk8s --atomic --output yaml --set dummy-app.replicas=3 --timeout 1800s "
458 "--reuse-values --version 1.2.3"
460 self
.helm_conn
._local
_async
_exec
.assert_called_with(
461 command
=command
, env
=self
.env
, raise_exception_on_error
=False
463 self
.helm_conn
.fs
.reverse_sync
.assert_called_with(from_path
=self
.cluster_id
)
464 self
.helm_conn
._store
_status
.assert_called_with(
465 cluster_id
=self
.cluster_id
,
466 kdu_instance
=kdu_instance
,
467 namespace
=self
.namespace
,
472 @asynctest.fail_on(active_handles
=True)
473 async def test_rollback(self
):
474 kdu_instance
= "stable-openldap-0005399828"
477 "chart": "openldap-1.2.3",
478 "name": kdu_instance
,
479 "namespace": self
.namespace
,
481 "status": "DEPLOYED",
483 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
484 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
485 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
486 return_value
=instance_info
489 await self
.helm_conn
.rollback(
490 self
.cluster_uuid
, kdu_instance
=kdu_instance
, revision
=1, db_dict
=db_dict
492 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
493 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
494 from_path
=self
.cluster_id
496 self
.helm_conn
._store
_status
.assert_called_with(
497 cluster_id
=self
.cluster_id
,
498 kdu_instance
=kdu_instance
,
499 namespace
=self
.namespace
,
501 operation
="rollback",
504 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 "
505 "rollback stable-openldap-0005399828 1 --namespace=testk8s --wait"
507 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
508 command
=command
, env
=self
.env
, raise_exception_on_error
=False
511 @asynctest.fail_on(active_handles
=True)
512 async def test_uninstall(self
):
513 kdu_instance
= "stable-openldap-0005399828"
515 "chart": "openldap-1.2.2",
516 "name": kdu_instance
,
517 "namespace": self
.namespace
,
519 "status": "DEPLOYED",
521 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
522 self
.helm_conn
._store
_status
= asynctest
.CoroutineMock()
523 self
.helm_conn
.get_instance_info
= asynctest
.CoroutineMock(
524 return_value
=instance_info
527 await self
.helm_conn
.uninstall(self
.cluster_uuid
, kdu_instance
)
528 self
.helm_conn
.fs
.sync
.assert_called_with(from_path
=self
.cluster_id
)
529 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
530 from_path
=self
.cluster_id
533 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 uninstall {} --namespace={}"
534 ).format(kdu_instance
, self
.namespace
)
535 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
536 command
=command
, env
=self
.env
, raise_exception_on_error
=True
539 @asynctest.fail_on(active_handles
=True)
540 async def test_get_services(self
):
541 kdu_instance
= "test_services_1"
542 service
= {"name": "testservice", "type": "LoadBalancer"}
543 self
.helm_conn
._local
_async
_exec
_pipe
= asynctest
.CoroutineMock(
546 self
.helm_conn
._parse
_services
= Mock(return_value
=["testservice"])
547 self
.helm_conn
._get
_service
= asynctest
.CoroutineMock(return_value
=service
)
549 services
= await self
.helm_conn
.get_services(
550 self
.cluster_uuid
, kdu_instance
, self
.namespace
552 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
553 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
554 from_path
=self
.cluster_id
556 self
.helm_conn
._parse
_services
.assert_called_once()
558 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 get manifest {} --namespace=testk8s"
559 ).format(kdu_instance
)
560 command2
= "/usr/bin/kubectl get --namespace={} -f -".format(self
.namespace
)
561 self
.helm_conn
._local
_async
_exec
_pipe
.assert_called_once_with(
562 command1
, command2
, env
=self
.env
, raise_exception_on_error
=True
565 services
, [service
], "Invalid service returned from get_service"
568 @asynctest.fail_on(active_handles
=True)
569 async def test_get_service(self
):
570 service_name
= "service1"
572 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
573 await self
.helm_conn
.get_service(
574 self
.cluster_uuid
, service_name
, self
.namespace
577 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
578 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
579 from_path
=self
.cluster_id
582 "/usr/bin/kubectl --kubeconfig=./tmp/helm3_cluster_id/.kube/config "
583 "--namespace=testk8s get service service1 -o=yaml"
585 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
586 command
=command
, env
=self
.env
, raise_exception_on_error
=True
589 @asynctest.fail_on(active_handles
=True)
590 async def test_inspect_kdu(self
):
591 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
593 kdu_model
= "stable/openldap:1.2.4"
594 repo_url
= "https://kubernetes-charts.storage.googleapis.com/"
595 await self
.helm_conn
.inspect_kdu(kdu_model
, repo_url
)
598 "/usr/bin/helm3 show all openldap --repo "
599 "https://kubernetes-charts.storage.googleapis.com/ "
602 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
604 @asynctest.fail_on(active_handles
=True)
605 async def test_help_kdu(self
):
606 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
608 kdu_model
= "stable/openldap:1.2.4"
609 repo_url
= "https://kubernetes-charts.storage.googleapis.com/"
610 await self
.helm_conn
.help_kdu(kdu_model
, repo_url
)
613 "/usr/bin/helm3 show readme openldap --repo "
614 "https://kubernetes-charts.storage.googleapis.com/ "
617 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
619 @asynctest.fail_on(active_handles
=True)
620 async def test_values_kdu(self
):
621 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
623 kdu_model
= "stable/openldap:1.2.4"
624 repo_url
= "https://kubernetes-charts.storage.googleapis.com/"
625 await self
.helm_conn
.values_kdu(kdu_model
, repo_url
)
628 "/usr/bin/helm3 show values openldap --repo "
629 "https://kubernetes-charts.storage.googleapis.com/ "
632 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
634 @asynctest.fail_on(active_handles
=True)
635 async def test_get_values_kdu(self
):
636 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
638 kdu_instance
= "stable-openldap-0005399828"
639 await self
.helm_conn
.get_values_kdu(
640 kdu_instance
, self
.namespace
, self
.env
["KUBECONFIG"]
644 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 get values "
645 "stable-openldap-0005399828 --namespace=testk8s --output yaml"
647 self
.helm_conn
._local
_async
_exec
.assert_called_with(command
=command
)
649 @asynctest.fail_on(active_handles
=True)
650 async def test_instances_list(self
):
651 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
653 await self
.helm_conn
.instances_list(self
.cluster_uuid
)
654 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
655 self
.helm_conn
.fs
.reverse_sync
.assert_called_once_with(
656 from_path
=self
.cluster_id
658 command
= "/usr/bin/helm3 list --all-namespaces --output yaml"
659 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
660 command
=command
, env
=self
.env
, raise_exception_on_error
=True
663 @asynctest.fail_on(active_handles
=True)
664 async def test_status_kdu(self
):
665 kdu_instance
= "stable-openldap-0005399828"
666 self
.helm_conn
._local
_async
_exec
= asynctest
.CoroutineMock(return_value
=("", 0))
668 await self
.helm_conn
._status
_kdu
(
669 self
.cluster_id
, kdu_instance
, self
.namespace
, yaml_format
=True
672 "env KUBECONFIG=./tmp/helm3_cluster_id/.kube/config /usr/bin/helm3 status {} --namespace={} --output yaml"
673 ).format(kdu_instance
, self
.namespace
)
674 self
.helm_conn
._local
_async
_exec
.assert_called_once_with(
677 raise_exception_on_error
=True,
678 show_error_log
=False,
681 @asynctest.fail_on(active_handles
=True)
682 async def test_store_status(self
):
683 kdu_instance
= "stable-openldap-0005399828"
687 "description": "Install complete",
690 "notes": "The openldap helm chart has been installed",
694 self
.helm_conn
._status
_kdu
= asynctest
.CoroutineMock(return_value
=status
)
695 self
.helm_conn
.write_app_status_to_db
= asynctest
.CoroutineMock(
699 await self
.helm_conn
._store
_status
(
700 cluster_id
=self
.cluster_id
,
701 kdu_instance
=kdu_instance
,
702 namespace
=self
.namespace
,
706 self
.helm_conn
._status
_kdu
.assert_called_once_with(
707 cluster_id
=self
.cluster_id
,
708 kdu_instance
=kdu_instance
,
709 namespace
=self
.namespace
,
712 self
.helm_conn
.write_app_status_to_db
.assert_called_once_with(
714 status
="Install complete",
715 detailed_status
=str(status
),
719 @asynctest.fail_on(active_handles
=True)
720 async def test_reset_uninstall_false(self
):
721 self
.helm_conn
._uninstall
_sw
= asynctest
.CoroutineMock()
723 await self
.helm_conn
.reset(self
.cluster_uuid
, force
=False, uninstall_sw
=False)
724 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
725 self
.helm_conn
.fs
.file_delete
.assert_called_once_with(
726 self
.cluster_id
, ignore_non_exist
=True
728 self
.helm_conn
._uninstall
_sw
.assert_not_called()
730 @asynctest.fail_on(active_handles
=True)
731 async def test_reset_uninstall(self
):
732 kdu_instance
= "stable-openldap-0021099429"
735 "app_version": "2.4.48",
736 "chart": "openldap-1.2.3",
737 "name": kdu_instance
,
738 "namespace": self
.namespace
,
740 "status": "deployed",
741 "updated": "2020-10-30 11:11:20.376744191 +0000 UTC",
744 self
.helm_conn
._get
_namespace
= Mock(return_value
=self
.namespace
)
745 self
.helm_conn
._uninstall
_sw
= asynctest
.CoroutineMock()
746 self
.helm_conn
.instances_list
= asynctest
.CoroutineMock(return_value
=instances
)
747 self
.helm_conn
.uninstall
= asynctest
.CoroutineMock()
749 await self
.helm_conn
.reset(self
.cluster_uuid
, force
=True, uninstall_sw
=True)
750 self
.helm_conn
.fs
.sync
.assert_called_once_with(from_path
=self
.cluster_id
)
751 self
.helm_conn
.fs
.file_delete
.assert_called_once_with(
752 self
.cluster_id
, ignore_non_exist
=True
754 self
.helm_conn
._get
_namespace
.assert_called_once_with(
755 cluster_uuid
=self
.cluster_uuid
757 self
.helm_conn
.instances_list
.assert_called_once_with(
758 cluster_uuid
=self
.cluster_uuid
760 self
.helm_conn
.uninstall
.assert_called_once_with(
761 cluster_uuid
=self
.cluster_uuid
, kdu_instance
=kdu_instance
763 self
.helm_conn
._uninstall
_sw
.assert_called_once_with(
764 cluster_id
=self
.cluster_id
, namespace
=self
.namespace
767 @asynctest.fail_on(active_handles
=True)
768 async def test_sync_repos_add(self
):
772 "url": "https://kubernetes-charts.storage.googleapis.com/",
775 self
.helm_conn
.repo_list
= asynctest
.CoroutineMock(return_value
=repo_list
)
777 def get_one_result(*args
, **kwargs
):
778 if args
[0] == "k8sclusters":
781 "helm_chart_repos": ["4b5550a9-990d-4d95-8a48-1f4614d6ac9c"]
784 elif args
[0] == "k8srepos":
786 "_id": "4b5550a9-990d-4d95-8a48-1f4614d6ac9c",
787 "type": "helm-chart",
789 "url": "https://charts.bitnami.com/bitnami",
792 self
.helm_conn
.db
.get_one
= asynctest
.Mock()
793 self
.helm_conn
.db
.get_one
.side_effect
= get_one_result
795 self
.helm_conn
.repo_add
= asynctest
.CoroutineMock()
796 self
.helm_conn
.repo_remove
= asynctest
.CoroutineMock()
798 deleted_repo_list
, added_repo_dict
= await self
.helm_conn
.synchronize_repos(
801 self
.helm_conn
.repo_remove
.assert_not_called()
802 self
.helm_conn
.repo_add
.assert_called_once_with(
803 self
.cluster_uuid
, "bitnami", "https://charts.bitnami.com/bitnami"
805 self
.assertEqual(deleted_repo_list
, [], "Deleted repo list should be empty")
808 {"4b5550a9-990d-4d95-8a48-1f4614d6ac9c": "bitnami"},
809 "Repos added should include only one bitnami",
812 @asynctest.fail_on(active_handles
=True)
813 async def test_sync_repos_delete(self
):
817 "url": "https://kubernetes-charts.storage.googleapis.com/",
819 {"name": "bitnami", "url": "https://charts.bitnami.com/bitnami"},
821 self
.helm_conn
.repo_list
= asynctest
.CoroutineMock(return_value
=repo_list
)
823 def get_one_result(*args
, **kwargs
):
824 if args
[0] == "k8sclusters":
825 return {"_admin": {"helm_chart_repos": []}}
827 self
.helm_conn
.db
.get_one
= asynctest
.Mock()
828 self
.helm_conn
.db
.get_one
.side_effect
= get_one_result
830 self
.helm_conn
.repo_add
= asynctest
.CoroutineMock()
831 self
.helm_conn
.repo_remove
= asynctest
.CoroutineMock()
833 deleted_repo_list
, added_repo_dict
= await self
.helm_conn
.synchronize_repos(
836 self
.helm_conn
.repo_add
.assert_not_called()
837 self
.helm_conn
.repo_remove
.assert_called_once_with(self
.cluster_uuid
, "bitnami")
839 deleted_repo_list
, ["bitnami"], "Deleted repo list should be bitnami"
841 self
.assertEqual(added_repo_dict
, {}, "No repos should be added")