Debian Codegraph @

magnum_capi_helm/tests/test_driver.py

raw
1 # Licensed under the Apache License, Version 2.0 (the "License"); you may
2 # not use this file except in compliance with the License. You may obtain
3 # a copy of the License at
4 #
5 # http://www.apache.org/licenses/LICENSE-2.0
6 #
7 # Unless required by applicable law or agreed to in writing, software
8 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
9 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
10 # License for the specific language governing permissions and limitations
11 # under the License.
12 from unittest import mock
13 from uuid import uuid4
14
15 from magnum.common import exception
16 from magnum.common import neutron
17 from magnum.objects import fields
18 from magnum.tests.unit.db import base
19 from magnum.tests.unit.objects import utils as obj_utils
20
21 from magnum_capi_helm.common import app_creds
22 from magnum_capi_helm.common import ca_certificates
23 from magnum_capi_helm.common import capi_monitor
24 from magnum_capi_helm import conf
25 from magnum_capi_helm import driver
26 from magnum_capi_helm import driver_utils
27 from magnum_capi_helm import helm
28 from magnum_capi_helm import kubernetes
29
30 CONF = conf.CONF
31
32
33 class ClusterAPIDriverTest(base.DbTestCase):
34 def setUp(self):
35 super(ClusterAPIDriverTest, self).setUp()
36 self.driver = driver.Driver()
37 self.cluster_obj = obj_utils.create_test_cluster(
38 self.context,
39 name="cluster_example_$A",
40 master_flavor_id="flavor_small",
41 flavor_id="flavor_medium",
42 stack_id="cluster-example-a-111111111111",
43 )
44 # add in missing node group flavor
45 for ng in self.cluster_obj.nodegroups:
46 if ng.role != "master":
47 ng.flavor_id = "flavor_medium"
48 ng.save()
49
50 def test_provides(self):
51 self.assertEqual(
52 [
53 {
54 "server_type": "vm",
55 "os": "ubuntu",
56 "coe": "kubernetes",
57 },
58 {
59 "server_type": "vm",
60 "os": "flatcar",
61 "coe": "kubernetes",
62 },
63 ],
64 self.driver.provides,
65 )
66
67 @mock.patch.object(driver.Driver, "_update_status_deleting")
68 @mock.patch.object(driver.Driver, "_update_status_updating")
69 @mock.patch.object(driver.Driver, "_update_all_nodegroups_status")
70 @mock.patch.object(driver.Driver, "_get_capi_cluster")
71 def test_update_cluster_status_creating(
72 self, mock_capi, mock_ng, mock_update, mock_delete
73 ):
74 mock_ng.return_value = True
75 mock_capi.return_value = {"spec": {}}
76 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
77
78 self.driver.update_cluster_status(self.context, self.cluster_obj)
79
80 mock_ng.assert_called_once_with(self.cluster_obj)
81 mock_update.assert_not_called()
82 mock_delete.assert_not_called()
83
84 @mock.patch.object(driver.Driver, "_update_status_deleting")
85 @mock.patch.object(driver.Driver, "_update_status_updating")
86 @mock.patch.object(driver.Driver, "_update_all_nodegroups_status")
87 @mock.patch.object(driver.Driver, "_get_capi_cluster")
88 def test_update_cluster_status_creating_not_found(
89 self, mock_capi, mock_ng, mock_update, mock_delete
90 ):
91 mock_ng.return_value = True
92 mock_capi.return_value = None
93 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
94
95 self.driver.update_cluster_status(self.context, self.cluster_obj)
96
97 mock_ng.assert_not_called()
98 mock_update.assert_not_called()
99 mock_delete.assert_not_called()
100
101 @mock.patch.object(driver.Driver, "_update_status_deleting")
102 @mock.patch.object(driver.Driver, "_update_status_updating")
103 @mock.patch.object(driver.Driver, "_update_all_nodegroups_status")
104 @mock.patch.object(driver.Driver, "_get_capi_cluster")
105 def test_update_cluster_status_created(
106 self, mock_capi, mock_ng, mock_update, mock_delete
107 ):
108 mock_ng.return_value = False
109 mock_capi.return_value = {"spec": {}}
110 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
111
112 self.driver.update_cluster_status(self.context, self.cluster_obj)
113
114 mock_ng.assert_called_once_with(self.cluster_obj)
115 mock_update.assert_called_once_with(self.cluster_obj, {"spec": {}})
116 mock_delete.assert_not_called()
117
118 @mock.patch.object(driver.Driver, "_update_status_deleting")
119 @mock.patch.object(driver.Driver, "_update_status_updating")
120 @mock.patch.object(driver.Driver, "_update_all_nodegroups_status")
121 @mock.patch.object(driver.Driver, "_get_capi_cluster")
122 def test_update_cluster_status_deleted(
123 self, mock_capi, mock_ng, mock_update, mock_delete
124 ):
125 mock_capi.return_value = None
126 self.cluster_obj.status = fields.ClusterStatus.DELETE_IN_PROGRESS
127
128 self.driver.update_cluster_status(self.context, self.cluster_obj)
129
130 mock_ng.assert_not_called()
131 mock_update.assert_not_called()
132 mock_delete.assert_called_once_with(self.context, self.cluster_obj)
133
134 @mock.patch.object(driver.Driver, "_update_status_deleting")
135 @mock.patch.object(driver.Driver, "_update_status_updating")
136 @mock.patch.object(driver.Driver, "_update_all_nodegroups_status")
137 @mock.patch.object(driver.Driver, "_get_capi_cluster")
138 def test_update_cluster_status_deleting(
139 self, mock_capi, mock_ng, mock_update, mock_delete
140 ):
141 mock_capi.return_value = {"spec": {}}
142 self.cluster_obj.status = fields.ClusterStatus.DELETE_IN_PROGRESS
143
144 self.driver.update_cluster_status(self.context, self.cluster_obj)
145
146 mock_ng.assert_called_once_with(self.cluster_obj)
147 mock_update.assert_not_called()
148 mock_delete.assert_not_called()
149
150 @mock.patch.object(driver.Driver, "_update_status_deleting")
151 @mock.patch.object(driver.Driver, "_update_status_updating")
152 @mock.patch.object(driver.Driver, "_update_all_nodegroups_status")
153 @mock.patch.object(driver.Driver, "_get_capi_cluster")
154 def test_update_cluster_status_create_complete(
155 self, mock_capi, mock_ng, mock_update, mock_delete
156 ):
157 mock_capi.return_value = {"spec": {}}
158 self.cluster_obj.status = fields.ClusterStatus.CREATE_COMPLETE
159
160 self.driver.update_cluster_status(self.context, self.cluster_obj)
161
162 mock_ng.assert_called_once_with(self.cluster_obj)
163 mock_update.assert_not_called()
164 mock_delete.assert_not_called()
165
166 @mock.patch.object(driver.Driver, "_update_worker_nodegroup_status")
167 @mock.patch.object(driver.Driver, "_update_control_plane_nodegroup_status")
168 def test_update_all_nodegroups_status_not_in_progress(
169 self, mock_cp, mock_w
170 ):
171 control_plane = [
172 ng
173 for ng in self.cluster_obj.nodegroups
174 if ng.role == driver.NODE_GROUP_ROLE_CONTROLLER
175 ][0]
176 control_plane.status = fields.ClusterStatus.CREATE_COMPLETE
177 mock_cp.return_value = control_plane
178 mock_w.return_value = None
179
180 result = self.driver._update_all_nodegroups_status(self.cluster_obj)
181
182 self.assertFalse(result)
183 control_plane = [
184 ng
185 for ng in self.cluster_obj.nodegroups
186 if ng.role == driver.NODE_GROUP_ROLE_CONTROLLER
187 ][0]
188 mock_cp.assert_called_once_with(self.cluster_obj, mock.ANY)
189 self.assertEqual(
190 control_plane.obj_to_primitive(),
191 mock_cp.call_args_list[0][0][1].obj_to_primitive(),
192 )
193 mock_w.assert_called_once_with(self.cluster_obj, mock.ANY)
194 worker = [
195 ng
196 for ng in self.cluster_obj.nodegroups
197 if ng.role != driver.NODE_GROUP_ROLE_CONTROLLER
198 ][0]
199 self.assertEqual(
200 worker.obj_to_primitive(),
201 mock_w.call_args_list[0][0][1].obj_to_primitive(),
202 )
203
204 @mock.patch.object(driver.Driver, "_update_worker_nodegroup_status")
205 @mock.patch.object(driver.Driver, "_update_control_plane_nodegroup_status")
206 def test_update_all_nodegroups_status_in_progress(self, mock_cp, mock_w):
207 control_plane = [
208 ng
209 for ng in self.cluster_obj.nodegroups
210 if ng.role == driver.NODE_GROUP_ROLE_CONTROLLER
211 ][0]
212 control_plane.status = fields.ClusterStatus.CREATE_IN_PROGRESS
213 mock_cp.return_value = control_plane
214 mock_w.return_value = None
215
216 result = self.driver._update_all_nodegroups_status(self.cluster_obj)
217
218 self.assertTrue(result)
219 mock_cp.assert_called_once_with(self.cluster_obj, mock.ANY)
220 mock_w.assert_called_once_with(self.cluster_obj, mock.ANY)
221
222 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
223 @mock.patch.object(kubernetes.Client, "load")
224 def test_update_worker_nodegroup_status_empty(
225 self, mock_load, mock_update
226 ):
227 mock_client = mock.MagicMock(spec=kubernetes.Client)
228 mock_load.return_value = mock_client
229 nodegroup = mock.MagicMock()
230 nodegroup.name = "workers"
231 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
232 md = {"status": {}}
233 mock_client.get_machine_deployment.return_value = md
234
235 self.driver._update_worker_nodegroup_status(
236 self.cluster_obj, nodegroup
237 )
238
239 mock_client.get_machine_deployment.assert_called_once_with(
240 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
241 )
242 mock_update.assert_called_once_with(
243 self.cluster_obj, nodegroup, driver.NodeGroupState.PENDING
244 )
245
246 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
247 @mock.patch.object(kubernetes.Client, "load")
248 def test_update_worker_nodegroup_status_scaling_up(
249 self, mock_load, mock_update
250 ):
251 mock_client = mock.MagicMock(spec=kubernetes.Client)
252 mock_load.return_value = mock_client
253 nodegroup = mock.MagicMock()
254 nodegroup.name = "workers"
255 md = {"status": {"phase": "ScalingUp"}}
256 mock_client.get_machine_deployment.return_value = md
257
258 self.driver._update_worker_nodegroup_status(
259 self.cluster_obj, nodegroup
260 )
261
262 mock_client.get_machine_deployment.assert_called_once_with(
263 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
264 )
265 mock_update.assert_called_once_with(
266 self.cluster_obj, mock.ANY, driver.NodeGroupState.PENDING
267 )
268
269 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
270 @mock.patch.object(kubernetes.Client, "load")
271 def test_update_worker_nodegroup_status_failed(
272 self, mock_load, mock_update
273 ):
274 mock_client = mock.MagicMock(spec=kubernetes.Client)
275 mock_load.return_value = mock_client
276 nodegroup = mock.MagicMock()
277 nodegroup.name = "workers"
278 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
279 md = {"status": {"phase": "Failed"}}
280 mock_client.get_machine_deployment.return_value = md
281
282 self.driver._update_worker_nodegroup_status(
283 self.cluster_obj, nodegroup
284 )
285
286 mock_client.get_machine_deployment.assert_called_once_with(
287 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
288 )
289 mock_update.assert_called_once_with(
290 self.cluster_obj, nodegroup, driver.NodeGroupState.FAILED
291 )
292
293 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
294 @mock.patch.object(kubernetes.Client, "load")
295 def test_update_worker_nodegroup_status_not_present_creating(
296 self, mock_load, mock_update
297 ):
298 mock_client = mock.MagicMock(spec=kubernetes.Client)
299 mock_load.return_value = mock_client
300 nodegroup = mock.MagicMock()
301 nodegroup.name = "workers"
302 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
303 mock_client.get_machine_deployment.return_value = None
304 mock_client.get_all_machines_by_label.return_value = None
305
306 self.driver._update_worker_nodegroup_status(
307 self.cluster_obj, nodegroup
308 )
309
310 mock_client.get_machine_deployment.assert_called_once_with(
311 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
312 )
313 mock_update.assert_called_once_with(
314 self.cluster_obj, nodegroup, driver.NodeGroupState.NOT_PRESENT
315 )
316 mock_client.get_all_machines_by_label.assert_not_called()
317 nodegroup.destroy.assert_not_called()
318 nodegroup.save.assert_not_called()
319
320 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
321 @mock.patch.object(kubernetes.Client, "load")
322 def test_update_worker_nodegroup_status_not_present_deleting(
323 self, mock_load, mock_update
324 ):
325 mock_client = mock.MagicMock(spec=kubernetes.Client)
326 mock_load.return_value = mock_client
327 nodegroup = mock.MagicMock()
328 nodegroup.name = "workers"
329 nodegroup.status = fields.ClusterStatus.DELETE_IN_PROGRESS
330 machine = {"status": {}}
331 mock_client.get_machine_deployment.return_value = None
332 mock_client.get_all_machines_by_label.return_value = machine
333
334 self.driver._update_worker_nodegroup_status(
335 self.cluster_obj, nodegroup
336 )
337
338 mock_client.get_machine_deployment.assert_called_once_with(
339 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
340 )
341 mock_client.get_all_machines_by_label.assert_called_once_with(
342 {
343 "capi.stackhpc.com/cluster": "cluster-example-a-111111111111",
344 "capi.stackhpc.com/component": "worker",
345 "capi.stackhpc.com/node-group": "workers",
346 },
347 "magnum-fakeproject",
348 )
349 mock_update.assert_called_once_with(
350 self.cluster_obj, nodegroup, driver.NodeGroupState.PENDING
351 )
352
353 @mock.patch.object(kubernetes.Client, "load")
354 def test_update_worker_nodegroup_status_machines_missing_non_default(
355 self, mock_load
356 ):
357 mock_client = mock.MagicMock(spec=kubernetes.Client)
358 mock_load.return_value = mock_client
359 nodegroup = mock.MagicMock()
360 nodegroup.name = "workers"
361 nodegroup.status = fields.ClusterStatus.DELETE_IN_PROGRESS
362 nodegroup.is_default = False
363 mock_client.get_machine_deployment.return_value = None
364 mock_client.get_all_machines_by_label.return_value = None
365
366 self.driver._update_worker_nodegroup_status(
367 self.cluster_obj, nodegroup
368 )
369
370 mock_client.get_machine_deployment.assert_called_once_with(
371 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
372 )
373 mock_client.get_all_machines_by_label.assert_called_once_with(
374 {
375 "capi.stackhpc.com/cluster": "cluster-example-a-111111111111",
376 "capi.stackhpc.com/component": "worker",
377 "capi.stackhpc.com/node-group": "workers",
378 },
379 "magnum-fakeproject",
380 )
381 nodegroup.destroy.assert_called_once_with()
382 nodegroup.save.assert_not_called()
383
384 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
385 @mock.patch.object(kubernetes.Client, "load")
386 def test_update_worker_nodegroup_status_running(
387 self, mock_load, mock_update
388 ):
389 mock_client = mock.MagicMock(spec=kubernetes.Client)
390 mock_load.return_value = mock_client
391 nodegroup = mock.MagicMock()
392 nodegroup.name = "workers"
393 md = {"status": {"phase": "Running"}}
394 mock_client.get_machine_deployment.return_value = md
395
396 self.driver._update_worker_nodegroup_status(
397 self.cluster_obj, nodegroup
398 )
399
400 mock_client.get_machine_deployment.assert_called_once_with(
401 "cluster-example-a-111111111111-workers", "magnum-fakeproject"
402 )
403 mock_update.assert_called_once_with(
404 self.cluster_obj, mock.ANY, driver.NodeGroupState.READY
405 )
406
407 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
408 @mock.patch.object(kubernetes.Client, "load")
409 def test_update_control_plane_nodegroup_status_empty(
410 self, mock_load, mock_update
411 ):
412 mock_client = mock.MagicMock(spec=kubernetes.Client)
413 mock_load.return_value = mock_client
414 nodegroup = mock.MagicMock()
415 nodegroup.name = "masters"
416 mock_client.get_kubeadm_control_plane.return_value = None
417
418 self.driver._update_control_plane_nodegroup_status(
419 self.cluster_obj, nodegroup
420 )
421
422 mock_client.get_kubeadm_control_plane.assert_called_once_with(
423 "cluster-example-a-111111111111-control-plane",
424 "magnum-fakeproject",
425 )
426 mock_update.assert_called_once_with(
427 self.cluster_obj, mock.ANY, driver.NodeGroupState.NOT_PRESENT
428 )
429
430 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
431 @mock.patch.object(kubernetes.Client, "load")
432 def test_update_control_plane_nodegroup_status_condition_false(
433 self, mock_load, mock_update
434 ):
435 mock_client = mock.MagicMock(spec=kubernetes.Client)
436 mock_load.return_value = mock_client
437 nodegroup = mock.MagicMock()
438 nodegroup.name = "masters"
439 kcp = {
440 "spec": {
441 "replicas": 3,
442 },
443 "status": {
444 "conditions": [
445 {"type": "MachinesReady", "status": "True"},
446 {"type": "Ready", "status": "True"},
447 {"type": "EtcdClusterHealthy", "status": "True"},
448 {
449 "type": "ControlPlaneComponentsHealthy",
450 "status": "False",
451 },
452 ],
453 "replicas": 3,
454 "updatedReplicas": 3,
455 "readyReplicas": 3,
456 },
457 }
458 mock_client.get_kubeadm_control_plane.return_value = kcp
459
460 self.driver._update_control_plane_nodegroup_status(
461 self.cluster_obj, nodegroup
462 )
463
464 mock_client.get_kubeadm_control_plane.assert_called_once_with(
465 "cluster-example-a-111111111111-control-plane",
466 "magnum-fakeproject",
467 )
468 mock_update.assert_called_once_with(
469 self.cluster_obj, mock.ANY, driver.NodeGroupState.PENDING
470 )
471
472 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
473 @mock.patch.object(kubernetes.Client, "load")
474 def test_update_control_plane_nodegroup_status_mismatched_replicas(
475 self, mock_load, mock_update
476 ):
477 mock_client = mock.MagicMock(spec=kubernetes.Client)
478 mock_load.return_value = mock_client
479 nodegroup = mock.MagicMock()
480 nodegroup.name = "masters"
481 kcp = {
482 "spec": {
483 "replicas": 3,
484 },
485 "status": {
486 "conditions": [
487 {"type": "MachinesReady", "status": "True"},
488 {"type": "Ready", "status": "True"},
489 {"type": "EtcdClusterHealthy", "status": "True"},
490 {
491 "type": "ControlPlaneComponentsHealthy",
492 "status": "True",
493 },
494 ],
495 "replicas": 3,
496 "updatedReplicas": 2,
497 "readyReplicas": 2,
498 },
499 }
500 mock_client.get_kubeadm_control_plane.return_value = kcp
501
502 self.driver._update_control_plane_nodegroup_status(
503 self.cluster_obj, nodegroup
504 )
505
506 mock_client.get_kubeadm_control_plane.assert_called_once_with(
507 "cluster-example-a-111111111111-control-plane",
508 "magnum-fakeproject",
509 )
510 mock_update.assert_called_once_with(
511 self.cluster_obj, mock.ANY, driver.NodeGroupState.PENDING
512 )
513
514 @mock.patch.object(driver.Driver, "_update_nodegroup_status")
515 @mock.patch.object(kubernetes.Client, "load")
516 def test_update_control_plane_nodegroup_status_ready(
517 self, mock_load, mock_update
518 ):
519 mock_client = mock.MagicMock(spec=kubernetes.Client)
520 mock_load.return_value = mock_client
521 nodegroup = mock.MagicMock()
522 nodegroup.name = "masters"
523 kcp = {
524 "spec": {
525 "replicas": 3,
526 },
527 "status": {
528 "conditions": [
529 {"type": "MachinesReady", "status": "True"},
530 {"type": "Ready", "status": "True"},
531 {"type": "EtcdClusterHealthy", "status": "True"},
532 {
533 "type": "ControlPlaneComponentsHealthy",
534 "status": "True",
535 },
536 ],
537 "replicas": 3,
538 "updatedReplicas": 3,
539 "readyReplicas": 3,
540 },
541 }
542 mock_client.get_kubeadm_control_plane.return_value = kcp
543
544 self.driver._update_control_plane_nodegroup_status(
545 self.cluster_obj, nodegroup
546 )
547
548 mock_client.get_kubeadm_control_plane.assert_called_once_with(
549 "cluster-example-a-111111111111-control-plane",
550 "magnum-fakeproject",
551 )
552 mock_update.assert_called_once_with(
553 self.cluster_obj, mock.ANY, driver.NodeGroupState.READY
554 )
555
556 @mock.patch.object(kubernetes.Client, "load")
557 def test_nodegroup_machines_exist(self, mock_load):
558 mock_client = mock.MagicMock(spec=kubernetes.Client)
559 mock_load.return_value = mock_client
560 mock_client.get_all_machines_by_label.return_value = ["item1"]
561 nodegroup = obj_utils.create_test_nodegroup(self.context)
562
563 result = self.driver._nodegroup_machines_exist(
564 self.cluster_obj, nodegroup
565 )
566
567 self.assertTrue(result)
568 mock_client.get_all_machines_by_label.assert_called_once_with(
569 {
570 "capi.stackhpc.com/cluster": "cluster-example-a-111111111111",
571 "capi.stackhpc.com/component": "worker",
572 "capi.stackhpc.com/node-group": "nodegroup1",
573 },
574 "magnum-fakeproject",
575 )
576
577 @mock.patch.object(capi_monitor, "CAPIMonitor")
578 def test_get_monitor(self, mock_mon):
579 self.driver.get_monitor(self.context, self.cluster_obj)
580 mock_mon.assert_called_once_with(self.context, self.cluster_obj)
581
582 @mock.patch.object(kubernetes.Client, "load")
583 def test_get_capi_cluster(self, mock_load):
584 mock_client = mock.MagicMock(spec=kubernetes.Client)
585 mock_load.return_value = mock_client
586
587 self.driver._get_capi_cluster(self.cluster_obj)
588
589 mock_client.get_capi_cluster.assert_called_once_with(
590 "cluster-example-a-111111111111", "magnum-fakeproject"
591 )
592
593 @mock.patch.object(app_creds, "delete_app_cred")
594 @mock.patch.object(kubernetes.Client, "load")
595 def test_update_status_deleting(self, mock_load, mock_delete):
596 mock_client = mock.MagicMock(spec=kubernetes.Client)
597 mock_load.return_value = mock_client
598
599 self.driver._update_status_deleting(self.context, self.cluster_obj)
600
601 self.assertEqual("DELETE_COMPLETE", self.cluster_obj.status)
602 mock_delete.assert_called_once_with(self.context, self.cluster_obj)
603 mock_client.delete_all_secrets_by_label.assert_called_once_with(
604 "magnum.openstack.org/cluster-uuid",
605 self.cluster_obj.uuid,
606 "magnum-fakeproject",
607 )
608
609 def test_update_status_updating_not_ready(self):
610 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
611 capi_cluster = {}
612
613 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
614
615 self.assertEqual(
616 fields.ClusterStatus.CREATE_IN_PROGRESS, self.cluster_obj.status
617 )
618
619 @mock.patch.object(kubernetes.Client, "load")
620 def test_update_status_updating_condition_false(self, mock_load):
621 mock_client = mock.MagicMock(spec=kubernetes.Client)
622 mock_client.get_addons_by_label.return_value = []
623 mock_load.return_value = mock_client
624
625 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
626 capi_cluster = {
627 "status": {
628 "conditions": [
629 dict(type="InfrastructureReady", status="True"),
630 dict(type="ControlPlaneReady", status="True"),
631 dict(type="Ready", status="False"),
632 ]
633 }
634 }
635
636 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
637
638 self.assertEqual(
639 fields.ClusterStatus.CREATE_IN_PROGRESS, self.cluster_obj.status
640 )
641
642 @mock.patch.object(kubernetes.Client, "load")
643 def test_update_status_updating_ready_created(self, mock_load):
644 mock_client = mock.MagicMock(spec=kubernetes.Client)
645 mock_client.get_addons_by_label.return_value = []
646 mock_load.return_value = mock_client
647
648 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
649 capi_cluster = {
650 "status": {
651 "conditions": [
652 dict(type="InfrastructureReady", status="True"),
653 dict(type="ControlPlaneReady", status="True"),
654 dict(type="Ready", status="True"),
655 ]
656 }
657 }
658
659 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
660
661 self.assertEqual(
662 fields.ClusterStatus.CREATE_COMPLETE, self.cluster_obj.status
663 )
664
665 @mock.patch.object(kubernetes.Client, "load")
666 def test_update_status_updating_addons_unknown(self, mock_load):
667 mock_client = mock.MagicMock(spec=kubernetes.Client)
668 mock_client.get_addons_by_label.return_value = [
669 {
670 "metadata": {"name": "cni"},
671 "status": {},
672 },
673 {
674 "metadata": {"name": "monitoring"},
675 "status": {},
676 },
677 ]
678 mock_load.return_value = mock_client
679
680 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
681 capi_cluster = {
682 "status": {
683 "conditions": [
684 dict(type="InfrastructureReady", status="True"),
685 dict(type="ControlPlaneReady", status="True"),
686 dict(type="Ready", status="True"),
687 ]
688 }
689 }
690
691 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
692
693 self.assertEqual(
694 fields.ClusterStatus.CREATE_IN_PROGRESS, self.cluster_obj.status
695 )
696
697 @mock.patch.object(kubernetes.Client, "load")
698 def test_update_status_updating_addons_installing(self, mock_load):
699 mock_client = mock.MagicMock(spec=kubernetes.Client)
700 mock_client.get_addons_by_label.return_value = [
701 {
702 "metadata": {"name": "cni"},
703 "status": {"phase": "Deployed"},
704 },
705 {
706 "metadata": {"name": "monitoring"},
707 "status": {"phase": "Installing"},
708 },
709 ]
710 mock_load.return_value = mock_client
711
712 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
713 capi_cluster = {
714 "status": {
715 "conditions": [
716 dict(type="InfrastructureReady", status="True"),
717 dict(type="ControlPlaneReady", status="True"),
718 dict(type="Ready", status="True"),
719 ]
720 }
721 }
722
723 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
724
725 self.assertEqual(
726 fields.ClusterStatus.CREATE_IN_PROGRESS, self.cluster_obj.status
727 )
728
729 @mock.patch.object(kubernetes.Client, "load")
730 def test_update_status_updating_addons_deployed(self, mock_load):
731 mock_client = mock.MagicMock(spec=kubernetes.Client)
732 mock_client.get_addons_by_label.return_value = [
733 {
734 "metadata": {"name": "cni"},
735 "status": {"phase": "Deployed"},
736 },
737 {
738 "metadata": {"name": "monitoring"},
739 "status": {"phase": "Deployed"},
740 },
741 ]
742 mock_load.return_value = mock_client
743
744 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
745 capi_cluster = {
746 "status": {
747 "conditions": [
748 dict(type="InfrastructureReady", status="True"),
749 dict(type="ControlPlaneReady", status="True"),
750 dict(type="Ready", status="True"),
751 ]
752 }
753 }
754
755 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
756
757 self.assertEqual(
758 fields.ClusterStatus.CREATE_COMPLETE, self.cluster_obj.status
759 )
760
761 @mock.patch.object(kubernetes.Client, "load")
762 def test_update_status_updating_addons_failed(self, mock_load):
763 mock_client = mock.MagicMock(spec=kubernetes.Client)
764 mock_client.get_addons_by_label.return_value = [
765 {
766 "metadata": {"name": "cni"},
767 "status": {"phase": "Deployed"},
768 },
769 {
770 "metadata": {"name": "monitoring"},
771 "status": {"phase": "Failed"},
772 },
773 ]
774 mock_load.return_value = mock_client
775
776 self.cluster_obj.status = fields.ClusterStatus.CREATE_IN_PROGRESS
777 capi_cluster = {
778 "status": {
779 "conditions": [
780 dict(type="InfrastructureReady", status="True"),
781 dict(type="ControlPlaneReady", status="True"),
782 dict(type="Ready", status="True"),
783 ]
784 }
785 }
786
787 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
788
789 self.assertEqual(
790 fields.ClusterStatus.CREATE_FAILED, self.cluster_obj.status
791 )
792
793 @mock.patch.object(kubernetes.Client, "load")
794 def test_update_status_updating_ready_updated(self, mock_load):
795 mock_client = mock.MagicMock(spec=kubernetes.Client)
796 mock_client.get_addons_by_label.return_value = []
797 mock_load.return_value = mock_client
798
799 self.cluster_obj.status = fields.ClusterStatus.UPDATE_IN_PROGRESS
800 capi_cluster = {
801 "status": {
802 "conditions": [
803 dict(type="InfrastructureReady", status="True"),
804 dict(type="ControlPlaneReady", status="True"),
805 dict(type="Ready", status="True"),
806 ]
807 }
808 }
809
810 self.driver._update_status_updating(self.cluster_obj, capi_cluster)
811
812 self.assertEqual(
813 fields.ClusterStatus.UPDATE_COMPLETE, self.cluster_obj.status
814 )
815
816 def test_update_cluster_api_address(self):
817 capi_cluster = {
818 "spec": {"controlPlaneEndpoint": {"host": "foo", "port": 6443}}
819 }
820
821 self.driver._update_cluster_api_address(self.cluster_obj, capi_cluster)
822
823 self.assertEqual("https://foo:6443", self.cluster_obj.api_address)
824
825 def test_update_cluster_api_address_skip(self):
826 self.cluster_obj.api_address = "asdf"
827 capi_cluster = {"spec": {"foo": "bar"}}
828
829 self.driver._update_cluster_api_address(self.cluster_obj, capi_cluster)
830
831 self.assertEqual("asdf", self.cluster_obj.api_address)
832
833 def test_update_cluster_api_address_skip_on_delete(self):
834 self.cluster_obj.status = fields.ClusterStatus.DELETE_IN_PROGRESS
835 self.cluster_obj.api_address = "asdf"
836 capi_cluster = {
837 "spec": {"controlPlaneEndpoint": {"host": "foo", "port": 6443}}
838 }
839
840 self.driver._update_cluster_api_address(self.cluster_obj, capi_cluster)
841
842 self.assertEqual("asdf", self.cluster_obj.api_address)
843
844 def test_update_nodegroup_status_create_complete(self):
845 nodegroup = obj_utils.create_test_nodegroup(self.context)
846 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
847
848 updated = self.driver._update_nodegroup_status(
849 self.cluster_obj, nodegroup, driver.NodeGroupState.READY
850 )
851
852 self.assertEqual(fields.ClusterStatus.CREATE_COMPLETE, updated.status)
853
854 def test_update_nodegroup_status_update_complete(self):
855 nodegroup = obj_utils.create_test_nodegroup(self.context)
856 nodegroup.status = fields.ClusterStatus.UPDATE_IN_PROGRESS
857
858 updated = self.driver._update_nodegroup_status(
859 self.cluster_obj, nodegroup, driver.NodeGroupState.READY
860 )
861
862 self.assertEqual(fields.ClusterStatus.UPDATE_COMPLETE, updated.status)
863
864 def test_update_nodegroup_status_create_failed(self):
865 nodegroup = obj_utils.create_test_nodegroup(self.context)
866 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
867
868 updated = self.driver._update_nodegroup_status(
869 self.cluster_obj, nodegroup, driver.NodeGroupState.FAILED
870 )
871
872 self.assertEqual(fields.ClusterStatus.CREATE_FAILED, updated.status)
873
874 def test_update_nodegroup_status_update_failed(self):
875 nodegroup = obj_utils.create_test_nodegroup(self.context)
876 nodegroup.status = fields.ClusterStatus.UPDATE_IN_PROGRESS
877
878 updated = self.driver._update_nodegroup_status(
879 self.cluster_obj, nodegroup, driver.NodeGroupState.FAILED
880 )
881
882 self.assertEqual(fields.ClusterStatus.UPDATE_FAILED, updated.status)
883
884 def test_update_nodegroup_status_create_in_progress(self):
885 nodegroup = obj_utils.create_test_nodegroup(self.context)
886 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
887
888 updated = self.driver._update_nodegroup_status(
889 self.cluster_obj, nodegroup, driver.NodeGroupState.PENDING
890 )
891
892 self.assertEqual(
893 fields.ClusterStatus.CREATE_IN_PROGRESS, updated.status
894 )
895
896 def test_update_nodegroup_status_delete_in_progress(self):
897 nodegroup = obj_utils.create_test_nodegroup(self.context)
898 nodegroup.status = fields.ClusterStatus.DELETE_IN_PROGRESS
899
900 updated = self.driver._update_nodegroup_status(
901 self.cluster_obj, nodegroup, driver.NodeGroupState.PENDING
902 )
903
904 self.assertEqual(
905 fields.ClusterStatus.DELETE_IN_PROGRESS, updated.status
906 )
907 self.assertEqual(nodegroup.as_dict(), updated.as_dict())
908
909 def test_update_nodegroup_creating_but_not_found(self):
910 nodegroup = obj_utils.create_test_nodegroup(self.context)
911 nodegroup.status = fields.ClusterStatus.CREATE_IN_PROGRESS
912
913 updated = self.driver._update_nodegroup_status(
914 self.cluster_obj, nodegroup, driver.NodeGroupState.NOT_PRESENT
915 )
916
917 self.assertEqual(
918 fields.ClusterStatus.CREATE_IN_PROGRESS, updated.status
919 )
920
921 def test_update_nodegroup_status_delete_return_none(self):
922 nodegroup = obj_utils.create_test_nodegroup(self.context)
923 nodegroup.status = fields.ClusterStatus.DELETE_IN_PROGRESS
924
925 result = self.driver._update_nodegroup_status(
926 self.cluster_obj, nodegroup, driver.NodeGroupState.NOT_PRESENT
927 )
928
929 self.assertIsNone(result)
930
931 def test_update_nodegroup_status_delete_non_default_destroy(self):
932 nodegroup = mock.MagicMock()
933 nodegroup.status = fields.ClusterStatus.DELETE_IN_PROGRESS
934 nodegroup.is_default = False
935
936 result = self.driver._update_nodegroup_status(
937 self.cluster_obj, nodegroup, driver.NodeGroupState.NOT_PRESENT
938 )
939
940 self.assertIsNone(result)
941 nodegroup.destroy.assert_called_once_with()
942
943 def test_update_nodegroup_status_delete_unexpected_state(self):
944 nodegroup = obj_utils.create_test_nodegroup(self.context)
945 nodegroup.status = fields.ClusterStatus.ROLLBACK_IN_PROGRESS
946
947 updated = self.driver._update_nodegroup_status(
948 self.cluster_obj, nodegroup, driver.NodeGroupState.NOT_PRESENT
949 )
950
951 self.assertEqual(
952 fields.ClusterStatus.ROLLBACK_IN_PROGRESS, updated.status
953 )
954 self.assertEqual(nodegroup.as_dict(), updated.as_dict())
955
956 def test_namespace(self):
957 self.cluster_obj.project_id = "123-456F"
958
959 namespace = driver_utils.cluster_namespace(self.cluster_obj)
960
961 self.assertEqual("magnum-123456f", namespace)
962
963 def test_label_return_default(self):
964 self.cluster_obj.labels = dict()
965 self.cluster_obj.cluster_template.labels = dict()
966
967 result = self.driver._label(self.cluster_obj, "foo", "bar")
968
969 self.assertEqual("bar", result)
970
971 def test_label_return_template(self):
972 self.cluster_obj.cluster_template.labels = dict(foo=42)
973
974 result = self.driver._label(self.cluster_obj, "foo", "bar")
975
976 self.assertEqual("42", result)
977
978 def test_label_return_cluster(self):
979 self.cluster_obj.labels = dict(foo=41)
980 self.cluster_obj.cluster_template.labels = dict(foo=42)
981
982 result = self.driver._label(self.cluster_obj, "foo", "bar")
983
984 self.assertEqual("41", result)
985
986 def test_sanitized_name_no_suffix(self):
987 self.assertEqual(
988 "123-456fab", driver_utils.sanitized_name("123-456Fab")
989 )
990
991 def test_sanitized_name_with_suffix(self):
992 self.assertEqual(
993 "123-456-fab-1-asdf",
994 driver_utils.sanitized_name("123-456_Fab!!_1!!", "asdf"),
995 )
996 self.assertEqual(
997 "123-456-fab-1-asdf",
998 driver_utils.sanitized_name("123-456_Fab-1", "asdf"),
999 )
1000
1001 def test_get_kube_version_raises(self):
1002 mock_image = mock.Mock()
1003 mock_image.get.return_value = None
1004 mock_image.id = "myid"
1005
1006 e = self.assertRaises(
1007 exception.MagnumException,
1008 self.driver._get_kube_version,
1009 mock_image,
1010 )
1011
1012 self.assertEqual(
1013 "Image myid does not have a kube_version property.", str(e)
1014 )
1015 mock_image.get.assert_called_once_with("kube_version")
1016
1017 def test_get_kube_version_works(self):
1018 mock_image = mock.Mock()
1019 mock_image.get.return_value = "v1.27.9"
1020
1021 result = self.driver._get_kube_version(mock_image)
1022
1023 self.assertEqual("1.27.9", result)
1024 mock_image.get.assert_called_once_with("kube_version")
1025
1026 @mock.patch("magnum.common.clients.OpenStackClients", autospec=True)
1027 @mock.patch("magnum.api.utils.get_openstack_resource", autospec=True)
1028 def test_get_image_details_ubuntu(self, mock_get, mock_osc):
1029 mock_image = mock.Mock()
1030 image_metadata = {
1031 "os_distro": "ubuntu",
1032 "kube_version": "1.27.9",
1033 }
1034
1035 def image_side_effect(arg):
1036 return image_metadata[arg]
1037
1038 mock_image.get.side_effect = image_side_effect
1039 mock_image.id = "myid"
1040 mock_get.return_value = mock_image
1041
1042 id, version, distro = self.driver._get_image_details(
1043 self.context, "myimagename"
1044 )
1045
1046 self.assertEqual("1.27.9", version)
1047 self.assertEqual("myid", id)
1048 self.assertEqual("ubuntu", distro)
1049 mock_image.get.assert_any_call("kube_version")
1050 mock_image.get.assert_any_call("os_distro")
1051 mock_get.assert_called_once_with(mock.ANY, "myimagename", "images")
1052
1053 @mock.patch("magnum.common.clients.OpenStackClients", autospec=True)
1054 @mock.patch("magnum.api.utils.get_openstack_resource", autospec=True)
1055 def test_get_image_details_flatcar(self, mock_get, mock_osc):
1056 mock_image = mock.Mock()
1057 image_metadata = {
1058 "os_distro": "flatcar",
1059 "kube_version": "1.28.2",
1060 }
1061
1062 def image_side_effect(arg):
1063 return image_metadata[arg]
1064
1065 mock_image.get.side_effect = image_side_effect
1066 mock_image.id = "myid-flatcar"
1067 mock_get.return_value = mock_image
1068
1069 id, version, distro = self.driver._get_image_details(
1070 self.context, "myimagename"
1071 )
1072
1073 self.assertEqual("1.28.2", version)
1074 self.assertEqual("myid-flatcar", id)
1075 self.assertEqual("flatcar", distro)
1076 mock_image.get.assert_any_call("kube_version")
1077 mock_image.get.assert_any_call("os_distro")
1078 mock_get.assert_called_once_with(mock.ANY, "myimagename", "images")
1079
1080 def test_get_chart_release_name_length(self):
1081 self.cluster_obj.stack_id = "foo"
1082
1083 result = driver_utils.chart_release_name(self.cluster_obj)
1084
1085 self.assertEqual("foo", result)
1086
1087 def test_generate_release_name_skip(self):
1088 self.cluster_obj.stack_id = "foo"
1089 self.driver._generate_release_name(self.cluster_obj)
1090 self.assertEqual("foo", self.cluster_obj.stack_id)
1091
1092 def test_generate_release_name_generates(self):
1093 self.cluster_obj.stack_id = None
1094 self.cluster_obj.name = "a" * 77
1095
1096 self.driver._generate_release_name(self.cluster_obj)
1097 first = self.cluster_obj.stack_id
1098
1099 self.assertEqual(43, len(first))
1100 self.assertTrue(self.cluster_obj.name[:30] in first)
1101
1102 self.cluster_obj.stack_id = None
1103 self.driver._generate_release_name(self.cluster_obj)
1104 second = self.cluster_obj.stack_id
1105
1106 self.assertNotEqual(first, second)
1107 self.assertEqual(43, len(second))
1108 self.assertTrue(self.cluster_obj.name[:30] in second)
1109
1110 def test_get_monitoring_enabled_from_template(self):
1111
1112 # Check default if label is not present
1113 self.assertFalse(self.driver._get_monitoring_enabled(self.cluster_obj))
1114
1115 for val in ["true", "True", "TRUE"]:
1116
1117 self.cluster_obj.cluster_template.labels["monitoring_enabled"] = (
1118 val
1119 )
1120
1121 result = self.driver._get_monitoring_enabled(self.cluster_obj)
1122
1123 self.assertTrue(result)
1124
1125 def test_get_kube_dash_enabled_from_template(self):
1126 # Check default if label is not present
1127 self.assertTrue(self.driver._get_kube_dash_enabled(self.cluster_obj))
1128
1129 for val in ["false", "False", "FALSE"]:
1130
1131 self.cluster_obj.cluster_template.labels[
1132 "kube_dashboard_enabled"
1133 ] = val
1134
1135 result = self.driver._get_kube_dash_enabled(self.cluster_obj)
1136
1137 self.assertFalse(result)
1138
1139 def test_get_chart_version_from_config(self):
1140 version = self.driver._get_chart_version(self.cluster_obj)
1141
1142 self.assertEqual(CONF.capi_helm.default_helm_chart_version, version)
1143
1144 def test_get_chart_version_from_template(self):
1145 self.cluster_obj.cluster_template.labels["capi_helm_chart_version"] = (
1146 "1.42.0"
1147 )
1148
1149 version = self.driver._get_chart_version(self.cluster_obj)
1150
1151 self.assertEqual("1.42.0", version)
1152
1153 def _get_cluster_helm_standard_values(self):
1154 """Return standard helm values which can be modified for tests.
1155
1156 There is little point in multiple tests writing the same dictionary
1157 that contains all aspects of a cluster when the side effect they are
1158 testing is limited to boot volumes, or keypairs.
1159 """
1160 app_cred_name = "cluster-example-a-111111111111-cloud-credentials"
1161 ext_net_id = self.cluster_obj.cluster_template.external_network_id
1162
1163 return {
1164 "kubernetesVersion": "1.27.4",
1165 "machineImageId": "imageid1",
1166 "cloudCredentialsSecretName": app_cred_name,
1167 "clusterNetworking": {
1168 "externalNetworkId": ext_net_id,
1169 "internalNetwork": {
1170 "networkFilter": None,
1171 "subnetFilter": None,
1172 "nodeCidr": "10.0.0.0/24",
1173 },
1174 "dnsNameservers": ["8.8.1.1"],
1175 },
1176 "etcd": {},
1177 "apiServer": {
1178 "enableLoadBalancer": True,
1179 "loadBalancerProvider": "amphora",
1180 },
1181 "controlPlane": {
1182 "machineFlavor": "flavor_small",
1183 "machineCount": 3,
1184 "healthCheck": {"enabled": True},
1185 },
1186 "addons": {
1187 "monitoring": {"enabled": False},
1188 "kubernetesDashboard": {"enabled": True},
1189 "ingress": {"enabled": False},
1190 "openstack": {
1191 "csiCinder": mock.ANY,
1192 "cloudConfig": {
1193 "LoadBalancer": {
1194 "lb-provider": "amphora",
1195 "lb-method": "ROUND_ROBIN",
1196 "create-monitor": True,
1197 },
1198 },
1199 },
1200 },
1201 "nodeGroups": [
1202 {
1203 "name": "test-worker",
1204 "machineFlavor": "flavor_medium",
1205 "machineCount": 3,
1206 },
1207 ],
1208 "osDistro": "ubuntu",
1209 "nodeGroupDefaults": {
1210 "healthCheck": {"enabled": True},
1211 },
1212 "machineSSHKeyName": None,
1213 }
1214
1215 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1216 @mock.patch.object(
1217 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1218 )
1219 @mock.patch.object(
1220 driver.Driver,
1221 "_storageclass_definitions",
1222 return_value=mock.ANY,
1223 )
1224 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1225 @mock.patch.object(neutron, "get_network", autospec=True)
1226 @mock.patch.object(
1227 driver.Driver, "_ensure_certificate_secrets", autospec=True
1228 )
1229 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1230 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1231 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1232 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1233 def test_create_cluster(
1234 self,
1235 mock_install,
1236 mock_image,
1237 mock_load,
1238 mock_appcred,
1239 mock_certs,
1240 mock_get_net,
1241 mock_validate_allowed_flavor,
1242 mock_storageclasses,
1243 mock_get_keystone_auth_enabled,
1244 mock_get_allowed_cidrs,
1245 ):
1246 mock_image.return_value = (
1247 "imageid1",
1248 "1.27.4",
1249 "ubuntu",
1250 )
1251 mock_client = mock.MagicMock(spec=kubernetes.Client)
1252 mock_load.return_value = mock_client
1253 mock_get_net.side_effect = (
1254 lambda c, net, source, target, external: f"{net}-{external}"
1255 )
1256
1257 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1258
1259 expected_values = self._get_cluster_helm_standard_values()
1260
1261 mock_install.assert_called_once_with(
1262 self.driver._helm_client,
1263 "cluster-example-a-111111111111",
1264 "openstack-cluster",
1265 mock.ANY, # NOTE(dalees): Compared separately for improved diff
1266 repo=CONF.capi_helm.helm_chart_repo,
1267 version=CONF.capi_helm.default_helm_chart_version,
1268 namespace="magnum-fakeproject",
1269 )
1270
1271 helm_install_values = mock_install.call_args[0][3]
1272 self.assertDictEqual(helm_install_values, expected_values)
1273
1274 mock_client.ensure_namespace.assert_called_once_with(
1275 "magnum-fakeproject"
1276 )
1277 mock_appcred.assert_called_once_with(
1278 self.driver, self.context, self.cluster_obj
1279 )
1280 mock_certs.assert_called_once_with(
1281 self.driver, self.context, self.cluster_obj
1282 )
1283 self.assertEqual([], mock_get_net.call_args_list)
1284
1285 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1286 @mock.patch.object(
1287 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1288 )
1289 @mock.patch.object(
1290 driver.Driver,
1291 "_storageclass_definitions",
1292 return_value=mock.ANY,
1293 )
1294 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1295 @mock.patch.object(
1296 driver.Driver, "_ensure_certificate_secrets", autospec=True
1297 )
1298 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1299 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1300 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1301 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1302 def test_create_cluster_no_dns(
1303 self,
1304 mock_install,
1305 mock_image,
1306 mock_load,
1307 mock_appcred,
1308 mock_certs,
1309 mock_validate_allowed_flavor,
1310 mock_storageclasses,
1311 mock_get_keystone_auth_enabled,
1312 mock_get_allowed_cidrs,
1313 ):
1314 mock_image.return_value = ("imageid1", "1.27.4", "ubuntu")
1315 mock_client = mock.MagicMock(spec=kubernetes.Client)
1316 mock_load.return_value = mock_client
1317
1318 self.cluster_obj.cluster_template.dns_nameserver = ""
1319
1320 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1321
1322 expected_values = self._get_cluster_helm_standard_values()
1323 expected_values["clusterNetworking"]["dnsNameservers"] = None
1324
1325 mock_install.assert_called_once_with(
1326 self.driver._helm_client,
1327 "cluster-example-a-111111111111",
1328 "openstack-cluster",
1329 mock.ANY,
1330 repo=CONF.capi_helm.helm_chart_repo,
1331 version=CONF.capi_helm.default_helm_chart_version,
1332 namespace="magnum-fakeproject",
1333 )
1334
1335 helm_install_values = mock_install.call_args[0][3]
1336 self.assertDictEqual(helm_install_values, expected_values)
1337
1338 mock_client.ensure_namespace.assert_called_once_with(
1339 "magnum-fakeproject"
1340 )
1341 mock_appcred.assert_called_once_with(
1342 self.driver, self.context, self.cluster_obj
1343 )
1344 mock_certs.assert_called_once_with(
1345 self.driver, self.context, self.cluster_obj
1346 )
1347
1348 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1349 @mock.patch.object(
1350 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1351 )
1352 @mock.patch.object(
1353 driver.Driver,
1354 "_storageclass_definitions",
1355 return_value=mock.ANY,
1356 )
1357 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1358 @mock.patch.object(
1359 driver.Driver, "_ensure_certificate_secrets", autospec=True
1360 )
1361 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1362 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1363 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1364 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1365 def test_create_cluster_boot_volume(
1366 self,
1367 mock_install,
1368 mock_image,
1369 mock_load,
1370 mock_appcred,
1371 mock_certs,
1372 mock_validate_allowed_flavor,
1373 mock_storageclasses,
1374 mock_get_keystone_auth_enabled,
1375 mock_get_allowed_cidrs,
1376 ):
1377 mock_image.return_value = ("imageid1", "1.27.4", "ubuntu")
1378 mock_client = mock.MagicMock(spec=kubernetes.Client)
1379 mock_load.return_value = mock_client
1380
1381 CONF.cinder.default_boot_volume_type = "nvme"
1382 CONF.cinder.default_boot_volume_size = 12
1383
1384 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1385
1386 # Get standard values and modify them to match this test
1387 expected_values = self._get_cluster_helm_standard_values()
1388 expected_values["controlPlane"]["machineRootVolume"] = {
1389 "volumeType": "nvme",
1390 "diskSize": 12,
1391 }
1392 expected_values["nodeGroupDefaults"]["machineRootVolume"] = {
1393 "volumeType": "nvme",
1394 "diskSize": 12,
1395 }
1396
1397 mock_install.assert_called_once_with(
1398 self.driver._helm_client,
1399 "cluster-example-a-111111111111",
1400 "openstack-cluster",
1401 mock.ANY,
1402 repo=CONF.capi_helm.helm_chart_repo,
1403 version=CONF.capi_helm.default_helm_chart_version,
1404 namespace="magnum-fakeproject",
1405 )
1406
1407 helm_install_values = mock_install.call_args[0][3]
1408 self.assertDictEqual(helm_install_values, expected_values)
1409
1410 mock_client.ensure_namespace.assert_called_once_with(
1411 "magnum-fakeproject"
1412 )
1413 mock_appcred.assert_called_once_with(
1414 self.driver, self.context, self.cluster_obj
1415 )
1416 mock_certs.assert_called_once_with(
1417 self.driver, self.context, self.cluster_obj
1418 )
1419
1420 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1421 @mock.patch.object(
1422 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1423 )
1424 @mock.patch.object(
1425 driver.Driver,
1426 "_storageclass_definitions",
1427 return_value=mock.ANY,
1428 )
1429 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1430 @mock.patch.object(
1431 driver.Driver, "_ensure_certificate_secrets", autospec=True
1432 )
1433 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1434 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1435 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1436 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1437 def test_create_cluster_boot_volume_extra_network(
1438 self,
1439 mock_install,
1440 mock_image,
1441 mock_load,
1442 mock_appcred,
1443 mock_certs,
1444 mock_validate_allowed_flavor,
1445 mock_storageclasses,
1446 mock_get_keystone_auth_enabled,
1447 mock_get_allowed_cidrs,
1448 ):
1449 mock_image.return_value = (
1450 "imageid1",
1451 "1.27.4",
1452 "ubuntu",
1453 )
1454 mock_client = mock.MagicMock(spec=kubernetes.Client)
1455 mock_load.return_value = mock_client
1456
1457 CONF.cinder.default_boot_volume_type = "nvme"
1458 CONF.cinder.default_boot_volume_size = 12
1459 # Driver should combine boot volume with extra network.
1460 self.cluster_obj.cluster_template.labels["extra_network_name"] = "foo"
1461
1462 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1463
1464 expected_values = self._get_cluster_helm_standard_values()
1465 expected_values["controlPlane"]["machineRootVolume"] = {
1466 "volumeType": "nvme",
1467 "diskSize": 12,
1468 }
1469 expected_values["nodeGroupDefaults"]["machineRootVolume"] = {
1470 "volumeType": "nvme",
1471 "diskSize": 12,
1472 }
1473 expected_values["nodeGroupDefaults"]["machineNetworking"] = {
1474 "ports": [
1475 {},
1476 {
1477 "network": {
1478 "name": "foo",
1479 },
1480 "securityGroups": [],
1481 },
1482 ],
1483 }
1484
1485 mock_install.assert_called_once_with(
1486 self.driver._helm_client,
1487 "cluster-example-a-111111111111",
1488 "openstack-cluster",
1489 mock.ANY,
1490 repo=CONF.capi_helm.helm_chart_repo,
1491 version=CONF.capi_helm.default_helm_chart_version,
1492 namespace="magnum-fakeproject",
1493 )
1494
1495 helm_install_values = mock_install.call_args[0][3]
1496 self.assertDictEqual(helm_install_values, expected_values)
1497
1498 mock_client.ensure_namespace.assert_called_once_with(
1499 "magnum-fakeproject"
1500 )
1501 mock_appcred.assert_called_once_with(
1502 self.driver, self.context, self.cluster_obj
1503 )
1504 mock_certs.assert_called_once_with(
1505 self.driver, self.context, self.cluster_obj
1506 )
1507
1508 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1509 @mock.patch.object(
1510 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1511 )
1512 @mock.patch.object(
1513 driver.Driver,
1514 "_storageclass_definitions",
1515 return_value=mock.ANY,
1516 )
1517 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1518 @mock.patch.object(driver.Driver, "_ensure_certificate_secrets")
1519 @mock.patch.object(driver.Driver, "_create_appcred_secret")
1520 @mock.patch.object(kubernetes.Client, "load")
1521 @mock.patch.object(driver.Driver, "_get_image_details")
1522 @mock.patch.object(helm.Client, "install_or_upgrade")
1523 def test_create_cluster_with_keypair(
1524 self,
1525 mock_install,
1526 mock_image,
1527 mock_load,
1528 mock_appcred,
1529 mock_certs,
1530 mock_validate_allowed_flavor,
1531 mock_storageclasses,
1532 mock_get_keystone_auth_enabled,
1533 mock_get_allowed_cidrs,
1534 ):
1535 mock_image.return_value = (
1536 "imageid1",
1537 "1.27.4",
1538 "ubuntu",
1539 )
1540 mock_client = mock.MagicMock(spec=kubernetes.Client)
1541 mock_load.return_value = mock_client
1542
1543 self.cluster_obj.keypair = "kp1"
1544
1545 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1546
1547 expected_values = self._get_cluster_helm_standard_values()
1548 expected_values["machineSSHKeyName"] = "kp1"
1549
1550 mock_install.assert_called_once_with(
1551 "cluster-example-a-111111111111",
1552 "openstack-cluster",
1553 mock.ANY,
1554 repo=CONF.capi_helm.helm_chart_repo,
1555 version=CONF.capi_helm.default_helm_chart_version,
1556 namespace="magnum-fakeproject",
1557 )
1558 helm_install_values = mock_install.call_args[0][2]
1559 self.assertDictEqual(helm_install_values, expected_values)
1560
1561 mock_client.ensure_namespace.assert_called_once_with(
1562 "magnum-fakeproject"
1563 )
1564 mock_appcred.assert_called_once_with(self.context, self.cluster_obj)
1565 mock_certs.assert_called_once_with(self.context, self.cluster_obj)
1566
1567 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1568 @mock.patch.object(
1569 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1570 )
1571 @mock.patch.object(
1572 driver.Driver,
1573 "_storageclass_definitions",
1574 return_value=mock.ANY,
1575 )
1576 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1577 @mock.patch.object(driver.Driver, "_ensure_certificate_secrets")
1578 @mock.patch.object(driver.Driver, "_create_appcred_secret")
1579 @mock.patch.object(kubernetes.Client, "load")
1580 @mock.patch.object(driver.Driver, "_get_image_details")
1581 @mock.patch.object(helm.Client, "install_or_upgrade")
1582 def test_create_cluster_flatcar(
1583 self,
1584 mock_install,
1585 mock_image,
1586 mock_load,
1587 mock_appcred,
1588 mock_certs,
1589 mock_validate_allowed_flavor,
1590 mock_storageclasses,
1591 mock_get_keystone_auth_enabled,
1592 mock_get_allowed_cidrs,
1593 ):
1594 mock_image.return_value = (
1595 "imageid1",
1596 "1.27.4",
1597 "flatcar",
1598 )
1599 mock_client = mock.MagicMock(spec=kubernetes.Client)
1600 mock_load.return_value = mock_client
1601
1602 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1603
1604 expected_values = self._get_cluster_helm_standard_values()
1605 expected_values["osDistro"] = "flatcar"
1606
1607 mock_install.assert_called_once_with(
1608 "cluster-example-a-111111111111",
1609 "openstack-cluster",
1610 expected_values,
1611 repo=CONF.capi_helm.helm_chart_repo,
1612 version=CONF.capi_helm.default_helm_chart_version,
1613 namespace="magnum-fakeproject",
1614 )
1615
1616 mock_client.ensure_namespace.assert_called_once_with(
1617 "magnum-fakeproject"
1618 )
1619 mock_appcred.assert_called_once_with(self.context, self.cluster_obj)
1620 mock_certs.assert_called_once_with(self.context, self.cluster_obj)
1621
1622 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1623 @mock.patch.object(
1624 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1625 )
1626 @mock.patch.object(
1627 driver.Driver,
1628 "_storageclass_definitions",
1629 return_value=mock.ANY,
1630 )
1631 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1632 @mock.patch.object(
1633 driver.Driver, "_ensure_certificate_secrets", autospec=True
1634 )
1635 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1636 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1637 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1638 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1639 def test_create_cluster_no_autoheal(
1640 self,
1641 mock_install,
1642 mock_image,
1643 mock_load,
1644 mock_appcred,
1645 mock_certs,
1646 mock_validate_allowed_flavor,
1647 mock_storageclasses,
1648 mock_get_keystone_auth_enabled,
1649 mock_get_allowed_cidrs,
1650 ):
1651 mock_image.return_value = ("imageid1", "1.27.4", "ubuntu")
1652 mock_client = mock.MagicMock(spec=kubernetes.Client)
1653 mock_load.return_value = mock_client
1654
1655 self.cluster_obj.cluster_template.labels["auto_healing_enabled"] = (
1656 "false"
1657 )
1658
1659 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1660
1661 # Get standard values and modify them to match this test
1662 expected_values = self._get_cluster_helm_standard_values()
1663 expected_values["controlPlane"]["healthCheck"]["enabled"] = False
1664 expected_values["nodeGroupDefaults"]["healthCheck"]["enabled"] = False
1665
1666 mock_install.assert_called_once_with(
1667 self.driver._helm_client,
1668 "cluster-example-a-111111111111",
1669 "openstack-cluster",
1670 mock.ANY,
1671 repo=CONF.capi_helm.helm_chart_repo,
1672 version=CONF.capi_helm.default_helm_chart_version,
1673 namespace="magnum-fakeproject",
1674 )
1675 helm_install_values = mock_install.call_args[0][3]
1676 self.assertDictEqual(helm_install_values, expected_values)
1677
1678 mock_client.ensure_namespace.assert_called_once_with(
1679 "magnum-fakeproject"
1680 )
1681 mock_appcred.assert_called_once_with(
1682 self.driver, self.context, self.cluster_obj
1683 )
1684 mock_certs.assert_called_once_with(
1685 self.driver, self.context, self.cluster_obj
1686 )
1687
1688 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1689 @mock.patch.object(
1690 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1691 )
1692 @mock.patch.object(
1693 driver.Driver,
1694 "_storageclass_definitions",
1695 return_value=mock.ANY,
1696 )
1697 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1698 @mock.patch.object(
1699 driver.Driver, "_ensure_certificate_secrets", autospec=True
1700 )
1701 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1702 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1703 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1704 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1705 def test_create_cluster_etcd_block_device(
1706 self,
1707 mock_install,
1708 mock_image,
1709 mock_load,
1710 mock_appcred,
1711 mock_certs,
1712 mock_validate_allowed_flavor,
1713 mock_storageclasses,
1714 mock_get_keystone_auth_enabled,
1715 mock_get_allowed_cidrs,
1716 ):
1717 mock_image.return_value = ("imageid1", "1.27.4", "ubuntu")
1718 mock_client = mock.MagicMock(spec=kubernetes.Client)
1719 mock_load.return_value = mock_client
1720
1721 self.cluster_obj.cluster_template.labels.update(
1722 {
1723 "etcd_blockdevice_size": "10",
1724 "etcd_blockdevice_volume_type": "nvme",
1725 }
1726 )
1727
1728 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1729
1730 # Get standard values and modify them to match this test
1731 expected_values = self._get_cluster_helm_standard_values()
1732 expected_values["etcd"] = {
1733 "blockDevice": {
1734 "size": 10,
1735 "type": "Volume",
1736 "volumeType": "nvme",
1737 }
1738 }
1739
1740 mock_install.assert_called_once_with(
1741 self.driver._helm_client,
1742 "cluster-example-a-111111111111",
1743 "openstack-cluster",
1744 mock.ANY,
1745 repo=CONF.capi_helm.helm_chart_repo,
1746 version=CONF.capi_helm.default_helm_chart_version,
1747 namespace="magnum-fakeproject",
1748 )
1749
1750 helm_install_values = mock_install.call_args[0][3]
1751 self.assertDictEqual(helm_install_values, expected_values)
1752
1753 mock_client.ensure_namespace.assert_called_once_with(
1754 "magnum-fakeproject"
1755 )
1756 mock_appcred.assert_called_once_with(
1757 self.driver, self.context, self.cluster_obj
1758 )
1759 mock_certs.assert_called_once_with(
1760 self.driver, self.context, self.cluster_obj
1761 )
1762
1763 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1764 @mock.patch.object(
1765 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1766 )
1767 @mock.patch.object(
1768 driver.Driver,
1769 "_storageclass_definitions",
1770 return_value=mock.ANY,
1771 )
1772 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1773 @mock.patch.object(
1774 driver.Driver, "_ensure_certificate_secrets", autospec=True
1775 )
1776 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1777 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1778 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1779 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1780 def test_create_cluster_etcd_block_device_local(
1781 self,
1782 mock_install,
1783 mock_image,
1784 mock_load,
1785 mock_appcred,
1786 mock_certs,
1787 mock_validate_allowed_flavor,
1788 mock_storageclasses,
1789 mock_get_keystone_auth_enabled,
1790 mock_get_allowed_cidrs,
1791 ):
1792 mock_image.return_value = ("imageid1", "1.27.4", "ubuntu")
1793 mock_client = mock.MagicMock(spec=kubernetes.Client)
1794 mock_load.return_value = mock_client
1795
1796 self.cluster_obj.cluster_template.labels.update(
1797 {
1798 "etcd_blockdevice_size": "10",
1799 "etcd_blockdevice_type": "local",
1800 }
1801 )
1802
1803 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1804
1805 # Get standard values and modify them to match this test
1806 expected_values = self._get_cluster_helm_standard_values()
1807 expected_values["etcd"] = {
1808 "blockDevice": {
1809 "size": 10,
1810 "type": "Local",
1811 }
1812 }
1813
1814 mock_install.assert_called_once_with(
1815 self.driver._helm_client,
1816 "cluster-example-a-111111111111",
1817 "openstack-cluster",
1818 mock.ANY,
1819 repo=CONF.capi_helm.helm_chart_repo,
1820 version=CONF.capi_helm.default_helm_chart_version,
1821 namespace="magnum-fakeproject",
1822 )
1823
1824 helm_install_values = mock_install.call_args[0][3]
1825 self.assertDictEqual(helm_install_values, expected_values)
1826
1827 mock_client.ensure_namespace.assert_called_once_with(
1828 "magnum-fakeproject"
1829 )
1830 mock_appcred.assert_called_once_with(
1831 self.driver, self.context, self.cluster_obj
1832 )
1833 mock_certs.assert_called_once_with(
1834 self.driver, self.context, self.cluster_obj
1835 )
1836
1837 @mock.patch.object(driver.Driver, "_get_allowed_cidrs")
1838 @mock.patch.object(
1839 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
1840 )
1841 @mock.patch.object(
1842 driver.Driver,
1843 "_storageclass_definitions",
1844 return_value=mock.ANY,
1845 )
1846 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
1847 @mock.patch.object(
1848 driver.Driver, "_ensure_certificate_secrets", autospec=True
1849 )
1850 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
1851 @mock.patch.object(kubernetes.Client, "load", autospec=True)
1852 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
1853 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
1854 def test_create_cluster_etcd_block_device_legacy_labels(
1855 self,
1856 mock_install,
1857 mock_image,
1858 mock_load,
1859 mock_appcred,
1860 mock_certs,
1861 mock_validate_allowed_flavor,
1862 mock_storageclasses,
1863 mock_get_keystone_auth_enabled,
1864 mock_get_allowed_cidrs,
1865 ):
1866 mock_image.return_value = ("imageid1", "1.27.4", "ubuntu")
1867 mock_client = mock.MagicMock(spec=kubernetes.Client)
1868 mock_load.return_value = mock_client
1869
1870 # Test the legacy labels for etcd volume size
1871 self.cluster_obj.cluster_template.labels.update(
1872 {
1873 "etcd_volume_size": "10",
1874 "etcd_volume_type": "nvme",
1875 }
1876 )
1877
1878 self.driver.create_cluster(self.context, self.cluster_obj, 10)
1879
1880 # Get standard values and modify them to match this test
1881 expected_values = self._get_cluster_helm_standard_values()
1882 expected_values["etcd"] = {
1883 "blockDevice": {
1884 "size": 10,
1885 "type": "Volume",
1886 "volumeType": "nvme",
1887 }
1888 }
1889
1890 mock_install.assert_called_once_with(
1891 self.driver._helm_client,
1892 "cluster-example-a-111111111111",
1893 "openstack-cluster",
1894 mock.ANY,
1895 repo=CONF.capi_helm.helm_chart_repo,
1896 version=CONF.capi_helm.default_helm_chart_version,
1897 namespace="magnum-fakeproject",
1898 )
1899
1900 helm_install_values = mock_install.call_args[0][3]
1901 self.assertDictEqual(helm_install_values, expected_values)
1902
1903 mock_client.ensure_namespace.assert_called_once_with(
1904 "magnum-fakeproject"
1905 )
1906 mock_appcred.assert_called_once_with(
1907 self.driver, self.context, self.cluster_obj
1908 )
1909 mock_certs.assert_called_once_with(
1910 self.driver, self.context, self.cluster_obj
1911 )
1912
1913 @mock.patch.object(app_creds, "get_app_cred_string_data")
1914 @mock.patch.object(kubernetes.Client, "load")
1915 def test_create_appcred_secret(self, mock_load, mock_sd):
1916 mock_client = mock.MagicMock(spec=kubernetes.Client)
1917 mock_load.return_value = mock_client
1918 mock_sd.return_value = {"cacert": "ca", "clouds.yaml": "appcred"}
1919
1920 self.driver._create_appcred_secret(self.context, self.cluster_obj)
1921
1922 uuid = self.cluster_obj.uuid
1923 name = "cluster-example-a-111111111111"
1924 mock_client.apply_secret.assert_called_once_with(
1925 "cluster-example-a-111111111111-cloud-credentials",
1926 {
1927 "metadata": {
1928 "labels": {
1929 "magnum.openstack.org/project-id": "fake_project",
1930 "magnum.openstack.org/user-id": "fake_user",
1931 "magnum.openstack.org/cluster-uuid": uuid,
1932 "cluster.x-k8s.io/cluster-name": name,
1933 }
1934 },
1935 "stringData": {"cacert": "ca", "clouds.yaml": "appcred"},
1936 },
1937 "magnum-fakeproject",
1938 )
1939
1940 @mock.patch.object(ca_certificates, "get_certificate_string_data")
1941 @mock.patch.object(driver.Driver, "_k8s_resource_labels")
1942 @mock.patch.object(kubernetes.Client, "load")
1943 def test_ensure_certificate_secrets(
1944 self, mock_load, mock_labels, mock_string_data
1945 ):
1946 mock_client = mock.MagicMock(spec=kubernetes.Client)
1947 mock_load.return_value = mock_client
1948 mock_labels.return_value = dict(foo="bar")
1949 mock_string_data.return_value = {
1950 "ca": {"tls.crt": "cert1", "tls.key": "key1"},
1951 "proxy": {"tls.crt": "cert2", "tls.key": "key2"},
1952 }
1953
1954 self.driver._ensure_certificate_secrets(self.context, self.cluster_obj)
1955
1956 mock_client.apply_secret.assert_has_calls(
1957 [
1958 mock.call(
1959 "cluster-example-a-111111111111-ca",
1960 {
1961 "metadata": {"labels": {"foo": "bar"}},
1962 "type": "cluster.x-k8s.io/secret",
1963 "stringData": {"tls.crt": "cert1", "tls.key": "key1"},
1964 },
1965 "magnum-fakeproject",
1966 ),
1967 mock.call(
1968 "cluster-example-a-111111111111-proxy",
1969 {
1970 "metadata": {"labels": {"foo": "bar"}},
1971 "type": "cluster.x-k8s.io/secret",
1972 "stringData": {"tls.crt": "cert2", "tls.key": "key2"},
1973 },
1974 "magnum-fakeproject",
1975 ),
1976 ]
1977 )
1978 mock_string_data.assert_called_once_with(
1979 self.context, self.cluster_obj
1980 )
1981 mock_labels.assert_called_with(self.cluster_obj)
1982
1983 @mock.patch("magnum.common.clients.OpenStackClients.cinder")
1984 def test_get_storage_classes(self, mock_cinder):
1985 CONF.capi_helm.csi_cinder_default_volume_type = "type3"
1986 CONF.capi_helm.csi_cinder_availability_zone = "middle_earth_east"
1987 mock_vol_type_1 = mock.MagicMock()
1988 mock_vol_type_1.name = "type1"
1989 mock_vol_type_2 = mock.MagicMock()
1990 mock_vol_type_2.name = "type2"
1991 mock_vol_type_3 = mock.MagicMock()
1992 mock_vol_type_3.name = "type3"
1993 mock_volume_types = mock.Mock()
1994 mock_volume_types.list.return_value = [
1995 mock_vol_type_1,
1996 mock_vol_type_2,
1997 mock_vol_type_3,
1998 ]
1999 mock_cinder_client = mock.Mock()
2000 mock_cinder_client.volume_types = mock_volume_types
2001 mock_cinder.return_value = mock_cinder_client
2002 storage_classes = self.driver._storageclass_definitions(
2003 self.context, self.cluster_obj
2004 )
2005 self.assertIsInstance(storage_classes, dict)
2006 self.assertIsInstance(storage_classes["defaultStorageClass"], dict)
2007 self.assertIsInstance(
2008 storage_classes["additionalStorageClasses"], list
2009 )
2010 self.assertEqual(
2011 "type3", storage_classes["defaultStorageClass"]["volumeType"]
2012 )
2013 self.assertEqual(
2014 "middle_earth_east",
2015 storage_classes["additionalStorageClasses"][0]["availabilityZone"],
2016 )
2017
2018 @mock.patch("magnum.common.clients.OpenStackClients.cinder")
2019 def test_get_storage_class_volume_type_not_available(self, mock_cinder):
2020 CONF.capi_helm.csi_cinder_default_volume_type = "type4"
2021 CONF.capi_helm.csi_cinder_availability_zone = "middle_earth_east"
2022 mock_vol_type_1 = mock.MagicMock()
2023 mock_vol_type_1.name = "type1"
2024 mock_vol_type_2 = mock.MagicMock()
2025 mock_vol_type_2.name = "type2"
2026 mock_vol_type_3 = mock.MagicMock()
2027 mock_vol_type_3.name = "type3"
2028 mock_volume_types = mock.Mock()
2029 mock_volume_types.list.return_value = [
2030 mock_vol_type_1,
2031 mock_vol_type_2,
2032 mock_vol_type_3,
2033 ]
2034 mock_cinder_client = mock.Mock()
2035 mock_cinder_client.volume_types = mock_volume_types
2036 mock_cinder.return_value = mock_cinder_client
2037 self.assertRaisesRegex(
2038 exception.MagnumException,
2039 r"not\sa\svalid\sCinder",
2040 self.driver._storageclass_definitions,
2041 self.context,
2042 self.cluster_obj,
2043 )
2044
2045 @mock.patch("magnum.common.clients.OpenStackClients.cinder")
2046 def test_get_storage_class_volume_type_not_defined(self, mock_cinder):
2047 CONF.capi_helm.csi_cinder_default_volume_type = None
2048 CONF.capi_helm.csi_cinder_availability_zone = "middle_earth_east"
2049 mock_vol_type_1 = mock.MagicMock()
2050 mock_vol_type_1.name = "__TYPE1__"
2051 mock_vol_type_2 = mock.MagicMock()
2052 mock_vol_type_2.name = "type2"
2053 mock_vol_type_3 = mock.MagicMock()
2054 mock_vol_type_3.name = "type3"
2055 mock_volume_types = mock.Mock()
2056 mock_volume_types.list.return_value = [
2057 mock_vol_type_1,
2058 mock_vol_type_2,
2059 mock_vol_type_3,
2060 ]
2061 mock_cinder_client = mock.Mock()
2062 mock_cinder_client.volume_types = mock_volume_types
2063 mock_cinder.return_value = mock_cinder_client
2064 storage_classes = self.driver._storageclass_definitions(
2065 self.context, self.cluster_obj
2066 )
2067 default_storage_class = storage_classes["defaultStorageClass"]
2068 volume_type = default_storage_class["name"]
2069 self.assertEqual("type1", volume_type)
2070
2071 @mock.patch.object(helm.Client, "uninstall_release")
2072 def test_delete_cluster(self, mock_uninstall):
2073 self.driver.delete_cluster(self.context, self.cluster_obj)
2074
2075 mock_uninstall.assert_called_once_with(
2076 "cluster-example-a-111111111111", namespace="magnum-fakeproject"
2077 )
2078
2079 def test_update_cluster(self):
2080 self.assertRaises(
2081 NotImplementedError,
2082 self.driver.update_cluster,
2083 self.context,
2084 self.cluster_obj,
2085 )
2086
2087 @mock.patch.object(driver.Driver, "_update_helm_release")
2088 def test_resize_cluster(self, mock_update):
2089 self.driver.resize_cluster(
2090 self.context,
2091 self.cluster_obj,
2092 None,
2093 None,
2094 None,
2095 )
2096 mock_update.assert_called_once_with(self.context, self.cluster_obj)
2097
2098 @mock.patch.object(driver.Driver, "_update_helm_release")
2099 def test_resize_cluster_ignore_nodes_to_remove(self, mock_update):
2100 self.driver.resize_cluster(
2101 self.context,
2102 self.cluster_obj,
2103 None,
2104 ["node1"],
2105 None,
2106 )
2107 mock_update.assert_called_once_with(self.context, self.cluster_obj)
2108
2109 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2110 @mock.patch.object(driver.Driver, "_update_helm_release")
2111 def test_upgrade_cluster(
2112 self,
2113 mock_update,
2114 mock_validate_allowed_flavor,
2115 ):
2116 node_group = mock.MagicMock()
2117 mock_template = mock.MagicMock()
2118 mock_template.uuid = "foo"
2119
2120 self.driver.upgrade_cluster(
2121 self.context,
2122 self.cluster_obj,
2123 mock_template,
2124 1,
2125 node_group,
2126 )
2127
2128 # TODO(johngarbutt) improve the testing
2129 mock_update.assert_called_once_with(self.context, self.cluster_obj)
2130 self.assertEqual("UPDATE_IN_PROGRESS", self.cluster_obj.status)
2131
2132 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2133 @mock.patch.object(driver.Driver, "_update_helm_release")
2134 def test_create_nodegroup(
2135 self,
2136 mock_update,
2137 mock_validate_allowed_flavor,
2138 ):
2139 node_group = mock.MagicMock()
2140
2141 self.driver.create_nodegroup(
2142 self.context, self.cluster_obj, node_group
2143 )
2144
2145 mock_update.assert_called_once_with(self.context, self.cluster_obj)
2146 node_group.save.assert_called_once_with()
2147 self.assertEqual("CREATE_IN_PROGRESS", node_group.status)
2148
2149 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2150 @mock.patch.object(driver.Driver, "_update_helm_release")
2151 def test_update_nodegroup(
2152 self,
2153 mock_update,
2154 mock_validate_allowed_flavor,
2155 ):
2156 node_group = mock.MagicMock()
2157
2158 self.driver.update_nodegroup(
2159 self.context,
2160 self.cluster_obj,
2161 node_group,
2162 )
2163
2164 mock_update.assert_called_once_with(self.context, self.cluster_obj)
2165 node_group.save.assert_called_once_with()
2166 self.assertEqual("UPDATE_IN_PROGRESS", node_group.status)
2167
2168 @mock.patch.object(driver.Driver, "_update_helm_release")
2169 def test_delete_nodegroup(self, mock_update):
2170 self.driver.delete_nodegroup(
2171 self.context,
2172 self.cluster_obj,
2173 self.cluster_obj.nodegroups[1],
2174 )
2175
2176 mock_update.assert_called_once_with(
2177 self.context,
2178 self.cluster_obj,
2179 mock.ANY,
2180 )
2181 # because nodegroups equality is broken
2182 self.assertEqual(
2183 self.cluster_obj.nodegroups[0].as_dict(),
2184 mock_update.call_args.args[2][0].as_dict(),
2185 )
2186
2187 def test_create_federation(self):
2188 self.assertRaises(
2189 NotImplementedError,
2190 self.driver.create_federation,
2191 self.context,
2192 None,
2193 )
2194
2195 def test_update_federation(self):
2196 self.assertRaises(
2197 NotImplementedError,
2198 self.driver.update_federation,
2199 self.context,
2200 None,
2201 )
2202
2203 def test_delete_federation(self):
2204 self.assertRaises(
2205 NotImplementedError,
2206 self.driver.delete_federation,
2207 self.context,
2208 None,
2209 )
2210
2211 @mock.patch("novaclient.v2.flavors.FlavorManager", autospec=True)
2212 @mock.patch("novaclient.v2.client.Client", autospec=2)
2213 @mock.patch("novaclient.client.Client")
2214 @mock.patch("magnum.common.clients.OpenStackClients.nova")
2215 def test_validate_allowed_flavors_ram_error(
2216 self,
2217 mock_osc_nova,
2218 mock_nova_client,
2219 mock_versioned_nova_client,
2220 mock_flavor_manager,
2221 ):
2222 mock_flavor1 = mock.MagicMock(id=1, vcpus=1)
2223 mock_flavor1.name = "flavor_tiny"
2224 mock_flavor2 = mock.MagicMock(id=2, vcpus=1)
2225 mock_flavor2.name = "flavor_small"
2226 mock_flavor3 = mock.MagicMock(id=3, vcpus=4)
2227 mock_flavor3.name = "flavor_medium"
2228 # Assumes that the list returned by novaclient.flavors.(min_ram=xxxx)
2229 # is already filtered so no need to check that.
2230 filtered_flavors = [
2231 mock_flavor1,
2232 mock_flavor2,
2233 mock_flavor3,
2234 ]
2235 mock_flavor_manager.list.return_value = filtered_flavors
2236 mock_versioned_nova_client.flavors = mock_flavor_manager
2237 mock_osc_nova.return_value = mock_versioned_nova_client
2238 self.assertRaises(
2239 exception.MagnumException,
2240 self.driver._validate_allowed_flavor,
2241 self.context,
2242 "DS9",
2243 )
2244
2245 @mock.patch("novaclient.v2.flavors.FlavorManager", autospec=True)
2246 @mock.patch("novaclient.v2.client.Client", autospec=2)
2247 @mock.patch("novaclient.client.Client")
2248 @mock.patch("magnum.common.clients.OpenStackClients.nova")
2249 def test_validate_allowed_flavors_vcpu_error(
2250 self,
2251 mock_osc_nova,
2252 mock_nova_client,
2253 mock_versioned_nova_client,
2254 mock_flavor_manager,
2255 ):
2256 mock_flavor1 = mock.MagicMock(id=1, vcpus=1)
2257 mock_flavor1.name = "flavor_tiny"
2258 mock_flavor2 = mock.MagicMock(id=2, vcpus=1)
2259 mock_flavor2.name = "flavor_small"
2260 mock_flavor3 = mock.MagicMock(id=3, vcpus=4)
2261 mock_flavor3.name = "flavor_medium"
2262 # Assumes that the list returned by novaclient.flavors.(min_ram=xxxx)
2263 # is already filtered so no need to check that.
2264 filtered_flavors = [
2265 mock_flavor1,
2266 mock_flavor2,
2267 mock_flavor3,
2268 ]
2269 mock_flavor_manager.list.return_value = filtered_flavors
2270 mock_versioned_nova_client.flavors = mock_flavor_manager
2271 mock_osc_nova.return_value = mock_versioned_nova_client
2272 self.assertRaises(
2273 exception.MagnumException,
2274 self.driver._validate_allowed_flavor,
2275 self.context,
2276 2,
2277 )
2278 self.assertRaises(
2279 exception.MagnumException,
2280 self.driver._validate_allowed_flavor,
2281 self.context,
2282 "flavor_small",
2283 )
2284
2285 @mock.patch("novaclient.v2.flavors.FlavorManager", autospec=True)
2286 @mock.patch("novaclient.v2.client.Client", autospec=2)
2287 @mock.patch("novaclient.client.Client")
2288 @mock.patch("magnum.common.clients.OpenStackClients.nova")
2289 def test_validate_allowed_flavors_ram_ok(
2290 self,
2291 mock_osc_nova,
2292 mock_nova_client,
2293 mock_versioned_nova_client,
2294 mock_flavor_manager,
2295 ):
2296 mock_flavor1 = mock.MagicMock(id=1, vcpus=1)
2297 mock_flavor1.name = "flavor_tiny"
2298 mock_flavor2 = mock.MagicMock(id=2, vcpus=1)
2299 mock_flavor2.name = "flavor_small"
2300 mock_flavor3 = mock.MagicMock(id=3, vcpus=4)
2301 mock_flavor3.name = "flavor_medium"
2302 filtered_flavors = [
2303 mock_flavor1,
2304 mock_flavor2,
2305 mock_flavor3,
2306 ]
2307 mock_flavor_manager.list.return_value = filtered_flavors
2308 mock_versioned_nova_client.flavors = mock_flavor_manager
2309 mock_osc_nova.return_value = mock_versioned_nova_client
2310 try:
2311 self.driver._validate_allowed_flavor(self.context, 3)
2312 except Exception as e:
2313 self.fail("Raised exception %s" % e)
2314 try:
2315 self.driver._validate_allowed_flavor(self.context, "flavor_medium")
2316 except Exception as e:
2317 self.fail("Raised exception %s" % e)
2318
2319 @mock.patch("novaclient.v2.flavors.FlavorManager", autospec=True)
2320 @mock.patch("novaclient.v2.client.Client", autospec=2)
2321 @mock.patch("novaclient.client.Client")
2322 @mock.patch("magnum.common.clients.OpenStackClients.nova")
2323 def test_validate_upgrade_cluster_node_group(
2324 self,
2325 mock_osc_nova,
2326 mock_nova_client,
2327 mock_versioned_nova_client,
2328 mock_flavor_manager,
2329 ):
2330 mock_flavor1 = mock.MagicMock(id=1, vcpus=1)
2331 mock_flavor1.name = "flavor_tiny"
2332 mock_flavor2 = mock.MagicMock(id=2, vcpus=1)
2333 mock_flavor2.name = "flavor_small"
2334 mock_flavor3 = mock.MagicMock(id=3, vcpus=4)
2335 mock_flavor3.name = "flavor_medium"
2336 filtered_flavors = [
2337 mock_flavor1,
2338 mock_flavor2,
2339 mock_flavor3,
2340 ]
2341 mock_flavor_manager.list.return_value = filtered_flavors
2342 mock_versioned_nova_client.flavors = mock_flavor_manager
2343 mock_osc_nova.return_value = mock_versioned_nova_client
2344 node_group = mock.MagicMock()
2345 node_group.flavor_id
2346 mock_template = mock.MagicMock()
2347 mock_template.uuid = "foo"
2348
2349 for ng in self.cluster_obj.nodegroups:
2350 if ng.role != "master":
2351 ng.flavor_id = "flavor_small"
2352 ng.save()
2353 self.assertRaises(
2354 exception.MagnumException,
2355 self.driver.upgrade_cluster,
2356 self.context,
2357 self.cluster_obj,
2358 mock_template,
2359 1,
2360 node_group,
2361 )
2362
2363 @mock.patch.object(
2364 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
2365 )
2366 @mock.patch.object(
2367 driver.Driver,
2368 "_storageclass_definitions",
2369 return_value=mock.ANY,
2370 )
2371 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2372 @mock.patch.object(neutron, "get_network", autospec=True)
2373 @mock.patch.object(
2374 driver.Driver, "_ensure_certificate_secrets", autospec=True
2375 )
2376 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2377 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2378 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2379 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2380 def test_create_cluster_api_lb_allowed_cidrs(
2381 self,
2382 mock_install,
2383 mock_image,
2384 mock_load,
2385 mock_appcred,
2386 mock_certs,
2387 mock_get_net,
2388 mock_validate_allowed_flavor,
2389 mock_storageclasses,
2390 mock_get_keystone_auth_enabled,
2391 ):
2392 cidrs = "192.168.0.0/16,10.0.0.0/8,123.123.123.123/32"
2393 self.cluster_obj.labels = dict(api_master_lb_allowed_cidrs=cidrs)
2394 mock_image.return_value = (
2395 "imageid1",
2396 "1.27.4",
2397 "ubuntu",
2398 )
2399 mock_client = mock.MagicMock(spec=kubernetes.Client)
2400 mock_load.return_value = mock_client
2401
2402 self.driver.create_cluster(self.context, self.cluster_obj, 10)
2403 cidr_list = cidrs.split(",")
2404 helm_install_values = mock_install.call_args[0][3]
2405 self.assertEqual(
2406 helm_install_values["apiServer"]["allowedCidrs"], cidr_list
2407 )
2408
2409 @mock.patch.object(driver.Driver, "_get_k8s_keystone_auth_enabled")
2410 @mock.patch.object(
2411 driver.Driver,
2412 "_storageclass_definitions",
2413 return_value=mock.ANY,
2414 )
2415 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2416 @mock.patch.object(neutron, "get_network", autospec=True)
2417 @mock.patch.object(
2418 driver.Driver, "_ensure_certificate_secrets", autospec=True
2419 )
2420 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2421 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2422 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2423 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2424 def test_create_cluster_keystone_webhook_enabled(
2425 self,
2426 mock_install,
2427 mock_image,
2428 mock_load,
2429 mock_appcred,
2430 mock_certs,
2431 mock_get_net,
2432 mock_validate_allowed_flavor,
2433 mock_storageclasses,
2434 mock_get_keystone_auth_enabled,
2435 ):
2436 mock_image.return_value = (
2437 "imageid1",
2438 "1.27.4",
2439 "ubuntu",
2440 )
2441 mock_client = mock.MagicMock(spec=kubernetes.Client)
2442 mock_load.return_value = mock_client
2443 mock_get_keystone_auth_enabled.return_value = True # Enable webhook
2444 self.cluster_obj.labels = {}
2445
2446 self.driver.create_cluster(
2447 self.context, self.cluster_obj, "timeout-not-used"
2448 )
2449
2450 helm_install_values = mock_install.call_args[0][3]
2451 self.assertEqual(
2452 helm_install_values["authWebhook"], "k8s-keystone-auth"
2453 )
2454 self.assertTrue(
2455 helm_install_values["addons"]
2456 .get(
2457 "openstack", {}
2458 ) # Default to {} so that next .get isn't called on None type
2459 .get("k8sKeystoneAuth", {})
2460 .get("enabled")
2461 )
2462
2463 @mock.patch.object(driver.Driver, "_get_k8s_keystone_auth_enabled")
2464 @mock.patch.object(
2465 driver.Driver,
2466 "_storageclass_definitions",
2467 return_value=mock.ANY,
2468 )
2469 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2470 @mock.patch.object(neutron, "get_network", autospec=True)
2471 @mock.patch.object(
2472 driver.Driver, "_ensure_certificate_secrets", autospec=True
2473 )
2474 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2475 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2476 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2477 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2478 def test_create_cluster_keystone_webhook_disabled(
2479 self,
2480 mock_install,
2481 mock_image,
2482 mock_load,
2483 mock_appcred,
2484 mock_certs,
2485 mock_get_net,
2486 mock_validate_allowed_flavor,
2487 mock_storageclasses,
2488 mock_get_keystone_auth_enabled,
2489 ):
2490 mock_image.return_value = (
2491 "imageid1",
2492 "1.27.4",
2493 "ubuntu",
2494 )
2495 mock_client = mock.MagicMock(spec=kubernetes.Client)
2496 mock_load.return_value = mock_client
2497 mock_get_keystone_auth_enabled.return_value = False # Disable webhook
2498 self.cluster_obj.labels = {}
2499
2500 self.driver.create_cluster(
2501 self.context, self.cluster_obj, "timeout-not-used"
2502 )
2503
2504 helm_install_values = mock_install.call_args[0][3]
2505 self.assertNotEqual(
2506 helm_install_values.get("authWebhook"), "k8s-keystone-auth"
2507 )
2508 self.assertFalse(
2509 helm_install_values["addons"]
2510 .get("openstack", {})
2511 .get("k8sKeystoneAuth", {})
2512 .get("enabled")
2513 )
2514
2515 @mock.patch.object(
2516 driver.Driver,
2517 "_storageclass_definitions",
2518 return_value=mock.ANY,
2519 )
2520 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2521 @mock.patch.object(neutron, "get_network", autospec=True)
2522 @mock.patch.object(
2523 driver.Driver, "_ensure_certificate_secrets", autospec=True
2524 )
2525 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2526 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2527 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2528 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2529 def test_create_cluster_octavia_provider_amphora(
2530 self,
2531 mock_install,
2532 mock_image,
2533 mock_load,
2534 mock_appcred,
2535 mock_certs,
2536 mock_get_net,
2537 mock_validate_allowed_flavor,
2538 mock_storageclasses,
2539 ):
2540 mock_image.return_value = (
2541 "imageid1",
2542 "1.27.4",
2543 "ubuntu",
2544 )
2545 mock_client = mock.MagicMock(spec=kubernetes.Client)
2546 mock_load.return_value = mock_client
2547
2548 # Simulate setting provider label
2549 self.cluster_obj.labels = {
2550 "octavia_provider": "amphora",
2551 "octavia_lb_algorithm": "SOURCE_IP_PORT",
2552 }
2553
2554 self.driver.create_cluster(
2555 self.context, self.cluster_obj, "timeout-not-used"
2556 )
2557
2558 helm_install_values = mock_install.call_args[0][3]
2559 self.assertEqual(
2560 helm_install_values.get("apiServer", {}).get(
2561 "loadBalancerProvider"
2562 ),
2563 "amphora",
2564 )
2565 self.assertEqual(
2566 helm_install_values["addons"]
2567 .get("openstack", {})
2568 .get("cloudConfig", {})
2569 .get("LoadBalancer", {})
2570 .get("lb-provider"),
2571 "amphora",
2572 )
2573 self.assertEqual(
2574 helm_install_values["addons"]
2575 .get("openstack", {})
2576 .get("cloudConfig", {})
2577 .get("LoadBalancer", {})
2578 .get("lb-method"),
2579 "SOURCE_IP_PORT",
2580 )
2581
2582 @mock.patch.object(
2583 driver.Driver,
2584 "_storageclass_definitions",
2585 return_value=mock.ANY,
2586 )
2587 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2588 @mock.patch.object(neutron, "get_network", autospec=True)
2589 @mock.patch.object(
2590 driver.Driver, "_ensure_certificate_secrets", autospec=True
2591 )
2592 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2593 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2594 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2595 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2596 def test_create_cluster_octavia_provider_ovn(
2597 self,
2598 mock_install,
2599 mock_image,
2600 mock_load,
2601 mock_appcred,
2602 mock_certs,
2603 mock_get_net,
2604 mock_validate_allowed_flavor,
2605 mock_storageclasses,
2606 ):
2607 mock_image.return_value = (
2608 "imageid1",
2609 "1.27.4",
2610 "ubuntu",
2611 )
2612 mock_client = mock.MagicMock(spec=kubernetes.Client)
2613 mock_load.return_value = mock_client
2614
2615 # Simulate setting provider label
2616 self.cluster_obj.labels = {
2617 "octavia_provider": "ovn",
2618 }
2619
2620 self.driver.create_cluster(
2621 self.context, self.cluster_obj, "timeout-not-used"
2622 )
2623
2624 helm_install_values = mock_install.call_args[0][3]
2625 self.assertEqual(
2626 helm_install_values.get("apiServer", {}).get(
2627 "loadBalancerProvider"
2628 ),
2629 "ovn",
2630 )
2631 self.assertEqual(
2632 helm_install_values["addons"]
2633 .get("openstack", {})
2634 .get("cloudConfig", {})
2635 .get("LoadBalancer", {})
2636 .get("lb-provider"),
2637 "ovn",
2638 )
2639 # Check algorithm default if no label provided
2640 self.assertEqual(
2641 helm_install_values["addons"]
2642 .get("openstack", {})
2643 .get("cloudConfig", {})
2644 .get("LoadBalancer", {})
2645 .get("lb-method"),
2646 "SOURCE_IP_PORT",
2647 )
2648
2649 @mock.patch.object(
2650 driver.Driver,
2651 "_storageclass_definitions",
2652 return_value=mock.ANY,
2653 )
2654 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2655 @mock.patch.object(neutron, "get_network", autospec=True)
2656 @mock.patch.object(
2657 driver.Driver, "_ensure_certificate_secrets", autospec=True
2658 )
2659 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2660 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2661 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2662 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2663 def test_create_cluster_octavia_disable_monitor(
2664 self,
2665 mock_install,
2666 mock_image,
2667 mock_load,
2668 mock_appcred,
2669 mock_certs,
2670 mock_get_net,
2671 mock_validate_allowed_flavor,
2672 mock_storageclasses,
2673 ):
2674 mock_image.return_value = (
2675 "imageid1",
2676 "1.27.4",
2677 "ubuntu",
2678 )
2679 mock_client = mock.MagicMock(spec=kubernetes.Client)
2680 mock_load.return_value = mock_client
2681
2682 # Simulate setting provider label
2683 self.cluster_obj.labels = {
2684 "octavia_lb_healthcheck": False,
2685 }
2686
2687 self.driver.create_cluster(
2688 self.context, self.cluster_obj, "timeout-not-used"
2689 )
2690
2691 helm_install_values = mock_install.call_args[0][3]
2692 self.assertFalse(
2693 helm_install_values["addons"]
2694 .get("openstack", {})
2695 .get("cloudConfig", {})
2696 .get("LoadBalancer", {})
2697 .get("create-monitor")
2698 )
2699
2700 def test_validate_auto_scale_max_lt_min(self):
2701 self.cluster_obj.labels = dict(
2702 auto_scaling_enabled="true", min_node_count=3, max_node_count=0
2703 )
2704 self.assertRaises(
2705 exception.MagnumException,
2706 self.driver._get_autoscale_values,
2707 self.cluster_obj,
2708 self.cluster_obj.nodegroups[0],
2709 )
2710
2711 @mock.patch.object(
2712 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
2713 )
2714 @mock.patch.object(
2715 driver.Driver,
2716 "_storageclass_definitions",
2717 return_value=mock.ANY,
2718 )
2719 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2720 @mock.patch.object(neutron, "get_network", autospec=True)
2721 @mock.patch.object(
2722 driver.Driver, "_ensure_certificate_secrets", autospec=True
2723 )
2724 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2725 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2726 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2727 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2728 def test_create_cluster_auto_scale_enabled(
2729 self,
2730 mock_install,
2731 mock_image,
2732 mock_load,
2733 mock_appcred,
2734 mock_certs,
2735 mock_get_net,
2736 mock_validate_allowed_flavor,
2737 mock_storageclasses,
2738 mock_get_keystone_auth_enabled,
2739 ):
2740 auto_scale_labels = dict(
2741 auto_scaling_enabled="true", min_node_count=2, max_node_count=6
2742 )
2743 self.cluster_obj.labels = auto_scale_labels
2744
2745 mock_image.return_value = (
2746 "imageid1",
2747 "1.27.4",
2748 "ubuntu",
2749 )
2750 mock_client = mock.MagicMock(spec=kubernetes.Client)
2751 mock_load.return_value = mock_client
2752
2753 self.driver.create_cluster(self.context, self.cluster_obj, 10)
2754 helm_install_values = mock_install.call_args[0][3]
2755 self.assertEqual(
2756 helm_install_values["nodeGroups"][0]["autoscale"],
2757 auto_scale_labels["auto_scaling_enabled"],
2758 )
2759 self.assertEqual(
2760 helm_install_values["nodeGroups"][0]["machineCountMin"],
2761 auto_scale_labels["min_node_count"],
2762 )
2763 self.assertEqual(
2764 helm_install_values["nodeGroups"][0]["machineCountMax"],
2765 auto_scale_labels["max_node_count"],
2766 )
2767
2768 @mock.patch.object(
2769 driver.Driver, "_get_k8s_keystone_auth_enabled", return_value=False
2770 )
2771 @mock.patch.object(
2772 driver.Driver,
2773 "_storageclass_definitions",
2774 return_value=mock.ANY,
2775 )
2776 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2777 @mock.patch.object(neutron, "get_network", autospec=True)
2778 @mock.patch.object(
2779 driver.Driver, "_ensure_certificate_secrets", autospec=True
2780 )
2781 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2782 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2783 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2784 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2785 def test_create_cluster_auto_scale_disabled(
2786 self,
2787 mock_install,
2788 mock_image,
2789 mock_load,
2790 mock_appcred,
2791 mock_certs,
2792 mock_get_net,
2793 mock_validate_allowed_flavor,
2794 mock_storageclasses,
2795 mock_get_keystone_auth_enabled,
2796 ):
2797 auto_scale_labels = dict(
2798 auto_scaling_enabled="false", min_node_count=2, max_node_count=6
2799 )
2800 self.cluster_obj.labels = auto_scale_labels
2801
2802 mock_image.return_value = (
2803 "imageid1",
2804 "1.27.4",
2805 "ubuntu",
2806 )
2807 mock_client = mock.MagicMock(spec=kubernetes.Client)
2808 mock_load.return_value = mock_client
2809
2810 self.driver.create_cluster(self.context, self.cluster_obj, 10)
2811 helm_install_values = mock_install.call_args[0][3]
2812 self.assertNotIn(
2813 "autoscale",
2814 helm_install_values["nodeGroups"][0],
2815 )
2816 self.assertNotIn(
2817 "machineCountMin",
2818 helm_install_values["nodeGroups"][0],
2819 )
2820 self.assertNotIn(
2821 "machineCountMax",
2822 helm_install_values["nodeGroups"][0],
2823 )
2824
2825 @mock.patch.object(
2826 driver.Driver,
2827 "_storageclass_definitions",
2828 return_value=mock.ANY,
2829 )
2830 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2831 @mock.patch.object(neutron, "get_network", autospec=True)
2832 @mock.patch.object(
2833 driver.Driver, "_ensure_certificate_secrets", autospec=True
2834 )
2835 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2836 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2837 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2838 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2839 def test_nodegroup_node_count_validation(
2840 self,
2841 mock_install,
2842 mock_image,
2843 mock_load,
2844 mock_appcred,
2845 mock_certs,
2846 mock_get_net,
2847 mock_validate_allowed_flavor,
2848 mock_storageclasses,
2849 ):
2850 auto_scale_labels = dict(
2851 auto_scaling_enabled="true", min_node_count=2, max_node_count=6
2852 )
2853 self.cluster_obj.labels = auto_scale_labels
2854
2855 mock_image.return_value = (
2856 "imageid1",
2857 "1.27.4",
2858 "ubuntu",
2859 )
2860
2861 # Create cluster with extra node groups
2862 ng = obj_utils.create_test_nodegroup(
2863 self.context, min_node_count=3, max_node_count=2
2864 )
2865 self.cluster_obj.nodegroups.append(ng)
2866 self.assertRaises(
2867 exception.NodeGroupInvalidInput,
2868 self.driver.create_cluster,
2869 self.context,
2870 self.cluster_obj,
2871 "not-used",
2872 )
2873
2874 @mock.patch.object(
2875 driver.Driver,
2876 "_storageclass_definitions",
2877 return_value=mock.ANY,
2878 )
2879 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2880 @mock.patch.object(neutron, "get_network", autospec=True)
2881 @mock.patch.object(
2882 driver.Driver, "_ensure_certificate_secrets", autospec=True
2883 )
2884 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2885 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2886 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2887 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2888 def test_create_extra_nodegroup_auto_scale_values(
2889 self,
2890 mock_install,
2891 mock_image,
2892 mock_load,
2893 mock_appcred,
2894 mock_certs,
2895 mock_get_net,
2896 mock_validate_allowed_flavor,
2897 mock_storageclasses,
2898 ):
2899 auto_scale_labels = dict(
2900 auto_scaling_enabled="true", min_node_count=2, max_node_count=6
2901 )
2902 self.cluster_obj.labels = auto_scale_labels
2903
2904 mock_image.return_value = (
2905 "imageid1",
2906 "1.27.4",
2907 "ubuntu",
2908 )
2909
2910 # Create cluster with extra node groups
2911 non_auto_scale_nodegroup = obj_utils.create_test_nodegroup(
2912 self.context,
2913 uuid=uuid4(),
2914 id=123,
2915 name="non-autoscale-group",
2916 node_count=1,
2917 )
2918 self.cluster_obj.nodegroups.append(non_auto_scale_nodegroup)
2919 auto_scale_nodegroup = obj_utils.create_test_nodegroup(
2920 self.context,
2921 uuid=uuid4(),
2922 id=456,
2923 name="autoscale-group",
2924 node_count=1,
2925 min_node_count=1,
2926 max_node_count=3,
2927 )
2928 self.cluster_obj.nodegroups.append(auto_scale_nodegroup)
2929 self.driver.create_cluster(self.context, self.cluster_obj, 10)
2930 for ng in self.cluster_obj.nodegroups:
2931 print(ng)
2932
2933 # Unpack some values for asserting against
2934 helm_install_values = mock_install.call_args[0][3]
2935 helm_node_groups = helm_install_values["nodeGroups"]
2936 helm_values_default_nodegroup = [
2937 ng
2938 for ng in helm_node_groups
2939 if ng["name"] == self.cluster_obj.default_ng_worker.name
2940 ]
2941 helm_values_autoscale_nodegroup = [
2942 ng
2943 for ng in helm_node_groups
2944 if ng["name"] == auto_scale_nodegroup.name
2945 ]
2946 helm_values_non_autoscale_nodegroup = [
2947 ng
2948 for ng in helm_node_groups
2949 if ng["name"] == non_auto_scale_nodegroup.name
2950 ]
2951
2952 # Check that node groups were passed into Helm values correctly
2953 self.assertEqual(len(helm_values_default_nodegroup), 1)
2954 self.assertEqual(len(helm_values_autoscale_nodegroup), 1)
2955 self.assertEqual(len(helm_values_non_autoscale_nodegroup), 1)
2956
2957 # Check default node group values
2958 ng = helm_values_default_nodegroup[0]
2959 self.assertEqual(ng["autoscale"], "true")
2960 self.assertEqual(
2961 ng["machineCountMin"], auto_scale_labels["min_node_count"]
2962 )
2963 self.assertEqual(
2964 ng["machineCountMax"], auto_scale_labels["max_node_count"]
2965 )
2966
2967 # Check extra autoscaling node group values
2968 # NOTE: CAPO doesn't support scale to zero so
2969 # min node count should be max(1, ng.min_node_count)
2970 ng = helm_values_autoscale_nodegroup[0]
2971 self.assertEqual(ng["autoscale"], "true")
2972 self.assertEqual(
2973 ng["machineCountMin"], max(1, auto_scale_nodegroup.min_node_count)
2974 )
2975 self.assertEqual(
2976 ng["machineCountMax"], auto_scale_nodegroup.max_node_count
2977 )
2978
2979 # Check extra non-autoscaling node group values
2980 ng = helm_values_non_autoscale_nodegroup[0]
2981 self.assertEqual(ng.get("autoscale"), None)
2982 self.assertEqual(ng.get("machineCountMin"), None)
2983 self.assertEqual(ng.get("machineCountMax"), None)
2984
2985 @mock.patch.object(
2986 driver.Driver,
2987 "_storageclass_definitions",
2988 return_value=mock.ANY,
2989 )
2990 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
2991 @mock.patch.object(neutron, "get_network", autospec=True)
2992 @mock.patch.object(
2993 driver.Driver, "_ensure_certificate_secrets", autospec=True
2994 )
2995 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
2996 @mock.patch.object(kubernetes.Client, "load", autospec=True)
2997 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
2998 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
2999 def test_create_cluster_boot_volume_size_label_valid(
3000 self,
3001 mock_install,
3002 mock_image,
3003 mock_load,
3004 mock_appcred,
3005 mock_certs,
3006 mock_get_net,
3007 mock_validate_allowed_flavor,
3008 mock_storageclasses,
3009 ):
3010 disk_size_configuration_value = 15
3011 disk_size_label_value = 32
3012
3013 CONF.cinder.default_boot_volume_size = disk_size_configuration_value
3014 self.cluster_obj.labels = {
3015 "boot_volume_size": str(disk_size_label_value)
3016 }
3017
3018 mock_image.return_value = (
3019 "imageid1",
3020 "1.27.4",
3021 "ubuntu",
3022 )
3023 mock_client = mock.MagicMock(spec=kubernetes.Client)
3024 mock_load.return_value = mock_client
3025
3026 self.driver.create_cluster(self.context, self.cluster_obj, 10)
3027 helm_install_values = mock_install.call_args[0][3]
3028 self.assertEqual(
3029 helm_install_values["controlPlane"]["machineRootVolume"][
3030 "diskSize"
3031 ],
3032 disk_size_label_value,
3033 )
3034 self.assertEqual(
3035 helm_install_values["nodeGroupDefaults"]["machineRootVolume"][
3036 "diskSize"
3037 ],
3038 disk_size_label_value,
3039 )
3040
3041 @mock.patch.object(
3042 driver.Driver,
3043 "_storageclass_definitions",
3044 return_value=mock.ANY,
3045 )
3046 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
3047 @mock.patch.object(neutron, "get_network", autospec=True)
3048 @mock.patch.object(
3049 driver.Driver, "_ensure_certificate_secrets", autospec=True
3050 )
3051 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
3052 @mock.patch.object(kubernetes.Client, "load", autospec=True)
3053 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
3054 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
3055 def test_create_cluster_boot_volume_size_label_default(
3056 self,
3057 mock_install,
3058 mock_image,
3059 mock_load,
3060 mock_appcred,
3061 mock_certs,
3062 mock_get_net,
3063 mock_validate_allowed_flavor,
3064 mock_storageclasses,
3065 ):
3066 disk_size_configuration_value = 15
3067
3068 CONF.cinder.default_boot_volume_size = disk_size_configuration_value
3069 self.cluster_obj.labels = {}
3070
3071 mock_image.return_value = (
3072 "imageid1",
3073 "1.27.4",
3074 "ubuntu",
3075 )
3076 mock_client = mock.MagicMock(spec=kubernetes.Client)
3077 mock_load.return_value = mock_client
3078
3079 self.driver.create_cluster(self.context, self.cluster_obj, 10)
3080 helm_install_values = mock_install.call_args[0][3]
3081 self.assertEqual(
3082 helm_install_values["controlPlane"]["machineRootVolume"][
3083 "diskSize"
3084 ],
3085 disk_size_configuration_value,
3086 )
3087 self.assertEqual(
3088 helm_install_values["nodeGroupDefaults"]["machineRootVolume"][
3089 "diskSize"
3090 ],
3091 disk_size_configuration_value,
3092 )
3093
3094 @mock.patch.object(
3095 driver.Driver,
3096 "_storageclass_definitions",
3097 return_value=mock.ANY,
3098 )
3099 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
3100 @mock.patch.object(neutron, "get_network", autospec=True)
3101 @mock.patch.object(
3102 driver.Driver, "_ensure_certificate_secrets", autospec=True
3103 )
3104 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
3105 @mock.patch.object(kubernetes.Client, "load", autospec=True)
3106 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
3107 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
3108 def test_create_cluster_boot_volume_size_label_invalid(
3109 self,
3110 mock_install,
3111 mock_image,
3112 mock_load,
3113 mock_appcred,
3114 mock_certs,
3115 mock_get_net,
3116 mock_validate_allowed_flavor,
3117 mock_storageclasses,
3118 ):
3119 disk_size_configuration_value = 15
3120
3121 CONF.cinder.default_boot_volume_size = disk_size_configuration_value
3122 self.cluster_obj.labels = {"boot_volume_size": "NotANumber"}
3123
3124 mock_image.return_value = (
3125 "imageid1",
3126 "1.27.4",
3127 "ubuntu",
3128 )
3129 mock_client = mock.MagicMock(spec=kubernetes.Client)
3130 mock_load.return_value = mock_client
3131
3132 self.driver.create_cluster(self.context, self.cluster_obj, 10)
3133 helm_install_values = mock_install.call_args[0][3]
3134 self.assertEqual(
3135 helm_install_values["controlPlane"]["machineRootVolume"][
3136 "diskSize"
3137 ],
3138 disk_size_configuration_value,
3139 )
3140 self.assertEqual(
3141 helm_install_values["nodeGroupDefaults"]["machineRootVolume"][
3142 "diskSize"
3143 ],
3144 disk_size_configuration_value,
3145 )
3146
3147 @mock.patch.object(
3148 driver.Driver,
3149 "_storageclass_definitions",
3150 return_value=mock.ANY,
3151 )
3152 @mock.patch.object(driver.Driver, "_validate_allowed_flavor")
3153 @mock.patch.object(neutron, "get_network", autospec=True)
3154 @mock.patch.object(
3155 driver.Driver, "_ensure_certificate_secrets", autospec=True
3156 )
3157 @mock.patch.object(driver.Driver, "_create_appcred_secret", autospec=True)
3158 @mock.patch.object(kubernetes.Client, "load", autospec=True)
3159 @mock.patch.object(driver.Driver, "_get_image_details", autospec=True)
3160 @mock.patch.object(helm.Client, "install_or_upgrade", autospec=True)
3161 def test_nodegroup_node_count_min_max_equal(
3162 self,
3163 mock_install,
3164 mock_image,
3165 mock_load,
3166 mock_appcred,
3167 mock_certs,
3168 mock_get_net,
3169 mock_validate_allowed_flavor,
3170 mock_storageclasses,
3171 ):
3172 # When autoscaling is enabled but no min/max node counts are
3173 # provided for the default node group, we want autoscaling to
3174 # be disabled on the default node group.
3175 self.cluster_obj.labels = {"auto_scaling_enabled": "true"}
3176 mock_image.return_value = (
3177 "imageid1",
3178 "1.27.4",
3179 "ubuntu",
3180 )
3181 self.driver.create_cluster(self.context, self.cluster_obj, 10)
3182 helm_install_values = mock_install.call_args[0][3]
3183 helm_values_default_ng = next(
3184 ng
3185 for ng in helm_install_values["nodeGroups"]
3186 if ng["name"] == self.cluster_obj.default_ng_worker.name
3187 )
3188 self.assertEqual(helm_values_default_ng.get("autoscale"), None)
3189 self.assertEqual(helm_values_default_ng.get("machineCountMin"), None)
3190 self.assertEqual(helm_values_default_ng.get("machineCountMax"), None)
3191 self.assertEqual(helm_values_default_ng.get("machineCount"), 3)