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 #######################################################################################
19 from unittest
.mock
import MagicMock
, Mock
, mock_open
, patch
21 from osm_common
.dbmemory
import DbMemory
22 from osm_ng_ro
.ns_thread
import (
26 VimInteractionAffinityGroup
,
27 VimInteractionMigration
,
31 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
33 # Variables used in tests
35 "my_target_vim": {"vim_type": "openstack"},
38 "my_target_vim": {"vim_type": "aws"},
42 class TestConfigValidate(unittest
.TestCase
):
48 "refresh_image": 3600,
54 def test__get_configuration(self
):
55 with self
.subTest(i
=1, t
="Get config attributes with config input"):
56 configuration
= ConfigValidate(self
.config_dict
)
57 self
.assertEqual(configuration
.active
, 65)
58 self
.assertEqual(configuration
.build
, 20)
59 self
.assertEqual(configuration
.image
, 3600)
60 self
.assertEqual(configuration
.error
, 300)
61 self
.assertEqual(configuration
.queue_size
, 50)
63 with self
.subTest(i
=2, t
="Unallowed refresh active input"):
64 # > 60 (except -1) is not allowed to set, so it should return default value 60
65 self
.config_dict
["period"]["refresh_active"] = 20
66 configuration
= ConfigValidate(self
.config_dict
)
67 self
.assertEqual(configuration
.active
, 60)
69 with self
.subTest(i
=3, t
="Config to disable VM status periodic checks"):
70 # -1 is allowed to set to disable VM status updates
71 self
.config_dict
["period"]["refresh_active"] = -1
72 configuration
= ConfigValidate(self
.config_dict
)
73 self
.assertEqual(configuration
.active
, -1)
76 class TestNsWorker(unittest
.TestCase
):
77 @patch("logging.getLogger", autospec
=True)
78 def setUp(self
, mock_logger
):
79 mock_logger
= logging
.getLogger()
80 mock_logger
.disabled
= True
81 self
.task_depends
= None
83 self
.db_vims
= db_vims_openstack
84 self
.db
= Mock(DbMemory())
85 self
.worker_index
= "worker-3"
90 "refresh_image": 3600,
94 "process_id": "343435353",
95 "global": {"task_locked_time": 16373242100.994312},
102 "target_id": "my_target_vim",
105 "created_items": None,
106 "vim_id": "test-vim-id",
107 "vim_name": "test-vim",
108 "vim_status": "DONE",
113 "modified_at": 1637324200.994312,
114 "created_at": 1637324200.994312,
115 "to_check_at": 16373242400.994312,
119 "action_id": "123456",
121 "task_id": "123456:1",
125 "target_record": "test_target_record",
126 "target_record_id": "test_target_record_id",
130 self
.instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, self
.db
)
131 self
.instance
.db_vims
= db_vims_openstack
132 self
.instance
.refresh_config
= Mock()
134 def get_disabled_tasks(self
, db
, status
):
135 db_disabled_tasks
= db
.get_list(
138 "tasks.status": status
,
142 return db_disabled_tasks
144 def test_update_vm_refresh_disabled_task_with_status_build_vim_openstack_with_refresh(
147 """1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1."""
148 # Disabled task with status build is not enabled again
150 self
.ro_task
["tasks"][0]["status"] = "BUILD"
151 self
.config
["period"]["refresh_active"] = 70
152 self
.ro_task
["to_check_at"] = -1
153 db
.create("ro_tasks", self
.ro_task
)
154 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "BUILD"))
155 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
156 instance
.update_vm_refresh(self
.ro_task
)
158 len(self
.get_disabled_tasks(db
, "BUILD")), disabled_tasks_count
161 def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_no_refresh(
164 """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1."""
165 # As refresh_active parameter is equal to -1, task is not be enabled to process again
167 self
.config
["period"]["refresh_active"] = -1
168 self
.ro_task
["tasks"][0]["status"] = "DONE"
169 self
.ro_task
["to_check_at"] = -1
170 db
.create("ro_tasks", self
.ro_task
)
171 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
172 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
173 instance
.update_vm_refresh(self
.ro_task
)
174 self
.assertEqual(len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
)
176 def test_update_vm_refresh_disabled_task_with_status_done_vim_aws_with_refresh(
179 """2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1."""
180 # Disabled tasks should be enabled to process again as vim type aws
182 self
.config
["period"]["refresh_active"] = 66
183 self
.ro_task
["tasks"][0]["status"] = "DONE"
184 self
.ro_task
["to_check_at"] = -1
185 db
.create("ro_tasks", self
.ro_task
)
186 self
.ro_task2
= self
.ro_task
187 self
.ro_task2
["_id"] = "122437:1"
188 db
.create("ro_tasks", self
.ro_task2
)
189 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
190 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
191 with patch
.object(instance
, "db_vims", db_vims_aws
):
192 instance
.update_vm_refresh(self
.ro_task
)
194 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
- 2
197 def test_update_vm_refresh_no_disabled_task_with_status_done_vim_openstack_with_refresh(
200 """No disabled task with status DONE in DB, refresh_active parameter is not equal to -1."""
201 # There is not any disabled task, method does not change anything
203 self
.config
["period"]["refresh_active"] = 66
204 self
.ro_task
["tasks"][0]["status"] = "DONE"
205 self
.ro_task
["to_check_at"] = 16373242400.994312
206 db
.create("ro_tasks", self
.ro_task
)
207 self
.ro_task2
= self
.ro_task
208 self
.ro_task2
["_id"] = "122437:1"
209 db
.create("ro_tasks", self
.ro_task2
)
210 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
211 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
212 instance
.update_vm_refresh(self
.ro_task
)
213 self
.assertEqual(len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
)
215 def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_with_refresh(
218 """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1, vim type is Openstack."""
219 # Disabled task with status done is not enabled again as vim type is openstack
221 self
.ro_task
["tasks"][0]["status"] = "DONE"
222 self
.ro_task
["to_check_at"] = -1
223 db
.create("ro_tasks", self
.ro_task
)
224 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
225 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
226 instance
.update_vm_refresh(self
.ro_task
)
227 self
.assertEqual(len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
)
229 def test_process_pending_tasks_status_done_vim_aws_no_refresh(self
):
230 """Refresh_active parameter is equal to -1, task status is DONE."""
231 # Task should be disabled to process again
233 self
.config
["period"]["refresh_active"] = -1
234 self
.ro_task
["tasks"][0]["status"] = "DONE"
235 self
.ro_task
["to_check_at"] = 16373242400.994312
236 db
.create("ro_tasks", self
.ro_task
)
237 # Number of disabled tasks in DB
238 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
239 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
240 with patch
.object(instance
, "db_vims", db_vims_aws
):
241 instance
._process
_pending
_tasks
(self
.ro_task
)
243 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
+ 1
246 def test_process_pending_tasks_status_failed_vim_aws_no_refresh(self
):
247 """Refresh_active parameter is equal to -1, task status is FAILED."""
248 # Task is not disabled to process as task status is not DONE
250 self
.config
["period"]["refresh_active"] = -1
251 self
.ro_task
["tasks"][0]["status"] = "FAILED"
252 self
.ro_task
["to_check_at"] = 16373242400.994312
253 db
.create("ro_tasks", self
.ro_task
)
254 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "FAILED"))
255 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
256 with patch
.object(instance
, "db_vims", db_vims_aws
):
257 instance
._process
_pending
_tasks
(self
.ro_task
)
259 len(self
.get_disabled_tasks(db
, "FAILED")), disabled_tasks_count
262 def test_process_pending_tasks_status_done_vim_aws_with_refresh(self
):
263 """Refresh_active parameter is not equal to -1, task status is DONE."""
264 # Task is not disabled to process as refresh_active parameter is not -1
266 self
.config
["period"]["refresh_active"] = 70
267 self
.ro_task
["tasks"][0]["status"] = "DONE"
268 self
.ro_task
["to_check_at"] = 16373242400.994312
269 db
.create("ro_tasks", self
.ro_task
)
270 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
271 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
272 with patch
.object(instance
, "db_vims", db_vims_aws
):
273 instance
._process
_pending
_tasks
(self
.ro_task
)
275 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
278 @patch("osm_ng_ro.ns_thread.makedirs", return_value
="")
279 def test_create_file_cert(self
, mock_makedirs
):
280 vim_config
= {"config": {"ca_cert_content": "test"}}
284 with
patch("builtins.open", mock_open()) as mocked_file
:
285 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
286 nsw
._process
_vim
_config
(target_id
, vim_config
)
287 mocked_file
.assert_called_once_with(
288 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
291 vim_config
["config"]["ca_cert"]
292 == f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
295 @patch("osm_ng_ro.ns_thread.makedirs")
296 @patch("osm_ng_ro.ns_thread.path")
297 def test_create_file_cert_exists(self
, mock_path
, mock_makedirs
):
298 vim_config
= {"config": {"ca_cert_content": "test"}}
301 mock_path
.isdir
.return_value
= True
303 with
patch("builtins.open", mock_open()) as mocked_file
:
304 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
305 nsw
._process
_vim
_config
(target_id
, vim_config
)
306 mock_makedirs
.assert_not_called()
307 mocked_file
.assert_called_once_with(
308 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
311 vim_config
["config"]["ca_cert"]
312 == f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
315 @patch("osm_ng_ro.ns_thread.path")
316 @patch("osm_ng_ro.ns_thread.makedirs", side_effect
=Exception)
317 def test_create_file_cert_makedirs_except(self
, mock_makedirs
, mock_path
):
318 vim_config
= {"config": {"ca_cert_content": "test"}}
321 mock_path
.isdir
.return_value
= False
323 with
patch("builtins.open", mock_open()) as mocked_file
:
324 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
325 with self
.assertRaises(NsWorkerException
):
326 nsw
._process
_vim
_config
(target_id
, vim_config
)
327 mocked_file
.assert_not_called()
328 assert vim_config
["config"]["ca_cert_content"] == "test"
330 @patch("osm_ng_ro.ns_thread.makedirs", return_value
="")
331 def test_create_file_cert_open_excepts(self
, mock_makedirs
):
332 vim_config
= {"config": {"ca_cert_content": "test"}}
336 with
patch("builtins.open", mock_open()) as mocked_file
:
337 mocked_file
.side_effect
= Exception
338 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
339 with self
.assertRaises(NsWorkerException
):
340 nsw
._process
_vim
_config
(target_id
, vim_config
)
341 mocked_file
.assert_called_once_with(
342 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
344 assert vim_config
["config"]["ca_cert_content"] == "test"
346 def test_get_next_refresh_vim_type_openstack(self
):
347 next_refresh
= 163535353434.3434
348 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
349 self
.assertEqual(result
, -1)
351 def test_get_next_refresh_vim_type_openstack_refresh_disabled(self
):
352 next_refresh
= 163535353434.3434
353 self
.instance
.refresh_config
.active
= -1
354 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
355 self
.assertEqual(result
, -1)
357 def test_get_next_refresh_vim_type_aws_refresh_disabled(self
):
358 self
.db_vims
= db_vims_aws
359 next_refresh
= 163535353434.3434
360 self
.instance
.refresh_config
.active
= -1
361 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
362 self
.assertEqual(result
, -1)
364 def test_get_next_refresh_vim_type_aws(self
):
365 self
.instance
.db_vims
= db_vims_aws
366 next_refresh
= 163535353434.3434
367 self
.instance
.refresh_config
.active
= 140
368 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
369 self
.assertEqual(result
, next_refresh
+ 140)
372 class TestVimInteractionNet(unittest
.TestCase
):
374 module_name
= "osm_ro_plugin"
375 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
376 self
.task_depends
= None
378 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
380 # Enabling mocks and add cleanups
383 self
.addCleanup(mock
.stop
)
385 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
387 mgmt network is set in find_params
388 management_network_id in vim config
389 More than one network found in the VIM
392 logger
= "test_logger"
397 "management_network_id": "test_mgmt_id",
402 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
403 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
404 instance
, "logger", logging
405 ), patch
.object(instance
, "db_vims", db_vims
):
411 "action_id": "123456",
413 "task_id": "123456:1",
414 "status": "SCHEDULED",
417 "target_record": "test_target_record",
418 "target_record_id": "test_target_record_id",
419 # values coming from extra_dict
423 "name": "some_mgmt_name",
425 "depends_on": "test_depends_on",
430 task_index
= "task_index_2"
431 self
.target_vim
.get_network_list
.return_value
= [
432 {"id": "existing_net_1"},
433 {"id": "existing_net_2"},
435 with self
.assertLogs() as captured
:
436 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
437 self
.assertEqual(len(captured
.records
), 1)
439 "More than one network found with this criteria"
440 in captured
.records
[0].getMessage()
442 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
443 self
.assertEqual(result
[0], "FAILED")
444 self
.assertEqual(result
[1].get("created"), False)
445 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
447 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
449 mgmt network is set in find_params
450 management_network_id in vim config
451 The network could not be found in the VIM
454 logger
= "test_logger"
459 "management_network_id": "test_mgmt_id",
464 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
465 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
466 instance
, "db_vims", db_vims
467 ), patch
.object(instance
, "logger", logging
):
473 "action_id": "123456",
475 "task_id": "123456:1",
476 "status": "SCHEDULED",
479 "target_record": "test_target_record",
480 "target_record_id": "test_target_record_id",
482 # values coming from extra_dict
485 "name": "some_mgmt_name",
487 "depends_on": "test_depends_on",
492 task_index
= "task_index_3"
493 self
.target_vim
.get_network_list
.return_value
= []
494 with self
.assertLogs() as captured
:
495 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
496 self
.assertEqual(len(captured
.records
), 1)
498 "Network not found with this criteria"
499 in captured
.records
[0].getMessage()
501 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
502 self
.assertEqual(result
[0], "FAILED")
503 self
.assertEqual(result
[1].get("created"), False)
504 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
506 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
508 mgmt network is set in find_params
509 vim config does not have management_network_id or management_network_id
510 The network could not be found in the VIM
513 logger
= "test_logger"
521 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
522 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
523 instance
, "db_vims", db_vims
524 ), patch
.object(instance
, "logger", logging
):
530 "action_id": "123456",
532 "task_id": "123456:1",
533 "status": "SCHEDULED",
536 "target_record": "test_target_record",
537 "target_record_id": "test_target_record_id",
539 # values coming from extra_dict
542 "name": "some_mgmt_name",
544 "depends_on": "test_depends_on",
549 task_index
= "task_index_3"
550 self
.target_vim
.get_network_list
.return_value
= []
551 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
552 "item1": "sample_created_item"
554 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
555 self
.assertEqual(result
[0], "BUILD")
556 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
557 self
.assertEqual(result
[1].get("created"), True)
558 self
.assertDictEqual(
559 result
[1].get("created_items"), {"item1": "sample_created_item"}
561 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
563 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
565 mgmt network is set in find_params
566 management_network_name in vim config
567 More than one network found in the VIM
570 logger
= "test_logger"
575 "management_network_name": "test_mgmt_name",
580 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
581 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
582 instance
, "logger", logging
583 ), patch
.object(instance
, "db_vims", db_vims
):
589 "action_id": "123456",
591 "task_id": "123456:1",
592 "status": "SCHEDULED",
595 "target_record": "test_target_record",
596 "target_record_id": "test_target_record_id",
597 # values coming from extra_dict
601 "name": "some_mgmt_name",
603 "depends_on": "test_depends_on",
608 task_index
= "task_index_4"
609 self
.target_vim
.get_network_list
.return_value
= [
610 {"id": "existing_net_1"},
611 {"id": "existing_net_2"},
613 with self
.assertLogs() as captured
:
614 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
615 self
.assertEqual(len(captured
.records
), 1)
617 "More than one network found with this criteria"
618 in captured
.records
[0].getMessage()
620 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
621 self
.assertEqual(result
[0], "FAILED")
622 self
.assertEqual(result
[1].get("created"), False)
623 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
625 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
627 mgmt network is set in find_params
628 management_network_name in vim config
629 The network could not be found in the VIM
632 logger
= "test_logger"
637 "management_network_name": "test_mgmt_name",
642 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
643 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
644 instance
, "logger", logging
645 ), patch
.object(instance
, "db_vims", db_vims
):
651 "action_id": "123456",
653 "task_id": "123456:1",
654 "status": "SCHEDULED",
657 "target_record": "test_target_record",
658 "target_record_id": "test_target_record_id",
659 # values coming from extra_dict
663 "name": "some_mgmt_name",
665 "depends_on": "test_depends_on",
670 task_index
= "task_index_5"
671 self
.target_vim
.get_network_list
.return_value
= []
672 with self
.assertLogs() as captured
:
673 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
674 self
.assertEqual(len(captured
.records
), 1)
676 "Network not found with this criteria"
677 in captured
.records
[0].getMessage()
679 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
680 self
.assertEqual(result
[0], "FAILED")
681 self
.assertEqual(result
[1].get("created"), False)
682 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
684 def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self
):
686 mgmt network is set in find_params
687 management_network_name in vim config
688 network_name is set in find_params.get('filterdict')
689 More than one network found in the VIM
692 logger
= "test_logger"
697 "management_network_name": "test_mgmt_name",
701 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
702 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
703 instance
, "logger", logging
704 ), patch
.object(instance
, "db_vims", db_vims
):
710 "action_id": "123456",
712 "task_id": "123456:1",
713 "status": "SCHEDULED",
716 "target_record": "test_target_record",
717 "target_record_id": "test_target_record_id",
718 # values coming from extra_dict
722 "name": "some-network-name",
725 "name": "some_mgmt_name",
727 "depends_on": "test_depends_on",
732 task_index
= "task_index_6"
733 self
.target_vim
.get_network_list
.return_value
= [
734 {"id": "existing_net_1"},
735 {"id": "existing_net_2"},
737 with self
.assertLogs() as captured
:
738 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
739 self
.assertEqual(len(captured
.records
), 1)
741 "More than one network found with this criteria"
742 in captured
.records
[0].getMessage()
744 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
745 self
.assertEqual(result
[0], "FAILED")
746 self
.assertEqual(result
[1].get("created"), False)
747 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
749 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
751 There is find_params in the task
752 No mgmt in find_params
753 No filter_dict in find_params
756 logger
= "test_logger"
761 "management_network_name": "test_mgmt_name",
765 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
766 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
767 instance
, "logger", logging
768 ), patch
.object(instance
, "db_vims", db_vims
):
774 "action_id": "123456",
776 "task_id": "123456:1",
777 "status": "SCHEDULED",
780 "target_record": "test_target_record",
781 "target_record_id": "test_target_record_id",
782 # values coming from extra_dict
784 "find_params": {"wrong_param": "wrong_value"},
785 "depends_on": "test_depends_on",
790 task_index
= "task_index_4"
791 with self
.assertLogs() as captured
:
792 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
793 self
.assertEqual(len(captured
.records
), 1)
795 "Invalid find_params for new_net"
796 in captured
.records
[0].getMessage()
798 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
799 self
.assertEqual(result
[0], "FAILED")
800 self
.assertEqual(result
[1].get("created"), False)
801 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
803 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
805 management_network_name in find_params.get('filterdict')
806 The network could not be found in the VIM
807 There are items in the task.get(params)
810 logger
= "test_logger"
815 "management_network_name": "test_mgmt_name",
819 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
820 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
821 instance
, "logger", logging
822 ), patch
.object(instance
, "db_vims", db_vims
):
828 "action_id": "123456",
830 "task_id": "123456:1",
831 "status": "SCHEDULED",
834 "target_record": "test_target_record",
835 "target_record_id": "test_target_record_id",
836 # values coming from extra_dict
838 "net_name": "test_params",
842 "name": "some-network-name",
845 "name": "some_mgmt_name",
847 "depends_on": "test_depends_on",
852 task_index
= "task_index_8"
853 self
.target_vim
.get_network_list
.return_value
= []
854 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
855 self
.assertEqual(result
[0], "BUILD")
856 self
.assertEqual(result
[1].get("created"), False)
857 self
.assertEqual(result
[1].get("vim_id"), None)
858 self
.assertEqual(result
[1].get("created_items"), {})
859 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
861 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
863 mgmt network is set in find_params
864 management_network_name in vim config
865 network_name is set in find_params.get('filterdict')
866 Any network could not be found in the VIM
869 logger
= "test_logger"
874 "management_network_name": "test_mgmt_name",
878 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
879 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
880 instance
, "logger", logging
881 ), patch
.object(instance
, "db_vims", db_vims
):
887 "action_id": "123456",
889 "task_id": "123456:1",
890 "status": "SCHEDULED",
893 "target_record": "test_target_record",
894 "target_record_id": "test_target_record_id",
895 # values coming from extra_dict
899 "name": "some-network-name",
902 "name": "some_mgmt_name",
904 "depends_on": "test_depends_on",
909 task_index
= "task_index_9"
910 self
.target_vim
.get_network_list
.return_value
= []
911 with self
.assertLogs() as captured
:
912 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
913 self
.assertEqual(len(captured
.records
), 1)
915 "Network not found with this criteria"
916 in captured
.records
[0].getMessage()
918 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
919 self
.assertEqual(result
[0], "FAILED")
920 self
.assertEqual(result
[1].get("created"), False)
921 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
923 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
925 mgmt network is set in find_params
927 network_name is set in find_params.get('filterdict')
928 Any network could not be found in the VIM
931 logger
= "test_logger"
938 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
939 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
940 instance
, "logger", logging
941 ), patch
.object(instance
, "db_vims", db_vims
):
947 "action_id": "123456",
949 "task_id": "123456:1",
950 "status": "SCHEDULED",
953 "target_record": "test_target_record",
954 "target_record_id": "test_target_record_id",
955 # values coming from extra_dict
959 "name": "some-network-name",
962 "name": "some_mgmt_name",
964 "depends_on": "test_depends_on",
969 task_index
= "task_index_9"
970 self
.target_vim
.get_network_list
.return_value
= []
971 with self
.assertLogs() as captured
:
972 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
973 self
.assertEqual(len(captured
.records
), 1)
975 "Network not found with this criteria"
976 in captured
.records
[0].getMessage()
978 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
979 self
.assertEqual(result
[0], "FAILED")
980 self
.assertEqual(result
[1].get("created"), False)
981 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
983 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
985 mgmt network is set in find_params
986 management_network_name is not in db_vims.get('config')
987 One network found in the VIM
990 logger
= "test_logger"
997 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
998 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
999 instance
, "logger", logging
1000 ), patch
.object(instance
, "db_vims", db_vims
):
1006 "action_id": "123456",
1008 "task_id": "123456:1",
1009 "status": "SCHEDULED",
1011 "item": "test_item",
1012 "target_record": "test_target_record",
1013 "target_record_id": "test_target_record_id",
1014 # values coming from extra_dict
1018 "name": "some_mgmt_name",
1020 "depends_on": "test_depends_on",
1025 task_index
= "task_index_2"
1026 self
.target_vim
.get_network_list
.return_value
= [
1027 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
1029 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1030 self
.assertEqual(result
[0], "BUILD")
1031 self
.assertEqual(result
[1].get("created"), False)
1032 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
1034 def test__params_in_task_no_find_params(self
):
1037 find_params does not exist in the task
1040 logger
= "test_logger"
1041 my_vims
= "test-vim"
1045 "management_network_name": "test_mgmt_name",
1049 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1050 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1051 instance
, "logger", logging
1052 ), patch
.object(instance
, "db_vims", db_vims
):
1058 "action_id": "123456",
1060 "task_id": "123456:1",
1061 "status": "SCHEDULED",
1063 "item": "test_item",
1064 "target_record": "test_target_record",
1065 "target_record_id": "test_target_record_id",
1066 # values coming from extra_dict
1068 "net_name": "test-network",
1071 "depends_on": "test_depends_on",
1076 task_index
= "task_index_11"
1077 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
1078 "item1": "sample_created_item"
1080 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1081 self
.assertEqual(result
[0], "BUILD")
1082 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
1083 self
.assertEqual(result
[1].get("created"), True)
1085 result
[1].get("created_items"), {"item1": "sample_created_item"}
1087 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
1089 def test__no_params_in_task_no_find_params(self
):
1091 empty params in the task
1092 find_params does not exist in the task
1095 logger
= "test_logger"
1096 my_vims
= "test-vim"
1100 "management_network_name": "test_mgmt_name",
1104 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1105 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1106 instance
, "logger", logging
1107 ), patch
.object(instance
, "db_vims", db_vims
):
1113 "action_id": "123456",
1115 "task_id": "123456:1",
1116 "status": "SCHEDULED",
1118 "item": "test_item",
1119 "target_record": "test_target_record",
1120 "target_record_id": "test_target_record_id",
1121 # values coming from extra_dict
1123 "depends_on": "test_depends_on",
1128 task_index
= "task_index_12"
1129 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
1130 "VimConnConnectionException occurred."
1132 with self
.assertLogs() as captured
:
1133 instance
.new(ro_task
, task_index
, self
.task_depends
)
1134 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1136 def test__refresh_ro_task_vim_status_active(self
):
1138 vim_info.get('status') is ACTIVE
1141 logger
= "test_logger"
1142 my_vims
= "test-vim"
1144 "vim_openstack_1": {
1146 "vim_type": "openstack",
1149 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1151 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1152 ), patch
.object(instance
, "logger", logging
), patch
.object(
1153 instance
, "db_vims", db_vims
1159 "target_id": "vim_openstack_1",
1162 "created_items": None,
1163 "vim_id": "test-vim-id",
1164 "vim_name": "test-vim",
1166 "vim_details": "some-details",
1167 "vim_message": None,
1170 "modified_at": 1637324200.994312,
1171 "created_at": 1637324200.994312,
1172 "to_check_at": 1637324200.994312,
1176 self
.target_vim
.refresh_nets_status
.return_value
= {
1178 "vim_info": "some-details",
1184 task_status
= "DONE"
1185 ro_vim_item_update
= {
1186 "vim_status": "ACTIVE",
1188 result
= instance
.refresh(ro_task
)
1189 self
.assertEqual(result
[0], task_status
)
1190 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1192 def test__refresh_ro_task_vim_status_build(self
):
1194 vim_info.get('status') is BUILD
1197 logger
= "test_logger"
1198 my_vims
= "test-vim"
1200 "vim_openstack_1": {
1202 "vim_type": "openstack",
1205 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1207 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1208 ), patch
.object(instance
, "logger", logging
), patch
.object(
1209 instance
, "db_vims", db_vims
1215 "target_id": "vim_openstack_1",
1218 "created_items": None,
1219 "vim_id": "test-vim-id",
1220 "vim_name": "test-vim",
1221 "vim_status": "BUILD",
1223 "vim_message": None,
1226 "modified_at": 1637324200.994312,
1227 "created_at": 1637324200.994312,
1228 "to_check_at": 1637324200.994312,
1232 self
.target_vim
.refresh_nets_status
.return_value
= {
1234 "vim_info": "some-details",
1236 "name": "other-vim",
1240 task_status
= "BUILD"
1241 ro_vim_item_update
= {
1242 "vim_name": "other-vim",
1243 "vim_details": "some-details",
1245 result
= instance
.refresh(ro_task
)
1246 self
.assertEqual(result
[0], task_status
)
1247 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1249 def test__refresh_ro_task_vim_status_error(self
):
1251 vim_info.get('status') is ERROR
1254 logger
= "test_logger"
1255 my_vims
= "test-vim"
1257 "vim_openstack_1": {
1259 "vim_type": "openstack",
1262 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1264 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1265 ), patch
.object(instance
, "logger", logging
), patch
.object(
1266 instance
, "db_vims", db_vims
1272 "target_id": "vim_openstack_1",
1275 "created_items": None,
1276 "vim_id": "test-vim-id",
1277 "vim_name": "test-vim",
1278 "vim_status": "BUILD",
1280 "vim_message": None,
1283 "modified_at": 1637324200.994312,
1284 "created_at": 1637324200.994312,
1285 "to_check_at": 1637324200.994312,
1289 self
.target_vim
.refresh_nets_status
.return_value
= {
1291 "vim_info": "some-details",
1294 "error_msg": "some error message",
1297 task_status
= "FAILED"
1298 ro_vim_item_update
= {
1299 "vim_status": "ERROR",
1300 "vim_message": "some error message",
1302 result
= instance
.refresh(ro_task
)
1303 self
.assertEqual(result
[0], task_status
)
1304 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1306 def test__refresh_ro_task_VimConnException_occurred(self
):
1308 vimconn.VimConnException has occured
1311 logger
= "test_logger"
1312 my_vims
= "test-vim"
1314 "vim_openstack_1": {
1316 "vim_type": "openstack",
1319 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1321 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1322 ), patch
.object(instance
, "logger", logging
), patch
.object(
1323 instance
, "db_vims", db_vims
1329 "target_id": "vim_openstack_1",
1332 "created_items": None,
1333 "vim_id": "test-vim-id",
1334 "vim_name": "test-vim",
1335 "vim_status": "BUILD",
1337 "vim_message": None,
1340 "modified_at": 1637324200.994312,
1341 "created_at": 1637324200.994312,
1342 "to_check_at": 1637324200.994312,
1345 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
1346 "VimConnException occurred."
1348 with self
.assertLogs() as captured
:
1349 instance
.refresh(ro_task
)
1350 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1352 def test__refresh_ro_task_vim_status_deleted(self
):
1354 vim_info.get('status') is DELETED
1357 logger
= "test_logger"
1358 my_vims
= "test-vim"
1360 "vim_openstack_1": {
1362 "vim_type": "openstack",
1365 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1367 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1368 ), patch
.object(instance
, "logger", logging
), patch
.object(
1369 instance
, "db_vims", db_vims
1375 "target_id": "vim_openstack_1",
1378 "created_items": None,
1379 "vim_id": "test-vim-id",
1380 "vim_name": "test-vim",
1381 "vim_status": "BUILD",
1383 "vim_message": None,
1386 "modified_at": 163724200.994312,
1387 "created_at": 1637324200.994312,
1388 "to_check_at": 1637324200.994312,
1391 self
.target_vim
.refresh_nets_status
.return_value
= {
1393 "vim_info": "some-details",
1394 "status": "DELETED",
1396 "error_msg": "some error message",
1399 task_status
= "FAILED"
1400 ro_vim_item_update
= {
1401 "vim_status": "DELETED",
1402 "vim_message": "Deleted externally",
1405 result
= instance
.refresh(ro_task
)
1406 self
.assertEqual(result
[0], task_status
)
1407 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1409 def test__refresh_ro_task_empty_vim_dict(self
):
1411 vim_dict does not include vim_id key
1415 logger
= "test_logger"
1416 my_vims
= "test-vim"
1418 "vim_openstack_2": {
1422 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1424 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1425 ), patch
.object(instance
, "logger", logging
), patch
.object(
1426 instance
, "db_vims", db_vims
1432 "target_id": "vim_openstack_2",
1435 "created_items": None,
1436 "vim_id": "test-vim-id",
1437 "vim_name": "test-vim",
1438 "vim_status": "BUILD",
1440 "vim_message": None,
1443 "modified_at": 163724211.994312,
1444 "created_at": 1637324211.994312,
1445 "to_check_at": 1637324211.994312,
1448 self
.target_vim
.refresh_nets_status
.return_value
= {}
1449 with self
.assertRaises(KeyError):
1450 instance
.refresh(ro_task
)
1453 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1455 module_name
= "osm_ro_plugin"
1456 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1457 self
.task_depends
= None
1459 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1461 # Enabling mocks and add cleanups
1462 for mock
in patches
:
1464 self
.addCleanup(mock
.stop
)
1466 def test__new_affinity_group_ok(self
):
1468 create affinity group with attributes set in params
1471 logger
= "test_logger"
1472 my_vims
= "test-vim"
1479 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1480 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1481 instance
, "logger", logging
1482 ), patch
.object(instance
, "db_vims", db_vims
):
1488 "action_id": "123456",
1490 "task_id": "123456:1",
1491 "status": "SCHEDULED",
1493 "item": "test_item",
1494 "target_record": "test_target_record",
1495 "target_record_id": "test_target_record_id",
1496 # values coming from extra_dict
1498 "affinity_group_data": {
1499 "name": "affinity_group_1",
1501 "scope": "nfvi-node",
1505 "depends_on": "test_depends_on",
1510 task_index
= "task_index_1"
1511 self
.target_vim
.new_affinity_group
.return_value
= (
1512 "sample_affinity_group_id_1"
1514 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1515 self
.assertEqual(result
[0], "DONE")
1516 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1517 self
.assertEqual(result
[1].get("created"), True)
1518 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1520 def test__new_affinity_group_failed(self
):
1522 create affinity group with no attributes set in params
1525 logger
= "test_logger"
1526 my_vims
= "test-vim"
1533 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1534 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1535 instance
, "logger", logging
1536 ), patch
.object(instance
, "db_vims", db_vims
):
1542 "action_id": "123456",
1544 "task_id": "123456:1",
1545 "status": "SCHEDULED",
1547 "item": "test_item",
1548 "target_record": "test_target_record",
1549 "target_record_id": "test_target_record_id",
1550 # values coming from extra_dict
1553 "depends_on": "test_depends_on",
1558 task_index
= "task_index_2"
1559 self
.target_vim
.new_affinity_group
.return_value
= (
1560 "sample_affinity_group_id_1"
1562 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1563 self
.assertEqual(result
[0], "DONE")
1564 self
.assertEqual(result
[1].get("vim_id"), None)
1565 self
.assertEqual(result
[1].get("created"), False)
1566 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1568 def test__delete_affinity_group_ok(self
):
1570 delete affinity group with a proper 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,
1596 "vim_id": "sample_affinity_group_id_3",
1597 "vim_name": "sample_affinity_group_id_3",
1599 "vim_details": "some-details",
1600 "vim_message": None,
1605 task_index
= "task_index_3"
1606 self
.target_vim
.delete_affinity_group
.return_value
= (
1607 "sample_affinity_group_id_3"
1609 result
= instance
.delete(ro_task
, task_index
)
1610 self
.assertEqual(result
[0], "DONE")
1611 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1612 self
.assertEqual(result
[1].get("created"), False)
1613 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1615 def test__delete_affinity_group_failed(self
):
1617 delete affinity group with missing vim_id
1620 logger
= "test_logger"
1621 my_vims
= "test-vim"
1628 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1629 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1630 instance
, "logger", logging
1631 ), patch
.object(instance
, "db_vims", db_vims
):
1637 "task_id": "123456:1",
1642 "created_items": None,
1646 "vim_details": "some-details",
1647 "vim_message": None,
1652 task_index
= "task_index_4"
1653 self
.target_vim
.delete_affinity_group
.return_value
= ""
1654 result
= instance
.delete(ro_task
, task_index
)
1655 self
.assertEqual(result
[0], "DONE")
1656 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1657 self
.assertEqual(result
[1].get("created"), False)
1658 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1661 class TestVimInteractionResize(unittest
.TestCase
):
1663 module_name
= "osm_ro_plugin"
1664 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1665 self
.task_depends
= None
1667 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1669 # Enabling mocks and add cleanups
1670 for mock
in patches
:
1672 self
.addCleanup(mock
.stop
)
1674 def test__exec_resize_done(self
):
1676 create verticalscale task
1679 logger
= "test_logger"
1680 my_vims
= "test-vim"
1686 target_record_id
= (
1687 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1688 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1691 instance
= VimInteractionResize(db
, logger
, my_vims
, db_vims
)
1692 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1693 instance
, "logger", logging
1694 ), patch
.object(instance
, "db_vims", db_vims
):
1700 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1701 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1702 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1703 "status": "SCHEDULED",
1705 "item": "verticalscale",
1706 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1707 "target_record_id": target_record_id
,
1709 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1710 "flavor_dict": "flavor_dict",
1715 task_index
= "task_index_1"
1716 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1717 self
.assertEqual(result
[0], "DONE")
1718 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1721 class TestVimInteractionMigration(unittest
.TestCase
):
1723 module_name
= "osm_ro_plugin"
1724 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1725 self
.task_depends
= None
1727 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1729 # Enabling mocks and add cleanups
1730 for mock
in patches
:
1732 self
.addCleanup(mock
.stop
)
1734 def test__exec_migration_done(self
):
1739 logger
= "test_logger"
1740 my_vims
= "test-vim"
1746 target_record_id
= (
1747 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1748 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1751 instance
= VimInteractionMigration(db
, logger
, my_vims
, db_vims
)
1752 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1753 instance
, "logger", logging
1754 ), patch
.object(instance
, "db_vims", db_vims
):
1760 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1761 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1762 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1763 "status": "SCHEDULED",
1766 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1767 "target_record_id": target_record_id
,
1769 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1770 "migrate_host": "osm-test2",
1771 "vdu_vim_info": {0: {"interfaces": []}},
1776 self
.target_vim
.migrate_instance
.return_value
= "ACTIVE", "test"
1778 task_index
= "task_index_1"
1779 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1780 self
.assertEqual(result
[0], "DONE")
1781 self
.assertEqual(result
[1].get("vim_status"), "ACTIVE")