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",
823 "modified_at": 1637324200.994312,
824 "created_at": 1637324200.994312,
825 "to_check_at": 1637324200.994312,
829 self
.target_vim
.refresh_nets_status
.return_value
= {
831 "vim_info": "some-details",
838 ro_vim_item_update
= {
839 "vim_status": "ACTIVE",
841 result
= instance
.refresh(ro_task
)
842 self
.assertEqual(result
[0], task_status
)
843 self
.assertDictEqual(result
[1], ro_vim_item_update
)
845 def test__refresh_ro_task_vim_status_build(self
):
847 vim_info.get('status') is BUILD
850 logger
= "test_logger"
857 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
859 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
860 ), patch
.object(instance
, "logger", logging
), patch
.object(
861 instance
, "db_vims", db_vims
867 "target_id": "vim_openstack_1",
870 "created_items": None,
871 "vim_id": "test-vim-id",
872 "vim_name": "test-vim",
873 "vim_status": "BUILD",
878 "modified_at": 1637324200.994312,
879 "created_at": 1637324200.994312,
880 "to_check_at": 1637324200.994312,
884 self
.target_vim
.refresh_nets_status
.return_value
= {
886 "vim_info": "some-details",
892 task_status
= "BUILD"
893 ro_vim_item_update
= {
894 "vim_name": "other-vim",
895 "vim_details": "some-details",
897 result
= instance
.refresh(ro_task
)
898 self
.assertEqual(result
[0], task_status
)
899 self
.assertDictEqual(result
[1], ro_vim_item_update
)
901 def test__refresh_ro_task_vim_status_error(self
):
903 vim_info.get('status') is ERROR
906 logger
= "test_logger"
913 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
915 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
916 ), patch
.object(instance
, "logger", logging
), patch
.object(
917 instance
, "db_vims", db_vims
923 "target_id": "vim_openstack_1",
926 "created_items": None,
927 "vim_id": "test-vim-id",
928 "vim_name": "test-vim",
929 "vim_status": "BUILD",
934 "modified_at": 1637324200.994312,
935 "created_at": 1637324200.994312,
936 "to_check_at": 1637324200.994312,
940 self
.target_vim
.refresh_nets_status
.return_value
= {
942 "vim_info": "some-details",
945 "error_msg": "some error message",
948 task_status
= "FAILED"
949 ro_vim_item_update
= {
950 "vim_status": "ERROR",
951 "vim_message": "some error message",
953 result
= instance
.refresh(ro_task
)
954 self
.assertEqual(result
[0], task_status
)
955 self
.assertDictEqual(result
[1], ro_vim_item_update
)
957 def test__refresh_ro_task_VimConnException_occurred(self
):
959 vimconn.VimConnException has occured
962 logger
= "test_logger"
969 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
971 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
972 ), patch
.object(instance
, "logger", logging
), patch
.object(
973 instance
, "db_vims", db_vims
979 "target_id": "vim_openstack_1",
982 "created_items": None,
983 "vim_id": "test-vim-id",
984 "vim_name": "test-vim",
985 "vim_status": "BUILD",
990 "modified_at": 1637324200.994312,
991 "created_at": 1637324200.994312,
992 "to_check_at": 1637324200.994312,
995 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
996 "VimConnException occurred."
998 with self
.assertLogs() as captured
:
999 instance
.refresh(ro_task
)
1000 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1002 def test__refresh_ro_task_vim_status_deleted(self
):
1004 vim_info.get('status') is DELETED
1007 logger
= "test_logger"
1008 my_vims
= "test-vim"
1010 "vim_openstack_1": {
1014 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1016 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1017 ), patch
.object(instance
, "logger", logging
), patch
.object(
1018 instance
, "db_vims", db_vims
1024 "target_id": "vim_openstack_1",
1027 "created_items": None,
1028 "vim_id": "test-vim-id",
1029 "vim_name": "test-vim",
1030 "vim_status": "BUILD",
1032 "vim_message": None,
1035 "modified_at": 163724200.994312,
1036 "created_at": 1637324200.994312,
1037 "to_check_at": 1637324200.994312,
1040 self
.target_vim
.refresh_nets_status
.return_value
= {
1042 "vim_info": "some-details",
1043 "status": "DELETED",
1045 "error_msg": "some error message",
1048 task_status
= "FAILED"
1049 ro_vim_item_update
= {
1050 "vim_status": "DELETED",
1051 "vim_message": "Deleted externally",
1054 result
= instance
.refresh(ro_task
)
1055 self
.assertEqual(result
[0], task_status
)
1056 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1058 def test__refresh_ro_task_empty_vim_dict(self
):
1060 vim_dict does not include vim_id key
1064 logger
= "test_logger"
1065 my_vims
= "test-vim"
1067 "vim_openstack_2": {
1071 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1073 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1074 ), patch
.object(instance
, "logger", logging
), patch
.object(
1075 instance
, "db_vims", db_vims
1081 "target_id": "vim_openstack_2",
1084 "created_items": None,
1085 "vim_id": "test-vim-id",
1086 "vim_name": "test-vim",
1087 "vim_status": "BUILD",
1089 "vim_message": None,
1092 "modified_at": 163724211.994312,
1093 "created_at": 1637324211.994312,
1094 "to_check_at": 1637324211.994312,
1097 self
.target_vim
.refresh_nets_status
.return_value
= {}
1098 with self
.assertRaises(KeyError):
1099 instance
.refresh(ro_task
)
1102 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1104 module_name
= "osm_ro_plugin"
1105 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1106 self
.task_depends
= None
1108 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1110 # Enabling mocks and add cleanups
1111 for mock
in patches
:
1113 self
.addCleanup(mock
.stop
)
1115 def test__new_affinity_group_ok(self
):
1117 create affinity group with attributes set in params
1120 logger
= "test_logger"
1121 my_vims
= "test-vim"
1128 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1129 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1130 instance
, "logger", logging
1131 ), patch
.object(instance
, "db_vims", db_vims
):
1137 "action_id": "123456",
1139 "task_id": "123456:1",
1140 "status": "SCHEDULED",
1142 "item": "test_item",
1143 "target_record": "test_target_record",
1144 "target_record_id": "test_target_record_id",
1145 # values coming from extra_dict
1147 "affinity_group_data": {
1148 "name": "affinity_group_1",
1150 "scope": "nfvi-node",
1154 "depends_on": "test_depends_on",
1159 task_index
= "task_index_1"
1160 self
.target_vim
.new_affinity_group
.return_value
= (
1161 "sample_affinity_group_id_1"
1163 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1164 self
.assertEqual(result
[0], "DONE")
1165 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1166 self
.assertEqual(result
[1].get("created"), True)
1167 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1169 def test__new_affinity_group_failed(self
):
1171 create affinity group with no attributes set in params
1174 logger
= "test_logger"
1175 my_vims
= "test-vim"
1182 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1183 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1184 instance
, "logger", logging
1185 ), patch
.object(instance
, "db_vims", db_vims
):
1191 "action_id": "123456",
1193 "task_id": "123456:1",
1194 "status": "SCHEDULED",
1196 "item": "test_item",
1197 "target_record": "test_target_record",
1198 "target_record_id": "test_target_record_id",
1199 # values coming from extra_dict
1202 "depends_on": "test_depends_on",
1207 task_index
= "task_index_2"
1208 self
.target_vim
.new_affinity_group
.return_value
= (
1209 "sample_affinity_group_id_1"
1211 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1212 self
.assertEqual(result
[0], "DONE")
1213 self
.assertEqual(result
[1].get("vim_id"), None)
1214 self
.assertEqual(result
[1].get("created"), False)
1215 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1217 def test__delete_affinity_group_ok(self
):
1219 delete affinity group with a proper vim_id
1222 logger
= "test_logger"
1223 my_vims
= "test-vim"
1230 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1231 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1232 instance
, "logger", logging
1233 ), patch
.object(instance
, "db_vims", db_vims
):
1239 "task_id": "123456:1",
1244 "created_items": None,
1245 "vim_id": "sample_affinity_group_id_3",
1246 "vim_name": "sample_affinity_group_id_3",
1248 "vim_details": "some-details",
1249 "vim_message": None,
1254 task_index
= "task_index_3"
1255 self
.target_vim
.delete_affinity_group
.return_value
= (
1256 "sample_affinity_group_id_3"
1258 result
= instance
.delete(ro_task
, task_index
)
1259 self
.assertEqual(result
[0], "DONE")
1260 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1261 self
.assertEqual(result
[1].get("created"), False)
1262 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1264 def test__delete_affinity_group_failed(self
):
1266 delete affinity group with missing vim_id
1269 logger
= "test_logger"
1270 my_vims
= "test-vim"
1277 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1278 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1279 instance
, "logger", logging
1280 ), patch
.object(instance
, "db_vims", db_vims
):
1286 "task_id": "123456:1",
1291 "created_items": None,
1295 "vim_details": "some-details",
1296 "vim_message": None,
1301 task_index
= "task_index_4"
1302 self
.target_vim
.delete_affinity_group
.return_value
= ""
1303 result
= instance
.delete(ro_task
, task_index
)
1304 self
.assertEqual(result
[0], "DONE")
1305 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1306 self
.assertEqual(result
[1].get("created"), False)
1307 self
.assertEqual(result
[1].get("vim_status"), "DELETED")