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 #######################################################################################
17 from copy
import deepcopy
21 from unittest
.mock
import MagicMock
, mock_open
, patch
23 from novaclient
.v2
.servers
import Server
as NovaServer
24 from osm_common
import dbmongo
25 from osm_common
.dbbase
import DbException
26 from osm_ng_ro
.monitor
import (
36 from osm_ng_ro
.tests
.sample_data
import (
43 interface_with_binding
,
58 serialized_interface_info
,
59 serialized_server_info
,
77 from osm_ro_plugin
.vimconn
import VimConnector
81 def create_server(id: str, name
: str, status
: str = "ACTIVE", info
: dict = {}):
82 instance
= NovaServer(manager
="manager", info
=info
)
85 instance
.status
= status
89 # The preparation for the tests
90 sample_vim_connector_instance
= VimConnector(
91 uuid
=sample_vim
["_id"],
92 name
=sample_vim
["name"],
93 tenant_id
=sample_vim
.get("vim_tenant_id"),
94 tenant_name
=sample_vim
.get("vim_tenant_name"),
95 url
=sample_vim
["vim_url"],
97 sample_vm
= VmToMonitor(vm1_id
, target_record
)
98 sample_vm2
= VmToMonitor(vm2_id
, target_record
)
99 sample_vm3
= VmToMonitor("deleted-vm-id", target_record
)
100 server1
= create_server(vm1_id
, "server1")
101 server2
= create_server(vm2_id
, "server2")
102 server3
= create_server("other-vm-id3", "other-vm3")
103 server4
= create_server("other-vm-id4", "other-vm4")
104 all_server_info
= deepcopy(server_other_info
)
105 server7
= create_server(vm1_id
, "server7", info
=all_server_info
)
108 class CopyingMock(MagicMock
):
109 def __call__(self
, *args
, **kwargs
):
110 args
= deepcopy(args
)
111 kwargs
= deepcopy(kwargs
)
112 return super(CopyingMock
, self
).__call
__(*args
, **kwargs
)
115 def check_if_assert_not_called(mocks
: list):
116 for mocking
in mocks
:
117 mocking
.assert_not_called()
120 class TestMonitorVms(unittest
.TestCase
):
121 @patch("osm_ng_ro.monitor.MonitorVms.__init__")
122 @patch("osm_ng_ro.ns_thread.ConfigValidate")
123 @patch("osm_ng_ro.monitor.MonitorVms.get_db_vims")
124 @patch("osm_ng_ro.monitor.MonitorVms.load_vims")
125 @patch("logging.getLogger", autospec
=True)
131 mock_config_validate
,
134 # We are disabling the logging of exception not to print them to console.
135 mock_logger
= logging
.getLogger()
136 mock_logger
.disabled
= True
137 mock_init
.return_value
= None
138 self
.monitor
= MonitorVms(config
=config
)
139 self
.monitor
.db_vims
= []
140 self
.monitor
.db
= CopyingMock(dbmongo
.DbMongo(), autospec
=True)
141 self
.monitor
.config
= config
142 self
.monitor
.logger
= mock_logger
143 self
.monitor
.my_vims
= {}
144 self
.monitor
.refresh_config
= mock_config_validate
146 @patch("osm_ng_ro.ns_thread.ConfigValidate.__init__")
147 @patch("osm_ng_ro.monitor.MonitorVms.get_db_vims")
148 @patch("osm_ng_ro.monitor.MonitorVms.load_vims")
149 @patch("logging.getLogger", autospec
=True)
150 @patch("osm_ng_ro.monitor.MonitorVms.connect_db")
157 mock_config_validate_init
,
159 mock_config_validate_init
.return_value
= None
160 mock_get_db_vims
.return_value
= vims
161 instance
= MonitorVms(config
)
162 mock_config_validate_init
.assert_called_once_with(config
)
163 self
.assertDictEqual(instance
.config
, config
)
164 mock_load_vims
.assert_called_once()
165 self
.assertEqual(instance
.db_vims
, vims
)
166 mock_connect_db
.assert_called_once()
167 self
.assertIsNone(instance
.db
)
168 self
.assertIsNotNone(instance
.db_vims
)
169 mock_logger
.assert_called_once_with("ro.monitor")
171 @patch("osm_ng_ro.monitor.MonitorVms._load_vim")
172 def test_load_vims_empty_db_vims(self
, mock_load_vim
):
173 self
.monitor
.load_vims()
174 mock_load_vim
.assert_not_called()
176 @patch("osm_ng_ro.monitor.MonitorVms._load_vim")
177 def test_load_vims_vim_id_not_in_my_vims(self
, mock_load_vim
):
178 self
.monitor
.db_vims
= vims
179 self
.monitor
.my_vims
= {vim3_id
: "vim-obj3"}
180 self
.monitor
.load_vims()
181 _call_mock_load_vim
= mock_load_vim
.call_args_list
182 self
.assertEqual(mock_load_vim
.call_count
, 2)
184 _call_mock_load_vim
[0][0],
188 _call_mock_load_vim
[1][0],
192 @patch("osm_ng_ro.monitor.MonitorVms._load_vim")
193 def test_load_vims_vim_id_in_my_vims(self
, mock_load_vim
):
194 self
.monitor
.db_vims
= vims
195 self
.monitor
.my_vims
= {vim1_id
: "vim-obj1", vim2_id
: "vim-obj2"}
196 self
.monitor
.load_vims()
197 mock_load_vim
.assert_not_called()
199 @patch("osm_common.dbmongo.DbMongo.db_connect")
200 @patch("osm_common.dbmongo.DbMongo.__init__")
201 @patch("osm_common.dbmemory.DbMemory.db_connect")
202 @patch("osm_common.dbmemory.DbMemory.__init__")
203 def test_connect_db_type_mongo(
206 mock_dbmemory_connect
,
208 mock_dbmongo_connect
,
210 self
.monitor
.db
= None
211 self
.monitor
.config
["database"]["driver"] = "mongo"
212 mock_dbmongo_init
.return_value
= None
213 self
.monitor
.connect_db()
214 mock_dbmongo_init
.assert_called_once()
215 mock_dbmongo_connect
.assert_called_once()
216 self
.monitor
.db
.db_connect
.assert_called_once_with(
217 self
.monitor
.config
["database"]
219 check_if_assert_not_called([mock_dbmemory_init
, mock_dbmemory_connect
])
221 @patch("osm_common.dbmongo.DbMongo.db_connect")
222 @patch("osm_common.dbmongo.DbMongo.__init__")
223 @patch("osm_common.dbmemory.DbMemory.db_connect")
224 @patch("osm_common.dbmemory.DbMemory.__init__")
225 def test_connect_db_type_mongo_initialize_exception(
228 mock_dbmemory_connect
,
230 mock_dbmongo_connect
,
232 self
.monitor
.db
= None
233 self
.monitor
.config
["database"]["driver"] = "mongo"
234 mock_dbmongo_init
.side_effect
= ValueError("Db object could not be created.")
235 with self
.assertRaises(MonitorDbException
) as err
:
236 self
.monitor
.connect_db()
237 self
.assertEqual(str(err
.exception
), "Db object could not be created.")
238 mock_dbmongo_init
.assert_called_once()
239 check_if_assert_not_called(
240 [mock_dbmongo_connect
, mock_dbmemory_init
, mock_dbmemory_connect
]
243 @patch("osm_common.dbmongo.DbMongo.db_connect")
244 @patch("osm_common.dbmongo.DbMongo.__init__")
245 @patch("osm_common.dbmemory.DbMemory.db_connect")
246 @patch("osm_common.dbmemory.DbMemory.__init__")
247 def test_connect_db_type_mongo_connection_exception(
250 mock_dbmemory_connect
,
252 mock_dbmongo_connect
,
254 self
.monitor
.db
= None
255 self
.monitor
.config
["database"]["driver"] = "mongo"
256 mock_dbmongo_init
.return_value
= None
257 mock_dbmongo_connect
.side_effect
= DbException("Connection failed")
258 with self
.assertRaises(MonitorDbException
) as err
:
259 self
.monitor
.connect_db()
260 self
.assertEqual(str(err
.exception
), "database exception Connection failed")
261 mock_dbmongo_init
.assert_called_once()
262 mock_dbmongo_connect
.assert_called_once_with(self
.monitor
.config
["database"])
263 check_if_assert_not_called([mock_dbmemory_init
, mock_dbmemory_connect
])
265 @patch("osm_common.dbmongo.DbMongo.db_connect")
266 @patch("osm_common.dbmongo.DbMongo.__init__")
267 @patch("osm_common.dbmemory.DbMemory.db_connect")
268 @patch("osm_common.dbmemory.DbMemory.__init__")
269 def test_connect_db_type_memory(
272 mock_dbmemory_connect
,
274 mock_dbmongo_connect
,
276 self
.monitor
.db
= None
277 self
.monitor
.config
["database"]["driver"] = "memory"
278 mock_dbmemory_init
.return_value
= None
279 self
.monitor
.connect_db()
280 mock_dbmemory_init
.assert_called_once()
281 mock_dbmemory_connect
.assert_called_once_with(self
.monitor
.config
["database"])
282 check_if_assert_not_called([mock_dbmongo_init
, mock_dbmongo_connect
])
284 @patch("osm_common.dbmongo.DbMongo.db_connect")
285 @patch("osm_common.dbmongo.DbMongo.__init__")
286 @patch("osm_common.dbmemory.DbMemory.db_connect")
287 @patch("osm_common.dbmemory.DbMemory.__init__")
288 def test_connect_db_existing_db(
291 mock_dbmemory_connect
,
293 mock_dbmongo_connect
,
295 self
.monitor
.connect_db()
296 check_if_assert_not_called(
300 mock_dbmemory_connect
,
301 mock_dbmongo_connect
,
305 @patch("osm_common.dbmongo.DbMongo.db_connect")
306 @patch("osm_common.dbmongo.DbMongo.__init__")
307 @patch("osm_common.dbmemory.DbMemory.db_connect")
308 @patch("osm_common.dbmemory.DbMemory.__init__")
309 def test_connect_db_wrong_driver_type(
312 mock_dbmemory_connect
,
314 mock_dbmongo_connect
,
316 self
.monitor
.db
= None
317 self
.monitor
.config
["database"]["driver"] = "posgresql"
318 with self
.assertRaises(MonitorDbException
) as err
:
319 self
.monitor
.connect_db()
322 "Invalid configuration param 'posgresql' at '[database]':'driver'",
324 check_if_assert_not_called(
328 mock_dbmemory_connect
,
329 mock_dbmongo_connect
,
333 def test_get_db_vims(self
):
334 self
.monitor
.db
.get_list
.return_value
= vims
335 result
= self
.monitor
.get_db_vims()
336 self
.assertEqual(result
, vims
)
337 self
.monitor
.db
.get_list
.assert_called_once_with(
338 "vim_accounts", {"vim_type": "openstack"}
341 def test_get_db_vims_db_raises(self
):
342 self
.monitor
.db
.get_list
.side_effect
= DbException("Connection failed.")
343 with self
.assertRaises(DbException
) as err
:
344 result
= self
.monitor
.get_db_vims()
345 self
.assertEqual(result
, None)
346 self
.assertEqual(str(err
.exception
), "database exception Connection failed.")
347 self
.monitor
.db
.get_list
.assert_called_once_with(
348 "vim_accounts", {"vim_type": "openstack"}
351 def test_find_ro_tasks_to_monitor(self
):
352 self
.monitor
.db
.get_list
.return_value
= [ro_task1
]
353 result
= self
.monitor
.find_ro_tasks_to_monitor()
354 self
.assertEqual(result
, [ro_task1
])
355 self
.monitor
.db
.get_list
.assert_called_once_with(
358 "tasks.status": ["DONE"],
359 "tasks.item": ["vdu"],
363 def test_find_ro_tasks_to_monitor_db_exception(self
):
364 self
.monitor
.db
.get_list
.side_effect
= DbException("Wrong database status")
365 with self
.assertRaises(DbException
) as err
:
366 result
= self
.monitor
.find_ro_tasks_to_monitor()
367 self
.assertEqual(result
, None)
368 self
.assertEqual(str(err
.exception
), "database exception Wrong database status")
369 self
.monitor
.db
.get_list
.assert_called_once_with(
372 "tasks.status": ["DONE"],
373 "tasks.item": ["vdu"],
377 def test_initialize_target_vim(self
):
378 vim_module_conn
= VimConnector
379 vim_connector_instance
= self
.monitor
._initialize
_target
_vim
(
380 vim_module_conn
, sample_vim
382 self
.assertIsInstance(vim_connector_instance
, VimConnector
)
383 self
.assertListEqual(
384 [vim_connector_instance
.id, vim_connector_instance
.name
],
385 [target_id
, "openstackETSI1"],
388 def test_initialize_target_vim_invalid_vim_connector_input(self
):
389 vim_module_conn
= "openstack_vim_connector"
390 with self
.assertRaises(TypeError) as err
:
391 self
.monitor
._initialize
_target
_vim
(vim_module_conn
, sample_vim
)
392 self
.assertEqual(str(err
.exception
), "'str' object is not callable")
394 def test_initialize_target_vim_missing_vim_keys(self
):
395 vim_module_conn
= VimConnector
398 "name": "openstackETSI1",
399 "vim_type": "openstack",
401 with self
.assertRaises(KeyError) as err
:
402 self
.monitor
._initialize
_target
_vim
(vim_module_conn
, sample_vim
)
403 self
.assertEqual(str(err
.exception
.args
[0]), "vim_url")
405 def test_initialize_target_vim_invalid_vim_input_type(self
):
406 vim_module_conn
= VimConnector
407 sample_vim
= [target_id
, "openstackETSI1"]
408 with self
.assertRaises(TypeError) as err
:
409 self
.monitor
._initialize
_target
_vim
(vim_module_conn
, sample_vim
)
411 str(err
.exception
), "list indices must be integers or slices, not str"
414 @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
415 @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
416 @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
417 def test_load_vim(self
, mock_target_vim
, mock_load_plugin
, mock_vim_config
):
418 self
.monitor
.my_vims
= {}
419 sample_vim
["schema_version"] = "1.11"
420 self
.monitor
.db
.get_one
.return_value
= sample_vim
421 mock_load_plugin
.return_value
= VimConnector
422 mock_target_vim
.return_value
= sample_vim_connector_instance
423 self
.monitor
._load
_vim
(target_id
)
424 self
.assertEqual(self
.monitor
.my_vims
[target_id
], sample_vim_connector_instance
)
425 mock_vim_config
.assert_called_once()
426 self
.monitor
.db
.get_one
.assert_called_once_with(
427 db_vim_collection
, {"_id": target_id
}
429 self
.monitor
.db
.encrypt_decrypt_fields
.assert_called_once_with(
432 fields
=("password", "secret"),
433 schema_version
="1.11",
436 mock_vim_config
.assert_called_once_with(target_id
, sample_vim
)
437 mock_load_plugin
.assert_called_once_with(plugin_name
)
438 mock_target_vim
.assert_called_once_with(VimConnector
, sample_vim
)
440 @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
441 @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
442 @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
443 def test_load_vim_target_vim_not_found(
444 self
, mock_target_vim
, mock_load_plugin
, mock_vim_config
446 self
.monitor
.my_vims
= {}
447 self
.monitor
.db
.get_one
.return_value
= None
448 with self
.assertRaises(MonitorVimException
) as err
:
449 self
.monitor
._load
_vim
(target_id
)
452 "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
453 "'NoneType' object has no attribute 'get'",
455 self
.monitor
.db
.get_one
.assert_called_once_with(
456 db_vim_collection
, {"_id": target_id
}
458 check_if_assert_not_called(
460 self
.monitor
.db
.encrypt_decrypt_fields
,
467 @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
468 @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
469 @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
470 def test_load_vim_decrypt_fields_raises(
471 self
, mock_target_vim
, mock_load_plugin
, mock_vim_config
473 self
.monitor
.my_vims
= {}
474 sample_vim
["schema_version"] = "1.11"
475 self
.monitor
.db
.get_one
.return_value
= sample_vim
476 self
.monitor
.db
.encrypt_decrypt_fields
.side_effect
= DbException(
477 "Value could not decrypted."
479 with self
.assertRaises(MonitorVimException
) as err
:
480 self
.monitor
._load
_vim
(target_id
)
483 "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
484 "database exception Value could not decrypted.",
486 self
.monitor
.db
.get_one
.assert_called_once_with(
487 db_vim_collection
, {"_id": target_id
}
489 self
.monitor
.db
.encrypt_decrypt_fields
.assert_called_once_with(
492 fields
=("password", "secret"),
493 schema_version
="1.11",
496 check_if_assert_not_called([mock_vim_config
, mock_load_plugin
, mock_target_vim
])
498 @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
499 @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
500 @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
501 def test_load_vim_process_vim_config_raises(
502 self
, mock_target_vim
, mock_load_plugin
, mock_vim_config
504 self
.monitor
.my_vims
= {}
505 sample_vim
["schema_version"] = "1.11"
506 self
.monitor
.db
.get_one
.return_value
= sample_vim
507 mock_vim_config
.side_effect
= MonitorVimException(
508 "Error writing file config_1234"
510 with self
.assertRaises(MonitorVimException
) as err
:
511 self
.monitor
._load
_vim
(target_id
)
514 "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
515 "Error writing file config_1234",
517 self
.monitor
.db
.get_one
.assert_called_once_with(
518 db_vim_collection
, {"_id": target_id
}
520 self
.monitor
.db
.encrypt_decrypt_fields
.assert_called_once_with(
523 fields
=("password", "secret"),
524 schema_version
="1.11",
527 mock_vim_config
.assert_called_once_with(target_id
, sample_vim
)
528 check_if_assert_not_called([mock_load_plugin
, mock_target_vim
])
530 @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
531 @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
532 @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
533 def test_load_vim_load_plugin_raises(
534 self
, mock_target_vim
, mock_load_plugin
, mock_vim_config
536 self
.monitor
.my_vims
= {}
537 sample_vim
["schema_version"] = "1.11"
538 self
.monitor
.db
.get_one
.return_value
= sample_vim
539 mock_load_plugin
.side_effect
= MonitorVimException(
540 "Cannot load plugin osm_rovim_openstack"
542 with self
.assertRaises(MonitorVimException
) as err
:
543 self
.monitor
._load
_vim
(target_id
)
546 "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
547 "Cannot load plugin osm_rovim_openstack",
549 self
.monitor
.db
.get_one
.assert_called_once_with(
550 db_vim_collection
, {"_id": target_id
}
552 self
.monitor
.db
.encrypt_decrypt_fields
.assert_called_once_with(
555 fields
=("password", "secret"),
556 schema_version
="1.11",
559 mock_vim_config
.assert_called_once_with(target_id
, sample_vim
)
560 mock_load_plugin
.assert_called_once_with(plugin_name
)
561 mock_target_vim
.assert_not_called()
563 @patch("osm_ng_ro.monitor.MonitorVms._process_vim_config")
564 @patch("osm_ng_ro.monitor.MonitorVms._load_plugin")
565 @patch("osm_ng_ro.monitor.MonitorVms._initialize_target_vim")
566 def test_load_vim_initialize_target_vim_raises(
567 self
, mock_target_vim
, mock_load_plugin
, mock_vim_config
569 self
.monitor
.my_vims
= {}
570 self
.monitor
.db
.get_one
.return_value
= sample_vim
571 sample_vim
["schema_version"] = "1.0"
572 mock_load_plugin
.return_value
= VimConnector
573 mock_target_vim
.side_effect
= TypeError("'module' object is not callable")
574 with self
.assertRaises(MonitorVimException
) as err
:
575 self
.monitor
._load
_vim
(target_id
)
578 "Cannot load 55b2219a-7bb9-4644-9612-980dada84e83 plugin=rovim_openstack: "
579 "'module' object is not callable",
581 self
.monitor
.db
.get_one
.assert_called_once_with(
582 db_vim_collection
, {"_id": target_id
}
584 self
.monitor
.db
.encrypt_decrypt_fields
.assert_called_once_with(
587 fields
=("password", "secret"),
588 schema_version
="1.0",
591 mock_vim_config
.assert_called_once_with(target_id
, sample_vim
)
592 mock_load_plugin
.assert_called_once_with(plugin_name
)
593 mock_target_vim
.assert_called_once_with(VimConnector
, sample_vim
)
595 @patch("osm_ng_ro.monitor.makedirs")
596 @patch("osm_ng_ro.monitor.path")
597 @patch("builtins.open", new_callable
=mock_open())
598 def test_process_vim_config_vim_without_config(
599 self
, mock_open
, mock_path
, mock_makedirs
602 self
.monitor
._process
_vim
_config
(target_id
, db_vim
)
603 check_if_assert_not_called([mock_open
, mock_path
.isdir
, mock_makedirs
])
605 @patch("osm_ng_ro.monitor.random")
606 @patch("osm_ng_ro.monitor.makedirs")
607 @patch("osm_ng_ro.monitor.path")
608 @patch("builtins.open", new_callable
=mock_open())
609 def test_process_vim_config_vim_with_ca_cert(
610 self
, mock_open
, mock_path
, mock_makedirs
, mock_random
612 db_vim
= {"config": {"ca_cert_content": "my_vim_cert"}}
613 mock_path
.isdir
.return_value
= False
614 mock_random
.randint
.return_value
= 23242
615 self
.monitor
._process
_vim
_config
(target_id
, db_vim
)
616 self
.assertEqual(db_vim
["config"].get("ca_cert_content"), None)
618 db_vim
["config"].get("ca_cert"),
621 mock_path
.isdir
.asssert_called_once_with(file_name
)
622 mock_makedirs
.assert_called_once_with(file_name
)
623 mock_random
.randint
.assert_called_once()
624 mock_open
.assert_called_once_with(file_name
+ "/ca_cert", "w")
626 @patch("osm_ng_ro.monitor.random")
627 @patch("osm_ng_ro.monitor.makedirs")
628 @patch("osm_ng_ro.monitor.path")
629 @patch("builtins.open", new_callable
=mock_open())
630 def test_process_vim_config_vim_with_cacert_path_is_dir(
631 self
, mock_open
, mock_path
, mock_makedirs
, mock_random
633 db_vim
= {"config": {"ca_cert_content": "my_vim_cert"}}
634 mock_path
.isdir
.return_value
= True
635 mock_random
.randint
.return_value
= 23242
636 self
.monitor
._process
_vim
_config
(target_id
, db_vim
)
637 self
.assertEqual(db_vim
["config"].get("ca_cert_content"), None)
639 db_vim
["config"].get("ca_cert"),
642 mock_path
.isdir
.asssert_called_once_with(file_name
)
643 mock_makedirs
.assert_not_called()
644 mock_random
.randint
.assert_called_once()
645 mock_open
.assert_called_once_with(file_name
+ "/ca_cert", "w")
647 @patch("osm_ng_ro.monitor.random")
648 @patch("osm_ng_ro.monitor.makedirs")
649 @patch("osm_ng_ro.monitor.path")
650 @patch("builtins.open", new_callable
=mock_open())
651 def test_process_vim_config_vim_with_cacert_makedir_raises(
652 self
, mock_open
, mock_path
, mock_makedirs
, mock_random
654 db_vim
= {"config": {"ca_cert_content": "my_vim_cert"}}
655 mock_path
.isdir
.return_value
= False
656 mock_random
.randint
.return_value
= 23242
657 mock_makedirs
.side_effect
= OSError("Can not create directory")
658 with self
.assertRaises(MonitorVimException
) as err
:
659 self
.monitor
._process
_vim
_config
(target_id
, db_vim
)
662 "Error writing to file '/app/osm_ro/certs/55b2219a-7bb9-4644-9612-980dada84e83:23242': "
663 "Can not create directory",
665 self
.assertEqual(db_vim
["config"].get("ca_cert_content"), "my_vim_cert")
666 self
.assertEqual(db_vim
["config"].get("ca_cert"), None)
667 mock_path
.isdir
.asssert_called_once_with(file_name
)
668 mock_makedirs
.assert_called_once_with(file_name
)
669 mock_random
.randint
.assert_called_once()
670 mock_open
.assert_not_called()
672 @patch("osm_ng_ro.monitor.random")
673 @patch("osm_ng_ro.monitor.makedirs")
674 @patch("osm_ng_ro.monitor.path")
675 @patch("builtins.open", new_callable
=mock_open())
676 def test_process_vim_config_vim_with_cacert_mock_open_raises(
677 self
, mock_open
, mock_path
, mock_makedirs
, mock_random
679 db_vim
= {"config": {"ca_cert_content": "my_vim_cert"}}
680 mock_path
.isdir
.return_value
= False
681 mock_random
.randint
.return_value
= 23242
682 mock_open
.side_effect
= FileNotFoundError("File is not found.")
683 with self
.assertRaises(MonitorVimException
) as err
:
684 self
.monitor
._process
_vim
_config
(target_id
, db_vim
)
687 "Error writing to file '/app/osm_ro/certs/55b2219a-7bb9-4644-9612-980dada84e83:23242/ca_cert': "
688 "File is not found.",
690 self
.assertEqual(db_vim
["config"].get("ca_cert_content"), "my_vim_cert")
691 self
.assertEqual(db_vim
["config"].get("ca_cert"), None)
692 mock_path
.isdir
.asssert_called_once_with(file_name
)
693 mock_makedirs
.assert_called_once_with(file_name
)
694 mock_random
.randint
.assert_called_once()
695 mock_open
.assert_called_once_with(file_name
+ "/ca_cert", "w")
697 @patch("osm_ng_ro.monitor.random")
698 @patch("osm_ng_ro.monitor.makedirs")
699 @patch("osm_ng_ro.monitor.path")
700 @patch("builtins.open", new_callable
=mock_open())
701 def test_process_vim_config_vim_without_cacert(
702 self
, mock_open
, mock_path
, mock_makedirs
, mock_random
704 db_vim
= {"config": {}}
705 self
.monitor
._process
_vim
_config
(target_id
, db_vim
)
706 self
.assertEqual(db_vim
["config"].get("ca_cert"), None)
707 check_if_assert_not_called(
708 [mock_path
.isdir
, mock_makedirs
, mock_random
.randint
, mock_open
]
711 @patch("osm_ng_ro.monitor.entry_points")
712 def test_load_plugin_name_exists(self
, mock_entry_points
):
713 self
.monitor
.plugins
= {plugin_name
: VimConnector
}
714 result
= self
.monitor
._load
_plugin
(plugin_name
)
715 mock_entry_points
.assert_not_called()
716 self
.assertEqual(self
.monitor
.plugins
, {plugin_name
: VimConnector
})
717 self
.assertEqual(result
, VimConnector
)
719 @patch("osm_ng_ro.monitor.entry_points")
720 def test_load_plugin_name_does_not_exist(self
, mock_entry_points
):
721 self
.monitor
.plugins
= {}
722 mock_ep
= MagicMock()
723 mock_ep
.load
.return_value
= sample_vim_connector_instance
724 mock_entry_points
.return_value
= [mock_ep
]
725 result
= self
.monitor
._load
_plugin
(plugin_name
)
726 self
.assertEqual(mock_entry_points
.call_count
, 1)
727 mock_entry_points
.assert_called_once_with(
728 group
="osm_rovim.plugins", name
=plugin_name
731 self
.monitor
.plugins
, {plugin_name
: sample_vim_connector_instance
}
733 self
.assertEqual(result
, sample_vim_connector_instance
)
735 @patch("osm_ng_ro.monitor.entry_points")
736 def test_load_plugin_load_raises(self
, mock_entry_points
):
737 self
.monitor
.plugins
= {}
738 mock_entry_points
.return_value
= None
739 with self
.assertRaises(MonitorVimException
) as err
:
740 self
.monitor
._load
_plugin
(plugin_name
)
743 "Cannot load plugin osm_rovim_openstack: 'NoneType' object is not iterable",
745 self
.assertEqual(mock_entry_points
.call_count
, 1)
746 mock_entry_points
.assert_called_once_with(
747 group
="osm_rovim.plugins", name
=plugin_name
749 self
.assertEqual(self
.monitor
.plugins
, {})
751 @patch("osm_ng_ro.monitor.VmToMonitor")
752 def test_create_vm_to_monitor_empty_ro_task(self
, mock_vm_to_monitor
):
754 result
= self
.monitor
.create_vm_to_monitor(ro_task
)
755 self
.assertEqual(result
, None)
756 mock_vm_to_monitor
.assert_not_called()
758 @patch("osm_ng_ro.monitor.VmToMonitor")
759 def test_create_vm_to_monitor(self
, mock_vm_to_monitor
):
760 sample_vm
= VmToMonitor("sample_id", "sample_target_record")
761 mock_vm_to_monitor
.return_value
= sample_vm
762 result
= self
.monitor
.create_vm_to_monitor(ro_task1
)
763 self
.assertEqual(result
, sample_vm
)
764 mock_vm_to_monitor
.assert_called_once_with(
765 "ebd39f37-e607-4bce-9f10-ea4c5635f726", target_record
768 @patch("osm_ng_ro.monitor.VmToMonitor")
769 def test_create_vm_to_monitor_wrong_ro_task_format(self
, mock_vm_to_monitor
):
770 mock_vm_to_monitor
.return_value
= "VmtoMonitor"
771 with self
.assertRaises(KeyError) as err
:
772 self
.monitor
.create_vm_to_monitor(wrong_ro_task
)
773 self
.assertEqual(str(err
.exception
.args
[0]), "vim_info")
774 mock_vm_to_monitor
.assert_not_called()
776 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
777 def test_add_vm_to_existing_vim(self
, mock_create_vm_to_monitor
):
778 sample_vim1
= VimToMonitor(vim1_id
, [vm1_id
])
779 vims_to_monitor
= [sample_vim1
]
780 result
= self
.monitor
.add_vm_to_existing_vim(vims_to_monitor
, ro_task2
, vim1_id
)
781 self
.assertEqual(result
, True)
782 mock_create_vm_to_monitor
.assert_called_once_with(ro_task2
)
783 self
.assertEqual(2, len(sample_vim1
.vms
))
785 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
786 def test_add_vm_to_existing_vim_empty_vims_list(self
, mock_create_vm_to_monitor
):
788 result
= self
.monitor
.add_vm_to_existing_vim(vims_to_monitor
, ro_task1
, vim1_id
)
789 self
.assertEqual(result
, False)
790 mock_create_vm_to_monitor
.assert_not_called()
792 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
793 def test_add_vm_to_existing_vim_different_target_vim_id(
794 self
, mock_create_vm_to_monitor
796 sample_vim1
= VimToMonitor(vim1_id
, [vm1_id
])
797 vims_to_monitor
= [sample_vim1
]
798 result
= self
.monitor
.add_vm_to_existing_vim(vims_to_monitor
, ro_task2
, vim2_id
)
799 self
.assertEqual(result
, False)
800 mock_create_vm_to_monitor
.assert_not_called()
801 self
.assertEqual(1, len(sample_vim1
.vms
))
803 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
804 def test_add_vm_to_existing_vim_create_vm_to_monitor_raises(
805 self
, mock_create_vm_to_monitor
807 sample_vim1
= VimToMonitor(vim1_id
, [vm1_id
])
808 vims_to_monitor
= [sample_vim1
]
809 mock_create_vm_to_monitor
.side_effect
= KeyError(
810 "target_record does not exist."
812 with self
.assertRaises(KeyError) as err
:
813 self
.monitor
.add_vm_to_existing_vim(vims_to_monitor
, ro_task2
, vim1_id
)
814 self
.assertEqual(str(err
.exception
.args
[0]), "target_record does not exist.")
815 mock_create_vm_to_monitor
.assert_called_once_with(ro_task2
)
816 self
.assertEqual(1, len(sample_vim1
.vms
))
818 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
819 @patch("osm_ng_ro.monitor.VimToMonitor")
820 def test_add_new_vim_for_monitoring(
821 self
, mock_vim_to_monitor
, mock_create_vm_to_monitor
823 sample_vim
= VimToMonitor(vim1_id
, [])
824 mock_vim_to_monitor
.return_value
= sample_vim
825 self
.monitor
.add_new_vim_for_monitoring(vims_to_monitor
, ro_task1
, vim1_id
)
826 mock_vim_to_monitor
.assert_called_once_with(vim1_id
, [])
827 mock_create_vm_to_monitor
.assert_called_once_with(ro_task1
)
828 self
.assertEqual(len(sample_vim
.vms
), 1)
829 self
.assertEqual(len(vims_to_monitor
), 1)
831 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
832 @patch("osm_ng_ro.monitor.VimToMonitor")
833 def test_add_new_vim_for_monitoring_vim_to_monitor_raises(
834 self
, mock_vim_to_monitor
, mock_create_vm_to_monitor
837 mock_vim_to_monitor
.side_effect
= TypeError(
838 "Missing required positional arguments"
840 with self
.assertRaises(TypeError) as err
:
841 self
.monitor
.add_new_vim_for_monitoring(vims_to_monitor
, ro_task1
, None)
843 str(err
.exception
.args
[0]), "Missing required positional arguments"
845 mock_vim_to_monitor
.assert_called_once_with(None, [])
846 mock_create_vm_to_monitor
.assert_not_called()
847 self
.assertEqual(len(vims_to_monitor
), 0)
849 @patch("osm_ng_ro.monitor.MonitorVms.create_vm_to_monitor")
850 @patch("osm_ng_ro.monitor.VimToMonitor")
851 def test_add_new_vim_for_monitoring_create_vm_to_monitor_raises(
852 self
, mock_vim_to_monitor
, mock_create_vm_to_monitor
855 mock_create_vm_to_monitor
.side_effect
= KeyError("target_record is not found.")
856 with self
.assertRaises(KeyError) as err
:
857 self
.monitor
.add_new_vim_for_monitoring(vims_to_monitor
, ro_task1
, vim1_id
)
858 self
.assertEqual(str(err
.exception
.args
[0]), "target_record is not found.")
859 mock_vim_to_monitor
.assert_called_once_with(vim1_id
, [])
860 mock_create_vm_to_monitor
.assert_called_once_with(ro_task1
)
861 self
.assertEqual(len(vims_to_monitor
), 0)
863 @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
864 @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
865 def test_prepare_vims_to_monitor_no_proper_existing_vim(
866 self
, mock_add_new_vim_for_monitoring
, mock_add_vm_to_existing_vim
868 mock_add_vm_to_existing_vim
.return_value
= False
869 self
.monitor
.prepare_vims_to_monitor(vims_to_monitor
, ro_task1
, vim1_id
)
870 mock_add_vm_to_existing_vim
.assert_called_once_with(
871 vims_to_monitor
, ro_task1
, vim1_id
873 mock_add_new_vim_for_monitoring
.assert_called_once_with(
874 vims_to_monitor
, ro_task1
, vim1_id
877 @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
878 @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
879 def test_prepare_vims_to_monitor_proper_existing_vim(
880 self
, mock_add_new_vim_for_monitoring
, mock_add_vm_to_existing_vim
882 mock_add_vm_to_existing_vim
.return_value
= True
883 self
.monitor
.prepare_vims_to_monitor(vims_to_monitor
, ro_task1
, vim1_id
)
884 mock_add_vm_to_existing_vim
.assert_called_once_with(
885 vims_to_monitor
, ro_task1
, vim1_id
887 mock_add_new_vim_for_monitoring
.assert_not_called()
889 @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
890 @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
891 def test_prepare_vims_to_monitor_add_vm_to_existing_vim_raises(
892 self
, mock_add_new_vim_for_monitoring
, mock_add_vm_to_existing_vim
894 mock_add_vm_to_existing_vim
.side_effect
= KeyError(
895 "target_record is not found."
897 with self
.assertRaises(KeyError) as err
:
898 self
.monitor
.prepare_vims_to_monitor(vims_to_monitor
, ro_task1
, vim1_id
)
899 self
.assertEqual(str(err
.exception
.args
[0]), "target_record is not found.")
900 mock_add_vm_to_existing_vim
.assert_called_once_with(
901 vims_to_monitor
, ro_task1
, vim1_id
903 mock_add_new_vim_for_monitoring
.assert_not_called()
905 @patch("osm_ng_ro.monitor.MonitorVms.add_vm_to_existing_vim")
906 @patch("osm_ng_ro.monitor.MonitorVms.add_new_vim_for_monitoring")
907 def test_prepare_vims_to_monitor_add_new_vim_for_monitoring_raises(
908 self
, mock_add_new_vim_for_monitoring
, mock_add_vm_to_existing_vim
910 mock_add_vm_to_existing_vim
.return_value
= False
911 mock_add_new_vim_for_monitoring
.side_effect
= KeyError(
912 "target_record is not found."
914 with self
.assertRaises(KeyError) as err
:
915 self
.monitor
.prepare_vims_to_monitor(vims_to_monitor
, ro_task1
, vim1_id
)
916 self
.assertEqual(str(err
.exception
.args
[0]), "target_record is not found.")
917 mock_add_vm_to_existing_vim
.assert_called_once_with(
918 vims_to_monitor
, ro_task1
, vim1_id
920 mock_add_new_vim_for_monitoring
.assert_called_once_with(
921 vims_to_monitor
, ro_task1
, vim1_id
924 def test_get_db_paths(self
):
925 self
.monitor
.db
.get_one
.return_value
= sample_vnfr
933 ) = self
.monitor
._get
_db
_paths
(target_record
)
935 vim_info_path
, "vdur.0.vim_info.vim:f239ed93-756b-408e-89f8-fcbf47a9d8f7"
937 self
.assertEqual(vim_id
, vim4_id
)
938 self
.assertEqual(vdur_path
, "vdur.0")
939 self
.assertEqual(vdur_index
, 0)
940 self
.assertEqual(vnfr_id
, vnfr_id
)
941 self
.assertDictEqual(db_vnfr
, sample_vnfr
)
942 self
.monitor
.db
.get_one
.assert_called_once_with(
948 def test_get_db_paths_empty_vnfr(self
):
949 self
.monitor
.db
.get_one
.return_value
= None
957 ) = self
.monitor
._get
_db
_paths
(target_record
)
959 vim_info_path
, "vdur.0.vim_info.vim:f239ed93-756b-408e-89f8-fcbf47a9d8f7"
961 self
.assertEqual(vim_id
, vim4_id
)
962 self
.assertEqual(vdur_path
, "vdur.0")
963 self
.assertEqual(vdur_index
, 0)
964 self
.assertEqual(vnfr_id
, vnfr_id
)
965 self
.assertEqual(db_vnfr
, None)
966 self
.monitor
.db
.get_one
.assert_called_once_with(
972 def test_get_db_paths_invalid_target_record(self
):
973 invalid_target_record
= "vnfrs:35c034cc-8c5b-48c4-bfa2-17a71577ef19:f239ed93-756b-408e-89f8-fcbf47a9d8f7"
974 with self
.assertRaises(MonitorVmsException
) as err
:
975 self
.monitor
._get
_db
_paths
(invalid_target_record
)
977 str(err
.exception
.args
[0]),
978 "not enough values to unpack (expected 4, got 3)",
980 self
.monitor
.db
.get_one
.assert_not_called()
982 def test_get_db_paths_db_raises(self
):
983 self
.monitor
.db
.get_one
.side_effect
= DbException("Connection Failed.")
984 with self
.assertRaises(MonitorVmsException
) as err
:
985 self
.monitor
._get
_db
_paths
(target_record
)
987 str(err
.exception
.args
[0]), "database exception Connection Failed."
989 self
.monitor
.db
.get_one
.assert_called_once_with(
995 def test_check_if_vdur_vim_info_exists(self
):
997 result
= self
.monitor
._check
_if
_vdur
_vim
_info
_exists
(sample_vnfr
, vdur_index
)
998 self
.assertEqual(result
, True)
1000 def test_check_if_vdur_vim_info_exists_wrong_vdur_index(self
):
1002 result
= self
.monitor
._check
_if
_vdur
_vim
_info
_exists
(sample_vnfr
, vdur_index
)
1003 self
.assertEqual(result
, None)
1005 def test_check_if_vdur_vim_info_exists_empty_vnfr(self
):
1007 result
= self
.monitor
._check
_if
_vdur
_vim
_info
_exists
({}, vdur_index
)
1008 self
.assertEqual(result
, None)
1010 def test_check_if_vdur_vim_info_exists_str_vdur_index(self
):
1012 result
= self
.monitor
._check
_if
_vdur
_vim
_info
_exists
({}, vdur_index
)
1013 self
.assertEqual(result
, None)
1015 def test_check_if_vdur_vim_info_exists_none_vnfr(self
):
1017 result
= self
.monitor
._check
_if
_vdur
_vim
_info
_exists
(None, vdur_index
)
1018 self
.assertEqual(result
, None)
1020 @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1021 @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1022 @patch("osm_ng_ro.monitor.deepcopy")
1023 def test_get_vm_data_from_db(
1024 self
, mock_deepcopy
, mock_vim_info_exists
, mock_get_db_paths
1028 db_vnfr
= sample_vnfr
1029 mock_get_db_paths
.return_value
= (
1037 mock_vim_info_exists
.return_value
= True
1038 mock_deepcopy
.return_value
= sample_vim_info
1041 vdur_vim_info_update_result
,
1043 existing_vim_info_result
,
1045 vim_info_path_result
,
1046 ) = self
.monitor
._get
_vm
_data
_from
_db
(sample_vm
)
1047 self
.assertEqual(vdur_path_result
, vdur_path
)
1048 self
.assertEqual(vdur_vim_info_update_result
, sample_vim_info
)
1049 self
.assertEqual(db_vnfr_result
, db_vnfr
)
1050 self
.assertEqual(existing_vim_info_result
, sample_vim_info
)
1051 self
.assertEqual(vnfr_id_result
, vnfr_id
)
1052 self
.assertEqual(vim_info_path_result
, vim_info_path
)
1053 mock_deepcopy
.assert_called_once_with(sample_vim_info
)
1054 mock_get_db_paths
.assert_called_once_with(target_record
)
1055 mock_vim_info_exists
.assert_called_once_with(db_vnfr
, vdur_index
)
1057 @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1058 @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1059 @patch("osm_ng_ro.monitor.deepcopy")
1060 def test_get_vm_data_from_db_no_vim_info(
1061 self
, mock_deepcopy
, mock_vim_info_exists
, mock_get_db_paths
1065 db_vnfr
= sample_vnfr
1066 mock_get_db_paths
.return_value
= (
1074 mock_vim_info_exists
.return_value
= False
1075 result
= self
.monitor
._get
_vm
_data
_from
_db
(sample_vm
)
1076 self
.assertEqual(result
, None)
1077 mock_deepcopy
.assert_not_called()
1078 mock_get_db_paths
.assert_called_once_with(target_record
)
1079 mock_vim_info_exists
.assert_called_once_with(db_vnfr
, vdur_index
)
1081 @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1082 @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1083 @patch("osm_ng_ro.monitor.deepcopy")
1084 def test_get_vm_data_from_db_get_db_path_raises(
1085 self
, mock_deepcopy
, mock_vim_info_exists
, mock_get_db_paths
1087 mock_get_db_paths
.side_effect
= DbException("Connection failed.")
1088 with self
.assertRaises(DbException
) as err
:
1089 self
.monitor
._get
_vm
_data
_from
_db
(sample_vm
)
1091 str(err
.exception
.args
[0]), "database exception Connection failed."
1093 mock_get_db_paths
.assert_called_once_with(target_record
)
1094 check_if_assert_not_called([mock_deepcopy
, mock_vim_info_exists
])
1096 @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1097 @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1098 @patch("osm_ng_ro.monitor.deepcopy")
1099 def test_get_vm_data_from_db_vnfr_without_correct_vdur_index(
1100 self
, mock_deepcopy
, mock_vim_info_exists
, mock_get_db_paths
1104 db_vnfr
= sample_vnfr
1105 mock_get_db_paths
.return_value
= (
1113 mock_vim_info_exists
.return_value
= True
1114 with self
.assertRaises(IndexError) as err
:
1115 self
.monitor
._get
_vm
_data
_from
_db
(sample_vm
)
1116 self
.assertEqual(str(err
.exception
.args
[0]), "list index out of range")
1117 mock_deepcopy
.assert_not_called()
1118 mock_get_db_paths
.assert_called_once_with(target_record
)
1119 mock_vim_info_exists
.assert_called_once_with(db_vnfr
, vdur_index
)
1121 @patch("osm_ng_ro.monitor.MonitorVms._get_db_paths")
1122 @patch("osm_ng_ro.monitor.MonitorVms._check_if_vdur_vim_info_exists")
1123 @patch("osm_ng_ro.monitor.deepcopy")
1124 def test_get_vm_data_from_db_vnfr_without_proper_vim_id(
1125 self
, mock_deepcopy
, mock_vim_info_exists
, mock_get_db_paths
1127 vim_id
= "5239ed93-756b-408e-89f8-fcbf47a9d8f7"
1129 db_vnfr
= sample_vnfr
1130 mock_get_db_paths
.return_value
= (
1138 mock_vim_info_exists
.return_value
= True
1139 self
.monitor
._get
_vm
_data
_from
_db
(sample_vm
)
1140 mock_deepcopy
.assert_not_called()
1141 mock_get_db_paths
.assert_called_once_with(target_record
)
1142 mock_vim_info_exists
.assert_called_once_with(db_vnfr
, vdur_index
)
1144 def test_update_vim_info_for_deleted_vm_empty_input_dict(self
):
1145 vdur_vim_info_update
= {}
1146 self
.monitor
.update_vim_info_for_deleted_vm(vdur_vim_info_update
)
1148 vdur_vim_info_update
,
1152 def test_update_vim_info_for_deleted_vm_update_existing_info(self
):
1153 vdur_vim_info_update
= {
1154 "vim_status": "ACTIVE",
1155 "vim_message": None,
1156 "vim_details": None,
1158 "vim_name": "test7-vnf-hackfest_basic-VM-000000",
1160 self
.monitor
.update_vim_info_for_deleted_vm(vdur_vim_info_update
)
1162 vdur_vim_info_update
,
1166 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1167 @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1168 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1169 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1170 def test_report_deleted_vdur_no_vm_data_in_db(
1172 mock_update_in_database
,
1173 mock_backup_vdu_interfaces
,
1174 mock_update_vim_info_for_deleted_vm
,
1175 mock_get_vm_data_from_db
,
1177 mock_get_vm_data_from_db
.return_value
= None
1178 self
.monitor
.report_deleted_vdur(sample_vm
)
1179 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
1180 check_if_assert_not_called(
1182 mock_update_in_database
,
1183 mock_backup_vdu_interfaces
,
1184 mock_update_vim_info_for_deleted_vm
,
1188 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1189 @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1190 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1191 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1192 def test_report_deleted_vdur(
1194 mock_update_in_database
,
1195 mock_backup_vdu_interfaces
,
1196 mock_update_vim_info_for_deleted_vm
,
1197 mock_get_vm_data_from_db
,
1199 existing_vim_info
= sample_vim_info
1200 vdur_vim_info_update
= deleted_externally
1201 mock_get_vm_data_from_db
.return_value
= (
1203 vdur_vim_info_update
,
1210 vdur_path
+ ".status": "DELETED",
1212 self
.monitor
.report_deleted_vdur(sample_vm
)
1213 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
1214 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
1215 mock_update_vim_info_for_deleted_vm
.assert_called_once_with(
1216 vdur_vim_info_update
1218 mock_backup_vdu_interfaces
.assert_called_once_with(vdur_vim_info_update
)
1219 mock_update_in_database
.assert_called_once_with(
1220 [vdur_update
, {vim_info_path
: vdur_vim_info_update
}], vnfr_id
1223 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1224 @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1225 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1226 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1227 def test_report_deleted_vdur_vm_db_already_updated(
1229 mock_update_in_database
,
1230 mock_backup_vdu_interfaces
,
1231 mock_update_vim_info_for_deleted_vm
,
1232 mock_get_vm_data_from_db
,
1234 vdur_vim_info_update
= existing_vim_info
= deleted_externally
1235 mock_get_vm_data_from_db
.return_value
= (
1237 vdur_vim_info_update
,
1243 self
.monitor
.report_deleted_vdur(sample_vm
)
1244 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
1245 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
1246 mock_update_vim_info_for_deleted_vm
.assert_called_once_with(
1247 vdur_vim_info_update
1249 check_if_assert_not_called(
1250 [mock_backup_vdu_interfaces
, mock_update_in_database
]
1253 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1254 @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1255 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1256 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1257 def test_report_deleted_vdur_get_vm_data_raises(
1259 mock_update_in_database
,
1260 mock_backup_vdu_interfaces
,
1261 mock_update_vim_info_for_deleted_vm
,
1262 mock_get_vm_data_from_db
,
1264 mock_get_vm_data_from_db
.side_effect
= IndexError("list index out of range.")
1265 with self
.assertRaises(IndexError) as err
:
1266 self
.monitor
.report_deleted_vdur(sample_vm
)
1267 self
.assertEqual(str(err
.exception
.args
[0]), "list index out of range.")
1268 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
1269 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
1270 check_if_assert_not_called(
1272 mock_update_vim_info_for_deleted_vm
,
1273 mock_backup_vdu_interfaces
,
1274 mock_update_in_database
,
1278 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
1279 @patch("osm_ng_ro.monitor.MonitorVms.update_vim_info_for_deleted_vm")
1280 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
1281 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
1282 def test_report_deleted_vdur_update_in_database_raises(
1284 mock_update_in_database
,
1285 mock_backup_vdu_interfaces
,
1286 mock_update_vim_info_for_deleted_vm
,
1287 mock_get_vm_data_from_db
,
1289 existing_vim_info
= sample_vim_info
1290 vdur_vim_info_update
= deleted_externally
1291 mock_update_in_database
.side_effect
= MonitorDbException(
1292 "Error while updating differences in VNFR."
1294 mock_get_vm_data_from_db
.return_value
= (
1296 vdur_vim_info_update
,
1303 vdur_path
+ ".status": "DELETED",
1305 with self
.assertRaises(MonitorDbException
) as err
:
1306 self
.monitor
.report_deleted_vdur(sample_vm
)
1308 str(err
.exception
.args
[0]), "Error while updating differences in VNFR."
1310 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
1311 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
1312 mock_update_vim_info_for_deleted_vm
.assert_called_once_with(
1313 vdur_vim_info_update
1315 mock_backup_vdu_interfaces
.assert_called_once_with(vdur_vim_info_update
)
1316 mock_update_in_database
.assert_called_once_with(
1317 [vdur_update
, {vim_info_path
: vdur_vim_info_update
}], vnfr_id
1320 @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1321 @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1322 def test_update_vnfrs(self
, mock_report_deleted_vdur
, mock_report_vdur_updates
):
1323 vms_to_monitor
= [sample_vm
, sample_vm2
, sample_vm3
]
1324 servers
= [server1
, server2
, server3
, server4
]
1325 ports
= {"ports": [port1
, port2
]}
1326 self
.monitor
.update_vnfrs(servers
, ports
, vms_to_monitor
)
1327 self
.assertEqual(mock_report_vdur_updates
.call_count
, 2)
1328 mock_report_deleted_vdur
.assert_called_once_with(sample_vm3
)
1329 _call_mock_report_vdur_updates
= mock_report_vdur_updates
.call_args_list
1331 _call_mock_report_vdur_updates
[0].args
,
1332 (server1
, sample_vm
, ports
),
1335 _call_mock_report_vdur_updates
[1].args
,
1336 (server2
, sample_vm2
, ports
),
1339 @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1340 @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1341 def test_update_vnfrs_empty_vms_to_monitor(
1342 self
, mock_report_deleted_vdur
, mock_report_vdur_updates
1345 servers
= [server1
, server2
, server3
, server4
]
1346 ports
= {"ports": [port1
, port2
]}
1347 self
.monitor
.update_vnfrs(servers
, ports
, vms_to_monitor
)
1348 check_if_assert_not_called([mock_report_deleted_vdur
, mock_report_vdur_updates
])
1350 @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1351 @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1352 def test_update_vnfrs_empty_servers(
1353 self
, mock_report_deleted_vdur
, mock_report_vdur_updates
1355 vms_to_monitor
= [sample_vm
, sample_vm2
, sample_vm3
]
1357 ports
= {"ports": [port1
, port2
]}
1358 self
.monitor
.update_vnfrs(servers
, ports
, vms_to_monitor
)
1359 mock_report_vdur_updates
.assert_not_called()
1360 self
.assertEqual(mock_report_deleted_vdur
.call_count
, 3)
1361 _call_mock_report_deleted_vdur
= mock_report_deleted_vdur
.call_args_list
1363 _call_mock_report_deleted_vdur
[0].args
[0],
1367 _call_mock_report_deleted_vdur
[1].args
[0],
1371 _call_mock_report_deleted_vdur
[2].args
[0],
1375 @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1376 @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1377 def test_update_vnfrs_report_vdur_updates_raises(
1378 self
, mock_report_deleted_vdur
, mock_report_vdur_updates
1380 vms_to_monitor
= [sample_vm
, sample_vm2
, sample_vm3
]
1381 servers
= [server1
, server2
, server3
, server4
]
1382 ports
= {"ports": [port1
, port2
]}
1383 mock_report_vdur_updates
.side_effect
= IndexError("list index out of range.")
1384 with self
.assertRaises(IndexError) as err
:
1385 self
.monitor
.update_vnfrs(servers
, ports
, vms_to_monitor
)
1386 self
.assertEqual(str(err
.exception
.args
[0]), "list index out of range.")
1387 self
.assertEqual(mock_report_vdur_updates
.call_count
, 1)
1388 mock_report_deleted_vdur
.assert_not_called()
1389 _call_mock_report_vdur_updates
= mock_report_vdur_updates
.call_args_list
1391 _call_mock_report_vdur_updates
[0].args
,
1392 (server1
, sample_vm
, ports
),
1395 @patch("osm_ng_ro.monitor.MonitorVms.report_vdur_updates")
1396 @patch("osm_ng_ro.monitor.MonitorVms.report_deleted_vdur")
1397 def test_update_vnfrs_report_deleted_vdur_raises(
1398 self
, mock_report_deleted_vdur
, mock_report_vdur_updates
1400 vms_to_monitor
= [sample_vm
, sample_vm2
, sample_vm3
]
1401 servers
= [server1
, server2
, server3
, server4
]
1402 ports
= {"ports": [port1
, port2
]}
1403 mock_report_deleted_vdur
.side_effect
= DbException("DB is not in active state.")
1404 with self
.assertRaises(DbException
) as err
:
1405 self
.monitor
.update_vnfrs(servers
, ports
, vms_to_monitor
)
1407 str(err
.exception
.args
[0]), "database exception DB is not in active state."
1409 self
.assertEqual(mock_report_vdur_updates
.call_count
, 2)
1410 mock_report_deleted_vdur
.assert_called_once_with(sample_vm3
)
1411 _call_mock_report_vdur_updates
= mock_report_vdur_updates
.call_args_list
1413 _call_mock_report_vdur_updates
[0].args
,
1414 (server1
, sample_vm
, ports
),
1417 _call_mock_report_vdur_updates
[1].args
,
1418 (server2
, sample_vm2
, ports
),
1421 @patch("osm_ng_ro.monitor.yaml")
1422 def test_serialize_string_value(self
, mock_yaml
):
1423 value
= "some string"
1424 result
= self
.monitor
.serialize(value
)
1425 mock_yaml
.dump
.assert_not_called()
1426 self
.assertEqual(result
, value
)
1428 @patch("osm_ng_ro.monitor.yaml")
1429 def test_serialize_list_value(self
, mock_yaml
):
1432 ["image", "ghcr.io/foo/mysvc"],
1433 {"MYSVC_ENV": "to_nice_yaml"},
1437 ["image", "ghcr.io/foo/mysvc"],
1438 {"MYSVC_ENV": "to_nice_yaml"},
1440 mock_yaml
.dump
.return_value
= output
1441 result
= self
.monitor
.serialize(value
)
1442 mock_yaml
.dump
.assert_called_once()
1443 self
.assertEqual(result
, output
)
1445 @patch("osm_ng_ro.monitor.yaml")
1446 def test_serialize_dict_value(self
, mock_yaml
):
1449 "MYSVC_ENV": "to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml",
1452 "MYSVC_ENV": "to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml_to_nice_yaml",
1455 mock_yaml
.dump
.return_value
= output
1456 result
= self
.monitor
.serialize(value
)
1457 mock_yaml
.dump
.assert_called_once()
1458 self
.assertEqual(result
, output
)
1460 @patch("osm_ng_ro.monitor.yaml")
1461 def test_serialize_raise_representer_error(self
, mock_yaml
):
1463 "name": {"firstname": str, "lastname": str},
1466 mock_yaml
.dump
.side_effect
= yaml
.representer
.RepresenterError(
1467 "cannot represent an object"
1469 result
= self
.monitor
.serialize(value
)
1470 mock_yaml
.dump
.assert_called_once()
1471 self
.assertEqual(result
, str(value
))
1473 @patch("osm_ng_ro.monitor.yaml")
1474 def test_serialize_raise_yaml_error(self
, mock_yaml
):
1476 "name": {"firstname": str, "lastname": str},
1480 mock_yaml
.dump
.side_effect
= yaml
.YAMLError("cannot represent an object.")
1481 with self
.assertRaises(yaml
.YAMLError
) as err
:
1482 result
= self
.monitor
.serialize(value
)
1483 self
.assertEqual(result
, None)
1484 self
.assertEqual(str(err
.exception
.args
[0]), "cannot represent an object.")
1485 mock_yaml
.dump
.assert_called_once()
1487 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1488 def test_get_server_info_with_user_data(self
, mock_serialize
):
1489 all_server_info
= deepcopy(server_other_info
)
1491 "OS-EXT-SRV-ATTR:user_data": "EXT-USER-DATA",
1492 "user_data": "some-data",
1494 mock_serialize
.return_value
= serialized_server_info
1495 all_server_info
.update(user_data
)
1496 server5
= create_server(vm1_id
, "server5", info
=all_server_info
)
1497 result
= self
.monitor
._get
_server
_info
(server5
)
1498 self
.assertEqual(result
, serialized_server_info
)
1499 mock_serialize
.assert_called_once_with(server_other_info
)
1501 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1502 def test_get_server_info_without_user_data(self
, mock_serialize
):
1503 mock_serialize
.return_value
= serialized_server_info
1504 server5
= create_server(vm1_id
, "server5", info
=server_other_info
)
1505 result
= self
.monitor
._get
_server
_info
(server5
)
1506 self
.assertEqual(result
, serialized_server_info
)
1507 mock_serialize
.assert_called_once_with(server_other_info
)
1509 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1510 def test_get_server_info_empty_server_info(self
, mock_serialize
):
1511 server_other_info
= {}
1512 expected_result
= {}
1513 mock_serialize
.return_value
= expected_result
1514 server5
= create_server(vm1_id
, "server5", info
=server_other_info
)
1515 result
= self
.monitor
._get
_server
_info
(server5
)
1516 self
.assertEqual(result
, expected_result
)
1517 mock_serialize
.assert_called_once_with(server_other_info
)
1519 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1520 def test_get_server_info_serialize_raises(self
, mock_serialize
):
1521 server_other_info
= {
1522 "admin_state_up": "true",
1523 "binding:host_id": int,
1524 "binding:profile": {},
1525 "binding:vif_type": str,
1526 "binding:vnic_type": "normal",
1527 "created_at": "2023-02-22T05:35:46Z",
1529 mock_serialize
.side_effect
= yaml
.YAMLError("cannot represent an object.")
1530 server5
= create_server(vm1_id
, "server5", info
=server_other_info
)
1531 with self
.assertRaises(yaml
.YAMLError
) as err
:
1532 self
.monitor
._get
_server
_info
(server5
)
1533 self
.assertEqual(str(err
.exception
.args
[0]), "cannot represent an object.")
1534 mock_serialize
.assert_called_once_with(server_other_info
)
1536 @patch("osm_ng_ro.monitor.MonitorVms._get_server_info")
1537 def test_check_vm_status_updates_server_status_ok(self
, mock_server_info
):
1538 server6
= create_server("server6-id", "server6", status
="PAUSED")
1539 mock_server_info
.return_value
= serialized_server_info
1540 vdur_vim_info_update
= {}
1542 expected_vdur_vim_info_update
= {
1543 "vim_status": "PAUSED",
1544 "vim_details": serialized_server_info
,
1545 "vim_id": server6
.id,
1546 "vim_name": server6
.name
,
1548 expected_vdur_update
= {
1549 "vdur.0.status": "PAUSED",
1550 "vdur.0.name": server6
.name
,
1552 self
.monitor
.check_vm_status_updates(
1553 vdur_vim_info_update
, vdur_update
, server6
, vdur_path
1555 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1556 self
.assertDictEqual(vdur_update
, expected_vdur_update
)
1557 mock_server_info
.assert_called_once_with(server6
)
1559 @patch("osm_ng_ro.monitor.MonitorVms._get_server_info")
1560 def test_check_vm_status_updates_server_status_nok(self
, mock_server_info
):
1561 server8
= create_server("server8-id", "server8", status
="FAILED")
1562 mock_server_info
.return_value
= serialized_server_info
1563 vdur_vim_info_update
= {}
1565 expected_vdur_vim_info_update
= {
1566 "vim_status": "FAILED",
1567 "vim_details": serialized_server_info
,
1568 "vim_id": server8
.id,
1569 "vim_name": server8
.name
,
1570 "vim_message": "VIM status reported FAILED",
1572 expected_vdur_update
= {
1573 "vdur.0.status": "FAILED",
1574 "vdur.0.name": server8
.name
,
1576 self
.monitor
.check_vm_status_updates(
1577 vdur_vim_info_update
, vdur_update
, server8
, vdur_path
1579 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1580 self
.assertDictEqual(vdur_update
, expected_vdur_update
)
1581 mock_server_info
.assert_called_once_with(server8
)
1583 @patch("osm_ng_ro.monitor.MonitorVms._get_server_info")
1584 def test_check_vm_status_updates_get_server_info_raises(self
, mock_server_info
):
1585 server8
= create_server("server8-id", "server8", status
="FAILED")
1586 mock_server_info
.side_effect
= yaml
.YAMLError("Cannot represent an object.")
1587 vdur_vim_info_update
= {}
1589 expected_vdur_vim_info_update
= {
1590 "vim_status": "FAILED",
1591 "vim_message": "VIM status reported FAILED",
1593 expected_vdur_update
= {
1594 "vdur.0.status": "FAILED",
1596 with self
.assertRaises(yaml
.YAMLError
) as err
:
1597 self
.monitor
.check_vm_status_updates(
1598 vdur_vim_info_update
, vdur_update
, server8
, vdur_path
1600 self
.assertEqual(str(err
.exception
.args
[0]), "Cannot represent an object.")
1601 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1602 self
.assertDictEqual(vdur_update
, expected_vdur_update
)
1603 mock_server_info
.assert_called_once_with(server8
)
1605 def test_get_interface_info(self
):
1606 interface
= {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1607 ports
= {"ports": [port1
, port2
]}
1608 result
= self
.monitor
.get_interface_info(ports
, interface
, server1
)
1609 self
.assertEqual(result
, port1
)
1611 def test_get_interface_info_port_id_mismatch(self
):
1612 interface
= {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1613 ports
= {"ports": [port2
]}
1614 result
= self
.monitor
.get_interface_info(ports
, interface
, server1
)
1615 self
.assertEqual(result
, None)
1617 def test_get_interface_info_device_id_mismatch(self
):
1618 interface
= {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1619 ports
= {"ports": [port1
, port2
]}
1620 result
= self
.monitor
.get_interface_info(ports
, interface
, server2
)
1621 self
.assertEqual(result
, None)
1623 def test_get_interface_info_empty_ports(self
):
1624 interface
= {"vim_interface_id": "4d081f50-e13a-4306-a67e-1edb28d76013"}
1625 ports
= {"ports": []}
1626 result
= self
.monitor
.get_interface_info(ports
, interface
, server2
)
1627 self
.assertEqual(result
, None)
1629 def test_check_vlan_pci_update(self
):
1630 interface_info
= interface_with_binding
1632 vdur_vim_info_update
= {"interfaces": [{}, {}]}
1633 expected_vdur_vim_info_update
= {
1634 "interfaces": [{}, {"pci": "0000:86:17.4", "vlan": 400}]
1636 self
.monitor
.check_vlan_pci_updates(interface_info
, index
, vdur_vim_info_update
)
1637 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1639 def test_check_vlan_pci_update_empty_interface_info(self
):
1642 vdur_vim_info_update
= {"interfaces": [{}, {}]}
1643 expected_vdur_vim_info_update
= {"interfaces": [{}, {}]}
1644 self
.monitor
.check_vlan_pci_updates(interface_info
, index
, vdur_vim_info_update
)
1645 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1647 def test_check_vlan_pci_update_index_out_of_range(self
):
1648 interface_info
= interface_with_binding
1650 vdur_vim_info_update
= {"interfaces": [{}]}
1651 expected_vdur_vim_info_update
= {"interfaces": [{}]}
1652 with self
.assertRaises(IndexError) as err
:
1653 self
.monitor
.check_vlan_pci_updates(
1654 interface_info
, index
, vdur_vim_info_update
1656 self
.assertEqual(str(err
.exception
.args
[0]), "list index out of range")
1657 self
.assertEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1659 def test_check_vlan_pci_update_empty_vdur_vim_info_update(self
):
1660 interface_info
= interface_with_binding
1662 vdur_vim_info_update
= {}
1663 expected_vdur_vim_info_update
= {}
1664 with self
.assertRaises(KeyError) as err
:
1665 self
.monitor
.check_vlan_pci_updates(
1666 interface_info
, index
, vdur_vim_info_update
1668 self
.assertEqual(str(err
.exception
.args
[0]), "interfaces")
1669 self
.assertEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1671 @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1672 def test_check_vdur_interface_updates(self
, mock_get_current_ip_address
):
1673 vdur_update
, vnfr_update
= {}, {}
1676 "fixed_ips": [{"ip_address": ip1_addr
}],
1677 "mac_address": mac1_addr
,
1679 mock_get_current_ip_address
.return_value
= ip1_addr
1680 expected_vdur_update
= {
1681 "vdur.0.interfaces.0.ip-address": ip1_addr
,
1682 "vdur.0.ip-address": ip1_addr
,
1683 "vdur.0.interfaces.0.mac-address": mac1_addr
,
1685 expected_vnfr_update
= {
1686 "35c034cc-8c5b-48c4-bfa2-17a71577ef19.ip-address": ip1_addr
1688 self
.monitor
.check_vdur_interface_updates(
1697 self
.assertEqual(vnfr_update
, expected_vnfr_update
)
1698 self
.assertEqual(vdur_update
, expected_vdur_update
)
1699 mock_get_current_ip_address
.assert_called_once_with(interface_info
)
1701 @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1702 def test_check_vdur_interface_updates_not_mgmt_interface(
1703 self
, mock_get_current_ip_address
1705 vdur_update
, vnfr_update
= {}, {}
1708 "fixed_ips": [{"ip_address": ip1_addr
}],
1709 "mac_address": mac1_addr
,
1711 mock_get_current_ip_address
.return_value
= ip1_addr
1713 expected_vdur_update
= {
1714 "vdur.0.interfaces.0.ip-address": ip1_addr
,
1715 "vdur.0.interfaces.0.mac-address": mac1_addr
,
1717 self
.monitor
.check_vdur_interface_updates(
1726 self
.assertEqual(vnfr_update
, {})
1727 self
.assertEqual(vdur_update
, expected_vdur_update
)
1728 mock_get_current_ip_address
.assert_called_once_with(interface_info
)
1730 @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1731 def test_check_vdur_interface_updates_without_mac_address(
1732 self
, mock_get_current_ip_address
1734 vdur_update
, vnfr_update
= {}, {}
1736 interface_info
= {"fixed_ips": [{"ip_address": ip1_addr
}]}
1737 mock_get_current_ip_address
.return_value
= ip1_addr
1738 expected_vdur_update
= {
1739 "vdur.0.interfaces.0.ip-address": ip1_addr
,
1740 "vdur.0.ip-address": ip1_addr
,
1741 "vdur.0.interfaces.0.mac-address": None,
1743 expected_vnfr_update
= {
1744 "35c034cc-8c5b-48c4-bfa2-17a71577ef19.ip-address": ip1_addr
1746 self
.monitor
.check_vdur_interface_updates(
1755 self
.assertEqual(vnfr_update
, expected_vnfr_update
)
1756 self
.assertEqual(vdur_update
, expected_vdur_update
)
1757 mock_get_current_ip_address
.assert_called_once_with(interface_info
)
1759 @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1760 def test_check_vdur_interface_updates_without_ip_address(
1761 self
, mock_get_current_ip_address
1763 vdur_update
, vnfr_update
= {}, {}
1765 interface_info
= {"fixed_ips": [], "mac_address": mac1_addr
}
1766 mock_get_current_ip_address
.return_value
= None
1767 expected_vdur_update
= {
1768 "vdur.0.interfaces.0.mac-address": mac1_addr
,
1770 expected_vnfr_update
= {}
1771 self
.monitor
.check_vdur_interface_updates(
1780 self
.assertEqual(vnfr_update
, expected_vnfr_update
)
1781 self
.assertEqual(vdur_update
, expected_vdur_update
)
1782 mock_get_current_ip_address
.assert_called_once_with(interface_info
)
1784 @patch("osm_ng_ro.monitor.MonitorVms._get_current_ip_address")
1785 def test_check_vdur_interface_updates_wrong_interface_info_format(
1786 self
, mock_get_current_ip_address
1788 vdur_update
, vnfr_update
= {}, {}
1790 interface_info
= {"fixed_ips": ip1_addr
, "mac_address": mac1_addr
}
1791 mock_get_current_ip_address
.side_effect
= TypeError(
1792 "str is not list like object."
1795 with self
.assertRaises(TypeError) as err
:
1796 self
.monitor
.check_vdur_interface_updates(
1805 self
.assertEqual(str(err
.exception
), "str is not list like object.")
1806 self
.assertEqual(vnfr_update
, {})
1807 self
.assertEqual(vdur_update
, {})
1808 mock_get_current_ip_address
.assert_called_once_with(interface_info
)
1810 def test_get_current_ip_address(self
):
1812 "fixed_ips": [{"ip_address": ip1_addr
}],
1813 "mac_address": mac1_addr
,
1815 result
= self
.monitor
._get
_current
_ip
_address
(interface_info
)
1816 self
.assertEqual(result
, ip1_addr
)
1818 def test_get_current_ip_address_no_ip(self
):
1819 interface_info
= {"fixed_ips": [{}], "mac_address": mac1_addr
}
1820 result
= self
.monitor
._get
_current
_ip
_address
(interface_info
)
1821 self
.assertEqual(result
, None)
1823 def test_backup_vdu_interfaces_without_vim_message(self
):
1824 vdur_vim_info_update
= {
1825 "interfaces": {"mac_address": mac1_addr
},
1827 expected_vdur_vim_info_update
= {
1828 "interfaces": {"mac_address": mac1_addr
},
1829 "interfaces_backup": {"mac_address": mac1_addr
},
1831 self
.monitor
.backup_vdu_interfaces(vdur_vim_info_update
)
1832 self
.assertDictEqual(expected_vdur_vim_info_update
, vdur_vim_info_update
)
1834 def test_backup_vdu_interfaces_with_vim_message(self
):
1835 vdur_vim_info_update
= {
1836 "interfaces": {"mac_address": mac1_addr
},
1837 "vim_message": "Deleted Externally",
1839 expected_vdur_vim_info_update
= {
1840 "interfaces": {"mac_address": mac1_addr
},
1841 "vim_message": "Deleted Externally",
1843 self
.monitor
.backup_vdu_interfaces(vdur_vim_info_update
)
1844 self
.assertDictEqual(expected_vdur_vim_info_update
, vdur_vim_info_update
)
1846 def test_backup_vdu_interfaces_with_empty_interfaces(self
):
1847 vdur_vim_info_update
= {
1850 expected_vdur_vim_info_update
= {
1853 self
.monitor
.backup_vdu_interfaces(vdur_vim_info_update
)
1854 self
.assertDictEqual(expected_vdur_vim_info_update
, vdur_vim_info_update
)
1856 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1857 def test_update_vdur_vim_info_interfaces(self
, mock_serialize
):
1859 vdur_vim_info_update
= {
1860 "interfaces": [{}, {"mac_address": mac1_addr
, "compute_node": "host1"}]
1862 all_server_info
= deepcopy(server_other_info
)
1863 host_data
= {"OS-EXT-SRV-ATTR:host": "nova"}
1864 mock_serialize
.return_value
= serialized_interface_info
1865 all_server_info
.update(host_data
)
1866 server7
= create_server(vm1_id
, "server7", info
=all_server_info
)
1867 expected_vdur_vim_info_update
= {
1871 "mac_address": mac2_addr
,
1872 "compute_node": "nova",
1873 "vim_info": serialized_interface_info
,
1874 "vim_net_id": net1_id
,
1875 "ip_address": ip1_addr
,
1879 self
.monitor
.update_vdur_vim_info_interfaces(
1880 vdur_vim_info_update
, index
, interface_info2
, server7
1882 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info_update
)
1883 mock_serialize
.assert_called_once_with(interface_info2
)
1885 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1886 def test_update_vdur_vim_info_interfaces_serialize_raises(self
, mock_serialize
):
1888 vdur_vim_info_update
= {
1889 "interfaces": [{}, {"mac_address": mac1_addr
, "compute_node": "host1"}]
1891 all_server_info
= deepcopy(server_other_info
)
1892 host_data
= {"OS-EXT-SRV-ATTR:host": "nova"}
1893 mock_serialize
.side_effect
= yaml
.YAMLError("Cannot represent an object.")
1894 all_server_info
.update(host_data
)
1895 server7
= create_server(vm1_id
, "server7", info
=all_server_info
)
1896 expected_vdur_vim_info
= deepcopy(vdur_vim_info_update
)
1897 with self
.assertRaises(yaml
.YAMLError
) as err
:
1898 self
.monitor
.update_vdur_vim_info_interfaces(
1899 vdur_vim_info_update
, index
, interface_info2
, server7
1901 self
.assertEqual(str(err
.exception
), "Cannot represent an object.")
1902 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info
)
1903 mock_serialize
.assert_called_once_with(interface_info2
)
1905 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1906 def test_update_vdur_vim_info_interfaces_empty_interface_info(self
, mock_serialize
):
1908 vdur_vim_info_update
= {
1909 "interfaces": [{}, {"mac_address": mac1_addr
, "compute_node": "host1"}]
1912 all_server_info
= deepcopy(server_other_info
)
1913 host_data
= {"OS-EXT-SRV-ATTR:host": "nova"}
1914 all_server_info
.update(host_data
)
1915 server7
= create_server(vm1_id
, "server7", info
=all_server_info
)
1916 expected_vdur_vim_info
= deepcopy(vdur_vim_info_update
)
1917 with self
.assertRaises(KeyError) as err
:
1918 self
.monitor
.update_vdur_vim_info_interfaces(
1919 vdur_vim_info_update
, index
, interface_info
, server7
1921 self
.assertEqual(str(err
.exception
.args
[0]), "mac_address")
1922 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info
)
1923 mock_serialize
.assert_not_called()
1925 @patch("osm_ng_ro.monitor.MonitorVms.serialize")
1926 def test_update_vdur_vim_info_interfaces_invalid_vdur_vim_info(
1927 self
, mock_serialize
1930 vdur_vim_info_update
= {
1931 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}, {}]
1933 expected_vdur_vim_info
= deepcopy(vdur_vim_info_update
)
1934 with self
.assertRaises(MonitorVmsException
) as err
:
1935 self
.monitor
.update_vdur_vim_info_interfaces(
1936 vdur_vim_info_update
, index
, interface_info2
, server7
1939 str(err
.exception
.args
[0]), "Existing interfaces info could not found."
1941 self
.assertDictEqual(vdur_vim_info_update
, expected_vdur_vim_info
)
1942 mock_serialize
.assert_not_called()
1944 @patch("osm_ng_ro.monitor.MonitorVms.update_vdur_vim_info_interfaces")
1945 @patch("osm_ng_ro.monitor.MonitorVms.check_vlan_pci_updates")
1946 @patch("osm_ng_ro.monitor.MonitorVms.check_vdur_interface_updates")
1947 def test_prepare_interface_updates(
1949 mock_check_vdur_interface_updates
,
1950 mock_check_vlan_pci_updates
,
1951 mock_update_vdur_vim_info_interfaces
,
1953 vdur_vim_info_update
= {
1954 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
1957 "fixed_ips": [{"ip_address": ip1_addr
}],
1958 "mac_address": mac2_addr
,
1959 "network_id": net1_id
,
1962 "mgmt_vdu_interface": True,
1963 "mgmt_vnf_interface": True,
1966 vnfr_update
, vdur_update
= {}, {}
1967 self
.monitor
.prepare_interface_updates(
1968 vdur_vim_info_update
,
1978 mock_update_vdur_vim_info_interfaces
.assert_called_once_with(
1979 vdur_vim_info_update
, index
, interface_info
, server7
1981 mock_check_vlan_pci_updates
.assert_called_once_with(
1982 interface_info
, index
, vdur_vim_info_update
1984 mock_check_vdur_interface_updates
.assert_called_once_with(
1994 @patch("osm_ng_ro.monitor.MonitorVms.update_vdur_vim_info_interfaces")
1995 @patch("osm_ng_ro.monitor.MonitorVms.check_vlan_pci_updates")
1996 @patch("osm_ng_ro.monitor.MonitorVms.check_vdur_interface_updates")
1997 def test_prepare_interface_updates_update_vdur_vim_info_interfaces_raises(
1999 mock_check_vdur_interface_updates
,
2000 mock_check_vlan_pci_updates
,
2001 mock_update_vdur_vim_info_interfaces
,
2003 vdur_vim_info_update
= {
2004 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2007 vnfr_update
, vdur_update
= {}, {}
2008 mock_update_vdur_vim_info_interfaces
.side_effect
= MonitorVmsException(
2009 "Existing interfaces info could not found."
2011 with self
.assertRaises(MonitorVmsException
) as err
:
2012 self
.monitor
.prepare_interface_updates(
2013 vdur_vim_info_update
,
2024 str(err
.exception
.args
[0]), "Existing interfaces info could not found."
2026 mock_update_vdur_vim_info_interfaces
.assert_called_once_with(
2027 vdur_vim_info_update
, index
, interface_info2
, server7
2029 check_if_assert_not_called(
2030 [mock_check_vlan_pci_updates
, mock_check_vdur_interface_updates
]
2033 @patch("osm_ng_ro.monitor.MonitorVms.update_vdur_vim_info_interfaces")
2034 @patch("osm_ng_ro.monitor.MonitorVms.check_vlan_pci_updates")
2035 @patch("osm_ng_ro.monitor.MonitorVms.check_vdur_interface_updates")
2036 def test_prepare_interface_updates_check_vlan_pci_updates_raises(
2038 mock_check_vdur_interface_updates
,
2039 mock_check_vlan_pci_updates
,
2040 mock_update_vdur_vim_info_interfaces
,
2042 vdur_vim_info_update
= {
2043 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2046 vnfr_update
, vdur_update
= {}, {}
2047 mock_check_vlan_pci_updates
.side_effect
= KeyError("vlan is not found.")
2048 with self
.assertRaises(KeyError) as err
:
2049 self
.monitor
.prepare_interface_updates(
2050 vdur_vim_info_update
,
2060 self
.assertEqual(str(err
.exception
.args
[0]), "vlan is not found.")
2061 mock_update_vdur_vim_info_interfaces
.assert_called_once_with(
2062 vdur_vim_info_update
, index
, interface_info2
, server7
2064 mock_check_vlan_pci_updates
.assert_called_once_with(
2065 interface_info2
, index
, vdur_vim_info_update
2067 mock_check_vdur_interface_updates
.assert_not_called()
2069 @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2070 @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2071 def test_check_vm_interface_updates(
2072 self
, mock_prepare_interface_updates
, mock_get_interface_info
2074 vdur_vim_info_update
= {
2075 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2079 "fixed_ips": [{"ip_address": ip1_addr
}],
2080 "mac_address": mac2_addr
,
2081 "network_id": net1_id
,
2084 vnfr_update
, vdur_update
= {}, {}
2085 ports
= {"ports": [port1
, port2
]}
2086 existing_vim_info
= sample_vim_info
2087 mock_get_interface_info
.return_value
= interface_info
2088 self
.monitor
.check_vm_interface_updates(
2092 vdur_vim_info_update
,
2098 mock_get_interface_info
.assert_called_once_with(ports
, old_interface
, server7
)
2099 mock_prepare_interface_updates
.assert_called_once_with(
2100 vdur_vim_info_update
,
2110 self
.assertNotIn("vim_message", vdur_vim_info_update
)
2112 @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2113 @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2114 def test_check_vm_interface_updates_interface_new_status_is_nok(
2115 self
, mock_prepare_interface_updates
, mock_get_interface_info
2117 vdur_vim_info_update
= {
2118 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2121 "fixed_ips": [{"ip_address": ip1_addr
}],
2122 "mac_address": mac2_addr
,
2123 "network_id": net1_id
,
2126 vnfr_update
, vdur_update
= {}, {}
2127 ports
= {"ports": [port1
, port2
]}
2128 existing_vim_info
= sample_vim_info
2129 mock_get_interface_info
.return_value
= interface_info
2130 self
.monitor
.check_vm_interface_updates(
2134 vdur_vim_info_update
,
2140 mock_get_interface_info
.assert_called_once_with(ports
, old_interface
, server7
)
2141 mock_prepare_interface_updates
.assert_not_called()
2143 vdur_vim_info_update
["vim_message"],
2144 "Interface 4d081f50-e13a-4306-a67e-1edb28d76013 status: DOWN",
2147 @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2148 @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2149 def test_check_vm_interface_updates_no_new_interface_info(
2150 self
, mock_prepare_interface_updates
, mock_get_interface_info
2152 vdur_vim_info_update
= {
2153 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2155 vnfr_update
, vdur_update
= {}, {}
2156 ports
= {"ports": [port1
, port2
]}
2157 existing_vim_info
= sample_vim_info
2158 mock_get_interface_info
.return_value
= None
2159 self
.monitor
.check_vm_interface_updates(
2163 vdur_vim_info_update
,
2169 mock_get_interface_info
.assert_called_once_with(ports
, old_interface
, server7
)
2170 mock_prepare_interface_updates
.assert_not_called()
2172 vdur_vim_info_update
["vim_message"],
2173 "Interface 4d081f50-e13a-4306-a67e-1edb28d76013 deleted externally.",
2176 @patch("osm_ng_ro.monitor.MonitorVms.get_interface_info")
2177 @patch("osm_ng_ro.monitor.MonitorVms.prepare_interface_updates")
2178 def test_check_vm_interface_updates_no_existing_interface(
2179 self
, mock_prepare_interface_updates
, mock_get_interface_info
2181 vdur_vim_info_update
= {
2182 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2185 "fixed_ips": [{"ip_address": ip1_addr
}],
2186 "mac_address": mac2_addr
,
2187 "network_id": net1_id
,
2190 vnfr_update
, vdur_update
= {}, {}
2191 ports
= {"ports": [port1
, port2
]}
2192 updated_sample_vim_info
= deepcopy(sample_vim_info
)
2193 updated_sample_vim_info
["interfaces"] = []
2194 existing_vim_info
= updated_sample_vim_info
2195 mock_get_interface_info
.return_value
= interface_info
2196 self
.monitor
.check_vm_interface_updates(
2200 vdur_vim_info_update
,
2206 check_if_assert_not_called(
2207 [mock_get_interface_info
, mock_prepare_interface_updates
]
2209 self
.assertNotIn("vim_message", vdur_vim_info_update
)
2211 def test_update_in_database(self
):
2212 all_updates
= [{"some-key": "some-value"}, {"other-key": "other-value"}]
2213 self
.monitor
.update_in_database(all_updates
, vnfr_id
)
2214 self
.assertEqual(self
.monitor
.db
.set_list
.call_count
, 2)
2215 _call_mock_set_list
= self
.monitor
.db
.set_list
.call_args_list
2217 _call_mock_set_list
[0][0],
2221 _call_mock_set_list
[0][1],
2224 "q_filter": {"_id": vnfr_id
},
2225 "update_dict": {"some-key": "some-value"},
2230 _call_mock_set_list
[1][0],
2234 _call_mock_set_list
[1][1],
2237 "q_filter": {"_id": vnfr_id
},
2238 "update_dict": {"other-key": "other-value"},
2243 def test_update_in_database_set_list_raises(self
):
2244 all_updates
= [{"some-key": "some-value"}, {"other-key": "other-value"}]
2245 self
.monitor
.db
.set_list
.side_effect
= DbException("Connection failed.")
2246 with self
.assertRaises(MonitorDbException
) as err
:
2247 self
.monitor
.update_in_database(all_updates
, vnfr_id
)
2249 str(err
.exception
.args
[0]),
2250 "Error while updating differences in VNFR database exception Connection failed.",
2252 self
.assertEqual(self
.monitor
.db
.set_list
.call_count
, 1)
2253 _call_mock_set_list
= self
.monitor
.db
.set_list
.call_args_list
2255 _call_mock_set_list
[0][0],
2259 _call_mock_set_list
[0][1],
2262 "q_filter": {"_id": vnfr_id
},
2263 "update_dict": {"some-key": "some-value"},
2268 def test_update_in_database_empty_all_updates(self
):
2270 self
.monitor
.update_in_database(all_updates
, vnfr_id
)
2271 self
.monitor
.db
.set_list
.assert_not_called()
2273 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2274 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2275 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2276 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2277 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2278 def test_report_vdur_updates_no_change_in_vdur(
2280 mock_update_in_database
,
2281 mock_backup_vdu_interfaces
,
2282 mock_check_vm_interface_updates
,
2283 mock_check_vm_status_updates
,
2284 mock_get_vm_data_from_db
,
2286 existing_vim_info
= sample_vim_info
2287 vdur_vim_info_update
= deepcopy(existing_vim_info
)
2288 mock_get_vm_data_from_db
.return_value
= (
2290 vdur_vim_info_update
,
2296 ports
= {"ports": [port1
, port2
]}
2297 self
.monitor
.report_vdur_updates(server7
, sample_vm
, ports
)
2298 check_if_assert_not_called(
2299 [mock_update_in_database
, mock_backup_vdu_interfaces
]
2301 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
2302 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
2303 mock_check_vm_status_updates
.assert_called_once_with(
2304 vdur_vim_info_update
, {}, server7
, vdur_path
2306 mock_check_vm_interface_updates
.assert_called_once_with(
2310 vdur_vim_info_update
,
2317 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2318 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2319 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2320 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2321 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2322 def test_report_vdur_updates_vdur_changed(
2324 mock_update_in_database
,
2325 mock_backup_vdu_interfaces
,
2326 mock_check_vm_interface_updates
,
2327 mock_check_vm_status_updates
,
2328 mock_get_vm_data_from_db
,
2330 existing_vim_info
= sample_vim_info
2331 vdur_vim_info_update
= {
2332 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2334 mock_get_vm_data_from_db
.return_value
= (
2336 vdur_vim_info_update
,
2342 all_updates
= [{}, {vim_info_path
: vdur_vim_info_update
}, {}]
2343 ports
= {"ports": [port1
, port2
]}
2344 self
.monitor
.report_vdur_updates(server7
, sample_vm
, ports
)
2345 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
2346 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
2347 mock_check_vm_status_updates
.assert_called_once_with(
2348 vdur_vim_info_update
, {}, server7
, vdur_path
2350 mock_check_vm_interface_updates
.assert_called_once_with(
2354 vdur_vim_info_update
,
2360 mock_backup_vdu_interfaces
.assert_called_once_with(vdur_vim_info_update
)
2361 mock_update_in_database
.assert_called_once_with(all_updates
, vnfr_id
)
2363 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2364 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2365 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2366 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2367 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2368 def test_report_vdur_updates_check_vm_status_updates_raises(
2370 mock_update_in_database
,
2371 mock_backup_vdu_interfaces
,
2372 mock_check_vm_interface_updates
,
2373 mock_check_vm_status_updates
,
2374 mock_get_vm_data_from_db
,
2376 existing_vim_info
= sample_vim_info
2377 vdur_vim_info_update
= {
2378 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2380 mock_get_vm_data_from_db
.return_value
= (
2382 vdur_vim_info_update
,
2388 ports
= {"ports": [port1
, port2
]}
2389 mock_check_vm_status_updates
.side_effect
= yaml
.YAMLError(
2390 "Cannot represent an object."
2392 with self
.assertRaises(yaml
.YAMLError
) as err
:
2393 self
.monitor
.report_vdur_updates(server7
, sample_vm
, ports
)
2394 self
.assertEqual(str(err
.exception
), "Cannot represent an object.")
2395 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
2396 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
2397 mock_check_vm_status_updates
.assert_called_once_with(
2398 vdur_vim_info_update
, {}, server7
, vdur_path
2400 check_if_assert_not_called(
2402 mock_check_vm_interface_updates
,
2403 mock_backup_vdu_interfaces
,
2404 mock_update_in_database
,
2408 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2409 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2410 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2411 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2412 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2413 def test_report_vdur_updates_database_update_raises(
2415 mock_update_in_database
,
2416 mock_backup_vdu_interfaces
,
2417 mock_check_vm_interface_updates
,
2418 mock_check_vm_status_updates
,
2419 mock_get_vm_data_from_db
,
2421 existing_vim_info
= sample_vim_info
2422 vdur_vim_info_update
= {
2423 "interfaces": [{"mac_address": mac1_addr
, "compute_node": "host1"}]
2425 mock_get_vm_data_from_db
.return_value
= (
2427 vdur_vim_info_update
,
2433 all_updates
= [{}, {vim_info_path
: vdur_vim_info_update
}, {}]
2434 ports
= {"ports": [port1
, port2
]}
2435 mock_update_in_database
.side_effect
= MonitorDbException(
2436 f
"Error while updating differences in VNFR {vnfr_id}."
2438 with self
.assertRaises(MonitorDbException
) as err
:
2439 self
.monitor
.report_vdur_updates(server7
, sample_vm
, ports
)
2441 str(err
.exception
), f
"Error while updating differences in VNFR {vnfr_id}."
2443 mock_get_vm_data_from_db
.assert_called_with(sample_vm
)
2444 self
.assertEqual(mock_get_vm_data_from_db
.call_count
, 1)
2445 mock_check_vm_status_updates
.assert_called_once_with(
2446 vdur_vim_info_update
, {}, server7
, vdur_path
2448 mock_check_vm_interface_updates
.assert_called_once_with(
2452 vdur_vim_info_update
,
2458 mock_backup_vdu_interfaces
.assert_called_once_with(vdur_vim_info_update
)
2459 mock_update_in_database
.assert_called_once_with(all_updates
, vnfr_id
)
2461 @patch("osm_ng_ro.monitor.MonitorVms._get_vm_data_from_db")
2462 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_status_updates")
2463 @patch("osm_ng_ro.monitor.MonitorVms.check_vm_interface_updates")
2464 @patch("osm_ng_ro.monitor.MonitorVms.backup_vdu_interfaces")
2465 @patch("osm_ng_ro.monitor.MonitorVms.update_in_database")
2466 def test_report_vdur_updates_no_vm_data(
2468 mock_update_in_database
,
2469 mock_backup_vdu_interfaces
,
2470 mock_check_vm_interface_updates
,
2471 mock_check_vm_status_updates
,
2472 mock_get_vm_data_from_db
,
2474 mock_get_vm_data_from_db
.return_value
= None
2475 ports
= {"ports": [port1
, port2
]}
2476 self
.monitor
.report_vdur_updates(server7
, sample_vm
, ports
)
2477 check_if_assert_not_called(
2479 mock_update_in_database
,
2480 mock_backup_vdu_interfaces
,
2481 mock_check_vm_interface_updates
,
2482 mock_check_vm_status_updates
,
2485 mock_get_vm_data_from_db
.assert_called_once_with(sample_vm
)
2487 @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2488 @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2489 @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2490 def test_run_no_db_vims(
2493 mock_prepare_vims_to_monitor
,
2494 mock_find_ro_tasks_to_monitor
,
2496 self
.monitor
.db_vims
= None
2498 check_if_assert_not_called(
2500 mock_prepare_vims_to_monitor
,
2501 mock_find_ro_tasks_to_monitor
,
2506 @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2507 @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2508 @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2509 def test_run_refresh_disabled(
2512 mock_prepare_vims_to_monitor
,
2513 mock_find_ro_tasks_to_monitor
,
2515 self
.monitor
.db_vims
= vims
2516 self
.monitor
.refresh_config
.active
= -1
2518 check_if_assert_not_called(
2520 mock_prepare_vims_to_monitor
,
2521 mock_find_ro_tasks_to_monitor
,
2526 @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2527 @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2528 @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2529 def test_run_no_proper_ro_task(
2532 mock_prepare_vims_to_monitor
,
2533 mock_find_ro_tasks_to_monitor
,
2535 self
.monitor
.db_vims
= vims
2536 self
.monitor
.refresh_config
.active
= 60
2537 mock_find_ro_tasks_to_monitor
.return_value
= []
2539 check_if_assert_not_called([mock_prepare_vims_to_monitor
, mock_update_vnfrs
])
2540 mock_find_ro_tasks_to_monitor
.assert_called_once()
2542 @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2543 @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2544 def test_run_with_proper_ro_task(
2545 self
, mock_update_vnfrs
, mock_find_ro_tasks_to_monitor
2547 self
.monitor
.db_vims
= vims
2548 all_servers
= [server1
, server2
]
2552 target_record
=target_record
,
2558 target_record
=target_record2
,
2561 all_ports
= {"ports": [port1
, port2
]}
2562 mock_vim_connector
= MagicMock()
2563 mock_vim_connector
.get_monitoring_data
.return_value
= all_servers
, all_ports
2564 self
.monitor
.my_vims
= {
2565 vim1_id
: mock_vim_connector
,
2566 vim2_id
: mock_vim_connector
,
2567 vim3_id
: mock_vim_connector
,
2569 self
.monitor
.refresh_config
.active
= 60
2570 mock_find_ro_tasks_to_monitor
.return_value
= [ro_task1
, ro_task2
]
2572 mock_find_ro_tasks_to_monitor
.assert_called_once()
2573 _call_mock_update_vnfrs
= mock_update_vnfrs
.call_args_list
2574 self
.assertEqual(mock_update_vnfrs
.call_count
, 2)
2576 _call_mock_update_vnfrs
[0][0],
2577 (all_servers
, all_ports
, vim1_vms
),
2580 _call_mock_update_vnfrs
[1][0],
2581 (all_servers
, all_ports
, vim2_vms
),
2583 self
.assertEqual(mock_vim_connector
.get_monitoring_data
.call_count
, 2)
2585 @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2586 @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2587 def test_run_update_vnfrs_raises(
2588 self
, mock_update_vnfrs
, mock_find_ro_tasks_to_monitor
2590 self
.monitor
.db_vims
= vims
2591 all_servers
= [server1
, server2
]
2595 target_record
=target_record
,
2598 all_ports
= {"ports": [port1
, port2
]}
2599 mock_vim_connector
= MagicMock()
2600 mock_vim_connector
.get_monitoring_data
.return_value
= all_servers
, all_ports
2601 self
.monitor
.my_vims
= {
2602 vim1_id
: mock_vim_connector
,
2603 vim2_id
: mock_vim_connector
,
2604 vim3_id
: mock_vim_connector
,
2606 self
.monitor
.refresh_config
.active
= 60
2607 mock_find_ro_tasks_to_monitor
.return_value
= [ro_task1
, ro_task2
]
2608 mock_update_vnfrs
.side_effect
= DbException("DB is not active state.")
2609 with self
.assertRaises(MonitorVmsException
) as err
:
2613 "Exception while monitoring Openstack VMs: database exception DB is not active state.",
2615 mock_find_ro_tasks_to_monitor
.assert_called_once()
2616 _call_mock_update_vnfrs
= mock_update_vnfrs
.call_args_list
2617 self
.assertEqual(mock_update_vnfrs
.call_count
, 1)
2619 _call_mock_update_vnfrs
[0][0],
2620 (all_servers
, all_ports
, vim1_vms
),
2622 self
.assertEqual(mock_vim_connector
.get_monitoring_data
.call_count
, 1)
2624 @patch("osm_ng_ro.monitor.MonitorVms.prepare_vims_to_monitor")
2625 @patch("osm_ng_ro.monitor.MonitorVms.find_ro_tasks_to_monitor")
2626 @patch("osm_ng_ro.monitor.MonitorVms.update_vnfrs")
2627 def test_run_prepare_vims_to_monitor_raises(
2630 mock_find_ro_tasks_to_monitor
,
2631 mock_prepare_vims_to_monitor
,
2633 self
.monitor
.db_vims
= vims
2634 mock_vim_connector
= MagicMock()
2635 self
.monitor
.my_vims
= {
2636 vim1_id
: mock_vim_connector
,
2637 vim2_id
: mock_vim_connector
,
2638 vim3_id
: mock_vim_connector
,
2640 self
.monitor
.refresh_config
.active
= 60
2641 mock_find_ro_tasks_to_monitor
.return_value
= [ro_task1
, ro_task2
]
2642 mock_prepare_vims_to_monitor
.side_effect
= KeyError("vim_id")
2643 with self
.assertRaises(MonitorVmsException
) as err
:
2646 str(err
.exception
), "Exception while monitoring Openstack VMs: 'vim_id'"
2648 mock_find_ro_tasks_to_monitor
.assert_called_once()
2649 check_if_assert_not_called(
2650 [mock_update_vnfrs
, mock_vim_connector
.get_monitoring_data
]
2653 @patch("osm_ng_ro.monitor.monitoring_task")
2654 @patch("osm_ng_ro.monitor.threading.Timer")
2655 @patch("osm_ng_ro.monitor.MonitorVms")
2656 def test_start_monitoring(
2657 self
, mock_monitor_vms
, mock_threading_timer
, mock_monitoring_task
2659 mock_monitor_vms
.return_value
.refresh_config
.active
= 20
2660 mock_threading_timer
.return_value
= mock_monitoring_task
2661 start_monitoring(config
)
2662 mock_threading_timer
.assert_called_once_with(
2663 20, start_monitoring
, args
=(config
,)
2665 mock_threading_timer
.return_value
= CopyingMock(threading
.Timer
)
2666 self
.assertEqual(mock_threading_timer
.call_count
, 1)
2667 mock_monitor_vms
.return_value
.run
.assert_called_once()
2668 mock_monitor_vms
.assert_called_once_with(config
)
2669 mock_monitoring_task
.start
.assert_called_once()
2671 @patch("osm_ng_ro.monitor.monitoring_task")
2672 @patch("osm_ng_ro.monitor.threading.Timer")
2673 @patch("osm_ng_ro.monitor.MonitorVms")
2674 def test_start_monitoring_empty_config(
2675 self
, mock_monitor_vms
, mock_threading_timer
, mock_monitoring_task
2677 with self
.assertRaises(MonitorVmsException
) as err
:
2678 start_monitoring(config
={})
2681 "Wrong configuration format is provided.",
2683 check_if_assert_not_called(
2684 [mock_threading_timer
, mock_monitor_vms
, mock_monitoring_task
]
2687 @patch("osm_ng_ro.monitor.monitoring_task")
2688 @patch("osm_ng_ro.monitor.threading.Timer")
2689 @patch("osm_ng_ro.monitor.MonitorVms")
2690 def test_start_monitoring_monitor_vms_raises(
2691 self
, mock_monitor_vms
, mock_threading_timer
, mock_monitoring_task
2693 mock_monitor_vms
.side_effect
= MonitorDbException("Can not connect to DB.")
2694 with self
.assertRaises(MonitorDbException
) as err
:
2695 start_monitoring(config
)
2696 self
.assertEqual(str(err
.exception
), "Can not connect to DB.")
2697 mock_monitor_vms
.assert_called_once_with(config
)
2698 check_if_assert_not_called([mock_threading_timer
, mock_monitoring_task
])
2700 @patch("osm_ng_ro.monitor.monitoring_task")
2701 @patch("osm_ng_ro.monitor.threading.Timer")
2702 @patch("osm_ng_ro.monitor.MonitorVms")
2703 def test_start_monitoring_timer_thread_raises(
2704 self
, mock_monitor_vms
, mock_threading_timer
, mock_monitoring_task
2706 mock_threading_timer
.side_effect
= RuntimeError(
2707 "cannot release un-acquired lock"
2709 mock_monitor_vms
.return_value
.refresh_config
.active
= 2
2710 with self
.assertRaises(RuntimeError) as err
:
2711 start_monitoring(config
)
2712 self
.assertEqual(str(err
.exception
), "cannot release un-acquired lock")
2713 mock_monitor_vms
.assert_called_once_with(config
)
2714 mock_monitor_vms
.return_value
.run
.assert_called_once()
2715 mock_threading_timer
.assert_called_once_with(
2716 2, start_monitoring
, args
=(config
,)
2718 mock_monitoring_task
.start
.assert_not_called()
2720 @patch("osm_ng_ro.monitor.monitoring_task")
2721 def test_stop_monitoring(self
, mock_monitoring_task
):
2722 mock_monitoring_task
.return_value
= CopyingMock(threading
.Timer
)
2724 self
.assertIsNotNone(mock_monitoring_task
)
2725 mock_monitoring_task
.cancel
.assert_called_once()
2727 @patch("osm_ng_ro.monitor.monitoring_task")
2728 def test_stop_monitoring_no_task(self
, mock_monitoring_task
):
2729 mock_monitoring_task
= CopyingMock(threading
.Timer
, return_value
=None)
2731 mock_monitoring_task
.cancel
.assert_not_called()
2734 if __name__
== "__main__":