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 VimInteractionAffinityGroup
, VimInteractionNet
23 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
26 class TestVimInteractionNet(unittest
.TestCase
):
28 module_name
= "osm_ro_plugin"
29 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
30 self
.task_depends
= None
32 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
34 # Enabling mocks and add cleanups
37 self
.addCleanup(mock
.stop
)
39 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
41 mgmt network is set in find_params
42 management_network_id in vim config
43 More than one network found in the VIM
46 logger
= "test_logger"
51 "management_network_id": "test_mgmt_id",
56 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
57 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
58 instance
, "logger", logging
59 ), patch
.object(instance
, "db_vims", db_vims
):
65 "action_id": "123456",
67 "task_id": "123456:1",
68 "status": "SCHEDULED",
71 "target_record": "test_target_record",
72 "target_record_id": "test_target_record_id",
73 # values coming from extra_dict
77 "name": "some_mgmt_name",
79 "depends_on": "test_depends_on",
84 task_index
= "task_index_2"
85 self
.target_vim
.get_network_list
.return_value
= [
86 {"id": "existing_net_1"},
87 {"id": "existing_net_2"},
89 with self
.assertLogs() as captured
:
90 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
91 self
.assertEqual(len(captured
.records
), 1)
93 "More than one network found with this criteria"
94 in captured
.records
[0].getMessage()
96 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
97 self
.assertEqual(result
[0], "FAILED")
98 self
.assertEqual(result
[1].get("created"), False)
99 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
101 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
103 mgmt network is set in find_params
104 management_network_id in vim config
105 The network could not be found in the VIM
108 logger
= "test_logger"
113 "management_network_id": "test_mgmt_id",
118 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
119 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
120 instance
, "db_vims", db_vims
121 ), patch
.object(instance
, "logger", logging
):
127 "action_id": "123456",
129 "task_id": "123456:1",
130 "status": "SCHEDULED",
133 "target_record": "test_target_record",
134 "target_record_id": "test_target_record_id",
136 # values coming from extra_dict
139 "name": "some_mgmt_name",
141 "depends_on": "test_depends_on",
146 task_index
= "task_index_3"
147 self
.target_vim
.get_network_list
.return_value
= []
148 with self
.assertLogs() as captured
:
149 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
150 self
.assertEqual(len(captured
.records
), 1)
152 "Network not found with this criteria"
153 in captured
.records
[0].getMessage()
155 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
156 self
.assertEqual(result
[0], "FAILED")
157 self
.assertEqual(result
[1].get("created"), False)
158 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
160 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
162 mgmt network is set in find_params
163 vim config does not have management_network_id or management_network_id
164 The network could not be found in the VIM
167 logger
= "test_logger"
175 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
176 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
177 instance
, "db_vims", db_vims
178 ), patch
.object(instance
, "logger", logging
):
184 "action_id": "123456",
186 "task_id": "123456:1",
187 "status": "SCHEDULED",
190 "target_record": "test_target_record",
191 "target_record_id": "test_target_record_id",
193 # values coming from extra_dict
196 "name": "some_mgmt_name",
198 "depends_on": "test_depends_on",
203 task_index
= "task_index_3"
204 self
.target_vim
.get_network_list
.return_value
= []
205 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
206 "item1": "sample_created_item"
208 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
209 self
.assertEqual(result
[0], "BUILD")
210 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
211 self
.assertEqual(result
[1].get("created"), True)
212 self
.assertDictEqual(
213 result
[1].get("created_items"), {"item1": "sample_created_item"}
215 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
217 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
219 mgmt network is set in find_params
220 management_network_name in vim config
221 More than one network found in the VIM
224 logger
= "test_logger"
229 "management_network_name": "test_mgmt_name",
234 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
235 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
236 instance
, "logger", logging
237 ), patch
.object(instance
, "db_vims", db_vims
):
243 "action_id": "123456",
245 "task_id": "123456:1",
246 "status": "SCHEDULED",
249 "target_record": "test_target_record",
250 "target_record_id": "test_target_record_id",
251 # values coming from extra_dict
255 "name": "some_mgmt_name",
257 "depends_on": "test_depends_on",
262 task_index
= "task_index_4"
263 self
.target_vim
.get_network_list
.return_value
= [
264 {"id": "existing_net_1"},
265 {"id": "existing_net_2"},
267 with self
.assertLogs() as captured
:
268 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
269 self
.assertEqual(len(captured
.records
), 1)
271 "More than one network found with this criteria"
272 in captured
.records
[0].getMessage()
274 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
275 self
.assertEqual(result
[0], "FAILED")
276 self
.assertEqual(result
[1].get("created"), False)
277 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
279 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
281 mgmt network is set in find_params
282 management_network_name in vim config
283 The network could not be found in the VIM
286 logger
= "test_logger"
291 "management_network_name": "test_mgmt_name",
296 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
297 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
298 instance
, "logger", logging
299 ), patch
.object(instance
, "db_vims", db_vims
):
305 "action_id": "123456",
307 "task_id": "123456:1",
308 "status": "SCHEDULED",
311 "target_record": "test_target_record",
312 "target_record_id": "test_target_record_id",
313 # values coming from extra_dict
317 "name": "some_mgmt_name",
319 "depends_on": "test_depends_on",
324 task_index
= "task_index_5"
325 self
.target_vim
.get_network_list
.return_value
= []
326 with self
.assertLogs() as captured
:
327 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
328 self
.assertEqual(len(captured
.records
), 1)
330 "Network not found with this criteria"
331 in captured
.records
[0].getMessage()
333 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
334 self
.assertEqual(result
[0], "FAILED")
335 self
.assertEqual(result
[1].get("created"), False)
336 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
338 def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self
):
340 mgmt network is set in find_params
341 management_network_name in vim config
342 network_name is set in find_params.get('filterdict')
343 More than one network found in the VIM
346 logger
= "test_logger"
351 "management_network_name": "test_mgmt_name",
355 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
356 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
357 instance
, "logger", logging
358 ), patch
.object(instance
, "db_vims", db_vims
):
364 "action_id": "123456",
366 "task_id": "123456:1",
367 "status": "SCHEDULED",
370 "target_record": "test_target_record",
371 "target_record_id": "test_target_record_id",
372 # values coming from extra_dict
376 "name": "some-network-name",
379 "name": "some_mgmt_name",
381 "depends_on": "test_depends_on",
386 task_index
= "task_index_6"
387 self
.target_vim
.get_network_list
.return_value
= [
388 {"id": "existing_net_1"},
389 {"id": "existing_net_2"},
391 with self
.assertLogs() as captured
:
392 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
393 self
.assertEqual(len(captured
.records
), 1)
395 "More than one network found with this criteria"
396 in captured
.records
[0].getMessage()
398 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
399 self
.assertEqual(result
[0], "FAILED")
400 self
.assertEqual(result
[1].get("created"), False)
401 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
403 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
405 There is find_params in the task
406 No mgmt in find_params
407 No filter_dict in find_params
410 logger
= "test_logger"
415 "management_network_name": "test_mgmt_name",
419 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
420 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
421 instance
, "logger", logging
422 ), patch
.object(instance
, "db_vims", db_vims
):
428 "action_id": "123456",
430 "task_id": "123456:1",
431 "status": "SCHEDULED",
434 "target_record": "test_target_record",
435 "target_record_id": "test_target_record_id",
436 # values coming from extra_dict
438 "find_params": {"wrong_param": "wrong_value"},
439 "depends_on": "test_depends_on",
444 task_index
= "task_index_4"
445 with self
.assertLogs() as captured
:
446 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
447 self
.assertEqual(len(captured
.records
), 1)
449 "Invalid find_params for new_net"
450 in captured
.records
[0].getMessage()
452 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
453 self
.assertEqual(result
[0], "FAILED")
454 self
.assertEqual(result
[1].get("created"), False)
455 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
457 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
459 management_network_name in find_params.get('filterdict')
460 The network could not be found in the VIM
461 There are items in the task.get(params)
464 logger
= "test_logger"
469 "management_network_name": "test_mgmt_name",
473 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
474 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
475 instance
, "logger", logging
476 ), patch
.object(instance
, "db_vims", db_vims
):
482 "action_id": "123456",
484 "task_id": "123456:1",
485 "status": "SCHEDULED",
488 "target_record": "test_target_record",
489 "target_record_id": "test_target_record_id",
490 # values coming from extra_dict
492 "net_name": "test_params",
496 "name": "some-network-name",
499 "name": "some_mgmt_name",
501 "depends_on": "test_depends_on",
506 task_index
= "task_index_8"
507 self
.target_vim
.get_network_list
.return_value
= []
508 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
509 self
.assertEqual(result
[0], "BUILD")
510 self
.assertEqual(result
[1].get("created"), False)
511 self
.assertEqual(result
[1].get("vim_id"), None)
512 self
.assertEqual(result
[1].get("created_items"), {})
513 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
515 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
517 mgmt network is set in find_params
518 management_network_name in vim config
519 network_name is set in find_params.get('filterdict')
520 Any network could not be found in the VIM
523 logger
= "test_logger"
528 "management_network_name": "test_mgmt_name",
532 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
533 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
534 instance
, "logger", logging
535 ), patch
.object(instance
, "db_vims", db_vims
):
541 "action_id": "123456",
543 "task_id": "123456:1",
544 "status": "SCHEDULED",
547 "target_record": "test_target_record",
548 "target_record_id": "test_target_record_id",
549 # values coming from extra_dict
553 "name": "some-network-name",
556 "name": "some_mgmt_name",
558 "depends_on": "test_depends_on",
563 task_index
= "task_index_9"
564 self
.target_vim
.get_network_list
.return_value
= []
565 with self
.assertLogs() as captured
:
566 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
567 self
.assertEqual(len(captured
.records
), 1)
569 "Network not found with this criteria"
570 in captured
.records
[0].getMessage()
572 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
573 self
.assertEqual(result
[0], "FAILED")
574 self
.assertEqual(result
[1].get("created"), False)
575 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
577 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
579 mgmt network is set in find_params
581 network_name is set in find_params.get('filterdict')
582 Any network could not be found in the VIM
585 logger
= "test_logger"
592 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
593 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
594 instance
, "logger", logging
595 ), patch
.object(instance
, "db_vims", db_vims
):
601 "action_id": "123456",
603 "task_id": "123456:1",
604 "status": "SCHEDULED",
607 "target_record": "test_target_record",
608 "target_record_id": "test_target_record_id",
609 # values coming from extra_dict
613 "name": "some-network-name",
616 "name": "some_mgmt_name",
618 "depends_on": "test_depends_on",
623 task_index
= "task_index_9"
624 self
.target_vim
.get_network_list
.return_value
= []
625 with self
.assertLogs() as captured
:
626 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
627 self
.assertEqual(len(captured
.records
), 1)
629 "Network not found with this criteria"
630 in captured
.records
[0].getMessage()
632 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
633 self
.assertEqual(result
[0], "FAILED")
634 self
.assertEqual(result
[1].get("created"), False)
635 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
637 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
639 mgmt network is set in find_params
640 management_network_name is not in db_vims.get('config')
641 One network found in the VIM
644 logger
= "test_logger"
651 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
652 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
653 instance
, "logger", logging
654 ), patch
.object(instance
, "db_vims", db_vims
):
660 "action_id": "123456",
662 "task_id": "123456:1",
663 "status": "SCHEDULED",
666 "target_record": "test_target_record",
667 "target_record_id": "test_target_record_id",
668 # values coming from extra_dict
672 "name": "some_mgmt_name",
674 "depends_on": "test_depends_on",
679 task_index
= "task_index_2"
680 self
.target_vim
.get_network_list
.return_value
= [
681 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
683 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
684 self
.assertEqual(result
[0], "BUILD")
685 self
.assertEqual(result
[1].get("created"), False)
686 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
688 def test__params_in_task_no_find_params(self
):
691 find_params does not exist in the task
694 logger
= "test_logger"
699 "management_network_name": "test_mgmt_name",
703 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
704 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
705 instance
, "logger", logging
706 ), patch
.object(instance
, "db_vims", db_vims
):
712 "action_id": "123456",
714 "task_id": "123456:1",
715 "status": "SCHEDULED",
718 "target_record": "test_target_record",
719 "target_record_id": "test_target_record_id",
720 # values coming from extra_dict
722 "net_name": "test-network",
725 "depends_on": "test_depends_on",
730 task_index
= "task_index_11"
731 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
732 "item1": "sample_created_item"
734 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
735 self
.assertEqual(result
[0], "BUILD")
736 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
737 self
.assertEqual(result
[1].get("created"), True)
739 result
[1].get("created_items"), {"item1": "sample_created_item"}
741 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
743 def test__no_params_in_task_no_find_params(self
):
745 empty params in the task
746 find_params does not exist in the task
749 logger
= "test_logger"
754 "management_network_name": "test_mgmt_name",
758 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
759 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
760 instance
, "logger", logging
761 ), patch
.object(instance
, "db_vims", db_vims
):
767 "action_id": "123456",
769 "task_id": "123456:1",
770 "status": "SCHEDULED",
773 "target_record": "test_target_record",
774 "target_record_id": "test_target_record_id",
775 # values coming from extra_dict
777 "depends_on": "test_depends_on",
782 task_index
= "task_index_12"
783 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
784 "VimConnConnectionException occurred."
786 with self
.assertLogs() as captured
:
787 instance
.new(ro_task
, task_index
, self
.task_depends
)
788 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
790 def test__refresh_ro_task_vim_status_active(self
):
792 vim_info.get('status') is ACTIVE
795 logger
= "test_logger"
802 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
804 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
805 ), patch
.object(instance
, "logger", logging
), patch
.object(
806 instance
, "db_vims", db_vims
812 "target_id": "vim_openstack_1",
815 "created_items": None,
816 "vim_id": "test-vim-id",
817 "vim_name": "test-vim",
819 "vim_details": "some-details",
822 "modified_at": 1637324200.994312,
823 "created_at": 1637324200.994312,
824 "to_check_at": 1637324200.994312,
828 self
.target_vim
.refresh_nets_status
.return_value
= {
830 "vim_info": "some-details",
837 ro_vim_item_update
= {
838 "vim_status": "ACTIVE",
840 result
= instance
.refresh(ro_task
)
841 self
.assertEqual(result
[0], task_status
)
842 self
.assertDictEqual(result
[1], ro_vim_item_update
)
844 def test__refresh_ro_task_vim_status_build(self
):
846 vim_info.get('status') is BUILD
849 logger
= "test_logger"
856 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
858 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
859 ), patch
.object(instance
, "logger", logging
), patch
.object(
860 instance
, "db_vims", db_vims
866 "target_id": "vim_openstack_1",
869 "created_items": None,
870 "vim_id": "test-vim-id",
871 "vim_name": "test-vim",
872 "vim_status": "BUILD",
876 "modified_at": 1637324200.994312,
877 "created_at": 1637324200.994312,
878 "to_check_at": 1637324200.994312,
882 self
.target_vim
.refresh_nets_status
.return_value
= {
884 "vim_info": "some-details",
890 task_status
= "BUILD"
891 ro_vim_item_update
= {
892 "vim_name": "other-vim",
893 "vim_details": "some-details",
895 result
= instance
.refresh(ro_task
)
896 self
.assertEqual(result
[0], task_status
)
897 self
.assertDictEqual(result
[1], ro_vim_item_update
)
899 def test__refresh_ro_task_vim_status_error(self
):
901 vim_info.get('status') is ERROR
904 logger
= "test_logger"
911 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
913 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
914 ), patch
.object(instance
, "logger", logging
), patch
.object(
915 instance
, "db_vims", db_vims
921 "target_id": "vim_openstack_1",
924 "created_items": None,
925 "vim_id": "test-vim-id",
926 "vim_name": "test-vim",
927 "vim_status": "BUILD",
931 "modified_at": 1637324200.994312,
932 "created_at": 1637324200.994312,
933 "to_check_at": 1637324200.994312,
937 self
.target_vim
.refresh_nets_status
.return_value
= {
939 "vim_info": "some-details",
942 "error_msg": "some error message",
945 task_status
= "FAILED"
946 ro_vim_item_update
= {
947 "vim_status": "ERROR",
948 "vim_details": "some error message",
950 result
= instance
.refresh(ro_task
)
951 self
.assertEqual(result
[0], task_status
)
952 self
.assertDictEqual(result
[1], ro_vim_item_update
)
954 def test__refresh_ro_task_VimConnException_occurred(self
):
956 vimconn.VimConnException has occured
959 logger
= "test_logger"
966 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
968 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
969 ), patch
.object(instance
, "logger", logging
), patch
.object(
970 instance
, "db_vims", db_vims
976 "target_id": "vim_openstack_1",
979 "created_items": None,
980 "vim_id": "test-vim-id",
981 "vim_name": "test-vim",
982 "vim_status": "BUILD",
986 "modified_at": 1637324200.994312,
987 "created_at": 1637324200.994312,
988 "to_check_at": 1637324200.994312,
991 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
992 "VimConnException occurred."
994 with self
.assertLogs() as captured
:
995 instance
.refresh(ro_task
)
996 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
998 def test__refresh_ro_task_vim_status_deleted(self
):
1000 vim_info.get('status') is DELETED
1003 logger
= "test_logger"
1004 my_vims
= "test-vim"
1006 "vim_openstack_1": {
1010 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1012 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1013 ), patch
.object(instance
, "logger", logging
), patch
.object(
1014 instance
, "db_vims", db_vims
1020 "target_id": "vim_openstack_1",
1023 "created_items": None,
1024 "vim_id": "test-vim-id",
1025 "vim_name": "test-vim",
1026 "vim_status": "BUILD",
1030 "modified_at": 163724200.994312,
1031 "created_at": 1637324200.994312,
1032 "to_check_at": 1637324200.994312,
1035 self
.target_vim
.refresh_nets_status
.return_value
= {
1037 "vim_info": "some-details",
1038 "status": "DELETED",
1040 "error_msg": "some error message",
1043 task_status
= "FAILED"
1044 ro_vim_item_update
= {
1045 "vim_status": "DELETED",
1046 "vim_details": "Deleted externally",
1049 result
= instance
.refresh(ro_task
)
1050 self
.assertEqual(result
[0], task_status
)
1051 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1053 def test__refresh_ro_task_empty_vim_dict(self
):
1055 vim_dict does not include vim_id key
1059 logger
= "test_logger"
1060 my_vims
= "test-vim"
1062 "vim_openstack_2": {
1066 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1068 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1069 ), patch
.object(instance
, "logger", logging
), patch
.object(
1070 instance
, "db_vims", db_vims
1076 "target_id": "vim_openstack_2",
1079 "created_items": None,
1080 "vim_id": "test-vim-id",
1081 "vim_name": "test-vim",
1082 "vim_status": "BUILD",
1086 "modified_at": 163724211.994312,
1087 "created_at": 1637324211.994312,
1088 "to_check_at": 1637324211.994312,
1091 self
.target_vim
.refresh_nets_status
.return_value
= {}
1092 with self
.assertRaises(KeyError):
1093 instance
.refresh(ro_task
)
1096 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1098 module_name
= "osm_ro_plugin"
1099 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1100 self
.task_depends
= None
1102 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1104 # Enabling mocks and add cleanups
1105 for mock
in patches
:
1107 self
.addCleanup(mock
.stop
)
1109 def test__new_affinity_group_ok(self
):
1111 create affinity group with attributes set in params
1114 logger
= "test_logger"
1115 my_vims
= "test-vim"
1122 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1123 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1124 instance
, "logger", logging
1125 ), patch
.object(instance
, "db_vims", db_vims
):
1131 "action_id": "123456",
1133 "task_id": "123456:1",
1134 "status": "SCHEDULED",
1136 "item": "test_item",
1137 "target_record": "test_target_record",
1138 "target_record_id": "test_target_record_id",
1139 # values coming from extra_dict
1141 "affinity_group_data": {
1142 "name": "affinity_group_1",
1144 "scope": "nfvi-node",
1148 "depends_on": "test_depends_on",
1153 task_index
= "task_index_1"
1154 self
.target_vim
.new_affinity_group
.return_value
= (
1155 "sample_affinity_group_id_1"
1157 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1158 self
.assertEqual(result
[0], "DONE")
1159 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1160 self
.assertEqual(result
[1].get("created"), True)
1161 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1163 def test__new_affinity_group_failed(self
):
1165 create affinity group with no attributes set in params
1168 logger
= "test_logger"
1169 my_vims
= "test-vim"
1176 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1177 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1178 instance
, "logger", logging
1179 ), patch
.object(instance
, "db_vims", db_vims
):
1185 "action_id": "123456",
1187 "task_id": "123456:1",
1188 "status": "SCHEDULED",
1190 "item": "test_item",
1191 "target_record": "test_target_record",
1192 "target_record_id": "test_target_record_id",
1193 # values coming from extra_dict
1196 "depends_on": "test_depends_on",
1201 task_index
= "task_index_2"
1202 self
.target_vim
.new_affinity_group
.return_value
= (
1203 "sample_affinity_group_id_1"
1205 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1206 self
.assertEqual(result
[0], "DONE")
1207 self
.assertEqual(result
[1].get("vim_id"), None)
1208 self
.assertEqual(result
[1].get("created"), False)
1209 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1211 def test__delete_affinity_group_ok(self
):
1213 delete affinity group with a proper vim_id
1216 logger
= "test_logger"
1217 my_vims
= "test-vim"
1224 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1225 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1226 instance
, "logger", logging
1227 ), patch
.object(instance
, "db_vims", db_vims
):
1233 "task_id": "123456:1",
1238 "created_items": None,
1239 "vim_id": "sample_affinity_group_id_3",
1240 "vim_name": "sample_affinity_group_id_3",
1242 "vim_details": "some-details",
1247 task_index
= "task_index_3"
1248 self
.target_vim
.delete_affinity_group
.return_value
= (
1249 "sample_affinity_group_id_3"
1251 result
= instance
.delete(ro_task
, task_index
)
1252 self
.assertEqual(result
[0], "DONE")
1253 self
.assertEqual(result
[1].get("vim_details"), "DELETED")
1254 self
.assertEqual(result
[1].get("created"), False)
1255 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1257 def test__delete_affinity_group_failed(self
):
1259 delete affinity group with missing vim_id
1262 logger
= "test_logger"
1263 my_vims
= "test-vim"
1270 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1271 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1272 instance
, "logger", logging
1273 ), patch
.object(instance
, "db_vims", db_vims
):
1279 "task_id": "123456:1",
1284 "created_items": None,
1288 "vim_details": "some-details",
1293 task_index
= "task_index_4"
1294 self
.target_vim
.delete_affinity_group
.return_value
= ""
1295 result
= instance
.delete(ro_task
, task_index
)
1296 self
.assertEqual(result
[0], "DONE")
1297 self
.assertEqual(result
[1].get("vim_details"), "DELETED")
1298 self
.assertEqual(result
[1].get("created"), False)
1299 self
.assertEqual(result
[1].get("vim_status"), "DELETED")