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_ng_ro
.ns_thread
import (
23 VimInteractionAffinityGroup
,
27 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
30 class TestVimInteractionNet(unittest
.TestCase
):
32 module_name
= "osm_ro_plugin"
33 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
34 self
.task_depends
= None
36 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
38 # Enabling mocks and add cleanups
41 self
.addCleanup(mock
.stop
)
43 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
45 mgmt network is set in find_params
46 management_network_id in vim config
47 More than one network found in the VIM
50 logger
= "test_logger"
55 "management_network_id": "test_mgmt_id",
60 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
61 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
62 instance
, "logger", logging
63 ), patch
.object(instance
, "db_vims", db_vims
):
69 "action_id": "123456",
71 "task_id": "123456:1",
72 "status": "SCHEDULED",
75 "target_record": "test_target_record",
76 "target_record_id": "test_target_record_id",
77 # values coming from extra_dict
81 "name": "some_mgmt_name",
83 "depends_on": "test_depends_on",
88 task_index
= "task_index_2"
89 self
.target_vim
.get_network_list
.return_value
= [
90 {"id": "existing_net_1"},
91 {"id": "existing_net_2"},
93 with self
.assertLogs() as captured
:
94 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
95 self
.assertEqual(len(captured
.records
), 1)
97 "More than one network found with this criteria"
98 in captured
.records
[0].getMessage()
100 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
101 self
.assertEqual(result
[0], "FAILED")
102 self
.assertEqual(result
[1].get("created"), False)
103 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
105 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
107 mgmt network is set in find_params
108 management_network_id in vim config
109 The network could not be found in the VIM
112 logger
= "test_logger"
117 "management_network_id": "test_mgmt_id",
122 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
123 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
124 instance
, "db_vims", db_vims
125 ), patch
.object(instance
, "logger", logging
):
131 "action_id": "123456",
133 "task_id": "123456:1",
134 "status": "SCHEDULED",
137 "target_record": "test_target_record",
138 "target_record_id": "test_target_record_id",
140 # values coming from extra_dict
143 "name": "some_mgmt_name",
145 "depends_on": "test_depends_on",
150 task_index
= "task_index_3"
151 self
.target_vim
.get_network_list
.return_value
= []
152 with self
.assertLogs() as captured
:
153 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
154 self
.assertEqual(len(captured
.records
), 1)
156 "Network not found with this criteria"
157 in captured
.records
[0].getMessage()
159 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
160 self
.assertEqual(result
[0], "FAILED")
161 self
.assertEqual(result
[1].get("created"), False)
162 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
164 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
166 mgmt network is set in find_params
167 vim config does not have management_network_id or management_network_id
168 The network could not be found in the VIM
171 logger
= "test_logger"
179 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
180 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
181 instance
, "db_vims", db_vims
182 ), patch
.object(instance
, "logger", logging
):
188 "action_id": "123456",
190 "task_id": "123456:1",
191 "status": "SCHEDULED",
194 "target_record": "test_target_record",
195 "target_record_id": "test_target_record_id",
197 # values coming from extra_dict
200 "name": "some_mgmt_name",
202 "depends_on": "test_depends_on",
207 task_index
= "task_index_3"
208 self
.target_vim
.get_network_list
.return_value
= []
209 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
210 "item1": "sample_created_item"
212 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
213 self
.assertEqual(result
[0], "BUILD")
214 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
215 self
.assertEqual(result
[1].get("created"), True)
216 self
.assertDictEqual(
217 result
[1].get("created_items"), {"item1": "sample_created_item"}
219 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
221 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
223 mgmt network is set in find_params
224 management_network_name in vim config
225 More than one network found in the VIM
228 logger
= "test_logger"
233 "management_network_name": "test_mgmt_name",
238 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
239 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
240 instance
, "logger", logging
241 ), patch
.object(instance
, "db_vims", db_vims
):
247 "action_id": "123456",
249 "task_id": "123456:1",
250 "status": "SCHEDULED",
253 "target_record": "test_target_record",
254 "target_record_id": "test_target_record_id",
255 # values coming from extra_dict
259 "name": "some_mgmt_name",
261 "depends_on": "test_depends_on",
266 task_index
= "task_index_4"
267 self
.target_vim
.get_network_list
.return_value
= [
268 {"id": "existing_net_1"},
269 {"id": "existing_net_2"},
271 with self
.assertLogs() as captured
:
272 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
273 self
.assertEqual(len(captured
.records
), 1)
275 "More than one network found with this criteria"
276 in captured
.records
[0].getMessage()
278 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
279 self
.assertEqual(result
[0], "FAILED")
280 self
.assertEqual(result
[1].get("created"), False)
281 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
283 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
285 mgmt network is set in find_params
286 management_network_name in vim config
287 The network could not be found in the VIM
290 logger
= "test_logger"
295 "management_network_name": "test_mgmt_name",
300 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
301 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
302 instance
, "logger", logging
303 ), patch
.object(instance
, "db_vims", db_vims
):
309 "action_id": "123456",
311 "task_id": "123456:1",
312 "status": "SCHEDULED",
315 "target_record": "test_target_record",
316 "target_record_id": "test_target_record_id",
317 # values coming from extra_dict
321 "name": "some_mgmt_name",
323 "depends_on": "test_depends_on",
328 task_index
= "task_index_5"
329 self
.target_vim
.get_network_list
.return_value
= []
330 with self
.assertLogs() as captured
:
331 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
332 self
.assertEqual(len(captured
.records
), 1)
334 "Network not found with this criteria"
335 in captured
.records
[0].getMessage()
337 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
338 self
.assertEqual(result
[0], "FAILED")
339 self
.assertEqual(result
[1].get("created"), False)
340 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
342 def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self
):
344 mgmt network is set in find_params
345 management_network_name in vim config
346 network_name is set in find_params.get('filterdict')
347 More than one network found in the VIM
350 logger
= "test_logger"
355 "management_network_name": "test_mgmt_name",
359 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
360 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
361 instance
, "logger", logging
362 ), patch
.object(instance
, "db_vims", db_vims
):
368 "action_id": "123456",
370 "task_id": "123456:1",
371 "status": "SCHEDULED",
374 "target_record": "test_target_record",
375 "target_record_id": "test_target_record_id",
376 # values coming from extra_dict
380 "name": "some-network-name",
383 "name": "some_mgmt_name",
385 "depends_on": "test_depends_on",
390 task_index
= "task_index_6"
391 self
.target_vim
.get_network_list
.return_value
= [
392 {"id": "existing_net_1"},
393 {"id": "existing_net_2"},
395 with self
.assertLogs() as captured
:
396 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
397 self
.assertEqual(len(captured
.records
), 1)
399 "More than one network found with this criteria"
400 in captured
.records
[0].getMessage()
402 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
403 self
.assertEqual(result
[0], "FAILED")
404 self
.assertEqual(result
[1].get("created"), False)
405 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
407 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
409 There is find_params in the task
410 No mgmt in find_params
411 No filter_dict in find_params
414 logger
= "test_logger"
419 "management_network_name": "test_mgmt_name",
423 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
424 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
425 instance
, "logger", logging
426 ), patch
.object(instance
, "db_vims", db_vims
):
432 "action_id": "123456",
434 "task_id": "123456:1",
435 "status": "SCHEDULED",
438 "target_record": "test_target_record",
439 "target_record_id": "test_target_record_id",
440 # values coming from extra_dict
442 "find_params": {"wrong_param": "wrong_value"},
443 "depends_on": "test_depends_on",
448 task_index
= "task_index_4"
449 with self
.assertLogs() as captured
:
450 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
451 self
.assertEqual(len(captured
.records
), 1)
453 "Invalid find_params for new_net"
454 in captured
.records
[0].getMessage()
456 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
457 self
.assertEqual(result
[0], "FAILED")
458 self
.assertEqual(result
[1].get("created"), False)
459 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
461 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
463 management_network_name in find_params.get('filterdict')
464 The network could not be found in the VIM
465 There are items in the task.get(params)
468 logger
= "test_logger"
473 "management_network_name": "test_mgmt_name",
477 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
478 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
479 instance
, "logger", logging
480 ), patch
.object(instance
, "db_vims", db_vims
):
486 "action_id": "123456",
488 "task_id": "123456:1",
489 "status": "SCHEDULED",
492 "target_record": "test_target_record",
493 "target_record_id": "test_target_record_id",
494 # values coming from extra_dict
496 "net_name": "test_params",
500 "name": "some-network-name",
503 "name": "some_mgmt_name",
505 "depends_on": "test_depends_on",
510 task_index
= "task_index_8"
511 self
.target_vim
.get_network_list
.return_value
= []
512 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
513 self
.assertEqual(result
[0], "BUILD")
514 self
.assertEqual(result
[1].get("created"), False)
515 self
.assertEqual(result
[1].get("vim_id"), None)
516 self
.assertEqual(result
[1].get("created_items"), {})
517 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
519 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
521 mgmt network is set in find_params
522 management_network_name in vim config
523 network_name is set in find_params.get('filterdict')
524 Any network could not be found in the VIM
527 logger
= "test_logger"
532 "management_network_name": "test_mgmt_name",
536 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
537 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
538 instance
, "logger", logging
539 ), patch
.object(instance
, "db_vims", db_vims
):
545 "action_id": "123456",
547 "task_id": "123456:1",
548 "status": "SCHEDULED",
551 "target_record": "test_target_record",
552 "target_record_id": "test_target_record_id",
553 # values coming from extra_dict
557 "name": "some-network-name",
560 "name": "some_mgmt_name",
562 "depends_on": "test_depends_on",
567 task_index
= "task_index_9"
568 self
.target_vim
.get_network_list
.return_value
= []
569 with self
.assertLogs() as captured
:
570 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
571 self
.assertEqual(len(captured
.records
), 1)
573 "Network not found with this criteria"
574 in captured
.records
[0].getMessage()
576 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
577 self
.assertEqual(result
[0], "FAILED")
578 self
.assertEqual(result
[1].get("created"), False)
579 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
581 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
583 mgmt network is set in find_params
585 network_name is set in find_params.get('filterdict')
586 Any network could not be found in the VIM
589 logger
= "test_logger"
596 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
597 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
598 instance
, "logger", logging
599 ), patch
.object(instance
, "db_vims", db_vims
):
605 "action_id": "123456",
607 "task_id": "123456:1",
608 "status": "SCHEDULED",
611 "target_record": "test_target_record",
612 "target_record_id": "test_target_record_id",
613 # values coming from extra_dict
617 "name": "some-network-name",
620 "name": "some_mgmt_name",
622 "depends_on": "test_depends_on",
627 task_index
= "task_index_9"
628 self
.target_vim
.get_network_list
.return_value
= []
629 with self
.assertLogs() as captured
:
630 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
631 self
.assertEqual(len(captured
.records
), 1)
633 "Network not found with this criteria"
634 in captured
.records
[0].getMessage()
636 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
637 self
.assertEqual(result
[0], "FAILED")
638 self
.assertEqual(result
[1].get("created"), False)
639 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
641 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
643 mgmt network is set in find_params
644 management_network_name is not in db_vims.get('config')
645 One network found in the VIM
648 logger
= "test_logger"
655 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
656 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
657 instance
, "logger", logging
658 ), patch
.object(instance
, "db_vims", db_vims
):
664 "action_id": "123456",
666 "task_id": "123456:1",
667 "status": "SCHEDULED",
670 "target_record": "test_target_record",
671 "target_record_id": "test_target_record_id",
672 # values coming from extra_dict
676 "name": "some_mgmt_name",
678 "depends_on": "test_depends_on",
683 task_index
= "task_index_2"
684 self
.target_vim
.get_network_list
.return_value
= [
685 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
687 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
688 self
.assertEqual(result
[0], "BUILD")
689 self
.assertEqual(result
[1].get("created"), False)
690 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
692 def test__params_in_task_no_find_params(self
):
695 find_params does not exist in the task
698 logger
= "test_logger"
703 "management_network_name": "test_mgmt_name",
707 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
708 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
709 instance
, "logger", logging
710 ), patch
.object(instance
, "db_vims", db_vims
):
716 "action_id": "123456",
718 "task_id": "123456:1",
719 "status": "SCHEDULED",
722 "target_record": "test_target_record",
723 "target_record_id": "test_target_record_id",
724 # values coming from extra_dict
726 "net_name": "test-network",
729 "depends_on": "test_depends_on",
734 task_index
= "task_index_11"
735 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
736 "item1": "sample_created_item"
738 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
739 self
.assertEqual(result
[0], "BUILD")
740 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
741 self
.assertEqual(result
[1].get("created"), True)
743 result
[1].get("created_items"), {"item1": "sample_created_item"}
745 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
747 def test__no_params_in_task_no_find_params(self
):
749 empty params in the task
750 find_params does not exist in the task
753 logger
= "test_logger"
758 "management_network_name": "test_mgmt_name",
762 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
763 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
764 instance
, "logger", logging
765 ), patch
.object(instance
, "db_vims", db_vims
):
771 "action_id": "123456",
773 "task_id": "123456:1",
774 "status": "SCHEDULED",
777 "target_record": "test_target_record",
778 "target_record_id": "test_target_record_id",
779 # values coming from extra_dict
781 "depends_on": "test_depends_on",
786 task_index
= "task_index_12"
787 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
788 "VimConnConnectionException occurred."
790 with self
.assertLogs() as captured
:
791 instance
.new(ro_task
, task_index
, self
.task_depends
)
792 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
794 def test__refresh_ro_task_vim_status_active(self
):
796 vim_info.get('status') is ACTIVE
799 logger
= "test_logger"
806 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
808 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
809 ), patch
.object(instance
, "logger", logging
), patch
.object(
810 instance
, "db_vims", db_vims
816 "target_id": "vim_openstack_1",
819 "created_items": None,
820 "vim_id": "test-vim-id",
821 "vim_name": "test-vim",
823 "vim_details": "some-details",
827 "modified_at": 1637324200.994312,
828 "created_at": 1637324200.994312,
829 "to_check_at": 1637324200.994312,
833 self
.target_vim
.refresh_nets_status
.return_value
= {
835 "vim_info": "some-details",
842 ro_vim_item_update
= {
843 "vim_status": "ACTIVE",
845 result
= instance
.refresh(ro_task
)
846 self
.assertEqual(result
[0], task_status
)
847 self
.assertDictEqual(result
[1], ro_vim_item_update
)
849 def test__refresh_ro_task_vim_status_build(self
):
851 vim_info.get('status') is BUILD
854 logger
= "test_logger"
861 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
863 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
864 ), patch
.object(instance
, "logger", logging
), patch
.object(
865 instance
, "db_vims", db_vims
871 "target_id": "vim_openstack_1",
874 "created_items": None,
875 "vim_id": "test-vim-id",
876 "vim_name": "test-vim",
877 "vim_status": "BUILD",
882 "modified_at": 1637324200.994312,
883 "created_at": 1637324200.994312,
884 "to_check_at": 1637324200.994312,
888 self
.target_vim
.refresh_nets_status
.return_value
= {
890 "vim_info": "some-details",
896 task_status
= "BUILD"
897 ro_vim_item_update
= {
898 "vim_name": "other-vim",
899 "vim_details": "some-details",
901 result
= instance
.refresh(ro_task
)
902 self
.assertEqual(result
[0], task_status
)
903 self
.assertDictEqual(result
[1], ro_vim_item_update
)
905 def test__refresh_ro_task_vim_status_error(self
):
907 vim_info.get('status') is ERROR
910 logger
= "test_logger"
917 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
919 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
920 ), patch
.object(instance
, "logger", logging
), patch
.object(
921 instance
, "db_vims", db_vims
927 "target_id": "vim_openstack_1",
930 "created_items": None,
931 "vim_id": "test-vim-id",
932 "vim_name": "test-vim",
933 "vim_status": "BUILD",
938 "modified_at": 1637324200.994312,
939 "created_at": 1637324200.994312,
940 "to_check_at": 1637324200.994312,
944 self
.target_vim
.refresh_nets_status
.return_value
= {
946 "vim_info": "some-details",
949 "error_msg": "some error message",
952 task_status
= "FAILED"
953 ro_vim_item_update
= {
954 "vim_status": "ERROR",
955 "vim_message": "some error message",
957 result
= instance
.refresh(ro_task
)
958 self
.assertEqual(result
[0], task_status
)
959 self
.assertDictEqual(result
[1], ro_vim_item_update
)
961 def test__refresh_ro_task_VimConnException_occurred(self
):
963 vimconn.VimConnException has occured
966 logger
= "test_logger"
973 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
975 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
976 ), patch
.object(instance
, "logger", logging
), patch
.object(
977 instance
, "db_vims", db_vims
983 "target_id": "vim_openstack_1",
986 "created_items": None,
987 "vim_id": "test-vim-id",
988 "vim_name": "test-vim",
989 "vim_status": "BUILD",
994 "modified_at": 1637324200.994312,
995 "created_at": 1637324200.994312,
996 "to_check_at": 1637324200.994312,
999 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
1000 "VimConnException occurred."
1002 with self
.assertLogs() as captured
:
1003 instance
.refresh(ro_task
)
1004 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1006 def test__refresh_ro_task_vim_status_deleted(self
):
1008 vim_info.get('status') is DELETED
1011 logger
= "test_logger"
1012 my_vims
= "test-vim"
1014 "vim_openstack_1": {
1018 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1020 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1021 ), patch
.object(instance
, "logger", logging
), patch
.object(
1022 instance
, "db_vims", db_vims
1028 "target_id": "vim_openstack_1",
1031 "created_items": None,
1032 "vim_id": "test-vim-id",
1033 "vim_name": "test-vim",
1034 "vim_status": "BUILD",
1036 "vim_message": None,
1039 "modified_at": 163724200.994312,
1040 "created_at": 1637324200.994312,
1041 "to_check_at": 1637324200.994312,
1044 self
.target_vim
.refresh_nets_status
.return_value
= {
1046 "vim_info": "some-details",
1047 "status": "DELETED",
1049 "error_msg": "some error message",
1052 task_status
= "FAILED"
1053 ro_vim_item_update
= {
1054 "vim_status": "DELETED",
1055 "vim_message": "Deleted externally",
1058 result
= instance
.refresh(ro_task
)
1059 self
.assertEqual(result
[0], task_status
)
1060 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1062 def test__refresh_ro_task_empty_vim_dict(self
):
1064 vim_dict does not include vim_id key
1068 logger
= "test_logger"
1069 my_vims
= "test-vim"
1071 "vim_openstack_2": {
1075 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1077 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1078 ), patch
.object(instance
, "logger", logging
), patch
.object(
1079 instance
, "db_vims", db_vims
1085 "target_id": "vim_openstack_2",
1088 "created_items": None,
1089 "vim_id": "test-vim-id",
1090 "vim_name": "test-vim",
1091 "vim_status": "BUILD",
1093 "vim_message": None,
1096 "modified_at": 163724211.994312,
1097 "created_at": 1637324211.994312,
1098 "to_check_at": 1637324211.994312,
1101 self
.target_vim
.refresh_nets_status
.return_value
= {}
1102 with self
.assertRaises(KeyError):
1103 instance
.refresh(ro_task
)
1106 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1108 module_name
= "osm_ro_plugin"
1109 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1110 self
.task_depends
= None
1112 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1114 # Enabling mocks and add cleanups
1115 for mock
in patches
:
1117 self
.addCleanup(mock
.stop
)
1119 def test__new_affinity_group_ok(self
):
1121 create affinity group with attributes set in params
1124 logger
= "test_logger"
1125 my_vims
= "test-vim"
1132 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1133 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1134 instance
, "logger", logging
1135 ), patch
.object(instance
, "db_vims", db_vims
):
1141 "action_id": "123456",
1143 "task_id": "123456:1",
1144 "status": "SCHEDULED",
1146 "item": "test_item",
1147 "target_record": "test_target_record",
1148 "target_record_id": "test_target_record_id",
1149 # values coming from extra_dict
1151 "affinity_group_data": {
1152 "name": "affinity_group_1",
1154 "scope": "nfvi-node",
1158 "depends_on": "test_depends_on",
1163 task_index
= "task_index_1"
1164 self
.target_vim
.new_affinity_group
.return_value
= (
1165 "sample_affinity_group_id_1"
1167 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1168 self
.assertEqual(result
[0], "DONE")
1169 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1170 self
.assertEqual(result
[1].get("created"), True)
1171 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1173 def test__new_affinity_group_failed(self
):
1175 create affinity group with no attributes set in params
1178 logger
= "test_logger"
1179 my_vims
= "test-vim"
1186 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1187 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1188 instance
, "logger", logging
1189 ), patch
.object(instance
, "db_vims", db_vims
):
1195 "action_id": "123456",
1197 "task_id": "123456:1",
1198 "status": "SCHEDULED",
1200 "item": "test_item",
1201 "target_record": "test_target_record",
1202 "target_record_id": "test_target_record_id",
1203 # values coming from extra_dict
1206 "depends_on": "test_depends_on",
1211 task_index
= "task_index_2"
1212 self
.target_vim
.new_affinity_group
.return_value
= (
1213 "sample_affinity_group_id_1"
1215 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1216 self
.assertEqual(result
[0], "DONE")
1217 self
.assertEqual(result
[1].get("vim_id"), None)
1218 self
.assertEqual(result
[1].get("created"), False)
1219 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1221 def test__delete_affinity_group_ok(self
):
1223 delete affinity group with a proper vim_id
1226 logger
= "test_logger"
1227 my_vims
= "test-vim"
1234 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1235 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1236 instance
, "logger", logging
1237 ), patch
.object(instance
, "db_vims", db_vims
):
1243 "task_id": "123456:1",
1248 "created_items": None,
1249 "vim_id": "sample_affinity_group_id_3",
1250 "vim_name": "sample_affinity_group_id_3",
1252 "vim_details": "some-details",
1253 "vim_message": None,
1258 task_index
= "task_index_3"
1259 self
.target_vim
.delete_affinity_group
.return_value
= (
1260 "sample_affinity_group_id_3"
1262 result
= instance
.delete(ro_task
, task_index
)
1263 self
.assertEqual(result
[0], "DONE")
1264 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1265 self
.assertEqual(result
[1].get("created"), False)
1266 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1268 def test__delete_affinity_group_failed(self
):
1270 delete affinity group with missing vim_id
1273 logger
= "test_logger"
1274 my_vims
= "test-vim"
1281 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1282 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1283 instance
, "logger", logging
1284 ), patch
.object(instance
, "db_vims", db_vims
):
1290 "task_id": "123456:1",
1295 "created_items": None,
1299 "vim_details": "some-details",
1300 "vim_message": None,
1305 task_index
= "task_index_4"
1306 self
.target_vim
.delete_affinity_group
.return_value
= ""
1307 result
= instance
.delete(ro_task
, task_index
)
1308 self
.assertEqual(result
[0], "DONE")
1309 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1310 self
.assertEqual(result
[1].get("created"), False)
1311 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1314 class TestVimInteractionResize(unittest
.TestCase
):
1316 module_name
= "osm_ro_plugin"
1317 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1318 self
.task_depends
= None
1320 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1322 # Enabling mocks and add cleanups
1323 for mock
in patches
:
1325 self
.addCleanup(mock
.stop
)
1327 def test__exec_resize_done(self
):
1329 create verticalscale task
1332 logger
= "test_logger"
1333 my_vims
= "test-vim"
1339 target_record_id
= (
1340 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1341 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1344 instance
= VimInteractionResize(db
, logger
, my_vims
, db_vims
)
1345 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1346 instance
, "logger", logging
1347 ), patch
.object(instance
, "db_vims", db_vims
):
1353 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1354 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1355 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1356 "status": "SCHEDULED",
1358 "item": "verticalscale",
1359 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1360 "target_record_id": target_record_id
,
1362 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1363 "flavor_dict": "flavor_dict",
1368 task_index
= "task_index_1"
1369 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1370 self
.assertEqual(result
[0], "DONE")
1371 self
.assertEqual(result
[1].get("vim_status"), "DONE")