1 # -*- coding: utf-8 -*-
4 # Copyright 2017-2018 VMware Inc.
5 # This file is part of ETSI OSM
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact: osslegalrouting@vmware.com
24 """ Mock tests for VMware vROPs plugin recevier """
31 from io
import UnsupportedOperation
35 # sys.path.append("/root/MON/")
37 log
= logging
.getLogger(__name__
)
39 sys
.path
.append(os
.path
.join(os
.path
.dirname(os
.path
.abspath(__file__
)), "..", "..", ".."))
41 from osm_mon
.plugins
.vRealiseOps
import plugin_receiver
as monPluginRec
42 from osm_mon
.core
.database
import VimCredentials
45 class Message(object):
46 """A class to mock a message object value for alarm and matric requests"""
49 """Initialize a mocked message instance"""
50 self
.topic
= "alarm_or_metric_request"
52 self
.value
= json
.dumps({"mock_value": "mock_details"})
57 class TestPluginReceiver(unittest
.TestCase
):
58 """Test class for Plugin Receiver class methods"""
61 """Setup the tests for plugin_receiver class methods"""
62 super(TestPluginReceiver
, self
).setUp()
63 self
.plugin_receiver
= monPluginRec
.PluginReceiver()
65 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_alarm_status')
66 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'create_alarm')
67 def test_consume_create_alarm_request_key(self
, m_create_alarm
, m_publish_create_alarm_status
):
68 """Test functionality of consume for create_alarm_request key"""
70 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
72 value
= {"vim_uuid": vim_uuid
, "alarm_create_request": "alarm_details"}
73 m_create_alarm
.return_value
= "test_alarm_id"
75 # Call the consume method of plugin_receiver
76 self
.plugin_receiver
.handle_alarm_requests('create_alarm_request', value
, vim_uuid
)
78 # verify if create_alarm and publish methods called with correct params
79 m_create_alarm
.assert_called_with(value
)
80 m_publish_create_alarm_status
.assert_called_with("test_alarm_id", value
)
82 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_alarm_status')
83 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_alarm')
84 def test_consume_update_alarm_request_key(self
, m_update_alarm
,
85 m_publish_update_alarm_status
):
86 """Test functionality of consume for update_alarm_request key"""
88 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
90 value
= {"vim_uuid": vim_uuid
, "alarm_update_request": "alarm_details"}
92 # set return value to mocked method
93 m_update_alarm
.return_value
= "test_alarm_id"
95 # Call the consume method of plugin_receiver
96 self
.plugin_receiver
.handle_alarm_requests('update_alarm_request', value
, vim_uuid
)
98 # verify update_alarm and publish method called with correct params
99 m_update_alarm
.assert_called_with(value
)
100 m_publish_update_alarm_status
.assert_called_with("test_alarm_id", value
)
102 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_alarm_status')
103 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'delete_alarm')
104 def test_consume_delete_alarm_request_key(self
, m_delete_alarm
,
105 m_publish_delete_alarm_status
):
106 """Test functionality of consume for delete_alarm_request key"""
108 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
110 value
= {"vim_uuid": vim_uuid
, "alarm_delete_request": "alarm_details"}
111 m_delete_alarm
.return_value
= "test_alarm_id"
113 # Call the consume method of plugin_receiver and check delete_alarm request
114 self
.plugin_receiver
.handle_alarm_requests('delete_alarm_request', value
, vim_uuid
)
115 m_delete_alarm
.assert_called_with(value
)
117 # Check if publish method called with correct parameters
118 m_publish_delete_alarm_status
.assert_called_with("test_alarm_id", value
)
120 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_list_alarm_response')
121 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'list_alarms')
122 def test_consume_list_alarm_request_key(self
, m_list_alarms
,
123 m_publish_list_alarm_response
):
124 """ Test functionality of list alarm request key"""
126 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
127 value
= {"vim_uuid": vim_uuid
, "alarm_list_request": "alarm_details"}
129 test_alarm_list
= [{"alarm_uuid": "alarm1_details"}, {"alarm_uuid": "alarm2_details"}]
131 m_list_alarms
.return_value
= test_alarm_list
133 # Call the consume method of plugin_receiver and check delete_alarm request
134 self
.plugin_receiver
.handle_alarm_requests('list_alarm_request', value
, vim_uuid
)
135 m_list_alarms
.assert_called_with(value
)
137 # Check if publish method called with correct parameters
138 m_publish_list_alarm_response
.assert_called_with(test_alarm_list
, value
)
140 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_alarm_status')
141 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'create_alarm')
142 def test_consume_invalid_alarm_request_key(self
, m_create_alarm
,
143 m_publish_create_alarm_status
):
144 """Test functionality of consume for vim_access_credentials invalid request key"""
146 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
148 # Call the consume method of plugin_receiver
149 with self
.assertRaises(UnsupportedOperation
):
150 self
.plugin_receiver
.handle_alarm_requests('invalid_key', {}, vim_uuid
)
152 # verify that create_alarm and publish_create_alarm_status methods not called
153 m_create_alarm
.assert_not_called()
154 m_publish_create_alarm_status
.assert_not_called()
156 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
157 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
158 def test_consume_invalid_metric_request_key(self
, m_get_metrics_data
,
159 m_publish_metric_data_status
):
160 """Test functionality of invalid metric key request"""
162 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
164 # Call the consume method of plugin_receiver
165 with self
.assertRaises(UnsupportedOperation
):
166 self
.plugin_receiver
.handle_metric_requests('invalid_key', {}, vim_uuid
)
168 # verify that get metrics data and publish methods not called
169 m_get_metrics_data
.assert_not_called()
170 m_publish_metric_data_status
.assert_not_called()
172 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
173 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
174 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
175 def test_consume_read_metric_data_request_key(self
, m_get_vim_access_config
,
177 m_publish_metric_data_status
):
178 """Test functionality of consume for read_metric_data_request key"""
180 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
182 value
= {"vim_uuid": vim_uuid
, "metric_name": "metric_details"}
183 m_get_metrics_data
.return_value
= {"metrics_data": "metrics_details"}
185 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
186 'vrops_user': 'user',
187 'vrops_password': 'passwd',
188 'vim_url': 'vcd_url',
189 'admin_username': 'admin',
190 'admin_password': 'admin_passwd',
192 'tenant_id': 'org_vdc_1'}
194 # Call the consume method of plugin_receiver
195 self
.plugin_receiver
.handle_metric_requests('read_metric_data_request', value
, vim_uuid
)
196 m_get_metrics_data
.assert_called_with(value
)
198 # Check if publish method called with correct parameters
199 m_publish_metric_data_status
.assert_called_with({"metrics_data": "metrics_details"})
201 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_metric_response')
202 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
203 def test_consume_create_metric_request_key(self
, m_verify_metric
,
204 m_publish_create_metric_response
):
205 """Test functionality of consume for create_metric_request key"""
207 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
208 value
= {"vim_uuid": vim_uuid
, "metric_create": "metric_details"}
210 # set the return value
211 m_verify_metric
.return_value
= True
213 # Call the consume method of plugin_receiver
214 self
.plugin_receiver
.handle_metric_requests('create_metric_request', value
, vim_uuid
)
215 m_verify_metric
.assert_called_with(value
)
217 # Check if publish method called with correct parameters
218 m_publish_create_metric_response
.assert_called_with(value
, True)
220 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_metric_response')
221 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
222 def test_consume_update_metric_request_key(self
, m_verify_metric
,
223 m_publish_update_metric_response
):
224 """Test functionality of update metric request key"""
226 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
228 value
= {"vim_uuid": vim_uuid
, "metric_create": "metric_details"}
230 # set the return value
231 m_verify_metric
.return_value
= True
233 # Call the consume method of plugin_receiver
234 self
.plugin_receiver
.handle_metric_requests('update_metric_request', value
, vim_uuid
)
236 # verify mocked methods called with correct parameters
237 m_verify_metric
.assert_called_with(value
)
238 m_publish_update_metric_response
.assert_called_with(value
, True)
240 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_metric_response')
241 def test_consume_delete_metric_request_key(self
, m_publish_delete_metric_response
):
242 """Test functionality of consume for delete_metric_request key"""
244 # Note: vROPS doesn't support deleting metric data
245 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
247 value
= {"vim_uuid": vim_uuid
, "metric_name": "metric_details"}
249 # Call the consume method of plugin_receiver
250 self
.plugin_receiver
.handle_metric_requests('delete_metric_request', value
, vim_uuid
)
252 # Check if publish method called with correct parameters
253 m_publish_delete_metric_response
.assert_called_with(value
)
255 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
256 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
257 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
258 def test_create_alarm_successful(self
, m_get_vim_access_config
,
259 m_configure_rest_plugin
,
261 """ Test functionality of create alarm method-positive case"""
263 # Mock config_alarm_info
264 config_alarm_info
= {"schema_version": 1.0,
265 "schema_type": "create_alarm_request",
266 "vim_type": "VMware",
268 "alarm_create_request": {"correlation_id": 1,
269 "alarm_name": "CPU_Utilize_Threshold",
270 "metric_name": "CPU_UTILIZATION",
271 "tenant_uuid": "tenant_uuid",
272 "resource_uuid": "resource_uuid",
273 "description": "test_create_alarm",
274 "severity": "CRITICAL",
276 "threshold_value": 10,
278 "statistic": "AVERAGE"}}
280 # set return value to plugin uuid
281 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
282 'vrops_user': 'user',
283 'vrops_password': 'passwd',
284 'vim_url': 'vcd_url',
285 'admin_username': 'admin',
286 'admin_password': 'admin_passwd',
288 'tenant_id': 'org_vdc_1'}
290 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
291 m_configure_alarm
.return_value
= "alarm_uuid"
293 # call create alarm method under test
294 self
.plugin_receiver
.create_alarm(config_alarm_info
)
296 # verify mocked methods get called with correct params
297 m_get_vim_access_config
.assert_called_with(config_alarm_info
['vim_uuid'])
298 m_configure_rest_plugin
.assert_called_with()
299 m_configure_alarm
.assert_called_with(config_alarm_info
["alarm_create_request"])
301 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
302 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
303 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
304 def test_create_alarm_failed(self
, m_get_vim_access_config
,
305 m_configure_rest_plugin
,
307 """ Test functionality of create alarm method negative case"""
309 # Mock config_alarm_info
310 config_alarm_info
= {"schema_version": 1.0,
311 "schema_type": "create_alarm_request",
312 "vim_type": "VMware",
314 "alarm_create_request": {"correlation_id": 1,
315 "alarm_name": "CPU_Utilize_Threshold",
316 "metric_name": "CPU_UTILIZATION",
317 "tenant_uuid": "tenant_uuid",
318 "resource_uuid": "resource_uuid",
319 "description": "test_create_alarm",
320 "severity": "CRITICAL",
322 "threshold_value": 10,
324 "statistic": "AVERAGE"}}
326 # set return value to plugin uuid and alarm_uuid to None
327 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
328 'vrops_user': 'user',
329 'vrops_password': 'passwd',
330 'vim_url': 'vcd_url',
331 'admin_username': 'admin',
332 'admin_password': 'admin_passwd',
334 'tenant_id': 'org_vdc_1'}
335 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
336 m_configure_alarm
.return_value
= None
338 # call create alarm method under test
339 alarm_uuid
= self
.plugin_receiver
.create_alarm(config_alarm_info
)
341 # verify mocked method called with correct params
342 m_get_vim_access_config
.assert_called_with(config_alarm_info
['vim_uuid'])
343 m_configure_rest_plugin
.assert_called_with()
344 m_configure_alarm
.assert_called_with(config_alarm_info
["alarm_create_request"])
346 # verify create alarm method returns None when failed
347 self
.assertEqual(alarm_uuid
, None)
349 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
350 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
351 def test_update_alarm_successful(self
, m_get_vim_access_config
, m_update_alarm_configuration
):
352 """ Test functionality of update alarm method-positive case"""
354 # Mock update_alarm_info
355 update_alarm_info
= {"schema_version": 1.0, "schema_type": "update_alarm_request",
356 "vim_type": "VMware", "vim_uuid": "1",
357 "alarm_update_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
359 # set return value to mocked method
360 m_update_alarm_configuration
.return_value
= "alarm_uuid"
361 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
362 'vrops_user': 'user',
363 'vrops_password': 'passwd',
364 'vim_url': 'vcd_url',
365 'admin_username': 'admin',
366 'admin_password': 'admin_passwd',
368 'tenant_id': 'org_vdc_1'}
370 # check update alarm gets called and returned correct value
371 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
373 # check mocked method get called with correct param
374 m_get_vim_access_config
.assert_called_with(update_alarm_info
['vim_uuid'])
375 m_update_alarm_configuration
.assert_called_with(update_alarm_info
["alarm_update_request"])
377 # check return value and passed values are correct
378 self
.assertEqual(ret_value
, "alarm_uuid")
380 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
381 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
382 def test_update_alarm_failed(self
, m_get_vim_access_config
, m_update_alarm_configuration
):
383 """ Test functionality of update alarm method negative case"""
385 # Mock update_alarm_info
386 update_alarm_info
= {"schema_version": 1.0, "schema_type": "update_alarm_request",
387 "vim_type": "VMware", "vim_uuid": "1",
388 "alarm_update_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
390 # set return value to mocked method
391 m_update_alarm_configuration
.return_value
= None
392 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
393 'vrops_user': 'user',
394 'vrops_password': 'passwd',
395 'vim_url': 'vcd_url',
396 'admin_username': 'admin',
397 'admin_password': 'admin_passwd',
399 'tenant_id': 'org_vdc_1'}
401 # check update alarm gets called and returned correct value
402 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
404 # check mocked method get called with correct param
405 m_get_vim_access_config
.assert_called_with(update_alarm_info
['vim_uuid'])
406 m_update_alarm_configuration
.assert_called_with(update_alarm_info
["alarm_update_request"])
408 # check return value and passed values are correct
409 self
.assertEqual(ret_value
, None)
411 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
412 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
413 def test_delete_alarm_successful(self
, m_get_vim_access_config
, m_delete_alarm_configuration
):
414 """ Test functionality of delete alarm method-positive case"""
416 # Mock delete_alarm_info
417 delete_alarm_info
= {"schema_version": 1.0, "schema_type": "delete_alarm_request",
418 "vim_type": "VMware", "vim_uuid": "1",
419 "alarm_delete_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
421 # set return value to mocked method
422 m_delete_alarm_configuration
.return_value
= "alarm_uuid"
423 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
424 'vrops_user': 'user',
425 'vrops_password': 'passwd',
426 'vim_url': 'vcd_url',
427 'admin_username': 'admin',
428 'admin_password': 'admin_passwd',
430 'tenant_id': 'org_vdc_1'}
432 # check delete alarm gets called and returned correct value
433 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
435 # check mocked method get called with correct param
436 m_get_vim_access_config
.assert_called_with(delete_alarm_info
['vim_uuid'])
437 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
["alarm_delete_request"])
439 # check return value and passed values are correct
440 self
.assertEqual(ret_value
, "alarm_uuid")
442 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
443 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
444 def test_delete_alarm_failed(self
, m_get_vim_access_config
, m_delete_alarm_configuration
):
445 """ Test functionality of delete alarm method-negative case"""
447 # Mock update_alarm_info
448 delete_alarm_info
= {"schema_version": 1.0, "schema_type": "delete_alarm_request",
449 "vim_type": "VMware", "vim_uuid": "1",
450 "alarm_delete_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
452 # set return value to mocked method
453 m_delete_alarm_configuration
.return_value
= None
454 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
455 'vrops_user': 'user',
456 'vrops_password': 'passwd',
457 'vim_url': 'vcd_url',
458 'admin_username': 'admin',
459 'admin_password': 'admin_passwd',
461 'tenant_id': 'org_vdc_1'}
463 # check delete alarm gets called and returned correct value
464 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
466 # check mocked method get called with correct param
467 m_get_vim_access_config
.assert_called_with(delete_alarm_info
['vim_uuid'])
468 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
["alarm_delete_request"])
470 # check return value to check failed status
471 self
.assertEqual(ret_value
, None)
473 def test_publish_create_alarm_status(self
):
474 """ Test functionality of publish create alarm status method"""
476 # Mock config_alarm_info
477 config_alarm_info
= {'vim_type': 'VMware', "vim_uuid": "1",
478 'alarm_create_request': {
479 'threshold_value': 0,
480 'severity': 'CRITICAL',
481 'alarm_name': 'CPU_Utilization_Above_Threshold',
482 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
483 'correlation_id': 1234,
484 'statistic': 'AVERAGE',
485 'metric_name': 'CPU_UTILIZATION'}
490 # call publish create status method under test
491 self
.plugin_receiver
.publish_create_alarm_status(alarm_uuid
, config_alarm_info
)
493 # verify mocked method called with correct params
494 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
496 def test_publish_update_alarm_status(self
):
497 """ Test functionality of publish update alarm status method"""
499 # Mock update_alarm_info
500 update_alarm_info
= {'vim_type': 'VMware',
502 'schema_type': 'update_alarm_request',
503 'alarm_update_request': {'alarm_uuid': '6486e69',
504 'correlation_id': 14203,
511 # call publish update alarm status method under test
512 self
.plugin_receiver
.publish_update_alarm_status(alarm_uuid
, update_alarm_info
)
514 # verify mocked method called with correct params
515 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
517 def test_publish_delete_alarm_status(self
):
518 """ Test functionality of publish delete alarm status method"""
520 # Mock delete_alarm_info
521 delete_alarm_info
= {'vim_type': 'VMware',
523 'schema_type': 'delete_alarm_request',
524 'alarm_delete_request': {'alarm_uuid': '6486e69',
525 'correlation_id': 14203,
532 # call publish delete alarm status method under test
533 self
.plugin_receiver
.publish_delete_alarm_status(alarm_uuid
, delete_alarm_info
)
535 # verify mocked method called with correct params
536 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
538 def test_publish_metrics_data_status(self
):
539 """ Test functionality of publish metrics data status method"""
544 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
545 'resource_uuid': 'e14b20', 'correlation_id': 14203,
546 'metrics_data': {'time_series': [15162011, 15162044],
547 'metrics_series': [0.1166666671, 0.1266666650]},
548 'tenant_uuid': 123, 'unit': '%'
551 # call publish metrics data status method under test
552 self
.plugin_receiver
.publish_metrics_data_status(metrics_data
)
554 # verify mocked method called with correct params
555 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
557 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
558 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
559 def test_verify_metric_supported_metric(self
, m_get_vim_access_config
,
560 m_verify_metric_support
):
561 """ Test functionality of verify metric method"""
564 metric_info
= {'vim_uuid': '1',
565 'metric_create_request': {'metric_unit': '%',
566 'metric_name': 'CPU_UTILIZATION',
567 'resource_uuid': 'e14b203'}}
569 # set mocked function return value to true
570 m_verify_metric_support
.return_value
= True
571 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
572 'vrops_user': 'user',
573 'vrops_password': 'passwd',
574 'vim_url': 'vcd_url',
575 'admin_username': 'admin',
576 'admin_password': 'admin_passwd',
578 'tenant_id': 'org_vdc_1'}
580 # call verify_metric method under test
581 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
583 # verify mocked method called with correct params
584 m_get_vim_access_config
.assert_called_with(metric_info
['vim_uuid'])
585 m_verify_metric_support
.assert_called_with(metric_info
['metric_create_request'])
587 # verify the return value
588 self
.assertEqual(ret_value
, True)
590 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
591 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
592 def test_verify_metric_unsupported_metric(self
, m_get_vim_access_config
,
593 m_verify_metric_support
):
594 """ Test functionality of verify metric method-negative case"""
596 # mock metric_info with unsupported metrics name
597 metric_info
= {'vim_uuid': '1',
598 'metric_create_request': {'metric_unit': '%',
599 'metric_name': 'Invalid',
600 'resource_uuid': 'e14b203'}}
602 # set mocked function return value to true
603 m_verify_metric_support
.return_value
= False
604 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
605 'vrops_user': 'user',
606 'vrops_password': 'passwd',
607 'vim_url': 'vcd_url',
608 'admin_username': 'admin',
609 'admin_password': 'admin_passwd',
611 'tenant_id': 'org_vdc_1'}
613 # call verify_metric method under test
614 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
616 # verify mocked method called with correct params
617 m_get_vim_access_config
.assert_called_with(metric_info
['vim_uuid'])
618 m_verify_metric_support
.assert_called_with(metric_info
['metric_create_request'])
620 # verify the return value
621 self
.assertEqual(ret_value
, False)
623 def test_publish_create_metric_response(self
):
624 """ Test functionality of publish create metric response method"""
629 'vim_type': 'VMware',
630 'correlation_id': 14203,
631 'schema_type': 'create_metric_request',
632 'metric_create_request': {
633 'resource_uuid': '6486e69',
634 'metric_name': 'CPU_UTILIZATION',
641 # call publish create metric method under test
642 self
.plugin_receiver
.publish_create_metric_response(metric_info
, metric_status
)
644 # verify mocked method called with correct params
645 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
647 def test_publish_update_metric_response(self
):
648 """ Test functionality of publish update metric response method"""
653 'vim_type': 'VMware',
654 'correlation_id': 14203,
655 'schema_type': 'update_metric_request',
657 'resource_uuid': '6486e69',
658 'metric_name': 'CPU_UTILIZATION',
665 # call publish update metric method under test
666 self
.plugin_receiver
.publish_update_metric_response(metric_info
, metric_status
)
668 # verify mocked method called with correct params
669 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
671 def test_publish_delete_metric_response(self
):
672 """ Test functionality of publish delete metric response method"""
675 metric_info
= {'vim_uuid': '1', 'vim_type': 'VMware', 'correlation_id': 14203,
676 'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69',
677 'metric_name': 'CPU_UTILIZATION',
678 'schema_type': 'delete_metric_request'}
680 # call publish delete metric method under test-vROPS doesn't support
681 # delete metric,just returns response with success
682 self
.plugin_receiver
.publish_delete_metric_response(metric_info
)
684 # verify mocked method called with correct params
685 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
687 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_triggered_alarms_list')
688 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
689 def test_list_alarms(self
, m_get_vim_access_config
, m_get_triggered_alarms_list
):
690 """ Test functionality of list alarms method"""
692 # Mock list alarm input
695 'vim_type': 'VMware',
696 'alarm_list_request': {
697 'severity': 'CRITICAL',
698 'correlation_id': 14203,
699 'alarm_name': 'CPU_Utilization_Above_Threshold',
700 'resource_uuid': 'd14b203c'}}
702 # set return value to mocked method
703 m_return
= [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
704 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
705 'cancel_date': '0000-00-00T00:00:00', 'alarm_instance_uuid': 'd9e3bc84',
706 'alarm_uuid': '5714977d', 'vim_type': 'VMware',
707 'start_date': '2018-01-12T08:34:05'},
708 {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57',
709 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
710 'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6',
711 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware',
712 'start_date': '2017-12-20T09:37:57'}]
713 m_get_triggered_alarms_list
.return_value
= m_return
715 m_get_vim_access_config
.return_value
= {'vrops_site': 'abc',
716 'vrops_user': 'user',
717 'vrops_password': 'passwd',
718 'vim_url': 'vcd_url',
719 'admin_username': 'admin',
720 'admin_password': 'admin_passwd',
722 'tenant_id': 'org_vdc_1'}
724 # call list alarms method under test
725 return_value
= self
.plugin_receiver
.list_alarms(list_alarm_input
)
727 # verify mocked method called with correct params
728 m_get_vim_access_config
.assert_called_with(list_alarm_input
['vim_uuid'])
729 m_get_triggered_alarms_list
.assert_called_with(list_alarm_input
['alarm_list_request'])
731 # verify list alarm method returns correct list
732 self
.assertEqual(return_value
, m_return
)
734 def test_publish_list_alarm_response(self
):
735 """ Test functionality of publish list alarm response method"""
737 # Mock list alarm input
738 msg_key
= 'list_alarm_response'
739 topic
= 'alarm_response'
740 list_alarm_input
= {'vim_uuid': '1',
741 'vim_type': 'VMware',
742 'alarm_list_request': {
743 'severity': 'CRITICAL',
744 'correlation_id': 14203,
745 'alarm_name': 'CPU_Utilization_Above_Threshold',
746 'resource_uuid': 'd14b203c'}}
748 triggered_alarm_list
= [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
749 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
750 'cancel_date': '0000-00-00T00:00:00',
751 'start_date': '2018-01-12T08:34:05',
752 'alarm_instance_uuid': 'd9e3bc84',
753 'alarm_uuid': '5714977d',
757 # call publish list alarm response method under test
758 response
= self
.plugin_receiver
.publish_list_alarm_response(triggered_alarm_list
, list_alarm_input
)
760 # verify mocked method called with correct params
761 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
763 def test_publish_access_update_response(self
):
764 """ Test functionality of publish access update response method"""
766 # Mock required inputs
767 access_update_status
= True
768 access_info_req
= {'vim_type': 'VMware',
770 'access_config': {'vrops_password': 'vmware',
771 'vcloud-site': 'https://192.169.241.105',
772 'vrops_user': 'Admin', 'correlation_id': 14203,
776 # call publish access update response method under test
777 response
= self
.plugin_receiver
.publish_access_update_response(access_update_status
, access_info_req
)
779 # verify mocked method called with correct params
780 # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
782 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
783 def test_update_access_credentials_successful(self
, m_write_access_config
):
784 """ Test functionality of update access credentials-positive case"""
787 access_info
= {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
788 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
789 'admin_username': 'admin', 'admin_password': 'vmware',
790 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
791 'vcenter_user': 'admin', 'vcenter_password': 'vmware',
792 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
795 expected_status
= m_write_access_config
.return_value
= True
797 # call publish update access credentials method under test
798 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
800 # check write_access_config called with correct params
801 m_write_access_config
.assert_called_with(access_info
)
803 # verify update access credentials returns correct status
804 self
.assertEqual(expected_status
, actual_status
)
806 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
807 def test_update_access_credentials_less_config_params(self
, m_write_access_config
):
808 """ Test functionality of update access credentials-negative case"""
811 access_info
= {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
812 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
813 'admin_username': 'admin', 'admin_password': 'vmware',
814 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443', 'vcenter_user': 'admin',
815 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
818 expected_status
= m_write_access_config
.return_value
= False
820 # call publish update access credentials method under test
821 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
823 # check if mocked method not called
824 m_write_access_config
.assert_not_called()
826 # verify update access credentials returns correct status
827 self
.assertEqual(expected_status
, actual_status
)
829 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
830 def test_update_access_credentials_failed(self
, m_write_access_config
):
831 """ Test functionality of update access credentials-failed case """
834 access_info
= {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
835 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
836 'admin_username': 'admin', 'admin_password': 'vmware',
837 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
838 'vcenter_user': 'admin', 'vcenter_password': 'vmware',
839 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
842 expected_status
= m_write_access_config
.return_value
= False
844 # call publish update access credentials method under test
845 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
847 # check write_access_config called with correct params
848 m_write_access_config
.assert_called_with(access_info
)
850 # verify update access credentials returns correct status
851 self
.assertEqual(expected_status
, actual_status
)
853 def test_write_access_config_successful(self
):
854 """ Test functionality of write access config method-positive case"""
857 access_info
= {'vrops_sit': 'https://192.169.241.13', 'vrops_user': 'admin',
858 'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
859 'admin_username': 'admin', 'admin_password': 'vmware',
860 'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
861 'vcenter_user': 'admin', 'vcenter_password': 'vmware',
862 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
864 # call write access config method under test
865 actual_status
= self
.plugin_receiver
.write_access_config(access_info
)
867 # verify write access config returns correct status
868 self
.assertEqual(True, actual_status
)
870 def test_write_access_config_failed(self
):
871 """ Test functionality of write access config method-negative case"""
874 access_info
= [] # provided incorrect info to generate error
876 # call write access config method under test
877 actual_status
= self
.plugin_receiver
.write_access_config(access_info
)
879 # verify write access config returns correct status
880 self
.assertEqual(False, actual_status
)
882 @mock.patch
.object(monPluginRec
.AuthManager
, 'get_credentials')
883 def test_get_vim_access_config(self
, m_get_credentials
):
884 """ Test functionality of get_vim_access_config method-positive case"""
886 # Mock vim_uuid & access_info
888 vim_details
= VimCredentials()
889 vim_details
.name
= "vrops_vcd82"
890 vim_details
.password
= "passwd"
891 vim_details
.tenant_name
= "MANO-VDC"
892 vim_details
.type = "VMware"
893 vim_details
.url
= "https://10.10.1.1"
894 vim_details
.user
= "admin"
895 vim_details
.uuid
= "1"
896 vim_details
.config
= '{"orgname": "MANO-Org", "tenant_id": "MANO-VDC",\
897 "admin_username": "administrator","admin_password": "vcd_pwd",\
898 "vrops_user": "admin", "vrops_password": "vrops_pwd",\
899 "vrops_site": "https://10.10.1.2","nsx_user": "admin",\
900 "nsx_manager": "https://10.10.1.3", "nsx_password":"nsx_pwd",\
901 "sdn_controller": "None", "sdn_port_mapping": "None",\
902 "vcenter_ip": "10.10.1.4", "vcenter_user": "admin@vsphere.local",\
903 "vcenter_password": "vcenter_pwd", "vcenter_port": "443"}'
904 m_get_credentials
.return_value
= vim_details
905 expected_config
= {'vrops_password': 'vrops_pwd', 'vcenter_password': 'vcenter_pwd',
906 'name': 'vrops_vcd82', 'org_user': 'admin',
907 'org_password': 'passwd', 'nsx_user': 'admin', 'vim_tenant_name': 'MANO-VDC',
908 'admin_username': 'administrator', 'vcenter_port': '443',
909 'vim_url': 'https://10.10.1.1', 'orgname': 'MANO-Org',
910 'admin_password': 'vcd_pwd', 'vrops_user': 'admin', 'vcenter_ip': '10.10.1.4',
911 'vrops_site': 'https://10.10.1.2', 'nsx_manager': 'https://10.10.1.3',
912 'nsx_password': 'nsx_pwd', 'vim_type': 'VMware', 'vim_uuid': '1',
913 'vcenter_user': 'admin@vsphere.local'}
915 # call get_vim_access_config method under test
916 actual_config
= self
.plugin_receiver
.get_vim_access_config('1')
918 # verify that mocked method is called
919 m_get_credentials
.assert_called_with(vim_uuid
)
921 # Verify return value with expected value
922 self
.assertEqual(expected_config
, actual_config
)
924 # For testing purpose
925 # if __name__ == '__main__':