1 #######################################################################################
2 # Copyright ETSI Contributors and Others.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16 #######################################################################################
20 from unittest
.mock
import MagicMock
, patch
22 from osm_common
.dbmemory
import DbMemory
23 from osm_ng_ro
.ns_thread
import (
26 VimInteractionAffinityGroup
,
27 VimInteractionMigration
,
31 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
34 class TestConfigValidate(unittest
.TestCase
):
40 "refresh_image": 3600,
46 def test__get_configuration(self
):
47 with self
.subTest(i
=1, t
="Get config attributes with config input"):
48 configuration
= ConfigValidate(self
.config_dict
)
49 self
.assertEqual(configuration
.active
, 65)
50 self
.assertEqual(configuration
.build
, 20)
51 self
.assertEqual(configuration
.image
, 3600)
52 self
.assertEqual(configuration
.error
, 300)
53 self
.assertEqual(configuration
.queue_size
, 50)
55 with self
.subTest(i
=2, t
="Unallowed refresh active input"):
56 # > 60 (except -1) is not allowed to set, so it should return default value 60
57 self
.config_dict
["period"]["refresh_active"] = 20
58 configuration
= ConfigValidate(self
.config_dict
)
59 self
.assertEqual(configuration
.active
, 60)
61 with self
.subTest(i
=3, t
="Config to disable VM status periodic checks"):
62 # -1 is allowed to set to disable VM status updates
63 self
.config_dict
["period"]["refresh_active"] = -1
64 configuration
= ConfigValidate(self
.config_dict
)
65 self
.assertEqual(configuration
.active
, -1)
68 class TestNsWorker(unittest
.TestCase
):
70 self
.task_depends
= None
72 self
.worker_index
= "worker-3"
77 "refresh_image": 3600,
81 "process_id": "343435353",
82 "global": {"task_locked_time": 16373242100.994312},
89 "target_id": "vim_openstack_1",
92 "created_items": None,
93 "vim_id": "test-vim-id",
94 "vim_name": "test-vim",
100 "modified_at": 1637324200.994312,
101 "created_at": 1637324200.994312,
102 "to_check_at": 16373242400.994312,
106 "action_id": "123456",
108 "task_id": "123456:1",
112 "target_record": "test_target_record",
113 "target_record_id": "test_target_record_id",
118 def get_disabled_tasks(self
, db
, status
):
119 db_disabled_tasks
= db
.get_list(
122 "tasks.status": status
,
126 return db_disabled_tasks
128 def test__update_vm_refresh(self
):
131 t
="1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1",
133 # Disabled task with status build will not enabled again
135 self
.ro_task
["tasks"][0]["status"] = "BUILD"
136 self
.ro_task
["to_check_at"] = -1
137 db
.create("ro_tasks", self
.ro_task
)
138 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "BUILD"))
139 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
140 with patch
.object(instance
, "logger", logging
):
141 instance
.update_vm_refresh()
143 len(self
.get_disabled_tasks(db
, "BUILD")), disabled_tasks_count
148 t
="1 disabled task with status DONE in DB, refresh_active parameter is equal to -1",
150 # As refresh_active parameter is equal to -1, task will not be enabled to process again
152 self
.config
["period"]["refresh_active"] = -1
153 self
.ro_task
["tasks"][0]["status"] = "DONE"
154 self
.ro_task
["to_check_at"] = -1
155 db
.create("ro_tasks", self
.ro_task
)
156 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
157 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
158 with patch
.object(instance
, "logger", logging
):
159 instance
.update_vm_refresh()
161 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
166 t
="2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1",
168 # Disabled tasks should be enabled to process again
170 self
.config
["period"]["refresh_active"] = 66
171 self
.ro_task
["tasks"][0]["status"] = "DONE"
172 self
.ro_task
["to_check_at"] = -1
173 db
.create("ro_tasks", self
.ro_task
)
174 self
.ro_task2
= self
.ro_task
175 self
.ro_task2
["_id"] = "122437:1"
176 db
.create("ro_tasks", self
.ro_task2
)
177 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
178 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
179 with patch
.object(instance
, "logger", logging
):
180 instance
.update_vm_refresh()
182 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
- 2
187 t
="No disabled task with status DONE in DB, refresh_active parameter is not equal to -1",
189 # If there is not any disabled task, method will not change anything
191 self
.config
["period"]["refresh_active"] = 66
192 self
.ro_task
["tasks"][0]["status"] = "DONE"
193 self
.ro_task
["to_check_at"] = 16373242400.994312
194 db
.create("ro_tasks", self
.ro_task
)
195 self
.ro_task2
= self
.ro_task
196 self
.ro_task2
["_id"] = "122437:1"
197 db
.create("ro_tasks", self
.ro_task2
)
198 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
199 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
200 with patch
.object(instance
, "logger", logging
):
201 instance
.update_vm_refresh()
203 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
206 def test__process_pending_tasks(self
):
209 t
="refresh_active parameter is equal to -1, task status is DONE",
211 # Task should be disabled to process again
213 self
.config
["period"]["refresh_active"] = -1
214 self
.ro_task
["tasks"][0]["status"] = "DONE"
215 self
.ro_task
["to_check_at"] = 16373242400.994312
216 db
.create("ro_tasks", self
.ro_task
)
217 # Number of disabled tasks in DB
218 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
219 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
220 with patch
.object(instance
, "logger", logging
):
221 instance
._process
_pending
_tasks
(self
.ro_task
)
223 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
+ 1
227 i
=2, t
="refresh_active parameter is equal to -1, task status is FAILED"
229 # Task will not be disabled to process as task status is not DONE
231 self
.config
["period"]["refresh_active"] = -1
232 self
.ro_task
["tasks"][0]["status"] = "FAILED"
233 self
.ro_task
["to_check_at"] = 16373242400.994312
234 db
.create("ro_tasks", self
.ro_task
)
235 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "FAILED"))
236 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
237 with patch
.object(instance
, "logger", logging
):
238 instance
._process
_pending
_tasks
(self
.ro_task
)
240 len(self
.get_disabled_tasks(db
, "FAILED")), disabled_tasks_count
244 i
=3, t
="refresh_active parameter is not equal to -1, task status is DONE"
246 # Task will not be disabled to process as refresh_active parameter is not -1
248 self
.config
["period"]["refresh_active"] = 70
249 self
.ro_task
["tasks"][0]["status"] = "DONE"
250 self
.ro_task
["to_check_at"] = 16373242400.994312
251 db
.create("ro_tasks", self
.ro_task
)
252 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
253 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
254 with patch
.object(instance
, "logger", logging
):
255 instance
._process
_pending
_tasks
(self
.ro_task
)
257 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
261 class TestVimInteractionNet(unittest
.TestCase
):
263 module_name
= "osm_ro_plugin"
264 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
265 self
.task_depends
= None
267 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
269 # Enabling mocks and add cleanups
272 self
.addCleanup(mock
.stop
)
274 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
276 mgmt network is set in find_params
277 management_network_id in vim config
278 More than one network found in the VIM
281 logger
= "test_logger"
286 "management_network_id": "test_mgmt_id",
291 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
292 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
293 instance
, "logger", logging
294 ), patch
.object(instance
, "db_vims", db_vims
):
300 "action_id": "123456",
302 "task_id": "123456:1",
303 "status": "SCHEDULED",
306 "target_record": "test_target_record",
307 "target_record_id": "test_target_record_id",
308 # values coming from extra_dict
312 "name": "some_mgmt_name",
314 "depends_on": "test_depends_on",
319 task_index
= "task_index_2"
320 self
.target_vim
.get_network_list
.return_value
= [
321 {"id": "existing_net_1"},
322 {"id": "existing_net_2"},
324 with self
.assertLogs() as captured
:
325 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
326 self
.assertEqual(len(captured
.records
), 1)
328 "More than one network found with this criteria"
329 in captured
.records
[0].getMessage()
331 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
332 self
.assertEqual(result
[0], "FAILED")
333 self
.assertEqual(result
[1].get("created"), False)
334 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
336 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
338 mgmt network is set in find_params
339 management_network_id in vim config
340 The network could not be found in the VIM
343 logger
= "test_logger"
348 "management_network_id": "test_mgmt_id",
353 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
354 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
355 instance
, "db_vims", db_vims
356 ), patch
.object(instance
, "logger", logging
):
362 "action_id": "123456",
364 "task_id": "123456:1",
365 "status": "SCHEDULED",
368 "target_record": "test_target_record",
369 "target_record_id": "test_target_record_id",
371 # values coming from extra_dict
374 "name": "some_mgmt_name",
376 "depends_on": "test_depends_on",
381 task_index
= "task_index_3"
382 self
.target_vim
.get_network_list
.return_value
= []
383 with self
.assertLogs() as captured
:
384 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
385 self
.assertEqual(len(captured
.records
), 1)
387 "Network not found with this criteria"
388 in captured
.records
[0].getMessage()
390 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
391 self
.assertEqual(result
[0], "FAILED")
392 self
.assertEqual(result
[1].get("created"), False)
393 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
395 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
397 mgmt network is set in find_params
398 vim config does not have management_network_id or management_network_id
399 The network could not be found in the VIM
402 logger
= "test_logger"
410 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
411 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
412 instance
, "db_vims", db_vims
413 ), patch
.object(instance
, "logger", logging
):
419 "action_id": "123456",
421 "task_id": "123456:1",
422 "status": "SCHEDULED",
425 "target_record": "test_target_record",
426 "target_record_id": "test_target_record_id",
428 # values coming from extra_dict
431 "name": "some_mgmt_name",
433 "depends_on": "test_depends_on",
438 task_index
= "task_index_3"
439 self
.target_vim
.get_network_list
.return_value
= []
440 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
441 "item1": "sample_created_item"
443 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
444 self
.assertEqual(result
[0], "BUILD")
445 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
446 self
.assertEqual(result
[1].get("created"), True)
447 self
.assertDictEqual(
448 result
[1].get("created_items"), {"item1": "sample_created_item"}
450 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
452 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
454 mgmt network is set in find_params
455 management_network_name in vim config
456 More than one network found in the VIM
459 logger
= "test_logger"
464 "management_network_name": "test_mgmt_name",
469 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
470 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
471 instance
, "logger", logging
472 ), patch
.object(instance
, "db_vims", db_vims
):
478 "action_id": "123456",
480 "task_id": "123456:1",
481 "status": "SCHEDULED",
484 "target_record": "test_target_record",
485 "target_record_id": "test_target_record_id",
486 # values coming from extra_dict
490 "name": "some_mgmt_name",
492 "depends_on": "test_depends_on",
497 task_index
= "task_index_4"
498 self
.target_vim
.get_network_list
.return_value
= [
499 {"id": "existing_net_1"},
500 {"id": "existing_net_2"},
502 with self
.assertLogs() as captured
:
503 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
504 self
.assertEqual(len(captured
.records
), 1)
506 "More than one network found with this criteria"
507 in captured
.records
[0].getMessage()
509 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
510 self
.assertEqual(result
[0], "FAILED")
511 self
.assertEqual(result
[1].get("created"), False)
512 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
514 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
516 mgmt network is set in find_params
517 management_network_name in vim config
518 The network could not be found in the VIM
521 logger
= "test_logger"
526 "management_network_name": "test_mgmt_name",
531 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
532 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
533 instance
, "logger", logging
534 ), patch
.object(instance
, "db_vims", db_vims
):
540 "action_id": "123456",
542 "task_id": "123456:1",
543 "status": "SCHEDULED",
546 "target_record": "test_target_record",
547 "target_record_id": "test_target_record_id",
548 # values coming from extra_dict
552 "name": "some_mgmt_name",
554 "depends_on": "test_depends_on",
559 task_index
= "task_index_5"
560 self
.target_vim
.get_network_list
.return_value
= []
561 with self
.assertLogs() as captured
:
562 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
563 self
.assertEqual(len(captured
.records
), 1)
565 "Network not found with this criteria"
566 in captured
.records
[0].getMessage()
568 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
569 self
.assertEqual(result
[0], "FAILED")
570 self
.assertEqual(result
[1].get("created"), False)
571 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
573 def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self
):
575 mgmt network is set in find_params
576 management_network_name in vim config
577 network_name is set in find_params.get('filterdict')
578 More than one network found in the VIM
581 logger
= "test_logger"
586 "management_network_name": "test_mgmt_name",
590 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
591 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
592 instance
, "logger", logging
593 ), patch
.object(instance
, "db_vims", db_vims
):
599 "action_id": "123456",
601 "task_id": "123456:1",
602 "status": "SCHEDULED",
605 "target_record": "test_target_record",
606 "target_record_id": "test_target_record_id",
607 # values coming from extra_dict
611 "name": "some-network-name",
614 "name": "some_mgmt_name",
616 "depends_on": "test_depends_on",
621 task_index
= "task_index_6"
622 self
.target_vim
.get_network_list
.return_value
= [
623 {"id": "existing_net_1"},
624 {"id": "existing_net_2"},
626 with self
.assertLogs() as captured
:
627 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
628 self
.assertEqual(len(captured
.records
), 1)
630 "More than one network found with this criteria"
631 in captured
.records
[0].getMessage()
633 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
634 self
.assertEqual(result
[0], "FAILED")
635 self
.assertEqual(result
[1].get("created"), False)
636 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
638 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
640 There is find_params in the task
641 No mgmt in find_params
642 No filter_dict in find_params
645 logger
= "test_logger"
650 "management_network_name": "test_mgmt_name",
654 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
655 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
656 instance
, "logger", logging
657 ), patch
.object(instance
, "db_vims", db_vims
):
663 "action_id": "123456",
665 "task_id": "123456:1",
666 "status": "SCHEDULED",
669 "target_record": "test_target_record",
670 "target_record_id": "test_target_record_id",
671 # values coming from extra_dict
673 "find_params": {"wrong_param": "wrong_value"},
674 "depends_on": "test_depends_on",
679 task_index
= "task_index_4"
680 with self
.assertLogs() as captured
:
681 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
682 self
.assertEqual(len(captured
.records
), 1)
684 "Invalid find_params for new_net"
685 in captured
.records
[0].getMessage()
687 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
688 self
.assertEqual(result
[0], "FAILED")
689 self
.assertEqual(result
[1].get("created"), False)
690 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
692 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
694 management_network_name in find_params.get('filterdict')
695 The network could not be found in the VIM
696 There are items in the task.get(params)
699 logger
= "test_logger"
704 "management_network_name": "test_mgmt_name",
708 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
709 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
710 instance
, "logger", logging
711 ), patch
.object(instance
, "db_vims", db_vims
):
717 "action_id": "123456",
719 "task_id": "123456:1",
720 "status": "SCHEDULED",
723 "target_record": "test_target_record",
724 "target_record_id": "test_target_record_id",
725 # values coming from extra_dict
727 "net_name": "test_params",
731 "name": "some-network-name",
734 "name": "some_mgmt_name",
736 "depends_on": "test_depends_on",
741 task_index
= "task_index_8"
742 self
.target_vim
.get_network_list
.return_value
= []
743 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
744 self
.assertEqual(result
[0], "BUILD")
745 self
.assertEqual(result
[1].get("created"), False)
746 self
.assertEqual(result
[1].get("vim_id"), None)
747 self
.assertEqual(result
[1].get("created_items"), {})
748 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
750 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
752 mgmt network is set in find_params
753 management_network_name in vim config
754 network_name is set in find_params.get('filterdict')
755 Any network could not be found in the VIM
758 logger
= "test_logger"
763 "management_network_name": "test_mgmt_name",
767 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
768 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
769 instance
, "logger", logging
770 ), patch
.object(instance
, "db_vims", db_vims
):
776 "action_id": "123456",
778 "task_id": "123456:1",
779 "status": "SCHEDULED",
782 "target_record": "test_target_record",
783 "target_record_id": "test_target_record_id",
784 # values coming from extra_dict
788 "name": "some-network-name",
791 "name": "some_mgmt_name",
793 "depends_on": "test_depends_on",
798 task_index
= "task_index_9"
799 self
.target_vim
.get_network_list
.return_value
= []
800 with self
.assertLogs() as captured
:
801 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
802 self
.assertEqual(len(captured
.records
), 1)
804 "Network not found with this criteria"
805 in captured
.records
[0].getMessage()
807 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
808 self
.assertEqual(result
[0], "FAILED")
809 self
.assertEqual(result
[1].get("created"), False)
810 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
812 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
814 mgmt network is set in find_params
816 network_name is set in find_params.get('filterdict')
817 Any network could not be found in the VIM
820 logger
= "test_logger"
827 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
828 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
829 instance
, "logger", logging
830 ), patch
.object(instance
, "db_vims", db_vims
):
836 "action_id": "123456",
838 "task_id": "123456:1",
839 "status": "SCHEDULED",
842 "target_record": "test_target_record",
843 "target_record_id": "test_target_record_id",
844 # values coming from extra_dict
848 "name": "some-network-name",
851 "name": "some_mgmt_name",
853 "depends_on": "test_depends_on",
858 task_index
= "task_index_9"
859 self
.target_vim
.get_network_list
.return_value
= []
860 with self
.assertLogs() as captured
:
861 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
862 self
.assertEqual(len(captured
.records
), 1)
864 "Network not found with this criteria"
865 in captured
.records
[0].getMessage()
867 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
868 self
.assertEqual(result
[0], "FAILED")
869 self
.assertEqual(result
[1].get("created"), False)
870 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
872 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
874 mgmt network is set in find_params
875 management_network_name is not in db_vims.get('config')
876 One network found in the VIM
879 logger
= "test_logger"
886 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
887 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
888 instance
, "logger", logging
889 ), patch
.object(instance
, "db_vims", db_vims
):
895 "action_id": "123456",
897 "task_id": "123456:1",
898 "status": "SCHEDULED",
901 "target_record": "test_target_record",
902 "target_record_id": "test_target_record_id",
903 # values coming from extra_dict
907 "name": "some_mgmt_name",
909 "depends_on": "test_depends_on",
914 task_index
= "task_index_2"
915 self
.target_vim
.get_network_list
.return_value
= [
916 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
918 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
919 self
.assertEqual(result
[0], "BUILD")
920 self
.assertEqual(result
[1].get("created"), False)
921 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
923 def test__params_in_task_no_find_params(self
):
926 find_params does not exist in the task
929 logger
= "test_logger"
934 "management_network_name": "test_mgmt_name",
938 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
939 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
940 instance
, "logger", logging
941 ), patch
.object(instance
, "db_vims", db_vims
):
947 "action_id": "123456",
949 "task_id": "123456:1",
950 "status": "SCHEDULED",
953 "target_record": "test_target_record",
954 "target_record_id": "test_target_record_id",
955 # values coming from extra_dict
957 "net_name": "test-network",
960 "depends_on": "test_depends_on",
965 task_index
= "task_index_11"
966 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
967 "item1": "sample_created_item"
969 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
970 self
.assertEqual(result
[0], "BUILD")
971 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
972 self
.assertEqual(result
[1].get("created"), True)
974 result
[1].get("created_items"), {"item1": "sample_created_item"}
976 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
978 def test__no_params_in_task_no_find_params(self
):
980 empty params in the task
981 find_params does not exist in the task
984 logger
= "test_logger"
989 "management_network_name": "test_mgmt_name",
993 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
994 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
995 instance
, "logger", logging
996 ), patch
.object(instance
, "db_vims", db_vims
):
1002 "action_id": "123456",
1004 "task_id": "123456:1",
1005 "status": "SCHEDULED",
1007 "item": "test_item",
1008 "target_record": "test_target_record",
1009 "target_record_id": "test_target_record_id",
1010 # values coming from extra_dict
1012 "depends_on": "test_depends_on",
1017 task_index
= "task_index_12"
1018 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
1019 "VimConnConnectionException occurred."
1021 with self
.assertLogs() as captured
:
1022 instance
.new(ro_task
, task_index
, self
.task_depends
)
1023 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1025 def test__refresh_ro_task_vim_status_active(self
):
1027 vim_info.get('status') is ACTIVE
1030 logger
= "test_logger"
1031 my_vims
= "test-vim"
1033 "vim_openstack_1": {
1037 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1039 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1040 ), patch
.object(instance
, "logger", logging
), patch
.object(
1041 instance
, "db_vims", db_vims
1047 "target_id": "vim_openstack_1",
1050 "created_items": None,
1051 "vim_id": "test-vim-id",
1052 "vim_name": "test-vim",
1054 "vim_details": "some-details",
1055 "vim_message": None,
1058 "modified_at": 1637324200.994312,
1059 "created_at": 1637324200.994312,
1060 "to_check_at": 1637324200.994312,
1064 self
.target_vim
.refresh_nets_status
.return_value
= {
1066 "vim_info": "some-details",
1072 task_status
= "DONE"
1073 ro_vim_item_update
= {
1074 "vim_status": "ACTIVE",
1076 result
= instance
.refresh(ro_task
)
1077 self
.assertEqual(result
[0], task_status
)
1078 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1080 def test__refresh_ro_task_vim_status_build(self
):
1082 vim_info.get('status') is BUILD
1085 logger
= "test_logger"
1086 my_vims
= "test-vim"
1088 "vim_openstack_1": {
1092 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1094 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1095 ), patch
.object(instance
, "logger", logging
), patch
.object(
1096 instance
, "db_vims", db_vims
1102 "target_id": "vim_openstack_1",
1105 "created_items": None,
1106 "vim_id": "test-vim-id",
1107 "vim_name": "test-vim",
1108 "vim_status": "BUILD",
1110 "vim_message": None,
1113 "modified_at": 1637324200.994312,
1114 "created_at": 1637324200.994312,
1115 "to_check_at": 1637324200.994312,
1119 self
.target_vim
.refresh_nets_status
.return_value
= {
1121 "vim_info": "some-details",
1123 "name": "other-vim",
1127 task_status
= "BUILD"
1128 ro_vim_item_update
= {
1129 "vim_name": "other-vim",
1130 "vim_details": "some-details",
1132 result
= instance
.refresh(ro_task
)
1133 self
.assertEqual(result
[0], task_status
)
1134 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1136 def test__refresh_ro_task_vim_status_error(self
):
1138 vim_info.get('status') is ERROR
1141 logger
= "test_logger"
1142 my_vims
= "test-vim"
1144 "vim_openstack_1": {
1148 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1150 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1151 ), patch
.object(instance
, "logger", logging
), patch
.object(
1152 instance
, "db_vims", db_vims
1158 "target_id": "vim_openstack_1",
1161 "created_items": None,
1162 "vim_id": "test-vim-id",
1163 "vim_name": "test-vim",
1164 "vim_status": "BUILD",
1166 "vim_message": None,
1169 "modified_at": 1637324200.994312,
1170 "created_at": 1637324200.994312,
1171 "to_check_at": 1637324200.994312,
1175 self
.target_vim
.refresh_nets_status
.return_value
= {
1177 "vim_info": "some-details",
1180 "error_msg": "some error message",
1183 task_status
= "FAILED"
1184 ro_vim_item_update
= {
1185 "vim_status": "ERROR",
1186 "vim_message": "some error message",
1188 result
= instance
.refresh(ro_task
)
1189 self
.assertEqual(result
[0], task_status
)
1190 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1192 def test__refresh_ro_task_VimConnException_occurred(self
):
1194 vimconn.VimConnException has occured
1197 logger
= "test_logger"
1198 my_vims
= "test-vim"
1200 "vim_openstack_1": {
1204 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1206 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1207 ), patch
.object(instance
, "logger", logging
), patch
.object(
1208 instance
, "db_vims", db_vims
1214 "target_id": "vim_openstack_1",
1217 "created_items": None,
1218 "vim_id": "test-vim-id",
1219 "vim_name": "test-vim",
1220 "vim_status": "BUILD",
1222 "vim_message": None,
1225 "modified_at": 1637324200.994312,
1226 "created_at": 1637324200.994312,
1227 "to_check_at": 1637324200.994312,
1230 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
1231 "VimConnException occurred."
1233 with self
.assertLogs() as captured
:
1234 instance
.refresh(ro_task
)
1235 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1237 def test__refresh_ro_task_vim_status_deleted(self
):
1239 vim_info.get('status') is DELETED
1242 logger
= "test_logger"
1243 my_vims
= "test-vim"
1245 "vim_openstack_1": {
1249 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1251 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1252 ), patch
.object(instance
, "logger", logging
), patch
.object(
1253 instance
, "db_vims", db_vims
1259 "target_id": "vim_openstack_1",
1262 "created_items": None,
1263 "vim_id": "test-vim-id",
1264 "vim_name": "test-vim",
1265 "vim_status": "BUILD",
1267 "vim_message": None,
1270 "modified_at": 163724200.994312,
1271 "created_at": 1637324200.994312,
1272 "to_check_at": 1637324200.994312,
1275 self
.target_vim
.refresh_nets_status
.return_value
= {
1277 "vim_info": "some-details",
1278 "status": "DELETED",
1280 "error_msg": "some error message",
1283 task_status
= "FAILED"
1284 ro_vim_item_update
= {
1285 "vim_status": "DELETED",
1286 "vim_message": "Deleted externally",
1289 result
= instance
.refresh(ro_task
)
1290 self
.assertEqual(result
[0], task_status
)
1291 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1293 def test__refresh_ro_task_empty_vim_dict(self
):
1295 vim_dict does not include vim_id key
1299 logger
= "test_logger"
1300 my_vims
= "test-vim"
1302 "vim_openstack_2": {
1306 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1308 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1309 ), patch
.object(instance
, "logger", logging
), patch
.object(
1310 instance
, "db_vims", db_vims
1316 "target_id": "vim_openstack_2",
1319 "created_items": None,
1320 "vim_id": "test-vim-id",
1321 "vim_name": "test-vim",
1322 "vim_status": "BUILD",
1324 "vim_message": None,
1327 "modified_at": 163724211.994312,
1328 "created_at": 1637324211.994312,
1329 "to_check_at": 1637324211.994312,
1332 self
.target_vim
.refresh_nets_status
.return_value
= {}
1333 with self
.assertRaises(KeyError):
1334 instance
.refresh(ro_task
)
1337 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1339 module_name
= "osm_ro_plugin"
1340 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1341 self
.task_depends
= None
1343 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1345 # Enabling mocks and add cleanups
1346 for mock
in patches
:
1348 self
.addCleanup(mock
.stop
)
1350 def test__new_affinity_group_ok(self
):
1352 create affinity group with attributes set in params
1355 logger
= "test_logger"
1356 my_vims
= "test-vim"
1363 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1364 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1365 instance
, "logger", logging
1366 ), patch
.object(instance
, "db_vims", db_vims
):
1372 "action_id": "123456",
1374 "task_id": "123456:1",
1375 "status": "SCHEDULED",
1377 "item": "test_item",
1378 "target_record": "test_target_record",
1379 "target_record_id": "test_target_record_id",
1380 # values coming from extra_dict
1382 "affinity_group_data": {
1383 "name": "affinity_group_1",
1385 "scope": "nfvi-node",
1389 "depends_on": "test_depends_on",
1394 task_index
= "task_index_1"
1395 self
.target_vim
.new_affinity_group
.return_value
= (
1396 "sample_affinity_group_id_1"
1398 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1399 self
.assertEqual(result
[0], "DONE")
1400 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1401 self
.assertEqual(result
[1].get("created"), True)
1402 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1404 def test__new_affinity_group_failed(self
):
1406 create affinity group with no attributes set in params
1409 logger
= "test_logger"
1410 my_vims
= "test-vim"
1417 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1418 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1419 instance
, "logger", logging
1420 ), patch
.object(instance
, "db_vims", db_vims
):
1426 "action_id": "123456",
1428 "task_id": "123456:1",
1429 "status": "SCHEDULED",
1431 "item": "test_item",
1432 "target_record": "test_target_record",
1433 "target_record_id": "test_target_record_id",
1434 # values coming from extra_dict
1437 "depends_on": "test_depends_on",
1442 task_index
= "task_index_2"
1443 self
.target_vim
.new_affinity_group
.return_value
= (
1444 "sample_affinity_group_id_1"
1446 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1447 self
.assertEqual(result
[0], "DONE")
1448 self
.assertEqual(result
[1].get("vim_id"), None)
1449 self
.assertEqual(result
[1].get("created"), False)
1450 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1452 def test__delete_affinity_group_ok(self
):
1454 delete affinity group with a proper vim_id
1457 logger
= "test_logger"
1458 my_vims
= "test-vim"
1465 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1466 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1467 instance
, "logger", logging
1468 ), patch
.object(instance
, "db_vims", db_vims
):
1474 "task_id": "123456:1",
1479 "created_items": None,
1480 "vim_id": "sample_affinity_group_id_3",
1481 "vim_name": "sample_affinity_group_id_3",
1483 "vim_details": "some-details",
1484 "vim_message": None,
1489 task_index
= "task_index_3"
1490 self
.target_vim
.delete_affinity_group
.return_value
= (
1491 "sample_affinity_group_id_3"
1493 result
= instance
.delete(ro_task
, task_index
)
1494 self
.assertEqual(result
[0], "DONE")
1495 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1496 self
.assertEqual(result
[1].get("created"), False)
1497 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1499 def test__delete_affinity_group_failed(self
):
1501 delete affinity group with missing vim_id
1504 logger
= "test_logger"
1505 my_vims
= "test-vim"
1512 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1513 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1514 instance
, "logger", logging
1515 ), patch
.object(instance
, "db_vims", db_vims
):
1521 "task_id": "123456:1",
1526 "created_items": None,
1530 "vim_details": "some-details",
1531 "vim_message": None,
1536 task_index
= "task_index_4"
1537 self
.target_vim
.delete_affinity_group
.return_value
= ""
1538 result
= instance
.delete(ro_task
, task_index
)
1539 self
.assertEqual(result
[0], "DONE")
1540 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1541 self
.assertEqual(result
[1].get("created"), False)
1542 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1545 class TestVimInteractionResize(unittest
.TestCase
):
1547 module_name
= "osm_ro_plugin"
1548 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1549 self
.task_depends
= None
1551 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1553 # Enabling mocks and add cleanups
1554 for mock
in patches
:
1556 self
.addCleanup(mock
.stop
)
1558 def test__exec_resize_done(self
):
1560 create verticalscale task
1563 logger
= "test_logger"
1564 my_vims
= "test-vim"
1570 target_record_id
= (
1571 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1572 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1575 instance
= VimInteractionResize(db
, logger
, my_vims
, db_vims
)
1576 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1577 instance
, "logger", logging
1578 ), patch
.object(instance
, "db_vims", db_vims
):
1584 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1585 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1586 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1587 "status": "SCHEDULED",
1589 "item": "verticalscale",
1590 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1591 "target_record_id": target_record_id
,
1593 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1594 "flavor_dict": "flavor_dict",
1599 task_index
= "task_index_1"
1600 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1601 self
.assertEqual(result
[0], "DONE")
1602 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1605 class TestVimInteractionMigration(unittest
.TestCase
):
1607 module_name
= "osm_ro_plugin"
1608 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1609 self
.task_depends
= None
1611 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1613 # Enabling mocks and add cleanups
1614 for mock
in patches
:
1616 self
.addCleanup(mock
.stop
)
1618 def test__exec_migration_done(self
):
1623 logger
= "test_logger"
1624 my_vims
= "test-vim"
1630 target_record_id
= (
1631 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1632 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1635 instance
= VimInteractionMigration(db
, logger
, my_vims
, db_vims
)
1636 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1637 instance
, "logger", logging
1638 ), patch
.object(instance
, "db_vims", db_vims
):
1644 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1645 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1646 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1647 "status": "SCHEDULED",
1650 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1651 "target_record_id": target_record_id
,
1653 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1654 "migrate_host": "osm-test2",
1655 "vdu_vim_info": {0: {"interfaces": []}},
1660 self
.target_vim
.migrate_instance
.return_value
= "ACTIVE", "test"
1662 task_index
= "task_index_1"
1663 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1664 self
.assertEqual(result
[0], "DONE")
1665 self
.assertEqual(result
[1].get("vim_status"), "ACTIVE")