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
,
30 VimInteractionSharedVolume
,
32 from osm_ro_plugin
.vimconn
import VimConnConnectionException
, VimConnException
34 # Variables used in tests
36 "my_target_vim": {"vim_type": "openstack"},
39 "my_target_vim": {"vim_type": "aws"},
43 class TestConfigValidate(unittest
.TestCase
):
49 "refresh_image": 3600,
55 def test__get_configuration(self
):
56 with self
.subTest(i
=1, t
="Get config attributes with config input"):
57 configuration
= ConfigValidate(self
.config_dict
)
58 self
.assertEqual(configuration
.active
, 65)
59 self
.assertEqual(configuration
.build
, 20)
60 self
.assertEqual(configuration
.image
, 3600)
61 self
.assertEqual(configuration
.error
, 300)
62 self
.assertEqual(configuration
.queue_size
, 50)
64 with self
.subTest(i
=2, t
="Unallowed refresh active input"):
65 # > 60 (except -1) is not allowed to set, so it should return default value 60
66 self
.config_dict
["period"]["refresh_active"] = 20
67 configuration
= ConfigValidate(self
.config_dict
)
68 self
.assertEqual(configuration
.active
, 60)
70 with self
.subTest(i
=3, t
="Config to disable VM status periodic checks"):
71 # -1 is allowed to set to disable VM status updates
72 self
.config_dict
["period"]["refresh_active"] = -1
73 configuration
= ConfigValidate(self
.config_dict
)
74 self
.assertEqual(configuration
.active
, -1)
77 class TestNsWorker(unittest
.TestCase
):
78 @patch("logging.getLogger", autospec
=True)
79 def setUp(self
, mock_logger
):
80 mock_logger
= logging
.getLogger()
81 mock_logger
.disabled
= True
82 self
.task_depends
= None
84 self
.db_vims
= db_vims_openstack
85 self
.db
= Mock(DbMemory())
86 self
.worker_index
= "worker-3"
91 "refresh_image": 3600,
95 "process_id": "343435353",
96 "global": {"task_locked_time": 16373242100.994312},
103 "target_id": "my_target_vim",
106 "created_items": None,
107 "vim_id": "test-vim-id",
108 "vim_name": "test-vim",
109 "vim_status": "DONE",
114 "modified_at": 1637324200.994312,
115 "created_at": 1637324200.994312,
116 "to_check_at": 16373242400.994312,
120 "action_id": "123456",
122 "task_id": "123456:1",
126 "target_record": "test_target_record",
127 "target_record_id": "test_target_record_id",
131 self
.instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, self
.db
)
132 self
.instance
.db_vims
= db_vims_openstack
133 self
.instance
.refresh_config
= Mock()
135 def get_disabled_tasks(self
, db
, status
):
136 db_disabled_tasks
= db
.get_list(
139 "tasks.status": status
,
143 return db_disabled_tasks
145 def test_update_vm_refresh_disabled_task_with_status_build_vim_openstack_with_refresh(
148 """1 disabled task with status BUILD in DB, refresh_active parameter is not equal to -1."""
149 # Disabled task with status build is not enabled again
151 self
.ro_task
["tasks"][0]["status"] = "BUILD"
152 self
.config
["period"]["refresh_active"] = 70
153 self
.ro_task
["to_check_at"] = -1
154 db
.create("ro_tasks", self
.ro_task
)
155 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "BUILD"))
156 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
157 instance
.update_vm_refresh(self
.ro_task
)
159 len(self
.get_disabled_tasks(db
, "BUILD")), disabled_tasks_count
162 def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_no_refresh(
165 """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1."""
166 # As refresh_active parameter is equal to -1, task is not be enabled to process again
168 self
.config
["period"]["refresh_active"] = -1
169 self
.ro_task
["tasks"][0]["status"] = "DONE"
170 self
.ro_task
["to_check_at"] = -1
171 db
.create("ro_tasks", self
.ro_task
)
172 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
173 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
174 instance
.update_vm_refresh(self
.ro_task
)
175 self
.assertEqual(len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
)
177 def test_update_vm_refresh_disabled_task_with_status_done_vim_aws_with_refresh(
180 """2 disabled task with status DONE in DB, refresh_active parameter is not equal to -1."""
181 # Disabled tasks should be enabled to process again as vim type aws
183 self
.config
["period"]["refresh_active"] = 66
184 self
.ro_task
["tasks"][0]["status"] = "DONE"
185 self
.ro_task
["to_check_at"] = -1
186 db
.create("ro_tasks", self
.ro_task
)
187 self
.ro_task2
= self
.ro_task
188 self
.ro_task2
["_id"] = "122437:1"
189 db
.create("ro_tasks", self
.ro_task2
)
190 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
191 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
192 with patch
.object(instance
, "db_vims", db_vims_aws
):
193 instance
.update_vm_refresh(self
.ro_task
)
195 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
- 2
198 def test_update_vm_refresh_no_disabled_task_with_status_done_vim_openstack_with_refresh(
201 """No disabled task with status DONE in DB, refresh_active parameter is not equal to -1."""
202 # There is not any disabled task, method does not change anything
204 self
.config
["period"]["refresh_active"] = 66
205 self
.ro_task
["tasks"][0]["status"] = "DONE"
206 self
.ro_task
["to_check_at"] = 16373242400.994312
207 db
.create("ro_tasks", self
.ro_task
)
208 self
.ro_task2
= self
.ro_task
209 self
.ro_task2
["_id"] = "122437:1"
210 db
.create("ro_tasks", self
.ro_task2
)
211 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
212 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
213 instance
.update_vm_refresh(self
.ro_task
)
214 self
.assertEqual(len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
)
216 def test_update_vm_refresh_disabled_task_with_status_done_vim_openstack_with_refresh(
219 """1 disabled task with status DONE in DB, refresh_active parameter is equal to -1, vim type is Openstack."""
220 # Disabled task with status done is not enabled again as vim type is openstack
222 self
.ro_task
["tasks"][0]["status"] = "DONE"
223 self
.ro_task
["to_check_at"] = -1
224 db
.create("ro_tasks", self
.ro_task
)
225 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
226 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
227 instance
.update_vm_refresh(self
.ro_task
)
228 self
.assertEqual(len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
)
230 def test_process_pending_tasks_status_done_vim_aws_no_refresh(self
):
231 """Refresh_active parameter is equal to -1, task status is DONE."""
232 # Task should be disabled to process again
234 self
.config
["period"]["refresh_active"] = -1
235 self
.ro_task
["tasks"][0]["status"] = "DONE"
236 self
.ro_task
["to_check_at"] = 16373242400.994312
237 db
.create("ro_tasks", self
.ro_task
)
238 # Number of disabled tasks in DB
239 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
240 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
241 with patch
.object(instance
, "db_vims", db_vims_aws
):
242 instance
._process
_pending
_tasks
(self
.ro_task
)
244 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
+ 1
247 def test_process_pending_tasks_status_failed_vim_aws_no_refresh(self
):
248 """Refresh_active parameter is equal to -1, task status is FAILED."""
249 # Task is not disabled to process as task status is not DONE
251 self
.config
["period"]["refresh_active"] = -1
252 self
.ro_task
["tasks"][0]["status"] = "FAILED"
253 self
.ro_task
["to_check_at"] = 16373242400.994312
254 db
.create("ro_tasks", self
.ro_task
)
255 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "FAILED"))
256 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
257 with patch
.object(instance
, "db_vims", db_vims_aws
):
258 instance
._process
_pending
_tasks
(self
.ro_task
)
260 len(self
.get_disabled_tasks(db
, "FAILED")), disabled_tasks_count
263 def test_process_pending_tasks_status_done_vim_aws_with_refresh(self
):
264 """Refresh_active parameter is not equal to -1, task status is DONE."""
265 # Task is not disabled to process as refresh_active parameter is not -1
267 self
.config
["period"]["refresh_active"] = 70
268 self
.ro_task
["tasks"][0]["status"] = "DONE"
269 self
.ro_task
["to_check_at"] = 16373242400.994312
270 db
.create("ro_tasks", self
.ro_task
)
271 disabled_tasks_count
= len(self
.get_disabled_tasks(db
, "DONE"))
272 instance
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
273 with patch
.object(instance
, "db_vims", db_vims_aws
):
274 instance
._process
_pending
_tasks
(self
.ro_task
)
276 len(self
.get_disabled_tasks(db
, "DONE")), disabled_tasks_count
279 @patch("osm_ng_ro.ns_thread.makedirs", return_value
="")
280 def test_create_file_cert(self
, mock_makedirs
):
281 vim_config
= {"config": {"ca_cert_content": "test"}}
285 with
patch("builtins.open", mock_open()) as mocked_file
:
286 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
287 nsw
._process
_vim
_config
(target_id
, vim_config
)
288 mocked_file
.assert_called_once_with(
289 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
292 vim_config
["config"]["ca_cert"]
293 == f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
296 @patch("osm_ng_ro.ns_thread.makedirs")
297 @patch("osm_ng_ro.ns_thread.path")
298 def test_create_file_cert_exists(self
, mock_path
, mock_makedirs
):
299 vim_config
= {"config": {"ca_cert_content": "test"}}
302 mock_path
.isdir
.return_value
= True
304 with
patch("builtins.open", mock_open()) as mocked_file
:
305 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
306 nsw
._process
_vim
_config
(target_id
, vim_config
)
307 mock_makedirs
.assert_not_called()
308 mocked_file
.assert_called_once_with(
309 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
312 vim_config
["config"]["ca_cert"]
313 == f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert"
316 @patch("osm_ng_ro.ns_thread.path")
317 @patch("osm_ng_ro.ns_thread.makedirs", side_effect
=Exception)
318 def test_create_file_cert_makedirs_except(self
, mock_makedirs
, mock_path
):
319 vim_config
= {"config": {"ca_cert_content": "test"}}
322 mock_path
.isdir
.return_value
= False
324 with
patch("builtins.open", mock_open()) as mocked_file
:
325 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
326 with self
.assertRaises(NsWorkerException
):
327 nsw
._process
_vim
_config
(target_id
, vim_config
)
328 mocked_file
.assert_not_called()
329 assert vim_config
["config"]["ca_cert_content"] == "test"
331 @patch("osm_ng_ro.ns_thread.makedirs", return_value
="")
332 def test_create_file_cert_open_excepts(self
, mock_makedirs
):
333 vim_config
= {"config": {"ca_cert_content": "test"}}
337 with
patch("builtins.open", mock_open()) as mocked_file
:
338 mocked_file
.side_effect
= Exception
339 nsw
= NsWorker(self
.worker_index
, self
.config
, self
.plugins
, db
)
340 with self
.assertRaises(NsWorkerException
):
341 nsw
._process
_vim
_config
(target_id
, vim_config
)
342 mocked_file
.assert_called_once_with(
343 f
"/app/osm_ro/certs/{target_id}:{self.worker_index}/ca_cert", "w"
345 assert vim_config
["config"]["ca_cert_content"] == "test"
347 def test_get_next_refresh_vim_type_openstack(self
):
348 next_refresh
= 163535353434.3434
349 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
350 self
.assertEqual(result
, -1)
352 def test_get_next_refresh_vim_type_openstack_refresh_disabled(self
):
353 next_refresh
= 163535353434.3434
354 self
.instance
.refresh_config
.active
= -1
355 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
356 self
.assertEqual(result
, -1)
358 def test_get_next_refresh_vim_type_aws_refresh_disabled(self
):
359 self
.db_vims
= db_vims_aws
360 next_refresh
= 163535353434.3434
361 self
.instance
.refresh_config
.active
= -1
362 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
363 self
.assertEqual(result
, -1)
365 def test_get_next_refresh_vim_type_aws(self
):
366 self
.instance
.db_vims
= db_vims_aws
367 next_refresh
= 163535353434.3434
368 self
.instance
.refresh_config
.active
= 140
369 result
= self
.instance
._get
_next
_refresh
(self
.ro_task
, next_refresh
)
370 self
.assertEqual(result
, next_refresh
+ 140)
373 class TestVimInteractionNet(unittest
.TestCase
):
375 module_name
= "osm_ro_plugin"
376 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
377 self
.task_depends
= None
379 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
381 # Enabling mocks and add cleanups
384 self
.addCleanup(mock
.stop
)
386 def test__mgmt_net_id_in_find_params_mgmt_several_vim_nets(self
):
388 mgmt network is set in find_params
389 management_network_id in vim config
390 More than one network found in the VIM
393 logger
= "test_logger"
398 "management_network_id": "test_mgmt_id",
403 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
404 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
405 instance
, "logger", logging
406 ), patch
.object(instance
, "db_vims", db_vims
):
412 "action_id": "123456",
414 "task_id": "123456:1",
415 "status": "SCHEDULED",
418 "target_record": "test_target_record",
419 "target_record_id": "test_target_record_id",
420 # values coming from extra_dict
424 "name": "some_mgmt_name",
426 "depends_on": "test_depends_on",
431 task_index
= "task_index_2"
432 self
.target_vim
.get_network_list
.return_value
= [
433 {"id": "existing_net_1"},
434 {"id": "existing_net_2"},
436 with self
.assertLogs() as captured
:
437 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
438 self
.assertEqual(len(captured
.records
), 1)
440 "More than one network found with this criteria"
441 in captured
.records
[0].getMessage()
443 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
444 self
.assertEqual(result
[0], "FAILED")
445 self
.assertEqual(result
[1].get("created"), False)
446 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
448 def test__mgmt_net_id_in_find_params_mgmt_no_vim_nets(self
):
450 mgmt network is set in find_params
451 management_network_id in vim config
452 The network could not be found in the VIM
455 logger
= "test_logger"
460 "management_network_id": "test_mgmt_id",
465 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
466 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
467 instance
, "db_vims", db_vims
468 ), patch
.object(instance
, "logger", logging
):
474 "action_id": "123456",
476 "task_id": "123456:1",
477 "status": "SCHEDULED",
480 "target_record": "test_target_record",
481 "target_record_id": "test_target_record_id",
483 # values coming from extra_dict
486 "name": "some_mgmt_name",
488 "depends_on": "test_depends_on",
493 task_index
= "task_index_3"
494 self
.target_vim
.get_network_list
.return_value
= []
495 with self
.assertLogs() as captured
:
496 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
497 self
.assertEqual(len(captured
.records
), 1)
499 "Network not found with this criteria"
500 in captured
.records
[0].getMessage()
502 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
503 self
.assertEqual(result
[0], "FAILED")
504 self
.assertEqual(result
[1].get("created"), False)
505 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
507 def test__mgmt_net_in_find_params_no_vim_config_no_vim_nets(self
):
509 mgmt network is set in find_params
510 vim config does not have management_network_id or management_network_id
511 The network could not be found in the VIM
514 logger
= "test_logger"
522 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
523 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
524 instance
, "db_vims", db_vims
525 ), patch
.object(instance
, "logger", logging
):
531 "action_id": "123456",
533 "task_id": "123456:1",
534 "status": "SCHEDULED",
537 "target_record": "test_target_record",
538 "target_record_id": "test_target_record_id",
540 # values coming from extra_dict
543 "name": "some_mgmt_name",
545 "depends_on": "test_depends_on",
550 task_index
= "task_index_3"
551 self
.target_vim
.get_network_list
.return_value
= []
552 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
553 "item1": "sample_created_item"
555 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
556 self
.assertEqual(result
[0], "BUILD")
557 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
558 self
.assertEqual(result
[1].get("created"), True)
559 self
.assertDictEqual(
560 result
[1].get("created_items"), {"item1": "sample_created_item"}
562 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
564 def test__mgmt_net_name_in_find_params_mgmt_several_vim_nets(self
):
566 mgmt network is set in find_params
567 management_network_name in vim config
568 More than one network found in the VIM
571 logger
= "test_logger"
576 "management_network_name": "test_mgmt_name",
581 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
582 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
583 instance
, "logger", logging
584 ), patch
.object(instance
, "db_vims", db_vims
):
590 "action_id": "123456",
592 "task_id": "123456:1",
593 "status": "SCHEDULED",
596 "target_record": "test_target_record",
597 "target_record_id": "test_target_record_id",
598 # values coming from extra_dict
602 "name": "some_mgmt_name",
604 "depends_on": "test_depends_on",
609 task_index
= "task_index_4"
610 self
.target_vim
.get_network_list
.return_value
= [
611 {"id": "existing_net_1"},
612 {"id": "existing_net_2"},
614 with self
.assertLogs() as captured
:
615 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
616 self
.assertEqual(len(captured
.records
), 1)
618 "More than one network found with this criteria"
619 in captured
.records
[0].getMessage()
621 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
622 self
.assertEqual(result
[0], "FAILED")
623 self
.assertEqual(result
[1].get("created"), False)
624 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
626 def test__mgmt_net_name_in_find_params_mgmt_no_vim_nets(self
):
628 mgmt network is set in find_params
629 management_network_name in vim config
630 The network could not be found in the VIM
633 logger
= "test_logger"
638 "management_network_name": "test_mgmt_name",
643 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
644 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
645 instance
, "logger", logging
646 ), patch
.object(instance
, "db_vims", db_vims
):
652 "action_id": "123456",
654 "task_id": "123456:1",
655 "status": "SCHEDULED",
658 "target_record": "test_target_record",
659 "target_record_id": "test_target_record_id",
660 # values coming from extra_dict
664 "name": "some_mgmt_name",
666 "depends_on": "test_depends_on",
671 task_index
= "task_index_5"
672 self
.target_vim
.get_network_list
.return_value
= []
673 with self
.assertLogs() as captured
:
674 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
675 self
.assertEqual(len(captured
.records
), 1)
677 "Network not found with this criteria"
678 in captured
.records
[0].getMessage()
680 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
681 self
.assertEqual(result
[0], "FAILED")
682 self
.assertEqual(result
[1].get("created"), False)
683 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
685 def test__mgmt_net_name_in_find_params_filterdict_several_vim_nets(self
):
687 mgmt network is set in find_params
688 management_network_name in vim config
689 network_name is set in find_params.get('filterdict')
690 More than one network found in the VIM
693 logger
= "test_logger"
698 "management_network_name": "test_mgmt_name",
702 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
703 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
704 instance
, "logger", logging
705 ), patch
.object(instance
, "db_vims", db_vims
):
711 "action_id": "123456",
713 "task_id": "123456:1",
714 "status": "SCHEDULED",
717 "target_record": "test_target_record",
718 "target_record_id": "test_target_record_id",
719 # values coming from extra_dict
723 "name": "some-network-name",
726 "name": "some_mgmt_name",
728 "depends_on": "test_depends_on",
733 task_index
= "task_index_6"
734 self
.target_vim
.get_network_list
.return_value
= [
735 {"id": "existing_net_1"},
736 {"id": "existing_net_2"},
738 with self
.assertLogs() as captured
:
739 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
740 self
.assertEqual(len(captured
.records
), 1)
742 "More than one network found with this criteria"
743 in captured
.records
[0].getMessage()
745 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
746 self
.assertEqual(result
[0], "FAILED")
747 self
.assertEqual(result
[1].get("created"), False)
748 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
750 def test__mgmt_net_name_in_find_params_no_filterdict_no_mgmt(self
):
752 There is find_params in the task
753 No mgmt in find_params
754 No filter_dict in find_params
757 logger
= "test_logger"
762 "management_network_name": "test_mgmt_name",
766 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
767 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
768 instance
, "logger", logging
769 ), patch
.object(instance
, "db_vims", db_vims
):
775 "action_id": "123456",
777 "task_id": "123456:1",
778 "status": "SCHEDULED",
781 "target_record": "test_target_record",
782 "target_record_id": "test_target_record_id",
783 # values coming from extra_dict
785 "find_params": {"wrong_param": "wrong_value"},
786 "depends_on": "test_depends_on",
791 task_index
= "task_index_4"
792 with self
.assertLogs() as captured
:
793 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
794 self
.assertEqual(len(captured
.records
), 1)
796 "Invalid find_params for new_net"
797 in captured
.records
[0].getMessage()
799 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
800 self
.assertEqual(result
[0], "FAILED")
801 self
.assertEqual(result
[1].get("created"), False)
802 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
804 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets_params_in_task(self
):
806 management_network_name in find_params.get('filterdict')
807 The network could not be found in the VIM
808 There are items in the task.get(params)
811 logger
= "test_logger"
816 "management_network_name": "test_mgmt_name",
820 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
821 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
822 instance
, "logger", logging
823 ), patch
.object(instance
, "db_vims", db_vims
):
829 "action_id": "123456",
831 "task_id": "123456:1",
832 "status": "SCHEDULED",
835 "target_record": "test_target_record",
836 "target_record_id": "test_target_record_id",
837 # values coming from extra_dict
839 "net_name": "test_params",
843 "name": "some-network-name",
846 "name": "some_mgmt_name",
848 "depends_on": "test_depends_on",
853 task_index
= "task_index_8"
854 self
.target_vim
.get_network_list
.return_value
= []
855 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
856 self
.assertEqual(result
[0], "BUILD")
857 self
.assertEqual(result
[1].get("created"), False)
858 self
.assertEqual(result
[1].get("vim_id"), None)
859 self
.assertEqual(result
[1].get("created_items"), {})
860 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
862 def test__mgmt_net_name_in_find_params_filterdict_no_vim_nets(self
):
864 mgmt network is set in find_params
865 management_network_name in vim config
866 network_name is set in find_params.get('filterdict')
867 Any network could not be found in the VIM
870 logger
= "test_logger"
875 "management_network_name": "test_mgmt_name",
879 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
880 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
881 instance
, "logger", logging
882 ), patch
.object(instance
, "db_vims", db_vims
):
888 "action_id": "123456",
890 "task_id": "123456:1",
891 "status": "SCHEDULED",
894 "target_record": "test_target_record",
895 "target_record_id": "test_target_record_id",
896 # values coming from extra_dict
900 "name": "some-network-name",
903 "name": "some_mgmt_name",
905 "depends_on": "test_depends_on",
910 task_index
= "task_index_9"
911 self
.target_vim
.get_network_list
.return_value
= []
912 with self
.assertLogs() as captured
:
913 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
914 self
.assertEqual(len(captured
.records
), 1)
916 "Network not found with this criteria"
917 in captured
.records
[0].getMessage()
919 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
920 self
.assertEqual(result
[0], "FAILED")
921 self
.assertEqual(result
[1].get("created"), False)
922 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
924 def test__mgmt_net_in_find_params_filterdict_no_config_no_vim_nets(self
):
926 mgmt network is set in find_params
928 network_name is set in find_params.get('filterdict')
929 Any network could not be found in the VIM
932 logger
= "test_logger"
939 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
940 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
941 instance
, "logger", logging
942 ), patch
.object(instance
, "db_vims", db_vims
):
948 "action_id": "123456",
950 "task_id": "123456:1",
951 "status": "SCHEDULED",
954 "target_record": "test_target_record",
955 "target_record_id": "test_target_record_id",
956 # values coming from extra_dict
960 "name": "some-network-name",
963 "name": "some_mgmt_name",
965 "depends_on": "test_depends_on",
970 task_index
= "task_index_9"
971 self
.target_vim
.get_network_list
.return_value
= []
972 with self
.assertLogs() as captured
:
973 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
974 self
.assertEqual(len(captured
.records
), 1)
976 "Network not found with this criteria"
977 in captured
.records
[0].getMessage()
979 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
980 self
.assertEqual(result
[0], "FAILED")
981 self
.assertEqual(result
[1].get("created"), False)
982 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
984 def test__mgmt_net_name_in_find_params_mgmt_no_config_one_vim_net(self
):
986 mgmt network is set in find_params
987 management_network_name is not in db_vims.get('config')
988 One network found in the VIM
991 logger
= "test_logger"
998 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
999 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1000 instance
, "logger", logging
1001 ), patch
.object(instance
, "db_vims", db_vims
):
1007 "action_id": "123456",
1009 "task_id": "123456:1",
1010 "status": "SCHEDULED",
1012 "item": "test_item",
1013 "target_record": "test_target_record",
1014 "target_record_id": "test_target_record_id",
1015 # values coming from extra_dict
1019 "name": "some_mgmt_name",
1021 "depends_on": "test_depends_on",
1026 task_index
= "task_index_2"
1027 self
.target_vim
.get_network_list
.return_value
= [
1028 {"id": "4d83a7c9-3ef4-4a45-99c8-aca3550490dd"}
1030 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1031 self
.assertEqual(result
[0], "BUILD")
1032 self
.assertEqual(result
[1].get("created"), False)
1033 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
1035 def test__params_in_task_no_find_params(self
):
1038 find_params does not exist in the task
1041 logger
= "test_logger"
1042 my_vims
= "test-vim"
1046 "management_network_name": "test_mgmt_name",
1050 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1051 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1052 instance
, "logger", logging
1053 ), patch
.object(instance
, "db_vims", db_vims
):
1059 "action_id": "123456",
1061 "task_id": "123456:1",
1062 "status": "SCHEDULED",
1064 "item": "test_item",
1065 "target_record": "test_target_record",
1066 "target_record_id": "test_target_record_id",
1067 # values coming from extra_dict
1069 "net_name": "test-network",
1072 "depends_on": "test_depends_on",
1077 task_index
= "task_index_11"
1078 self
.target_vim
.new_network
.return_value
= "sample_net_id", {
1079 "item1": "sample_created_item"
1081 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1082 self
.assertEqual(result
[0], "BUILD")
1083 self
.assertEqual(result
[1].get("vim_id"), "sample_net_id")
1084 self
.assertEqual(result
[1].get("created"), True)
1086 result
[1].get("created_items"), {"item1": "sample_created_item"}
1088 self
.assertEqual(result
[1].get("vim_status"), "BUILD")
1090 def test__no_params_in_task_no_find_params(self
):
1092 empty params in the task
1093 find_params does not exist in the task
1096 logger
= "test_logger"
1097 my_vims
= "test-vim"
1101 "management_network_name": "test_mgmt_name",
1105 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1106 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1107 instance
, "logger", logging
1108 ), patch
.object(instance
, "db_vims", db_vims
):
1114 "action_id": "123456",
1116 "task_id": "123456:1",
1117 "status": "SCHEDULED",
1119 "item": "test_item",
1120 "target_record": "test_target_record",
1121 "target_record_id": "test_target_record_id",
1122 # values coming from extra_dict
1124 "depends_on": "test_depends_on",
1129 task_index
= "task_index_12"
1130 self
.target_vim
.new_network
.side_effect
= VimConnConnectionException(
1131 "VimConnConnectionException occurred."
1133 with self
.assertLogs() as captured
:
1134 instance
.new(ro_task
, task_index
, self
.task_depends
)
1135 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1137 def test__refresh_ro_task_vim_status_active(self
):
1139 vim_info.get('status') is ACTIVE
1142 logger
= "test_logger"
1143 my_vims
= "test-vim"
1145 "vim_openstack_1": {
1147 "vim_type": "openstack",
1150 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1152 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1153 ), patch
.object(instance
, "logger", logging
), patch
.object(
1154 instance
, "db_vims", db_vims
1160 "target_id": "vim_openstack_1",
1163 "created_items": None,
1164 "vim_id": "test-vim-id",
1165 "vim_name": "test-vim",
1167 "vim_details": "some-details",
1168 "vim_message": None,
1171 "modified_at": 1637324200.994312,
1172 "created_at": 1637324200.994312,
1173 "to_check_at": 1637324200.994312,
1177 self
.target_vim
.refresh_nets_status
.return_value
= {
1179 "vim_info": "some-details",
1185 task_status
= "DONE"
1186 ro_vim_item_update
= {
1187 "vim_status": "ACTIVE",
1189 result
= instance
.refresh(ro_task
)
1190 self
.assertEqual(result
[0], task_status
)
1191 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1193 def test__refresh_ro_task_vim_status_build(self
):
1195 vim_info.get('status') is BUILD
1198 logger
= "test_logger"
1199 my_vims
= "test-vim"
1201 "vim_openstack_1": {
1203 "vim_type": "openstack",
1206 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1208 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1209 ), patch
.object(instance
, "logger", logging
), patch
.object(
1210 instance
, "db_vims", db_vims
1216 "target_id": "vim_openstack_1",
1219 "created_items": None,
1220 "vim_id": "test-vim-id",
1221 "vim_name": "test-vim",
1222 "vim_status": "BUILD",
1224 "vim_message": None,
1227 "modified_at": 1637324200.994312,
1228 "created_at": 1637324200.994312,
1229 "to_check_at": 1637324200.994312,
1233 self
.target_vim
.refresh_nets_status
.return_value
= {
1235 "vim_info": "some-details",
1237 "name": "other-vim",
1241 task_status
= "BUILD"
1242 ro_vim_item_update
= {
1243 "vim_name": "other-vim",
1244 "vim_details": "some-details",
1246 result
= instance
.refresh(ro_task
)
1247 self
.assertEqual(result
[0], task_status
)
1248 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1250 def test__refresh_ro_task_vim_status_error(self
):
1252 vim_info.get('status') is ERROR
1255 logger
= "test_logger"
1256 my_vims
= "test-vim"
1258 "vim_openstack_1": {
1260 "vim_type": "openstack",
1263 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1265 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1266 ), patch
.object(instance
, "logger", logging
), patch
.object(
1267 instance
, "db_vims", db_vims
1273 "target_id": "vim_openstack_1",
1276 "created_items": None,
1277 "vim_id": "test-vim-id",
1278 "vim_name": "test-vim",
1279 "vim_status": "BUILD",
1281 "vim_message": None,
1284 "modified_at": 1637324200.994312,
1285 "created_at": 1637324200.994312,
1286 "to_check_at": 1637324200.994312,
1290 self
.target_vim
.refresh_nets_status
.return_value
= {
1292 "vim_info": "some-details",
1295 "error_msg": "some error message",
1298 task_status
= "FAILED"
1299 ro_vim_item_update
= {
1300 "vim_status": "ERROR",
1301 "vim_message": "some error message",
1303 result
= instance
.refresh(ro_task
)
1304 self
.assertEqual(result
[0], task_status
)
1305 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1307 def test__refresh_ro_task_VimConnException_occurred(self
):
1309 vimconn.VimConnException has occured
1312 logger
= "test_logger"
1313 my_vims
= "test-vim"
1315 "vim_openstack_1": {
1317 "vim_type": "openstack",
1320 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1322 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1323 ), patch
.object(instance
, "logger", logging
), patch
.object(
1324 instance
, "db_vims", db_vims
1330 "target_id": "vim_openstack_1",
1333 "created_items": None,
1334 "vim_id": "test-vim-id",
1335 "vim_name": "test-vim",
1336 "vim_status": "BUILD",
1338 "vim_message": None,
1341 "modified_at": 1637324200.994312,
1342 "created_at": 1637324200.994312,
1343 "to_check_at": 1637324200.994312,
1346 self
.target_vim
.refresh_nets_status
.side_effect
= VimConnException(
1347 "VimConnException occurred."
1349 with self
.assertLogs() as captured
:
1350 instance
.refresh(ro_task
)
1351 self
.assertEqual(captured
.records
[0].levelname
, "ERROR")
1353 def test__refresh_ro_task_vim_status_deleted(self
):
1355 vim_info.get('status') is DELETED
1358 logger
= "test_logger"
1359 my_vims
= "test-vim"
1361 "vim_openstack_1": {
1363 "vim_type": "openstack",
1366 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1368 instance
, "my_vims", {"vim_openstack_1": self
.target_vim
}
1369 ), patch
.object(instance
, "logger", logging
), patch
.object(
1370 instance
, "db_vims", db_vims
1376 "target_id": "vim_openstack_1",
1379 "created_items": None,
1380 "vim_id": "test-vim-id",
1381 "vim_name": "test-vim",
1382 "vim_status": "BUILD",
1384 "vim_message": None,
1387 "modified_at": 163724200.994312,
1388 "created_at": 1637324200.994312,
1389 "to_check_at": 1637324200.994312,
1392 self
.target_vim
.refresh_nets_status
.return_value
= {
1394 "vim_info": "some-details",
1395 "status": "DELETED",
1397 "error_msg": "some error message",
1400 task_status
= "FAILED"
1401 ro_vim_item_update
= {
1402 "vim_status": "DELETED",
1403 "vim_message": "Deleted externally",
1406 result
= instance
.refresh(ro_task
)
1407 self
.assertEqual(result
[0], task_status
)
1408 self
.assertDictEqual(result
[1], ro_vim_item_update
)
1410 def test__refresh_ro_task_empty_vim_dict(self
):
1412 vim_dict does not include vim_id key
1416 logger
= "test_logger"
1417 my_vims
= "test-vim"
1419 "vim_openstack_2": {
1423 instance
= VimInteractionNet(db
, logger
, my_vims
, db_vims
)
1425 instance
, "my_vims", {"vim_openstack_2": self
.target_vim
}
1426 ), patch
.object(instance
, "logger", logging
), patch
.object(
1427 instance
, "db_vims", db_vims
1433 "target_id": "vim_openstack_2",
1436 "created_items": None,
1437 "vim_id": "test-vim-id",
1438 "vim_name": "test-vim",
1439 "vim_status": "BUILD",
1441 "vim_message": None,
1444 "modified_at": 163724211.994312,
1445 "created_at": 1637324211.994312,
1446 "to_check_at": 1637324211.994312,
1449 self
.target_vim
.refresh_nets_status
.return_value
= {}
1450 with self
.assertRaises(KeyError):
1451 instance
.refresh(ro_task
)
1454 class TestVimInteractionSharedVolume(unittest
.TestCase
):
1456 module_name
= "osm_ro_plugin"
1457 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1458 self
.task_depends
= None
1460 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1462 # Enabling mocks and add cleanups
1463 for mock
in patches
:
1465 self
.addCleanup(mock
.stop
)
1467 def test__new_shared_volume_ok(self
):
1469 create a shared volume with attributes set in params
1472 logger
= "test_logger"
1473 my_vims
= "test-vim"
1480 instance
= VimInteractionSharedVolume(db
, logger
, my_vims
, db_vims
)
1481 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1482 instance
, "logger", logging
1483 ), patch
.object(instance
, "db_vims", db_vims
):
1489 "action_id": "123456",
1491 "task_id": "123456:1",
1492 "status": "SCHEDULED",
1494 "item": "test_item",
1495 "target_record": "test_target_record",
1496 "target_record_id": "test_target_record_id",
1497 # values coming from extra_dict
1499 "shared_volume_data": {
1501 "name": "shared-volume",
1502 "type": "multiattach",
1506 "depends_on": "test_depends_on",
1510 task_index
= "task_index_1"
1511 self
.target_vim
.new_shared_volumes
.return_value
= ("", "shared-volume")
1512 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1513 self
.assertEqual(result
[0], "DONE")
1514 self
.assertEqual(result
[1].get("vim_id"), "shared-volume")
1515 self
.assertEqual(result
[1].get("created"), True)
1516 self
.assertEqual(result
[1].get("vim_status"), "ACTIVE")
1518 def test__new_shared_volume_failed(self
):
1520 create a shared volume with attributes set in params failed
1523 logger
= "test_logger"
1524 my_vims
= "test-vim"
1531 instance
= VimInteractionSharedVolume(db
, logger
, my_vims
, db_vims
)
1532 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1533 instance
, "logger", logging
1534 ), patch
.object(instance
, "db_vims", db_vims
):
1540 "action_id": "123456",
1542 "task_id": "123456:1",
1543 "status": "SCHEDULED",
1545 "item": "test_item",
1546 "target_record": "test_target_record",
1547 "target_record_id": "test_target_record_id",
1548 # values coming from extra_dict
1550 "shared_volume_data": {
1552 "name": "shared-volume",
1553 "type": "multiattach",
1557 "depends_on": "test_depends_on",
1561 task_index
= "task_index_1"
1562 self
.target_vim
.new_shared_volumes
.side_effect
= VimConnException(
1563 "Connection failed."
1565 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1566 self
.assertEqual(result
[0], "FAILED")
1567 self
.assertEqual(result
[1].get("vim_message"), "Connection failed.")
1568 self
.assertEqual(result
[1].get("created"), False)
1569 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
1571 def test__delete_shared_volume_ok(self
):
1573 Delete a shared volume with attributes set in params
1576 logger
= "test_logger"
1577 my_vims
= "test-vim"
1584 instance
= VimInteractionSharedVolume(db
, logger
, my_vims
, db_vims
)
1585 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1586 instance
, "logger", logging
1587 ), patch
.object(instance
, "db_vims", db_vims
):
1593 "task_id": "123456:1",
1598 "created_items": None,
1599 "vim_id": "sample_shared_volume_id_3",
1600 "vim_name": "sample_shared_volume_3",
1602 "vim_details": "some-details",
1603 "vim_message": None,
1608 task_index
= "task_index_3"
1609 self
.target_vim
.delete_shared_volumes
.return_value
= True
1610 result
= instance
.delete(ro_task
, task_index
)
1611 self
.assertEqual(result
[0], "DONE")
1612 self
.assertEqual(result
[1].get("vim_id"), None)
1613 self
.assertEqual(result
[1].get("created"), False)
1614 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1616 def test__delete_shared_volume_failed(self
):
1618 Delete a shared volume with attributes set in params failed
1621 logger
= "test_logger"
1622 my_vims
= "test-vim"
1629 instance
= VimInteractionSharedVolume(db
, logger
, my_vims
, db_vims
)
1630 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1631 instance
, "logger", logging
1632 ), patch
.object(instance
, "db_vims", db_vims
):
1639 "task_id": "123456:1",
1644 "created_items": None,
1645 "vim_id": "sample_shared_volume_id_3",
1646 "vim_name": "sample_shared_volume_3",
1648 "vim_details": "some-details",
1649 "vim_message": None,
1654 task_index
= "task_index_3"
1655 self
.target_vim
.delete_shared_volumes
.side_effect
= VimConnException(
1656 "Connection failed."
1658 result
= instance
.delete(ro_task
, task_index
)
1659 self
.assertEqual(result
[0], "FAILED")
1661 result
[1].get("vim_message"), "Error while deleting: Connection failed."
1663 self
.assertEqual(result
[1].get("vim_status"), "VIM_ERROR")
1666 class TestVimInteractionAffinityGroup(unittest
.TestCase
):
1668 module_name
= "osm_ro_plugin"
1669 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1670 self
.task_depends
= None
1672 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1674 # Enabling mocks and add cleanups
1675 for mock
in patches
:
1677 self
.addCleanup(mock
.stop
)
1679 def test__new_affinity_group_ok(self
):
1681 create affinity group with attributes set in params
1684 logger
= "test_logger"
1685 my_vims
= "test-vim"
1692 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1693 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1694 instance
, "logger", logging
1695 ), patch
.object(instance
, "db_vims", db_vims
):
1701 "action_id": "123456",
1703 "task_id": "123456:1",
1704 "status": "SCHEDULED",
1706 "item": "test_item",
1707 "target_record": "test_target_record",
1708 "target_record_id": "test_target_record_id",
1709 # values coming from extra_dict
1711 "affinity_group_data": {
1712 "name": "affinity_group_1",
1714 "scope": "nfvi-node",
1718 "depends_on": "test_depends_on",
1723 task_index
= "task_index_1"
1724 self
.target_vim
.new_affinity_group
.return_value
= (
1725 "sample_affinity_group_id_1"
1727 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1728 self
.assertEqual(result
[0], "DONE")
1729 self
.assertEqual(result
[1].get("vim_id"), "sample_affinity_group_id_1")
1730 self
.assertEqual(result
[1].get("created"), True)
1731 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1733 def test__new_affinity_group_failed(self
):
1735 create affinity group with no attributes set in params
1738 logger
= "test_logger"
1739 my_vims
= "test-vim"
1746 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1747 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1748 instance
, "logger", logging
1749 ), patch
.object(instance
, "db_vims", db_vims
):
1755 "action_id": "123456",
1757 "task_id": "123456:1",
1758 "status": "SCHEDULED",
1760 "item": "test_item",
1761 "target_record": "test_target_record",
1762 "target_record_id": "test_target_record_id",
1763 # values coming from extra_dict
1766 "depends_on": "test_depends_on",
1771 task_index
= "task_index_2"
1772 self
.target_vim
.new_affinity_group
.return_value
= (
1773 "sample_affinity_group_id_1"
1775 result
= instance
.new(ro_task
, task_index
, self
.task_depends
)
1776 self
.assertEqual(result
[0], "DONE")
1777 self
.assertEqual(result
[1].get("vim_id"), None)
1778 self
.assertEqual(result
[1].get("created"), False)
1779 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1781 def test__delete_affinity_group_ok(self
):
1783 delete affinity group with a proper vim_id
1786 logger
= "test_logger"
1787 my_vims
= "test-vim"
1794 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1795 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1796 instance
, "logger", logging
1797 ), patch
.object(instance
, "db_vims", db_vims
):
1803 "task_id": "123456:1",
1808 "created_items": None,
1809 "vim_id": "sample_affinity_group_id_3",
1810 "vim_name": "sample_affinity_group_id_3",
1812 "vim_details": "some-details",
1813 "vim_message": None,
1818 task_index
= "task_index_3"
1819 self
.target_vim
.delete_affinity_group
.return_value
= (
1820 "sample_affinity_group_id_3"
1822 result
= instance
.delete(ro_task
, task_index
)
1823 self
.assertEqual(result
[0], "DONE")
1824 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1825 self
.assertEqual(result
[1].get("created"), False)
1826 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1828 def test__delete_affinity_group_failed(self
):
1830 delete affinity group with missing vim_id
1833 logger
= "test_logger"
1834 my_vims
= "test-vim"
1841 instance
= VimInteractionAffinityGroup(db
, logger
, my_vims
, db_vims
)
1842 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1843 instance
, "logger", logging
1844 ), patch
.object(instance
, "db_vims", db_vims
):
1850 "task_id": "123456:1",
1855 "created_items": None,
1859 "vim_details": "some-details",
1860 "vim_message": None,
1865 task_index
= "task_index_4"
1866 self
.target_vim
.delete_affinity_group
.return_value
= ""
1867 result
= instance
.delete(ro_task
, task_index
)
1868 self
.assertEqual(result
[0], "DONE")
1869 self
.assertEqual(result
[1].get("vim_message"), "DELETED")
1870 self
.assertEqual(result
[1].get("created"), False)
1871 self
.assertEqual(result
[1].get("vim_status"), "DELETED")
1874 class TestVimInteractionResize(unittest
.TestCase
):
1876 module_name
= "osm_ro_plugin"
1877 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1878 self
.task_depends
= None
1880 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1882 # Enabling mocks and add cleanups
1883 for mock
in patches
:
1885 self
.addCleanup(mock
.stop
)
1887 def test__exec_resize_done(self
):
1889 create verticalscale task
1892 logger
= "test_logger"
1893 my_vims
= "test-vim"
1899 target_record_id
= (
1900 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1901 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1904 instance
= VimInteractionResize(db
, logger
, my_vims
, db_vims
)
1905 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1906 instance
, "logger", logging
1907 ), patch
.object(instance
, "db_vims", db_vims
):
1913 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1914 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1915 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1916 "status": "SCHEDULED",
1918 "item": "verticalscale",
1919 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1920 "target_record_id": target_record_id
,
1922 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1923 "flavor_dict": "flavor_dict",
1928 task_index
= "task_index_1"
1929 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1930 self
.assertEqual(result
[0], "DONE")
1931 self
.assertEqual(result
[1].get("vim_status"), "DONE")
1934 class TestVimInteractionMigration(unittest
.TestCase
):
1936 module_name
= "osm_ro_plugin"
1937 self
.target_vim
= MagicMock(name
=f
"{module_name}.vimconn.VimConnector")
1938 self
.task_depends
= None
1940 patches
= [patch(f
"{module_name}.vimconn.VimConnector", self
.target_vim
)]
1942 # Enabling mocks and add cleanups
1943 for mock
in patches
:
1945 self
.addCleanup(mock
.stop
)
1947 def test__exec_migration_done(self
):
1952 logger
= "test_logger"
1953 my_vims
= "test-vim"
1959 target_record_id
= (
1960 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
1961 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
1964 instance
= VimInteractionMigration(db
, logger
, my_vims
, db_vims
)
1965 with patch
.object(instance
, "my_vims", [self
.target_vim
]), patch
.object(
1966 instance
, "logger", logging
1967 ), patch
.object(instance
, "db_vims", db_vims
):
1973 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
1974 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
1975 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
1976 "status": "SCHEDULED",
1979 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
1980 "target_record_id": target_record_id
,
1982 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
1983 "migrate_host": "osm-test2",
1984 "vdu_vim_info": {0: {"interfaces": []}},
1989 self
.target_vim
.migrate_instance
.return_value
= "ACTIVE", "test"
1991 task_index
= "task_index_1"
1992 result
= instance
.exec(ro_task
, task_index
, self
.task_depends
)
1993 self
.assertEqual(result
[0], "DONE")
1994 self
.assertEqual(result
[1].get("vim_status"), "ACTIVE")