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
,
24 VimInteractionMigration
,
28 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
31 class TestVimInteractionNet(unittest
.TestCase
):
33 module_name
= "osm_ro_plugin"
34 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
35 self
.task_depends
= None
37 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
39 # Enabling mocks and add cleanups
42 self
.addCleanup(mock
.stop
)
44 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
46 mgmt network is set in find_params
47 management_network_id in vim config
48 More than one network found in the VIM
51 logger
= "test_logger"
56 "management_network_id": "test_mgmt_id",
61 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
62 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
63 instance
, "logger", logging
64 ), patch
.object(instance
, "db_vims", db_vims
):
70 "action_id": "123456",
72 "task_id": "123456:1",
73 "status": "SCHEDULED",
76 "target_record": "test_target_record",
77 "target_record_id": "test_target_record_id",
78 # values coming from extra_dict
82 "name": "some_mgmt_name",
84 "depends_on": "test_depends_on",
89 task_index
= "task_index_2"
90 self
.target_vim
.get_network_list
.return_value
= [
91 {"id": "existing_net_1"},
92 {"id": "existing_net_2"},
94 with self
.assertLogs() as captured
:
95 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
96 self
.assertEqual(len(captured
.records
), 1)
98 "More than one network found with this criteria"
99 in captured
.records
[0].getMessage()
101 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
102 self
.assertEqual(result
[0], "FAILED")
103 self
.assertEqual(result
[1].get("created"), False)
104 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
106 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
108 mgmt network is set in find_params
109 management_network_id in vim config
110 The network could not be found in the VIM
113 logger
= "test_logger"
118 "management_network_id": "test_mgmt_id",
123 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
124 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
125 instance
, "db_vims", db_vims
126 ), patch
.object(instance
, "logger", logging
):
132 "action_id": "123456",
134 "task_id": "123456:1",
135 "status": "SCHEDULED",
138 "target_record": "test_target_record",
139 "target_record_id": "test_target_record_id",
141 # values coming from extra_dict
144 "name": "some_mgmt_name",
146 "depends_on": "test_depends_on",
151 task_index
= "task_index_3"
152 self
.target_vim
.get_network_list
.return_value
= []
153 with self
.assertLogs() as captured
:
154 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
155 self
.assertEqual(len(captured
.records
), 1)
157 "Network not found with this criteria"
158 in captured
.records
[0].getMessage()
160 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
161 self
.assertEqual(result
[0], "FAILED")
162 self
.assertEqual(result
[1].get("created"), False)
163 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
165 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
167 mgmt network is set in find_params
168 vim config does not have management_network_id or management_network_id
169 The network could not be found in the VIM
172 logger
= "test_logger"
180 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
181 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
182 instance
, "db_vims", db_vims
183 ), patch
.object(instance
, "logger", logging
):
189 "action_id": "123456",
191 "task_id": "123456:1",
192 "status": "SCHEDULED",
195 "target_record": "test_target_record",
196 "target_record_id": "test_target_record_id",
198 # values coming from extra_dict
201 "name": "some_mgmt_name",
203 "depends_on": "test_depends_on",
208 task_index
= "task_index_3"
209 self
.target_vim
.get_network_list
.return_value
= []
210 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
211 "item1": "sample_created_item"
213 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
214 self
.assertEqual(result
[0], "BUILD")
215 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
216 self
.assertEqual(result
[1].get("created"), True)
217 self
.assertDictEqual(
218 result
[1].get("created_items"), {"item1": "sample_created_item"}
220 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
222 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
224 mgmt network is set in find_params
225 management_network_name in vim config
226 More than one network found in the VIM
229 logger
= "test_logger"
234 "management_network_name": "test_mgmt_name",
239 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
240 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
241 instance
, "logger", logging
242 ), patch
.object(instance
, "db_vims", db_vims
):
248 "action_id": "123456",
250 "task_id": "123456:1",
251 "status": "SCHEDULED",
254 "target_record": "test_target_record",
255 "target_record_id": "test_target_record_id",
256 # values coming from extra_dict
260 "name": "some_mgmt_name",
262 "depends_on": "test_depends_on",
267 task_index
= "task_index_4"
268 self
.target_vim
.get_network_list
.return_value
= [
269 {"id": "existing_net_1"},
270 {"id": "existing_net_2"},
272 with self
.assertLogs() as captured
:
273 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
274 self
.assertEqual(len(captured
.records
), 1)
276 "More than one network found with this criteria"
277 in captured
.records
[0].getMessage()
279 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
280 self
.assertEqual(result
[0], "FAILED")
281 self
.assertEqual(result
[1].get("created"), False)
282 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
284 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
286 mgmt network is set in find_params
287 management_network_name in vim config
288 The network could not be found in the VIM
291 logger
= "test_logger"
296 "management_network_name": "test_mgmt_name",
301 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
302 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
303 instance
, "logger", logging
304 ), patch
.object(instance
, "db_vims", db_vims
):
310 "action_id": "123456",
312 "task_id": "123456:1",
313 "status": "SCHEDULED",
316 "target_record": "test_target_record",
317 "target_record_id": "test_target_record_id",
318 # values coming from extra_dict
322 "name": "some_mgmt_name",
324 "depends_on": "test_depends_on",
329 task_index
= "task_index_5"
330 self
.target_vim
.get_network_list
.return_value
= []
331 with self
.assertLogs() as captured
:
332 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
333 self
.assertEqual(len(captured
.records
), 1)
335 "Network not found with this criteria"
336 in captured
.records
[0].getMessage()
338 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
339 self
.assertEqual(result
[0], "FAILED")
340 self
.assertEqual(result
[1].get("created"), False)
341 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
343 def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self
):
345 mgmt network is set in find_params
346 management_network_name in vim config
347 network_name is set in find_params.get('filterdict')
348 More than one network found in the VIM
351 logger
= "test_logger"
356 "management_network_name": "test_mgmt_name",
360 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
361 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
362 instance
, "logger", logging
363 ), patch
.object(instance
, "db_vims", db_vims
):
369 "action_id": "123456",
371 "task_id": "123456:1",
372 "status": "SCHEDULED",
375 "target_record": "test_target_record",
376 "target_record_id": "test_target_record_id",
377 # values coming from extra_dict
381 "name": "some-network-name",
384 "name": "some_mgmt_name",
386 "depends_on": "test_depends_on",
391 task_index
= "task_index_6"
392 self
.target_vim
.get_network_list
.return_value
= [
393 {"id": "existing_net_1"},
394 {"id": "existing_net_2"},
396 with self
.assertLogs() as captured
:
397 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
398 self
.assertEqual(len(captured
.records
), 1)
400 "More than one network found with this criteria"
401 in captured
.records
[0].getMessage()
403 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
404 self
.assertEqual(result
[0], "FAILED")
405 self
.assertEqual(result
[1].get("created"), False)
406 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
408 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
410 There is find_params in the task
411 No mgmt in find_params
412 No filter_dict in find_params
415 logger
= "test_logger"
420 "management_network_name": "test_mgmt_name",
424 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
425 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
426 instance
, "logger", logging
427 ), patch
.object(instance
, "db_vims", db_vims
):
433 "action_id": "123456",
435 "task_id": "123456:1",
436 "status": "SCHEDULED",
439 "target_record": "test_target_record",
440 "target_record_id": "test_target_record_id",
441 # values coming from extra_dict
443 "find_params": {"wrong_param": "wrong_value"},
444 "depends_on": "test_depends_on",
449 task_index
= "task_index_4"
450 with self
.assertLogs() as captured
:
451 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
452 self
.assertEqual(len(captured
.records
), 1)
454 "Invalid find_params for new_net"
455 in captured
.records
[0].getMessage()
457 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
458 self
.assertEqual(result
[0], "FAILED")
459 self
.assertEqual(result
[1].get("created"), False)
460 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
462 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
464 management_network_name in find_params.get('filterdict')
465 The network could not be found in the VIM
466 There are items in the task.get(params)
469 logger
= "test_logger"
474 "management_network_name": "test_mgmt_name",
478 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
479 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
480 instance
, "logger", logging
481 ), patch
.object(instance
, "db_vims", db_vims
):
487 "action_id": "123456",
489 "task_id": "123456:1",
490 "status": "SCHEDULED",
493 "target_record": "test_target_record",
494 "target_record_id": "test_target_record_id",
495 # values coming from extra_dict
497 "net_name": "test_params",
501 "name": "some-network-name",
504 "name": "some_mgmt_name",
506 "depends_on": "test_depends_on",
511 task_index
= "task_index_8"
512 self
.target_vim
.get_network_list
.return_value
= []
513 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
514 self
.assertEqual(result
[0], "BUILD")
515 self
.assertEqual(result
[1].get("created"), False)
516 self
.assertEqual(result
[1].get("vim_id"), None)
517 self
.assertEqual(result
[1].get("created_items"), {})
518 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
520 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
522 mgmt network is set in find_params
523 management_network_name in vim config
524 network_name is set in find_params.get('filterdict')
525 Any network could not be found in the VIM
528 logger
= "test_logger"
533 "management_network_name": "test_mgmt_name",
537 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
538 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
539 instance
, "logger", logging
540 ), patch
.object(instance
, "db_vims", db_vims
):
546 "action_id": "123456",
548 "task_id": "123456:1",
549 "status": "SCHEDULED",
552 "target_record": "test_target_record",
553 "target_record_id": "test_target_record_id",
554 # values coming from extra_dict
558 "name": "some-network-name",
561 "name": "some_mgmt_name",
563 "depends_on": "test_depends_on",
568 task_index
= "task_index_9"
569 self
.target_vim
.get_network_list
.return_value
= []
570 with self
.assertLogs() as captured
:
571 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
572 self
.assertEqual(len(captured
.records
), 1)
574 "Network not found with this criteria"
575 in captured
.records
[0].getMessage()
577 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
578 self
.assertEqual(result
[0], "FAILED")
579 self
.assertEqual(result
[1].get("created"), False)
580 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
582 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
584 mgmt network is set in find_params
586 network_name is set in find_params.get('filterdict')
587 Any network could not be found in the VIM
590 logger
= "test_logger"
597 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
598 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
599 instance
, "logger", logging
600 ), patch
.object(instance
, "db_vims", db_vims
):
606 "action_id": "123456",
608 "task_id": "123456:1",
609 "status": "SCHEDULED",
612 "target_record": "test_target_record",
613 "target_record_id": "test_target_record_id",
614 # values coming from extra_dict
618 "name": "some-network-name",
621 "name": "some_mgmt_name",
623 "depends_on": "test_depends_on",
628 task_index
= "task_index_9"
629 self
.target_vim
.get_network_list
.return_value
= []
630 with self
.assertLogs() as captured
:
631 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
632 self
.assertEqual(len(captured
.records
), 1)
634 "Network not found with this criteria"
635 in captured
.records
[0].getMessage()
637 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
638 self
.assertEqual(result
[0], "FAILED")
639 self
.assertEqual(result
[1].get("created"), False)
640 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
642 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
644 mgmt network is set in find_params
645 management_network_name is not in db_vims.get('config')
646 One network found in the VIM
649 logger
= "test_logger"
656 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
657 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
658 instance
, "logger", logging
659 ), patch
.object(instance
, "db_vims", db_vims
):
665 "action_id": "123456",
667 "task_id": "123456:1",
668 "status": "SCHEDULED",
671 "target_record": "test_target_record",
672 "target_record_id": "test_target_record_id",
673 # values coming from extra_dict
677 "name": "some_mgmt_name",
679 "depends_on": "test_depends_on",
684 task_index
= "task_index_2"
685 self
.target_vim
.get_network_list
.return_value
= [
686 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
688 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
689 self
.assertEqual(result
[0], "BUILD")
690 self
.assertEqual(result
[1].get("created"), False)
691 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
693 def test__params_in_task_no_find_params(self
):
696 find_params does not exist in the task
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-network",
730 "depends_on": "test_depends_on",
735 task_index
= "task_index_11"
736 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
737 "item1": "sample_created_item"
739 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
740 self
.assertEqual(result
[0], "BUILD")
741 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
742 self
.assertEqual(result
[1].get("created"), True)
744 result
[1].get("created_items"), {"item1": "sample_created_item"}
746 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
748 def test__no_params_in_task_no_find_params(self
):
750 empty params in the task
751 find_params does not exist in the task
754 logger
= "test_logger"
759 "management_network_name": "test_mgmt_name",
763 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
764 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
765 instance
, "logger", logging
766 ), patch
.object(instance
, "db_vims", db_vims
):
772 "action_id": "123456",
774 "task_id": "123456:1",
775 "status": "SCHEDULED",
778 "target_record": "test_target_record",
779 "target_record_id": "test_target_record_id",
780 # values coming from extra_dict
782 "depends_on": "test_depends_on",
787 task_index
= "task_index_12"
788 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
789 "VimConnConnectionException occurred."
791 with self
.assertLogs() as captured
:
792 instance
.new(ro_task
, task_index
, self
.task_depends
)
793 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
795 def test__refresh_ro_task_vim_status_active(self
):
797 vim_info.get('status') is ACTIVE
800 logger
= "test_logger"
807 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
809 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
810 ), patch
.object(instance
, "logger", logging
), patch
.object(
811 instance
, "db_vims", db_vims
817 "target_id": "vim_openstack_1",
820 "created_items": None,
821 "vim_id": "test-vim-id",
822 "vim_name": "test-vim",
824 "vim_details": "some-details",
828 "modified_at": 1637324200.994312,
829 "created_at": 1637324200.994312,
830 "to_check_at": 1637324200.994312,
834 self
.target_vim
.refresh_nets_status
.return_value
= {
836 "vim_info": "some-details",
843 ro_vim_item_update
= {
844 "vim_status": "ACTIVE",
846 result
= instance
.refresh(ro_task
)
847 self
.assertEqual(result
[0], task_status
)
848 self
.assertDictEqual(result
[1], ro_vim_item_update
)
850 def test__refresh_ro_task_vim_status_build(self
):
852 vim_info.get('status') is BUILD
855 logger
= "test_logger"
862 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
864 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
865 ), patch
.object(instance
, "logger", logging
), patch
.object(
866 instance
, "db_vims", db_vims
872 "target_id": "vim_openstack_1",
875 "created_items": None,
876 "vim_id": "test-vim-id",
877 "vim_name": "test-vim",
878 "vim_status": "BUILD",
883 "modified_at": 1637324200.994312,
884 "created_at": 1637324200.994312,
885 "to_check_at": 1637324200.994312,
889 self
.target_vim
.refresh_nets_status
.return_value
= {
891 "vim_info": "some-details",
897 task_status
= "BUILD"
898 ro_vim_item_update
= {
899 "vim_name": "other-vim",
900 "vim_details": "some-details",
902 result
= instance
.refresh(ro_task
)
903 self
.assertEqual(result
[0], task_status
)
904 self
.assertDictEqual(result
[1], ro_vim_item_update
)
906 def test__refresh_ro_task_vim_status_error(self
):
908 vim_info.get('status') is ERROR
911 logger
= "test_logger"
918 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
920 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
921 ), patch
.object(instance
, "logger", logging
), patch
.object(
922 instance
, "db_vims", db_vims
928 "target_id": "vim_openstack_1",
931 "created_items": None,
932 "vim_id": "test-vim-id",
933 "vim_name": "test-vim",
934 "vim_status": "BUILD",
939 "modified_at": 1637324200.994312,
940 "created_at": 1637324200.994312,
941 "to_check_at": 1637324200.994312,
945 self
.target_vim
.refresh_nets_status
.return_value
= {
947 "vim_info": "some-details",
950 "error_msg": "some error message",
953 task_status
= "FAILED"
954 ro_vim_item_update
= {
955 "vim_status": "ERROR",
956 "vim_message": "some error message",
958 result
= instance
.refresh(ro_task
)
959 self
.assertEqual(result
[0], task_status
)
960 self
.assertDictEqual(result
[1], ro_vim_item_update
)
962 def test__refresh_ro_task_VimConnException_occurred(self
):
964 vimconn.VimConnException has occured
967 logger
= "test_logger"
974 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
976 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
977 ), patch
.object(instance
, "logger", logging
), patch
.object(
978 instance
, "db_vims", db_vims
984 "target_id": "vim_openstack_1",
987 "created_items": None,
988 "vim_id": "test-vim-id",
989 "vim_name": "test-vim",
990 "vim_status": "BUILD",
995 "modified_at": 1637324200.994312,
996 "created_at": 1637324200.994312,
997 "to_check_at": 1637324200.994312,
1000 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
1001 "VimConnException occurred."
1003 with self
.assertLogs() as captured
:
1004 instance
.refresh(ro_task
)
1005 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1007 def test__refresh_ro_task_vim_status_deleted(self
):
1009 vim_info.get('status') is DELETED
1012 logger
= "test_logger"
1013 my_vims
= "test-vim"
1015 "vim_openstack_1": {
1019 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1021 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1022 ), patch
.object(instance
, "logger", logging
), patch
.object(
1023 instance
, "db_vims", db_vims
1029 "target_id": "vim_openstack_1",
1032 "created_items": None,
1033 "vim_id": "test-vim-id",
1034 "vim_name": "test-vim",
1035 "vim_status": "BUILD",
1037 "vim_message": None,
1040 "modified_at": 163724200.994312,
1041 "created_at": 1637324200.994312,
1042 "to_check_at": 1637324200.994312,
1045 self
.target_vim
.refresh_nets_status
.return_value
= {
1047 "vim_info": "some-details",
1048 "status": "DELETED",
1050 "error_msg": "some error message",
1053 task_status
= "FAILED"
1054 ro_vim_item_update
= {
1055 "vim_status": "DELETED",
1056 "vim_message": "Deleted externally",
1059 result
= instance
.refresh(ro_task
)
1060 self
.assertEqual(result
[0], task_status
)
1061 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1063 def test__refresh_ro_task_empty_vim_dict(self
):
1065 vim_dict does not include vim_id key
1069 logger
= "test_logger"
1070 my_vims
= "test-vim"
1072 "vim_openstack_2": {
1076 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1078 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1079 ), patch
.object(instance
, "logger", logging
), patch
.object(
1080 instance
, "db_vims", db_vims
1086 "target_id": "vim_openstack_2",
1089 "created_items": None,
1090 "vim_id": "test-vim-id",
1091 "vim_name": "test-vim",
1092 "vim_status": "BUILD",
1094 "vim_message": None,
1097 "modified_at": 163724211.994312,
1098 "created_at": 1637324211.994312,
1099 "to_check_at": 1637324211.994312,
1102 self
.target_vim
.refresh_nets_status
.return_value
= {}
1103 with self
.assertRaises(KeyError):
1104 instance
.refresh(ro_task
)
1107 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1109 module_name
= "osm_ro_plugin"
1110 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1111 self
.task_depends
= None
1113 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1115 # Enabling mocks and add cleanups
1116 for mock
in patches
:
1118 self
.addCleanup(mock
.stop
)
1120 def test__new_affinity_group_ok(self
):
1122 create affinity group with attributes set in params
1125 logger
= "test_logger"
1126 my_vims
= "test-vim"
1133 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1134 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1135 instance
, "logger", logging
1136 ), patch
.object(instance
, "db_vims", db_vims
):
1142 "action_id": "123456",
1144 "task_id": "123456:1",
1145 "status": "SCHEDULED",
1147 "item": "test_item",
1148 "target_record": "test_target_record",
1149 "target_record_id": "test_target_record_id",
1150 # values coming from extra_dict
1152 "affinity_group_data": {
1153 "name": "affinity_group_1",
1155 "scope": "nfvi-node",
1159 "depends_on": "test_depends_on",
1164 task_index
= "task_index_1"
1165 self
.target_vim
.new_affinity_group
.return_value
= (
1166 "sample_affinity_group_id_1"
1168 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1169 self
.assertEqual(result
[0], "DONE")
1170 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1171 self
.assertEqual(result
[1].get("created"), True)
1172 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1174 def test__new_affinity_group_failed(self
):
1176 create affinity group with no attributes set in params
1179 logger
= "test_logger"
1180 my_vims
= "test-vim"
1187 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1188 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1189 instance
, "logger", logging
1190 ), patch
.object(instance
, "db_vims", db_vims
):
1196 "action_id": "123456",
1198 "task_id": "123456:1",
1199 "status": "SCHEDULED",
1201 "item": "test_item",
1202 "target_record": "test_target_record",
1203 "target_record_id": "test_target_record_id",
1204 # values coming from extra_dict
1207 "depends_on": "test_depends_on",
1212 task_index
= "task_index_2"
1213 self
.target_vim
.new_affinity_group
.return_value
= (
1214 "sample_affinity_group_id_1"
1216 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1217 self
.assertEqual(result
[0], "DONE")
1218 self
.assertEqual(result
[1].get("vim_id"), None)
1219 self
.assertEqual(result
[1].get("created"), False)
1220 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1222 def test__delete_affinity_group_ok(self
):
1224 delete affinity group with a proper vim_id
1227 logger
= "test_logger"
1228 my_vims
= "test-vim"
1235 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1236 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1237 instance
, "logger", logging
1238 ), patch
.object(instance
, "db_vims", db_vims
):
1244 "task_id": "123456:1",
1249 "created_items": None,
1250 "vim_id": "sample_affinity_group_id_3",
1251 "vim_name": "sample_affinity_group_id_3",
1253 "vim_details": "some-details",
1254 "vim_message": None,
1259 task_index
= "task_index_3"
1260 self
.target_vim
.delete_affinity_group
.return_value
= (
1261 "sample_affinity_group_id_3"
1263 result
= instance
.delete(ro_task
, task_index
)
1264 self
.assertEqual(result
[0], "DONE")
1265 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1266 self
.assertEqual(result
[1].get("created"), False)
1267 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1269 def test__delete_affinity_group_failed(self
):
1271 delete affinity group with missing vim_id
1274 logger
= "test_logger"
1275 my_vims
= "test-vim"
1282 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1283 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1284 instance
, "logger", logging
1285 ), patch
.object(instance
, "db_vims", db_vims
):
1291 "task_id": "123456:1",
1296 "created_items": None,
1300 "vim_details": "some-details",
1301 "vim_message": None,
1306 task_index
= "task_index_4"
1307 self
.target_vim
.delete_affinity_group
.return_value
= ""
1308 result
= instance
.delete(ro_task
, task_index
)
1309 self
.assertEqual(result
[0], "DONE")
1310 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1311 self
.assertEqual(result
[1].get("created"), False)
1312 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1315 class TestVimInteractionResize(unittest
.TestCase
):
1317 module_name
= "osm_ro_plugin"
1318 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1319 self
.task_depends
= None
1321 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1323 # Enabling mocks and add cleanups
1324 for mock
in patches
:
1326 self
.addCleanup(mock
.stop
)
1328 def test__exec_resize_done(self
):
1330 create verticalscale task
1333 logger
= "test_logger"
1334 my_vims
= "test-vim"
1340 target_record_id
= (
1341 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1342 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1345 instance
= VimInteractionResize(db
, logger
, my_vims
, db_vims
)
1346 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1347 instance
, "logger", logging
1348 ), patch
.object(instance
, "db_vims", db_vims
):
1354 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1355 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1356 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1357 "status": "SCHEDULED",
1359 "item": "verticalscale",
1360 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1361 "target_record_id": target_record_id
,
1363 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1364 "flavor_dict": "flavor_dict",
1369 task_index
= "task_index_1"
1370 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1371 self
.assertEqual(result
[0], "DONE")
1372 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1375 class TestVimInteractionMigration(unittest
.TestCase
):
1377 module_name
= "osm_ro_plugin"
1378 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1379 self
.task_depends
= None
1381 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1383 # Enabling mocks and add cleanups
1384 for mock
in patches
:
1386 self
.addCleanup(mock
.stop
)
1388 def test__exec_migration_done(self
):
1393 logger
= "test_logger"
1394 my_vims
= "test-vim"
1400 target_record_id
= (
1401 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1402 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1405 instance
= VimInteractionMigration(db
, logger
, my_vims
, db_vims
)
1406 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1407 instance
, "logger", logging
1408 ), patch
.object(instance
, "db_vims", db_vims
):
1414 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1415 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1416 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1417 "status": "SCHEDULED",
1420 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1421 "target_record_id": target_record_id
,
1423 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1424 "migrate_host": "osm-test2",
1425 "vdu_vim_info": {0: {"interfaces": []}},
1430 self
.target_vim
.migrate_instance
.return_value
= "ACTIVE", "test"
1432 task_index
= "task_index_1"
1433 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1434 self
.assertEqual(result
[0], "DONE")
1435 self
.assertEqual(result
[1].get("vim_status"), "ACTIVE")