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 """
27 #sys.path.append("/root/MON/")
41 log
= logging
.getLogger(__name__
)
43 sys
.path
.append(os
.path
.join(os
.path
.dirname(os
.path
.abspath(__file__
)),"..","..",".."))
45 from osm_mon
.plugins
.vRealiseOps
import plugin_receiver
as monPluginRec
46 from osm_mon
.core
.database
import VimCredentials
49 class Message(object):
50 """A class to mock a message object value for alarm and matric requests"""
53 """Initialize a mocked message instance"""
54 self
.topic
= "alarm_or_metric_request"
56 self
.value
= json
.dumps({"mock_value": "mock_details"})
61 class TestPluginReceiver(unittest
.TestCase
):
62 """Test class for Plugin Receiver class methods"""
65 """Setup the tests for plugin_receiver class methods"""
66 super(TestPluginReceiver
, self
).setUp()
67 self
.plugin_receiver
= monPluginRec
.PluginReceiver()
69 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_alarm_status')
70 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'create_alarm')
71 def test_consume_create_alarm_request_key(self
, m_create_alarm
,\
72 m_publish_create_alarm_status
):
73 """Test functionality of consume for create_alarm_request key"""
75 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
78 msg
.topic
= "alarm_request"
79 msg
.key
= "create_alarm_request"
81 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"alarm_create_request":"alarm_details"})
82 m_create_alarm
.return_value
= "test_alarm_id"
84 config_alarm_info
= json
.loads(msg
.value
)
86 # Call the consume method of plugin_receiver
87 self
.plugin_receiver
.consume(msg
,vim_uuid
)
89 # verify if create_alarm and publish methods called with correct params
90 m_create_alarm
.assert_called_with(config_alarm_info
)
91 m_publish_create_alarm_status
.assert_called_with("test_alarm_id", config_alarm_info
)
94 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_alarm_status')
95 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_alarm')
96 def test_consume_update_alarm_request_key(self
, m_update_alarm
,\
97 m_publish_update_alarm_status
):
98 """Test functionality of consume for update_alarm_request key"""
100 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
103 msg
.topic
= "alarm_request"
104 msg
.key
= "update_alarm_request"
106 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"alarm_update_request":"alarm_details"})
108 # set return value to mocked method
109 m_update_alarm
.return_value
= "test_alarm_id"
111 update_alarm_info
= json
.loads(msg
.value
)
113 # Call the consume method of plugin_receiver
114 self
.plugin_receiver
.consume(msg
,vim_uuid
)
116 # verify update_alarm and publish method called with correct params
117 m_update_alarm
.assert_called_with(update_alarm_info
)
118 m_publish_update_alarm_status
.assert_called_with("test_alarm_id", update_alarm_info
)
121 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_alarm_status')
122 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'delete_alarm')
123 def test_consume_delete_alarm_request_key(self
, m_delete_alarm
,\
124 m_publish_delete_alarm_status
):
125 """Test functionality of consume for delete_alarm_request key"""
127 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
130 msg
.topic
= "alarm_request"
131 msg
.key
= "delete_alarm_request"
133 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"alarm_delete_request":"alarm_details"})
134 m_delete_alarm
.return_value
= "test_alarm_id"
136 delete_alarm_info
= json
.loads(msg
.value
)
138 # Call the consume method of plugin_receiver and check delete_alarm request
139 self
.plugin_receiver
.consume(msg
,vim_uuid
)
140 m_delete_alarm
.assert_called_with(delete_alarm_info
)
142 # Check if publish method called with correct parameters
143 m_publish_delete_alarm_status
.assert_called_with("test_alarm_id", delete_alarm_info
)
146 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_list_alarm_response')
147 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'list_alarms')
148 def test_consume_list_alarm_request_key(self
, m_list_alarms
,\
149 m_publish_list_alarm_response
):
150 """ Test functionality of list alarm request key"""
152 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
155 msg
.topic
= "alarm_request"
156 msg
.key
= "list_alarm_request"
157 test_alarm_list
= [{"alarm_uuid":"alarm1_details"},{"alarm_uuid":"alarm2_details"}]
159 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"alarm_list_request":"alarm_details"})
160 m_list_alarms
.return_value
= test_alarm_list
162 list_alarms_info
= json
.loads(msg
.value
)
164 # Call the consume method of plugin_receiver and check delete_alarm request
165 self
.plugin_receiver
.consume(msg
,vim_uuid
)
166 m_list_alarms
.assert_called_with(list_alarms_info
)
168 # Check if publish method called with correct parameters
169 m_publish_list_alarm_response
.assert_called_with(test_alarm_list
, list_alarms_info
)
172 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_access_update_response')
173 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_access_credentials')
174 def test_consume_vim_access_request_key(self
, m_update_access_credentials
,\
175 m_publish_access_update_response
):
176 """Test functionality of consume for vim_access_credentials request key"""
178 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
181 msg
.topic
= "access_credentials"
182 msg
.key
= "vim_access_credentials"
184 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"access_config":"access_details"})
185 # set return value to mocked method
186 m_update_access_credentials
.return_value
= True
188 access_info
= json
.loads(msg
.value
)
190 # Call the consume method of plugin_receiver
191 self
.plugin_receiver
.consume(msg
,vim_uuid
)
193 # check if mocked method called with required parameters
194 m_update_access_credentials
.assert_called_with("access_details")
196 # Check if publish method called with correct parameters
197 m_publish_access_update_response
.assert_called_with(True, access_info
)
200 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_alarm_status')
201 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'create_alarm')
202 def test_consume_invalid_alarm_request_key(self
, m_create_alarm
,\
203 m_publish_create_alarm_status
):
204 """Test functionality of consume for vim_access_credentials invalid request key"""
206 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
207 # Mock a message with invalid alarm request key
209 msg
.topic
= "alarm_request"
210 msg
.key
= "invalid_alarm_request" # invalid key
212 # Call the consume method of plugin_receiver
213 self
.plugin_receiver
.consume(msg
,vim_uuid
)
215 # verify that create_alarm and publish_create_alarm_status methods not called
216 m_create_alarm
.assert_not_called()
217 m_publish_create_alarm_status
.assert_not_called()
220 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
221 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
222 def test_consume_invalid_metric_request_key(self
, m_get_metrics_data
,\
223 m_publish_metric_data_status
):
224 """Test functionality of invalid metric key request"""
226 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
227 # Mock a message with invalid metric request key
229 msg
.topic
= "metric_request"
230 msg
.key
= "invalid_metric_data_request" #invalid key
232 # Call the consume method of plugin_receiver
233 self
.plugin_receiver
.consume(msg
,vim_uuid
)
235 # verify that get martics data and publish methods not called
236 m_get_metrics_data
.assert_not_called()
237 m_publish_metric_data_status
.assert_not_called()
240 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
241 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
242 @mock.patch
.object(monPluginRec
.PluginReceiver
,'get_vim_access_config')
243 def test_consume_read_metric_data_request_key(self
, m_get_vim_access_config
,\
245 m_publish_metric_data_status
):
246 """Test functionality of consume for read_metric_data_request key"""
248 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
251 msg
.topic
= "metric_request"
252 msg
.key
= "read_metric_data_request"
254 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"metric_name":"metric_details"})
255 m_get_metrics_data
.return_value
= {"metrics_data":"metrics_details"}
257 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
259 'vrops_password':'passwd',
261 'admin_username':'admin',
262 'admin_password':'admin_passwd',
264 'tenant_id':'org_vdc_1'}
266 metric_request_info
= json
.loads(msg
.value
)
268 # Call the consume method of plugin_receiver
269 self
.plugin_receiver
.consume(msg
,vim_uuid
)
270 m_get_metrics_data
.assert_called_with(metric_request_info
)
272 # Check if publish method called with correct parameters
273 m_publish_metric_data_status
.assert_called_with({"metrics_data":"metrics_details"})
276 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_metric_response')
277 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
278 def test_consume_create_metric_request_key(self
, m_verify_metric
,\
279 m_publish_create_metric_response
):
280 """Test functionality of consume for create_metric_request key"""
282 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
285 msg
.topic
= "metric_request"
286 msg
.key
= "create_metric_request"
288 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"metric_create":"metric_details"})
290 # set the return value
291 m_verify_metric
.return_value
= True
293 metric_info
= json
.loads(msg
.value
)
295 # Call the consume method of plugin_receiver
296 self
.plugin_receiver
.consume(msg
,vim_uuid
)
297 m_verify_metric
.assert_called_with(metric_info
)
299 # Check if publish method called with correct parameters
300 m_publish_create_metric_response
.assert_called_with(metric_info
, True)
303 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_metric_response')
304 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
305 def test_consume_update_metric_request_key(self
, m_verify_metric
,\
306 m_publish_update_metric_response
):
307 """Test functionality of update metric request key"""
309 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
312 msg
.topic
= "metric_request"
313 msg
.key
= "update_metric_request"
315 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"metric_create":"metric_details"})
317 # set the return value
318 m_verify_metric
.return_value
= True
320 metric_info
= json
.loads(msg
.value
)
322 # Call the consume method of plugin_receiver
323 self
.plugin_receiver
.consume(msg
,vim_uuid
)
325 # verify mocked methods called with correct parameters
326 m_verify_metric
.assert_called_with(metric_info
)
327 m_publish_update_metric_response
.assert_called_with(metric_info
, True)
330 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_metric_response')
331 def test_consume_delete_metric_request_key(self
, m_publish_delete_metric_response
):
332 """Test functionality of consume for delete_metric_request key"""
334 # Note: vROPS doesn't support deleting metric data
335 vim_uuid
= "f85fc39e-723d-4172-979b-de28b36465bb"
338 msg
.topic
= "metric_request"
339 msg
.key
= "delete_metric_request"
341 msg
.value
= json
.dumps({"vim_uuid":vim_uuid
,"metric_name":"metric_details"})
343 metric_info
= json
.loads(msg
.value
)
345 # Call the consume method of plugin_receiver
346 self
.plugin_receiver
.consume(msg
,vim_uuid
)
348 # Check if publish method called with correct parameters
349 m_publish_delete_metric_response
.assert_called_with(metric_info
)
352 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
353 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
354 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
355 def test_create_alarm_successful(self
, m_get_vim_access_config
,\
356 m_configure_rest_plugin
,\
358 """ Test functionality of create alarm method-positive case"""
360 # Mock config_alarm_info
361 config_alarm_info
= {"schema_version":1.0,
362 "schema_type":"create_alarm_request",
365 "alarm_create_request":{"correlation_id": 1,
366 "alarm_name": "CPU_Utilize_Threshold",
367 "metric_name": "CPU_UTILIZATION",
368 "tenant_uuid": "tenant_uuid",
369 "resource_uuid": "resource_uuid",
370 "description": "test_create_alarm",
371 "severity": "CRITICAL",
373 "threshold_value": 10,
375 "statistic": "AVERAGE"}}
377 # set return value to plugin uuid
378 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
380 'vrops_password':'passwd',
382 'admin_username':'admin',
383 'admin_password':'admin_passwd',
385 'tenant_id':'org_vdc_1'}
387 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
388 m_configure_alarm
.return_value
= "alarm_uuid"
390 # call create alarm method under test
391 self
.plugin_receiver
.create_alarm(config_alarm_info
)
393 # verify mocked methods get called with correct params
394 m_get_vim_access_config
.assert_called_with(config_alarm_info
['vim_uuid'])
395 m_configure_rest_plugin
.assert_called_with()
396 m_configure_alarm
.assert_called_with(config_alarm_info
["alarm_create_request"])
399 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
400 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
401 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
402 def test_create_alarm_failed(self
, m_get_vim_access_config
,\
403 m_configure_rest_plugin
,\
405 """ Test functionality of create alarm method negative case"""
407 # Mock config_alarm_info
408 config_alarm_info
= {"schema_version":1.0,
409 "schema_type":"create_alarm_request",
412 "alarm_create_request":{"correlation_id": 1,
413 "alarm_name": "CPU_Utilize_Threshold",
414 "metric_name": "CPU_UTILIZATION",
415 "tenant_uuid": "tenant_uuid",
416 "resource_uuid": "resource_uuid",
417 "description": "test_create_alarm",
418 "severity": "CRITICAL",
420 "threshold_value": 10,
422 "statistic": "AVERAGE"}}
424 # set return value to plugin uuid and alarm_uuid to None
425 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
427 'vrops_password':'passwd',
429 'admin_username':'admin',
430 'admin_password':'admin_passwd',
432 'tenant_id':'org_vdc_1'}
433 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
434 m_configure_alarm
.return_value
= None
436 # call create alarm method under test
437 alarm_uuid
= self
.plugin_receiver
.create_alarm(config_alarm_info
)
439 # verify mocked method called with correct params
440 m_get_vim_access_config
.assert_called_with(config_alarm_info
['vim_uuid'])
441 m_configure_rest_plugin
.assert_called_with()
442 m_configure_alarm
.assert_called_with(config_alarm_info
["alarm_create_request"])
444 # verify create alarm method returns None when failed
445 self
.assertEqual(alarm_uuid
, None)
448 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
449 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
450 def test_update_alarm_successful(self
, m_get_vim_access_config
, m_update_alarm_configuration
):
451 """ Test functionality of update alarm method-positive case"""
453 # Mock update_alarm_info
454 update_alarm_info
= {"schema_version":1.0,"schema_type":"update_alarm_request",
455 "vim_type":"VMware","vim_uuid":"1",
456 "alarm_update_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}}
458 # set return value to mocked method
459 m_update_alarm_configuration
.return_value
= "alarm_uuid"
460 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
462 'vrops_password':'passwd',
464 'admin_username':'admin',
465 'admin_password':'admin_passwd',
467 'tenant_id':'org_vdc_1'}
469 # check update alarm gets called and returned correct value
470 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
472 # check mocked method get called with correct param
473 m_get_vim_access_config
.assert_called_with(update_alarm_info
['vim_uuid'])
474 m_update_alarm_configuration
.assert_called_with(update_alarm_info
["alarm_update_request"])
476 # check return value and passed values are correct
477 self
.assertEqual(ret_value
, "alarm_uuid")
480 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
481 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
482 def test_update_alarm_failed(self
, m_get_vim_access_config
, m_update_alarm_configuration
):
483 """ Test functionality of update alarm method negative case"""
485 # Mock update_alarm_info
486 update_alarm_info
= {"schema_version":1.0,"schema_type":"update_alarm_request",
487 "vim_type":"VMware","vim_uuid":"1",
488 "alarm_update_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}}
490 # set return value to mocked method
491 m_update_alarm_configuration
.return_value
= None
492 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
494 'vrops_password':'passwd',
496 'admin_username':'admin',
497 'admin_password':'admin_passwd',
499 'tenant_id':'org_vdc_1'}
501 # check update alarm gets called and returned correct value
502 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
504 # check mocked method get called with correct param
505 m_get_vim_access_config
.assert_called_with(update_alarm_info
['vim_uuid'])
506 m_update_alarm_configuration
.assert_called_with(update_alarm_info
["alarm_update_request"])
508 # check return value and passed values are correct
509 self
.assertEqual(ret_value
, None)
512 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
513 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
514 def test_delete_alarm_successful(self
, m_get_vim_access_config
, m_delete_alarm_configuration
):
515 """ Test functionality of delete alarm method-positive case"""
517 # Mock delete_alarm_info
518 delete_alarm_info
= {"schema_version":1.0,"schema_type":"delete_alarm_request",
519 "vim_type":"VMware","vim_uuid":"1",
520 "alarm_delete_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}}
522 # set return value to mocked method
523 m_delete_alarm_configuration
.return_value
= "alarm_uuid"
524 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
526 'vrops_password':'passwd',
528 'admin_username':'admin',
529 'admin_password':'admin_passwd',
531 'tenant_id':'org_vdc_1'}
533 # check delete alarm gets called and returned correct value
534 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
536 # check mocked method get called with correct param
537 m_get_vim_access_config
.assert_called_with(delete_alarm_info
['vim_uuid'])
538 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
["alarm_delete_request"])
540 # check return value and passed values are correct
541 self
.assertEqual(ret_value
, "alarm_uuid")
544 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
545 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
546 def test_delete_alarm_failed(self
, m_get_vim_access_config
, m_delete_alarm_configuration
):
547 """ Test functionality of delete alarm method-negative case"""
549 # Mock update_alarm_info
550 delete_alarm_info
= {"schema_version":1.0,"schema_type":"delete_alarm_request",
551 "vim_type":"VMware","vim_uuid":"1",
552 "alarm_delete_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}}
554 # set return value to mocked method
555 m_delete_alarm_configuration
.return_value
= None
556 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
558 'vrops_password':'passwd',
560 'admin_username':'admin',
561 'admin_password':'admin_passwd',
563 'tenant_id':'org_vdc_1'}
565 # check delete alarm gets called and returned correct value
566 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
568 # check mocked method get called with correct param
569 m_get_vim_access_config
.assert_called_with(delete_alarm_info
['vim_uuid'])
570 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
["alarm_delete_request"])
572 # check return value to check failed status
573 self
.assertEqual(ret_value
, None)
576 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
577 def test_publish_create_alarm_status(self
, m_publish
):
578 """ Test functionality of publish create alarm status method"""
580 # Mock config_alarm_info
581 config_alarm_info
= {'vim_type': 'VMware', "vim_uuid":"1",
582 'alarm_create_request': {
583 'threshold_value': 0,
584 'severity': 'CRITICAL',
585 'alarm_name': 'CPU_Utilization_Above_Threshold',
586 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
587 'correlation_id': 1234,
588 'statistic': 'AVERAGE',
589 'metric_name': 'CPU_UTILIZATION'}
594 # call publish create status method under test
595 self
.plugin_receiver
.publish_create_alarm_status(alarm_uuid
, config_alarm_info
)
597 # verify mocked method called with correct params
598 m_publish
.assert_called_with(key
='create_alarm_response',\
600 topic
='alarm_response')
603 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
604 def test_publish_update_alarm_status(self
, m_publish
):
605 """ Test functionality of publish update alarm status method"""
607 # Mock update_alarm_info
608 update_alarm_info
= {'vim_type' : 'VMware',
610 'schema_type': 'update_alarm_request',
611 'alarm_update_request':{'alarm_uuid': '6486e69',
612 'correlation_id': 14203,
619 # call publish update alarm status method under test
620 self
.plugin_receiver
.publish_update_alarm_status(alarm_uuid
, update_alarm_info
)
622 # verify mocked method called with correct params
623 m_publish
.assert_called_with(key
='update_alarm_response',\
625 topic
='alarm_response')
628 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
629 def test_publish_delete_alarm_status(self
, m_publish
):
630 """ Test functionality of publish delete alarm status method"""
632 # Mock delete_alarm_info
633 delete_alarm_info
= {'vim_type' : 'VMware',
635 'schema_type': 'delete_alarm_request',
636 'alarm_delete_request':{'alarm_uuid': '6486e69',
637 'correlation_id': 14203,
644 # call publish delete alarm status method under test
645 self
.plugin_receiver
.publish_delete_alarm_status(alarm_uuid
, delete_alarm_info
)
647 # verify mocked method called with correct params
648 m_publish
.assert_called_with(key
='delete_alarm_response',\
650 topic
='alarm_response')
653 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
654 def test_publish_metrics_data_status(self
, m_publish
):
655 """ Test functionality of publish metrics data status method"""
660 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
661 'resource_uuid': 'e14b20', 'correlation_id': 14203,
662 'metrics_data': {'time_series': [15162011, 15162044],
663 'metrics_series': [0.1166666671, 0.1266666650]},
664 'tenant_uuid': 123, 'unit': '%'
667 # call publish metrics data status method under test
668 self
.plugin_receiver
.publish_metrics_data_status(metrics_data
)
670 # verify mocked method called with correct params
671 m_publish
.assert_called_with(key
='read_metric_data_response',\
673 topic
='metric_response')
676 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
677 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
678 def test_verify_metric_supported_metric(self
, m_get_vim_access_config
,\
679 m_verify_metric_support
):
680 """ Test functionality of verify metric method"""
683 metric_info
= {'vim_uuid':'1',\
684 'metric_create_request':{'metric_unit': '%',\
685 'metric_name': 'CPU_UTILIZATION',\
686 'resource_uuid': 'e14b203'}}
688 # set mocked function return value to true
689 m_verify_metric_support
.return_value
= True
690 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
692 'vrops_password':'passwd',
694 'admin_username':'admin',
695 'admin_password':'admin_passwd',
697 'tenant_id':'org_vdc_1'}
699 # call verify_metric method under test
700 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
702 # verify mocked method called with correct params
703 m_get_vim_access_config
.assert_called_with(metric_info
['vim_uuid'])
704 m_verify_metric_support
.assert_called_with(metric_info
['metric_create_request'])
706 # verify the return value
707 self
.assertEqual(ret_value
, True)
710 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
711 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
712 def test_verify_metric_unsupported_metric(self
, m_get_vim_access_config
,\
713 m_verify_metric_support
):
714 """ Test functionality of verify metric method-negative case"""
716 # mock metric_info with unsupported metrics name
717 metric_info
= {'vim_uuid':'1',\
718 'metric_create_request':{'metric_unit': '%',\
719 'metric_name': 'Invalid',\
720 'resource_uuid': 'e14b203'}}
722 # set mocked function return value to true
723 m_verify_metric_support
.return_value
= False
724 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
726 'vrops_password':'passwd',
728 'admin_username':'admin',
729 'admin_password':'admin_passwd',
731 'tenant_id':'org_vdc_1'}
733 # call verify_metric method under test
734 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
736 # verify mocked method called with correct params
737 m_get_vim_access_config
.assert_called_with(metric_info
['vim_uuid'])
738 m_verify_metric_support
.assert_called_with(metric_info
['metric_create_request'])
740 # verify the return value
741 self
.assertEqual(ret_value
, False)
744 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
745 def test_publish_create_metric_response(self
, m_publish
):
746 """ Test functionality of publish create metric response method"""
751 'vim_type' : 'VMware',
752 'correlation_id': 14203,
753 'schema_type': 'create_metric_request',
754 'metric_create_request':{
755 'resource_uuid': '6486e69',
756 'metric_name': 'CPU_UTILIZATION',
763 # call publish create metric method under test
764 self
.plugin_receiver
.publish_create_metric_response(metric_info
, metric_status
)
766 # verify mocked method called with correct params
767 m_publish
.assert_called_with(key
='create_metric_response',\
769 topic
='metric_response')
772 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
773 def test_publish_update_metric_response(self
, m_publish
):
774 """ Test functionality of publish update metric response method"""
779 'vim_type' : 'VMware',
780 'correlation_id': 14203,
781 'schema_type': 'update_metric_request',
783 'resource_uuid': '6486e69',
784 'metric_name': 'CPU_UTILIZATION',
791 # call publish update metric method under test
792 self
.plugin_receiver
.publish_update_metric_response(metric_info
, metric_status
)
794 # verify mocked method called with correct params
795 m_publish
.assert_called_with(key
='update_metric_response',\
797 topic
='metric_response')
800 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
801 def test_publish_delete_metric_response(self
, m_publish
):
802 """ Test functionality of publish delete metric response method"""
805 metric_info
= {'vim_uuid':'1', 'vim_type' : 'VMware','correlation_id': 14203,
806 'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69',
807 'metric_name': 'CPU_UTILIZATION',
808 'schema_type': 'delete_metric_request'}
812 # call publish delete metric method under test-vROPS doesn't support
813 # delete metric,just returns response with success
814 self
.plugin_receiver
.publish_delete_metric_response(metric_info
)
816 # verify mocked method called with correct params
817 m_publish
.assert_called_with(key
='delete_metric_response',\
819 topic
='metric_response')
822 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_triggered_alarms_list')
823 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'get_vim_access_config')
824 def test_list_alarms(self
, m_get_vim_access_config
, m_get_triggered_alarms_list
):
825 """ Test functionality of list alarms method"""
827 # Mock list alarm input
830 'vim_type' : 'VMware',
831 'alarm_list_request':{
832 'severity': 'CRITICAL',
833 'correlation_id': 14203,
834 'alarm_name': 'CPU_Utilization_Above_Threshold',
835 'resource_uuid': 'd14b203c'}}
837 # set return value to mocked method
838 m_return
= [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
839 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
840 'cancel_date': '0000-00-00T00:00:00','alarm_instance_uuid': 'd9e3bc84',
841 'alarm_uuid': '5714977d', 'vim_type': 'VMware',
842 'start_date': '2018-01-12T08:34:05'},
843 {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57',
844 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
845 'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6',
846 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware',
847 'start_date': '2017-12-20T09:37:57'}]
848 m_get_triggered_alarms_list
.return_value
= m_return
850 m_get_vim_access_config
.return_value
= {'vrops_site':'abc',
852 'vrops_password':'passwd',
854 'admin_username':'admin',
855 'admin_password':'admin_passwd',
857 'tenant_id':'org_vdc_1'}
860 # call list alarms method under test
861 return_value
= self
.plugin_receiver
.list_alarms(list_alarm_input
)
863 # verify mocked method called with correct params
864 m_get_vim_access_config
.assert_called_with(list_alarm_input
['vim_uuid'])
865 m_get_triggered_alarms_list
.assert_called_with(list_alarm_input
['alarm_list_request'])
867 # verify list alarm method returns correct list
868 self
.assertEqual(return_value
, m_return
)
871 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
872 def test_publish_list_alarm_response(self
, m_publish
):
873 """ Test functionality of publish list alarm response method"""
875 # Mock list alarm input
876 msg_key
= 'list_alarm_response'
877 topic
= 'alarm_response'
878 list_alarm_input
= {'vim_uuid':'1',
879 'vim_type' : 'VMware',
880 'alarm_list_request':{
881 'severity': 'CRITICAL',
882 'correlation_id': 14203,
883 'alarm_name': 'CPU_Utilization_Above_Threshold',
884 'resource_uuid': 'd14b203c'}}
886 triggered_alarm_list
= [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
887 'severity': 'CRITICAL','resource_uuid': 'e14b203c',
888 'cancel_date': '0000-00-00T00:00:00',
889 'start_date': '2018-01-12T08:34:05',
890 'alarm_instance_uuid': 'd9e3bc84',
891 'alarm_uuid': '5714977d',
895 # call publish list alarm response method under test
896 self
.plugin_receiver
.publish_list_alarm_response(triggered_alarm_list
, list_alarm_input
)
898 # verify mocked method called with correct params
899 m_publish
.assert_called_with(key
=msg_key
,value
=mock
.ANY
, topic
=topic
)
902 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
903 def test_publish_access_update_response(self
, m_publish
):
904 """ Test functionality of publish access update response method"""
906 # Mock required inputs
907 access_update_status
= True
908 msg_key
= 'vim_access_credentials_response'
909 topic
= 'access_credentials'
910 access_info_req
= {'vim_type': 'VMware',
912 'access_config': {'vrops_password': 'vmware',
913 'vcloud-site': 'https://192.169.241.105',
914 'vrops_user': 'Admin', 'correlation_id': 14203,
918 # call publish access update response method under test
919 self
.plugin_receiver
.publish_access_update_response(access_update_status
, access_info_req
)
921 # verify mocked method called with correct params
922 m_publish
.assert_called_with(key
=msg_key
,value
=mock
.ANY
, topic
=topic
)
925 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
926 def test_update_access_credentials_successful(self
, m_write_access_config
):
927 """ Test functionality of update access credentials-positive case"""
930 access_info
= {'vrops_site':'https://192.169.241.13','vrops_user':'admin',
931 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15',
932 'admin_username':'admin','admin_password':'vmware',
933 'vcenter_ip':'192.169.241.13','vcenter_port':'443',
934 'vcenter_user':'admin','vcenter_password':'vmware',
935 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
938 expected_status
= m_write_access_config
.return_value
= True
940 # call publish update access credentials method under test
941 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
943 # check write_access_config called with correct params
944 m_write_access_config
.assert_called_with(access_info
)
946 # verify update access credentials returns correct status
947 self
.assertEqual(expected_status
, actual_status
)
950 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
951 def test_update_access_credentials_less_config_params(self
, m_write_access_config
):
952 """ Test functionality of update access credentials-negative case"""
955 access_info
= {'vrops_site':'https://192.169.241.13','vrops_user':'admin',
956 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15',
957 'admin_username':'admin','admin_password':'vmware',
958 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin',
959 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
962 expected_status
= m_write_access_config
.return_value
= False
964 # call publish update access credentials method under test
965 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
967 # check if mocked method not called
968 m_write_access_config
.assert_not_called()
970 # verify update access credentials returns correct status
971 self
.assertEqual(expected_status
, actual_status
)
974 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
975 def test_update_access_credentials_failed(self
, m_write_access_config
):
976 """ Test functionality of update access credentials-failed case """
979 access_info
= {'vrops_site':'https://192.169.241.13','vrops_user':'admin',
980 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15',
981 'admin_username':'admin','admin_password':'vmware',
982 'vcenter_ip':'192.169.241.13','vcenter_port':'443',
983 'vcenter_user':'admin','vcenter_password':'vmware',
984 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
987 expected_status
= m_write_access_config
.return_value
= False
989 # call publish update access credentials method under test
990 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
992 # check write_access_config called with correct params
993 m_write_access_config
.assert_called_with(access_info
)
995 # verify update access credentials returns correct status
996 self
.assertEqual(expected_status
, actual_status
)
999 def test_write_access_config_successful(self
):
1000 """ Test functionality of write access config method-positive case"""
1003 access_info
= {'vrops_sit':'https://192.169.241.13','vrops_user':'admin',
1004 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15',
1005 'admin_username':'admin','admin_password':'vmware',
1006 'vcenter_ip':'192.169.241.13','vcenter_port':'443',
1007 'vcenter_user':'admin','vcenter_password':'vmware',
1008 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
1010 # call write access config method under test
1011 actual_status
= self
.plugin_receiver
.write_access_config(access_info
)
1013 # verify write access config returns correct status
1014 self
.assertEqual(True, actual_status
)
1017 def test_write_access_config_failed(self
):
1018 """ Test functionality of write access config method-negative case"""
1021 access_info
= [] # provided incorrect info to generate error
1023 # call write access config method under test
1024 actual_status
= self
.plugin_receiver
.write_access_config(access_info
)
1026 # verify write access config returns correct status
1027 self
.assertEqual(False, actual_status
)
1030 @mock.patch
.object(monPluginRec
.AuthManager
, 'get_credentials')
1031 def test_get_vim_access_config(self
, m_get_credentials
):
1032 """ Test functionality of get_vim_access_config method-positive case"""
1034 # Mock vim_uuid & access_info
1036 vim_details
= VimCredentials()
1037 vim_details
.name
= "vrops_vcd82"
1038 vim_details
.password
= "passwd"
1039 vim_details
.tenant_name
= "MANO-VDC"
1040 vim_details
.type = "VMware"
1041 vim_details
.url
= "https://10.10.1.1"
1042 vim_details
.user
= "admin"
1043 vim_details
.uuid
= "1"
1044 vim_details
.config
= '{"orgname": "MANO-Org", "tenant_id": "MANO-VDC",\
1045 "admin_username": "administrator","admin_password": "vcd_pwd",\
1046 "vrops_user": "admin", "vrops_password": "vrops_pwd",\
1047 "vrops_site": "https://10.10.1.2","nsx_user": "admin",\
1048 "nsx_manager": "https://10.10.1.3", "nsx_password":"nsx_pwd",\
1049 "sdn_controller": "None", "sdn_port_mapping": "None",\
1050 "vcenter_ip": "10.10.1.4", "vcenter_user": "admin@vsphere.local",\
1051 "vcenter_password": "vcenter_pwd", "vcenter_port": "443"}'
1052 m_get_credentials
.return_value
= vim_details
1053 expected_config
= {'vrops_password': 'vrops_pwd', 'vcenter_password': 'vcenter_pwd',
1054 'name': 'vrops_vcd82', 'org_user': 'admin',
1055 'org_password': 'passwd', 'nsx_user': 'admin', 'vim_tenant_name': 'MANO-VDC',
1056 'admin_username': 'administrator', 'vcenter_port': '443',
1057 'vim_url': 'https://10.10.1.1', 'orgname': 'MANO-Org',
1058 'admin_password':'vcd_pwd', 'vrops_user':'admin', 'vcenter_ip':'10.10.1.4',
1059 'vrops_site': 'https://10.10.1.2', 'nsx_manager': 'https://10.10.1.3',
1060 'nsx_password': 'nsx_pwd', 'vim_type': 'VMware', 'vim_uuid': '1',
1061 'vcenter_user': 'admin@vsphere.local'}
1063 # call get_vim_access_config method under test
1064 actual_config
= self
.plugin_receiver
.get_vim_access_config('1')
1066 #verify that mocked method is called
1067 m_get_credentials
.assert_called_with(vim_uuid
)
1069 #Verify return value with expected value
1070 self
.assertEqual(expected_config
, actual_config
)
1073 # For testing purpose
1074 #if __name__ == '__main__':