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
, Mock
, mock_open
, patch
22 from osm_common
.dbmemory
import DbMemory
23 from osm_ng_ro
.ns_thread
import (
27 VimInteractionAffinityGroup
,
28 VimInteractionMigration
,
32 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
35 class TestConfigValidate(unittest
.TestCase
):
41 "refresh_image": 3600,
47 def test__get_configuration(self
):
48 with self
.subTest(i
=1, t
="Get config attributes with config input"):
49 configuration
= ConfigValidate(self
.config_dict
)
50 self
.assertEqual(configuration
.active
, 65)
51 self
.assertEqual(configuration
.build
, 20)
52 self
.assertEqual(configuration
.image
, 3600)
53 self
.assertEqual(configuration
.error
, 300)
54 self
.assertEqual(configuration
.queue_size
, 50)
56 with self
.subTest(i
=2, t
="Unallowed refresh active input"):
57 # > 60 (except -1) is not allowed to set, so it should return default value 60
58 self
.config_dict
["period"]["refresh_active"] = 20
59 configuration
= ConfigValidate(self
.config_dict
)
60 self
.assertEqual(configuration
.active
, 60)
62 with self
.subTest(i
=3, t
="Config to disable VM status periodic checks"):
63 # -1 is allowed to set to disable VM status updates
64 self
.config_dict
["period"]["refresh_active"] = -1
65 configuration
= ConfigValidate(self
.config_dict
)
66 self
.assertEqual(configuration
.active
, -1)
69 class TestNsWorker(unittest
.TestCase
):
71 self
.task_depends
= None
73 self
.worker_index
= "worker-3"
78 "refresh_image": 3600,
82 "process_id": "343435353",
83 "global": {"task_locked_time": 16373242100.994312},
90 "target_id": "vim_openstack_1",
93 "created_items": None,
94 "vim_id": "test-vim-id",
95 "vim_name": "test-vim",
101 "modified_at": 1637324200.994312,
102 "created_at": 1637324200.994312,
103 "to_check_at": 16373242400.994312,
107 "action_id": "123456",
109 "task_id": "123456:1",
113 "target_record": "test_target_record",
114 "target_record_id": "test_target_record_id",
119 def get_disabled_tasks(self
, db
, status
):
120 db_disabled_tasks
= db
.get_list(
123 "tasks.status": status
,
127 return db_disabled_tasks
129 def test__update_vm_refresh(self
):
132 t
="1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1",
134 # Disabled task with status build will not enabled again
136 self
.ro_task
["tasks"][0]["status"] = "BUILD"
137 self
.ro_task
["to_check_at"] = -1
138 db
.create("ro_tasks", self
.ro_task
)
139 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "BUILD"))
140 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
141 with patch
.object(instance
, "logger", logging
):
142 instance
.update_vm_refresh()
144 len(self
.get_disabled_tasks(db
, "BUILD")), disabled_tasks_count
149 t
="1 disabled task with status DONE in DB, refresh_active parameter is equal to -1",
151 # As refresh_active parameter is equal to -1, task will not be enabled to process again
153 self
.config
["period"]["refresh_active"] = -1
154 self
.ro_task
["tasks"][0]["status"] = "DONE"
155 self
.ro_task
["to_check_at"] = -1
156 db
.create("ro_tasks", self
.ro_task
)
157 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
158 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
159 with patch
.object(instance
, "logger", logging
):
160 instance
.update_vm_refresh()
162 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
167 t
="2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1",
169 # Disabled tasks should be enabled to process again
171 self
.config
["period"]["refresh_active"] = 66
172 self
.ro_task
["tasks"][0]["status"] = "DONE"
173 self
.ro_task
["to_check_at"] = -1
174 db
.create("ro_tasks", self
.ro_task
)
175 self
.ro_task2
= self
.ro_task
176 self
.ro_task2
["_id"] = "122437:1"
177 db
.create("ro_tasks", self
.ro_task2
)
178 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
179 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
180 with patch
.object(instance
, "logger", logging
):
181 instance
.update_vm_refresh()
183 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
- 2
188 t
="No disabled task with status DONE in DB, refresh_active parameter is not equal to -1",
190 # If there is not any disabled task, method will not change anything
192 self
.config
["period"]["refresh_active"] = 66
193 self
.ro_task
["tasks"][0]["status"] = "DONE"
194 self
.ro_task
["to_check_at"] = 16373242400.994312
195 db
.create("ro_tasks", self
.ro_task
)
196 self
.ro_task2
= self
.ro_task
197 self
.ro_task2
["_id"] = "122437:1"
198 db
.create("ro_tasks", self
.ro_task2
)
199 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
200 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
201 with patch
.object(instance
, "logger", logging
):
202 instance
.update_vm_refresh()
204 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
207 def test__process_pending_tasks(self
):
210 t
="refresh_active parameter is equal to -1, task status is DONE",
212 # Task should be disabled to process again
214 self
.config
["period"]["refresh_active"] = -1
215 self
.ro_task
["tasks"][0]["status"] = "DONE"
216 self
.ro_task
["to_check_at"] = 16373242400.994312
217 db
.create("ro_tasks", self
.ro_task
)
218 # Number of disabled tasks in DB
219 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
220 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
221 with patch
.object(instance
, "logger", logging
):
222 instance
._process
_pending
_tasks
(self
.ro_task
)
224 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
+ 1
228 i
=2, t
="refresh_active parameter is equal to -1, task status is FAILED"
230 # Task will not be disabled to process as task status is not DONE
232 self
.config
["period"]["refresh_active"] = -1
233 self
.ro_task
["tasks"][0]["status"] = "FAILED"
234 self
.ro_task
["to_check_at"] = 16373242400.994312
235 db
.create("ro_tasks", self
.ro_task
)
236 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "FAILED"))
237 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
238 with patch
.object(instance
, "logger", logging
):
239 instance
._process
_pending
_tasks
(self
.ro_task
)
241 len(self
.get_disabled_tasks(db
, "FAILED")), disabled_tasks_count
245 i
=3, t
="refresh_active parameter is not equal to -1, task status is DONE"
247 # Task will not be disabled to process as refresh_active parameter is not -1
249 self
.config
["period"]["refresh_active"] = 70
250 self
.ro_task
["tasks"][0]["status"] = "DONE"
251 self
.ro_task
["to_check_at"] = 16373242400.994312
252 db
.create("ro_tasks", self
.ro_task
)
253 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
254 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
255 with patch
.object(instance
, "logger", logging
):
256 instance
._process
_pending
_tasks
(self
.ro_task
)
258 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
261 @patch("osm_ng_ro.ns_thread.makedirs", return_value
="")
262 def test_create_file_cert(self
, mock_makedirs
):
263 vim_config
= {"config": {"ca_cert_content": "test"}}
267 with
patch("builtins.open", mock_open()) as mocked_file
:
268 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
269 nsw
._process
_vim
_config
(target_id
, vim_config
)
270 mocked_file
.assert_called_once_with(
271 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
274 vim_config
["config"]["ca_cert"]
275 == f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
278 @patch("osm_ng_ro.ns_thread.makedirs")
279 @patch("osm_ng_ro.ns_thread.path")
280 def test_create_file_cert_exists(self
, mock_path
, mock_makedirs
):
281 vim_config
= {"config": {"ca_cert_content": "test"}}
284 mock_path
.isdir
.return_value
= True
286 with
patch("builtins.open", mock_open()) as mocked_file
:
287 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
288 nsw
._process
_vim
_config
(target_id
, vim_config
)
289 mock_makedirs
.assert_not_called()
290 mocked_file
.assert_called_once_with(
291 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
294 vim_config
["config"]["ca_cert"]
295 == f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
298 @patch("osm_ng_ro.ns_thread.path")
299 @patch("osm_ng_ro.ns_thread.makedirs", side_effect
=Exception)
300 def test_create_file_cert_makedirs_except(self
, mock_makedirs
, mock_path
):
301 vim_config
= {"config": {"ca_cert_content": "test"}}
304 mock_path
.isdir
.return_value
= False
306 with
patch("builtins.open", mock_open()) as mocked_file
:
307 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
308 with self
.assertRaises(NsWorkerException
):
309 nsw
._process
_vim
_config
(target_id
, vim_config
)
310 mocked_file
.assert_not_called()
311 assert vim_config
["config"]["ca_cert_content"] == "test"
313 @patch("osm_ng_ro.ns_thread.makedirs", return_value
="")
314 def test_create_file_cert_open_excepts(self
, mock_makedirs
):
315 vim_config
= {"config": {"ca_cert_content": "test"}}
319 with
patch("builtins.open", mock_open()) as mocked_file
:
320 mocked_file
.side_effect
= Exception
321 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
322 with self
.assertRaises(NsWorkerException
):
323 nsw
._process
_vim
_config
(target_id
, vim_config
)
324 mocked_file
.assert_called_once_with(
325 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
327 assert vim_config
["config"]["ca_cert_content"] == "test"
330 class TestVimInteractionNet(unittest
.TestCase
):
332 module_name
= "osm_ro_plugin"
333 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
334 self
.task_depends
= None
336 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
338 # Enabling mocks and add cleanups
341 self
.addCleanup(mock
.stop
)
343 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
345 mgmt network is set in find_params
346 management_network_id in vim config
347 More than one network found in the VIM
350 logger
= "test_logger"
355 "management_network_id": "test_mgmt_id",
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_mgmt_name",
383 "depends_on": "test_depends_on",
388 task_index
= "task_index_2"
389 self
.target_vim
.get_network_list
.return_value
= [
390 {"id": "existing_net_1"},
391 {"id": "existing_net_2"},
393 with self
.assertLogs() as captured
:
394 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
395 self
.assertEqual(len(captured
.records
), 1)
397 "More than one network found with this criteria"
398 in captured
.records
[0].getMessage()
400 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
401 self
.assertEqual(result
[0], "FAILED")
402 self
.assertEqual(result
[1].get("created"), False)
403 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
405 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
407 mgmt network is set in find_params
408 management_network_id in vim config
409 The network could not be found in the VIM
412 logger
= "test_logger"
417 "management_network_id": "test_mgmt_id",
422 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
423 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
424 instance
, "db_vims", db_vims
425 ), patch
.object(instance
, "logger", logging
):
431 "action_id": "123456",
433 "task_id": "123456:1",
434 "status": "SCHEDULED",
437 "target_record": "test_target_record",
438 "target_record_id": "test_target_record_id",
440 # values coming from extra_dict
443 "name": "some_mgmt_name",
445 "depends_on": "test_depends_on",
450 task_index
= "task_index_3"
451 self
.target_vim
.get_network_list
.return_value
= []
452 with self
.assertLogs() as captured
:
453 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
454 self
.assertEqual(len(captured
.records
), 1)
456 "Network not found with this criteria"
457 in captured
.records
[0].getMessage()
459 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
460 self
.assertEqual(result
[0], "FAILED")
461 self
.assertEqual(result
[1].get("created"), False)
462 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
464 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
466 mgmt network is set in find_params
467 vim config does not have management_network_id or management_network_id
468 The network could not be found in the VIM
471 logger
= "test_logger"
479 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
480 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
481 instance
, "db_vims", db_vims
482 ), patch
.object(instance
, "logger", logging
):
488 "action_id": "123456",
490 "task_id": "123456:1",
491 "status": "SCHEDULED",
494 "target_record": "test_target_record",
495 "target_record_id": "test_target_record_id",
497 # values coming from extra_dict
500 "name": "some_mgmt_name",
502 "depends_on": "test_depends_on",
507 task_index
= "task_index_3"
508 self
.target_vim
.get_network_list
.return_value
= []
509 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
510 "item1": "sample_created_item"
512 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
513 self
.assertEqual(result
[0], "BUILD")
514 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
515 self
.assertEqual(result
[1].get("created"), True)
516 self
.assertDictEqual(
517 result
[1].get("created_items"), {"item1": "sample_created_item"}
519 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
521 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
523 mgmt network is set in find_params
524 management_network_name in vim config
525 More than one network found in the VIM
528 logger
= "test_logger"
533 "management_network_name": "test_mgmt_name",
538 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
539 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
540 instance
, "logger", logging
541 ), patch
.object(instance
, "db_vims", db_vims
):
547 "action_id": "123456",
549 "task_id": "123456:1",
550 "status": "SCHEDULED",
553 "target_record": "test_target_record",
554 "target_record_id": "test_target_record_id",
555 # values coming from extra_dict
559 "name": "some_mgmt_name",
561 "depends_on": "test_depends_on",
566 task_index
= "task_index_4"
567 self
.target_vim
.get_network_list
.return_value
= [
568 {"id": "existing_net_1"},
569 {"id": "existing_net_2"},
571 with self
.assertLogs() as captured
:
572 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
573 self
.assertEqual(len(captured
.records
), 1)
575 "More than one network found with this criteria"
576 in captured
.records
[0].getMessage()
578 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
579 self
.assertEqual(result
[0], "FAILED")
580 self
.assertEqual(result
[1].get("created"), False)
581 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
583 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
585 mgmt network is set in find_params
586 management_network_name in vim config
587 The network could not be found in the VIM
590 logger
= "test_logger"
595 "management_network_name": "test_mgmt_name",
600 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
601 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
602 instance
, "logger", logging
603 ), patch
.object(instance
, "db_vims", db_vims
):
609 "action_id": "123456",
611 "task_id": "123456:1",
612 "status": "SCHEDULED",
615 "target_record": "test_target_record",
616 "target_record_id": "test_target_record_id",
617 # values coming from extra_dict
621 "name": "some_mgmt_name",
623 "depends_on": "test_depends_on",
628 task_index
= "task_index_5"
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_filterdict_several_vim_nets(self
):
644 mgmt network is set in find_params
645 management_network_name in vim config
646 network_name is set in find_params.get('filterdict')
647 More than one network found in the VIM
650 logger
= "test_logger"
655 "management_network_name": "test_mgmt_name",
659 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
660 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
661 instance
, "logger", logging
662 ), patch
.object(instance
, "db_vims", db_vims
):
668 "action_id": "123456",
670 "task_id": "123456:1",
671 "status": "SCHEDULED",
674 "target_record": "test_target_record",
675 "target_record_id": "test_target_record_id",
676 # values coming from extra_dict
680 "name": "some-network-name",
683 "name": "some_mgmt_name",
685 "depends_on": "test_depends_on",
690 task_index
= "task_index_6"
691 self
.target_vim
.get_network_list
.return_value
= [
692 {"id": "existing_net_1"},
693 {"id": "existing_net_2"},
695 with self
.assertLogs() as captured
:
696 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
697 self
.assertEqual(len(captured
.records
), 1)
699 "More than one network found with this criteria"
700 in captured
.records
[0].getMessage()
702 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
703 self
.assertEqual(result
[0], "FAILED")
704 self
.assertEqual(result
[1].get("created"), False)
705 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
707 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
709 There is find_params in the task
710 No mgmt in find_params
711 No filter_dict in find_params
714 logger
= "test_logger"
719 "management_network_name": "test_mgmt_name",
723 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
724 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
725 instance
, "logger", logging
726 ), patch
.object(instance
, "db_vims", db_vims
):
732 "action_id": "123456",
734 "task_id": "123456:1",
735 "status": "SCHEDULED",
738 "target_record": "test_target_record",
739 "target_record_id": "test_target_record_id",
740 # values coming from extra_dict
742 "find_params": {"wrong_param": "wrong_value"},
743 "depends_on": "test_depends_on",
748 task_index
= "task_index_4"
749 with self
.assertLogs() as captured
:
750 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
751 self
.assertEqual(len(captured
.records
), 1)
753 "Invalid find_params for new_net"
754 in captured
.records
[0].getMessage()
756 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
757 self
.assertEqual(result
[0], "FAILED")
758 self
.assertEqual(result
[1].get("created"), False)
759 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
761 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
763 management_network_name in find_params.get('filterdict')
764 The network could not be found in the VIM
765 There are items in the task.get(params)
768 logger
= "test_logger"
773 "management_network_name": "test_mgmt_name",
777 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
778 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
779 instance
, "logger", logging
780 ), patch
.object(instance
, "db_vims", db_vims
):
786 "action_id": "123456",
788 "task_id": "123456:1",
789 "status": "SCHEDULED",
792 "target_record": "test_target_record",
793 "target_record_id": "test_target_record_id",
794 # values coming from extra_dict
796 "net_name": "test_params",
800 "name": "some-network-name",
803 "name": "some_mgmt_name",
805 "depends_on": "test_depends_on",
810 task_index
= "task_index_8"
811 self
.target_vim
.get_network_list
.return_value
= []
812 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
813 self
.assertEqual(result
[0], "BUILD")
814 self
.assertEqual(result
[1].get("created"), False)
815 self
.assertEqual(result
[1].get("vim_id"), None)
816 self
.assertEqual(result
[1].get("created_items"), {})
817 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
819 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
821 mgmt network is set in find_params
822 management_network_name in vim config
823 network_name is set in find_params.get('filterdict')
824 Any network could not be found in the VIM
827 logger
= "test_logger"
832 "management_network_name": "test_mgmt_name",
836 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
837 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
838 instance
, "logger", logging
839 ), patch
.object(instance
, "db_vims", db_vims
):
845 "action_id": "123456",
847 "task_id": "123456:1",
848 "status": "SCHEDULED",
851 "target_record": "test_target_record",
852 "target_record_id": "test_target_record_id",
853 # values coming from extra_dict
857 "name": "some-network-name",
860 "name": "some_mgmt_name",
862 "depends_on": "test_depends_on",
867 task_index
= "task_index_9"
868 self
.target_vim
.get_network_list
.return_value
= []
869 with self
.assertLogs() as captured
:
870 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
871 self
.assertEqual(len(captured
.records
), 1)
873 "Network not found with this criteria"
874 in captured
.records
[0].getMessage()
876 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
877 self
.assertEqual(result
[0], "FAILED")
878 self
.assertEqual(result
[1].get("created"), False)
879 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
881 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
883 mgmt network is set in find_params
885 network_name is set in find_params.get('filterdict')
886 Any network could not be found in the VIM
889 logger
= "test_logger"
896 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
897 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
898 instance
, "logger", logging
899 ), patch
.object(instance
, "db_vims", db_vims
):
905 "action_id": "123456",
907 "task_id": "123456:1",
908 "status": "SCHEDULED",
911 "target_record": "test_target_record",
912 "target_record_id": "test_target_record_id",
913 # values coming from extra_dict
917 "name": "some-network-name",
920 "name": "some_mgmt_name",
922 "depends_on": "test_depends_on",
927 task_index
= "task_index_9"
928 self
.target_vim
.get_network_list
.return_value
= []
929 with self
.assertLogs() as captured
:
930 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
931 self
.assertEqual(len(captured
.records
), 1)
933 "Network not found with this criteria"
934 in captured
.records
[0].getMessage()
936 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
937 self
.assertEqual(result
[0], "FAILED")
938 self
.assertEqual(result
[1].get("created"), False)
939 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
941 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
943 mgmt network is set in find_params
944 management_network_name is not in db_vims.get('config')
945 One network found in the VIM
948 logger
= "test_logger"
955 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
956 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
957 instance
, "logger", logging
958 ), patch
.object(instance
, "db_vims", db_vims
):
964 "action_id": "123456",
966 "task_id": "123456:1",
967 "status": "SCHEDULED",
970 "target_record": "test_target_record",
971 "target_record_id": "test_target_record_id",
972 # values coming from extra_dict
976 "name": "some_mgmt_name",
978 "depends_on": "test_depends_on",
983 task_index
= "task_index_2"
984 self
.target_vim
.get_network_list
.return_value
= [
985 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
987 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
988 self
.assertEqual(result
[0], "BUILD")
989 self
.assertEqual(result
[1].get("created"), False)
990 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
992 def test__params_in_task_no_find_params(self
):
995 find_params does not exist in the task
998 logger
= "test_logger"
1003 "management_network_name": "test_mgmt_name",
1007 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1008 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1009 instance
, "logger", logging
1010 ), patch
.object(instance
, "db_vims", db_vims
):
1016 "action_id": "123456",
1018 "task_id": "123456:1",
1019 "status": "SCHEDULED",
1021 "item": "test_item",
1022 "target_record": "test_target_record",
1023 "target_record_id": "test_target_record_id",
1024 # values coming from extra_dict
1026 "net_name": "test-network",
1029 "depends_on": "test_depends_on",
1034 task_index
= "task_index_11"
1035 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
1036 "item1": "sample_created_item"
1038 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1039 self
.assertEqual(result
[0], "BUILD")
1040 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
1041 self
.assertEqual(result
[1].get("created"), True)
1043 result
[1].get("created_items"), {"item1": "sample_created_item"}
1045 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
1047 def test__no_params_in_task_no_find_params(self
):
1049 empty params in the task
1050 find_params does not exist in the task
1053 logger
= "test_logger"
1054 my_vims
= "test-vim"
1058 "management_network_name": "test_mgmt_name",
1062 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1063 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1064 instance
, "logger", logging
1065 ), patch
.object(instance
, "db_vims", db_vims
):
1071 "action_id": "123456",
1073 "task_id": "123456:1",
1074 "status": "SCHEDULED",
1076 "item": "test_item",
1077 "target_record": "test_target_record",
1078 "target_record_id": "test_target_record_id",
1079 # values coming from extra_dict
1081 "depends_on": "test_depends_on",
1086 task_index
= "task_index_12"
1087 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
1088 "VimConnConnectionException occurred."
1090 with self
.assertLogs() as captured
:
1091 instance
.new(ro_task
, task_index
, self
.task_depends
)
1092 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1094 def test__refresh_ro_task_vim_status_active(self
):
1096 vim_info.get('status') is ACTIVE
1099 logger
= "test_logger"
1100 my_vims
= "test-vim"
1102 "vim_openstack_1": {
1106 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1108 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1109 ), patch
.object(instance
, "logger", logging
), patch
.object(
1110 instance
, "db_vims", db_vims
1116 "target_id": "vim_openstack_1",
1119 "created_items": None,
1120 "vim_id": "test-vim-id",
1121 "vim_name": "test-vim",
1123 "vim_details": "some-details",
1124 "vim_message": None,
1127 "modified_at": 1637324200.994312,
1128 "created_at": 1637324200.994312,
1129 "to_check_at": 1637324200.994312,
1133 self
.target_vim
.refresh_nets_status
.return_value
= {
1135 "vim_info": "some-details",
1141 task_status
= "DONE"
1142 ro_vim_item_update
= {
1143 "vim_status": "ACTIVE",
1145 result
= instance
.refresh(ro_task
)
1146 self
.assertEqual(result
[0], task_status
)
1147 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1149 def test__refresh_ro_task_vim_status_build(self
):
1151 vim_info.get('status') is BUILD
1154 logger
= "test_logger"
1155 my_vims
= "test-vim"
1157 "vim_openstack_1": {
1161 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1163 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1164 ), patch
.object(instance
, "logger", logging
), patch
.object(
1165 instance
, "db_vims", db_vims
1171 "target_id": "vim_openstack_1",
1174 "created_items": None,
1175 "vim_id": "test-vim-id",
1176 "vim_name": "test-vim",
1177 "vim_status": "BUILD",
1179 "vim_message": None,
1182 "modified_at": 1637324200.994312,
1183 "created_at": 1637324200.994312,
1184 "to_check_at": 1637324200.994312,
1188 self
.target_vim
.refresh_nets_status
.return_value
= {
1190 "vim_info": "some-details",
1192 "name": "other-vim",
1196 task_status
= "BUILD"
1197 ro_vim_item_update
= {
1198 "vim_name": "other-vim",
1199 "vim_details": "some-details",
1201 result
= instance
.refresh(ro_task
)
1202 self
.assertEqual(result
[0], task_status
)
1203 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1205 def test__refresh_ro_task_vim_status_error(self
):
1207 vim_info.get('status') is ERROR
1210 logger
= "test_logger"
1211 my_vims
= "test-vim"
1213 "vim_openstack_1": {
1217 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1219 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1220 ), patch
.object(instance
, "logger", logging
), patch
.object(
1221 instance
, "db_vims", db_vims
1227 "target_id": "vim_openstack_1",
1230 "created_items": None,
1231 "vim_id": "test-vim-id",
1232 "vim_name": "test-vim",
1233 "vim_status": "BUILD",
1235 "vim_message": None,
1238 "modified_at": 1637324200.994312,
1239 "created_at": 1637324200.994312,
1240 "to_check_at": 1637324200.994312,
1244 self
.target_vim
.refresh_nets_status
.return_value
= {
1246 "vim_info": "some-details",
1249 "error_msg": "some error message",
1252 task_status
= "FAILED"
1253 ro_vim_item_update
= {
1254 "vim_status": "ERROR",
1255 "vim_message": "some error message",
1257 result
= instance
.refresh(ro_task
)
1258 self
.assertEqual(result
[0], task_status
)
1259 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1261 def test__refresh_ro_task_VimConnException_occurred(self
):
1263 vimconn.VimConnException has occured
1266 logger
= "test_logger"
1267 my_vims
= "test-vim"
1269 "vim_openstack_1": {
1273 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1275 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1276 ), patch
.object(instance
, "logger", logging
), patch
.object(
1277 instance
, "db_vims", db_vims
1283 "target_id": "vim_openstack_1",
1286 "created_items": None,
1287 "vim_id": "test-vim-id",
1288 "vim_name": "test-vim",
1289 "vim_status": "BUILD",
1291 "vim_message": None,
1294 "modified_at": 1637324200.994312,
1295 "created_at": 1637324200.994312,
1296 "to_check_at": 1637324200.994312,
1299 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
1300 "VimConnException occurred."
1302 with self
.assertLogs() as captured
:
1303 instance
.refresh(ro_task
)
1304 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1306 def test__refresh_ro_task_vim_status_deleted(self
):
1308 vim_info.get('status') is DELETED
1311 logger
= "test_logger"
1312 my_vims
= "test-vim"
1314 "vim_openstack_1": {
1318 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1320 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1321 ), patch
.object(instance
, "logger", logging
), patch
.object(
1322 instance
, "db_vims", db_vims
1328 "target_id": "vim_openstack_1",
1331 "created_items": None,
1332 "vim_id": "test-vim-id",
1333 "vim_name": "test-vim",
1334 "vim_status": "BUILD",
1336 "vim_message": None,
1339 "modified_at": 163724200.994312,
1340 "created_at": 1637324200.994312,
1341 "to_check_at": 1637324200.994312,
1344 self
.target_vim
.refresh_nets_status
.return_value
= {
1346 "vim_info": "some-details",
1347 "status": "DELETED",
1349 "error_msg": "some error message",
1352 task_status
= "FAILED"
1353 ro_vim_item_update
= {
1354 "vim_status": "DELETED",
1355 "vim_message": "Deleted externally",
1358 result
= instance
.refresh(ro_task
)
1359 self
.assertEqual(result
[0], task_status
)
1360 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1362 def test__refresh_ro_task_empty_vim_dict(self
):
1364 vim_dict does not include vim_id key
1368 logger
= "test_logger"
1369 my_vims
= "test-vim"
1371 "vim_openstack_2": {
1375 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1377 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1378 ), patch
.object(instance
, "logger", logging
), patch
.object(
1379 instance
, "db_vims", db_vims
1385 "target_id": "vim_openstack_2",
1388 "created_items": None,
1389 "vim_id": "test-vim-id",
1390 "vim_name": "test-vim",
1391 "vim_status": "BUILD",
1393 "vim_message": None,
1396 "modified_at": 163724211.994312,
1397 "created_at": 1637324211.994312,
1398 "to_check_at": 1637324211.994312,
1401 self
.target_vim
.refresh_nets_status
.return_value
= {}
1402 with self
.assertRaises(KeyError):
1403 instance
.refresh(ro_task
)
1406 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1408 module_name
= "osm_ro_plugin"
1409 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1410 self
.task_depends
= None
1412 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1414 # Enabling mocks and add cleanups
1415 for mock
in patches
:
1417 self
.addCleanup(mock
.stop
)
1419 def test__new_affinity_group_ok(self
):
1421 create affinity group with attributes set in params
1424 logger
= "test_logger"
1425 my_vims
= "test-vim"
1432 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1433 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1434 instance
, "logger", logging
1435 ), patch
.object(instance
, "db_vims", db_vims
):
1441 "action_id": "123456",
1443 "task_id": "123456:1",
1444 "status": "SCHEDULED",
1446 "item": "test_item",
1447 "target_record": "test_target_record",
1448 "target_record_id": "test_target_record_id",
1449 # values coming from extra_dict
1451 "affinity_group_data": {
1452 "name": "affinity_group_1",
1454 "scope": "nfvi-node",
1458 "depends_on": "test_depends_on",
1463 task_index
= "task_index_1"
1464 self
.target_vim
.new_affinity_group
.return_value
= (
1465 "sample_affinity_group_id_1"
1467 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1468 self
.assertEqual(result
[0], "DONE")
1469 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1470 self
.assertEqual(result
[1].get("created"), True)
1471 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1473 def test__new_affinity_group_failed(self
):
1475 create affinity group with no attributes set in params
1478 logger
= "test_logger"
1479 my_vims
= "test-vim"
1486 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1487 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1488 instance
, "logger", logging
1489 ), patch
.object(instance
, "db_vims", db_vims
):
1495 "action_id": "123456",
1497 "task_id": "123456:1",
1498 "status": "SCHEDULED",
1500 "item": "test_item",
1501 "target_record": "test_target_record",
1502 "target_record_id": "test_target_record_id",
1503 # values coming from extra_dict
1506 "depends_on": "test_depends_on",
1511 task_index
= "task_index_2"
1512 self
.target_vim
.new_affinity_group
.return_value
= (
1513 "sample_affinity_group_id_1"
1515 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1516 self
.assertEqual(result
[0], "DONE")
1517 self
.assertEqual(result
[1].get("vim_id"), None)
1518 self
.assertEqual(result
[1].get("created"), False)
1519 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1521 def test__delete_affinity_group_ok(self
):
1523 delete affinity group with a proper vim_id
1526 logger
= "test_logger"
1527 my_vims
= "test-vim"
1534 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1535 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1536 instance
, "logger", logging
1537 ), patch
.object(instance
, "db_vims", db_vims
):
1543 "task_id": "123456:1",
1548 "created_items": None,
1549 "vim_id": "sample_affinity_group_id_3",
1550 "vim_name": "sample_affinity_group_id_3",
1552 "vim_details": "some-details",
1553 "vim_message": None,
1558 task_index
= "task_index_3"
1559 self
.target_vim
.delete_affinity_group
.return_value
= (
1560 "sample_affinity_group_id_3"
1562 result
= instance
.delete(ro_task
, task_index
)
1563 self
.assertEqual(result
[0], "DONE")
1564 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1565 self
.assertEqual(result
[1].get("created"), False)
1566 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1568 def test__delete_affinity_group_failed(self
):
1570 delete affinity group with missing vim_id
1573 logger
= "test_logger"
1574 my_vims
= "test-vim"
1581 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1582 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1583 instance
, "logger", logging
1584 ), patch
.object(instance
, "db_vims", db_vims
):
1590 "task_id": "123456:1",
1595 "created_items": None,
1599 "vim_details": "some-details",
1600 "vim_message": None,
1605 task_index
= "task_index_4"
1606 self
.target_vim
.delete_affinity_group
.return_value
= ""
1607 result
= instance
.delete(ro_task
, task_index
)
1608 self
.assertEqual(result
[0], "DONE")
1609 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1610 self
.assertEqual(result
[1].get("created"), False)
1611 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1614 class TestVimInteractionResize(unittest
.TestCase
):
1616 module_name
= "osm_ro_plugin"
1617 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1618 self
.task_depends
= None
1620 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1622 # Enabling mocks and add cleanups
1623 for mock
in patches
:
1625 self
.addCleanup(mock
.stop
)
1627 def test__exec_resize_done(self
):
1629 create verticalscale task
1632 logger
= "test_logger"
1633 my_vims
= "test-vim"
1639 target_record_id
= (
1640 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1641 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1644 instance
= VimInteractionResize(db
, logger
, my_vims
, db_vims
)
1645 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1646 instance
, "logger", logging
1647 ), patch
.object(instance
, "db_vims", db_vims
):
1653 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1654 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1655 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1656 "status": "SCHEDULED",
1658 "item": "verticalscale",
1659 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1660 "target_record_id": target_record_id
,
1662 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1663 "flavor_dict": "flavor_dict",
1668 task_index
= "task_index_1"
1669 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1670 self
.assertEqual(result
[0], "DONE")
1671 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1674 class TestVimInteractionMigration(unittest
.TestCase
):
1676 module_name
= "osm_ro_plugin"
1677 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1678 self
.task_depends
= None
1680 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1682 # Enabling mocks and add cleanups
1683 for mock
in patches
:
1685 self
.addCleanup(mock
.stop
)
1687 def test__exec_migration_done(self
):
1692 logger
= "test_logger"
1693 my_vims
= "test-vim"
1699 target_record_id
= (
1700 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1701 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1704 instance
= VimInteractionMigration(db
, logger
, my_vims
, db_vims
)
1705 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1706 instance
, "logger", logging
1707 ), patch
.object(instance
, "db_vims", db_vims
):
1713 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1714 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1715 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1716 "status": "SCHEDULED",
1719 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1720 "target_record_id": target_record_id
,
1722 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1723 "migrate_host": "osm-test2",
1724 "vdu_vim_info": {0: {"interfaces": []}},
1729 self
.target_vim
.migrate_instance
.return_value
= "ACTIVE", "test"
1731 task_index
= "task_index_1"
1732 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1733 self
.assertEqual(result
[0], "DONE")
1734 self
.assertEqual(result
[1].get("vim_status"), "ACTIVE")