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
48 class Message(object):
49 """A class to mock a message object value for alarm and matric requests"""
52 """Initialize a mocked message instance"""
53 self
.topic
= "alarm_or_metric_request"
55 self
.value
= json
.dumps({"mock_value": "mock_details"})
60 class TestPluginReceiver(unittest
.TestCase
):
61 """Test class for Plugin Receiver class methods"""
64 """Setup the tests for plugin_receiver class methods"""
65 super(TestPluginReceiver
, self
).setUp()
66 self
.plugin_receiver
= monPluginRec
.PluginReceiver()
67 #self.mon_plugin = monPlugin.MonPlugin()
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
, m_publish_create_alarm_status
):
72 """Test functionality of consume for create_alarm_request key"""
76 msg
.topic
= "alarm_request"
77 msg
.key
= "create_alarm_request"
79 msg
.value
= json
.dumps({"alarm_create_request":"alarm_details"})
80 m_create_alarm
.return_value
= "test_alarm_id"
82 config_alarm_info
= json
.loads(msg
.value
)
84 # Call the consume method of plugin_receiver
85 self
.plugin_receiver
.consume(msg
)
87 # verify if create_alarm and publish methods called with correct params
88 m_create_alarm
.assert_called_with("alarm_details")
89 m_publish_create_alarm_status
.assert_called_with("test_alarm_id", config_alarm_info
)
92 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_alarm_status')
93 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_alarm')
94 def test_consume_update_alarm_request_key(self
, m_update_alarm
, m_publish_update_alarm_status
):
95 """Test functionality of consume for update_alarm_request key"""
99 msg
.topic
= "alarm_request"
100 msg
.key
= "update_alarm_request"
102 msg
.value
= json
.dumps({"alarm_update_request":"alarm_details"})
104 # set return value to mocked method
105 m_update_alarm
.return_value
= "test_alarm_id"
107 update_alarm_info
= json
.loads(msg
.value
)
109 # Call the consume method of plugin_receiver
110 self
.plugin_receiver
.consume(msg
)
112 # verify update_alarm and publish method called with correct params
113 m_update_alarm
.assert_called_with("alarm_details")
114 m_publish_update_alarm_status
.assert_called_with("test_alarm_id", update_alarm_info
)
117 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_alarm_status')
118 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'delete_alarm')
119 def test_consume_delete_alarm_request_key(self
, m_delete_alarm
, m_publish_delete_alarm_status
):
120 """Test functionality of consume for delete_alarm_request key"""
124 msg
.topic
= "alarm_request"
125 msg
.key
= "delete_alarm_request"
127 msg
.value
= json
.dumps({"alarm_delete_request":"alarm_details"})
128 m_delete_alarm
.return_value
= "test_alarm_id"
130 delete_alarm_info
= json
.loads(msg
.value
)
132 # Call the consume method of plugin_receiver and check delete_alarm request
133 self
.plugin_receiver
.consume(msg
)
134 m_delete_alarm
.assert_called_with("alarm_details")
136 # Check if publish method called with correct parameters
137 m_publish_delete_alarm_status
.assert_called_with("test_alarm_id", delete_alarm_info
)
140 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_list_alarm_response')
141 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'list_alarms')
142 def test_consume_list_alarm_request_key(self
, m_list_alarms
, m_publish_list_alarm_response
):
143 """ Test functionality of list alarm request key"""
147 msg
.topic
= "alarm_request"
148 msg
.key
= "list_alarm_request"
149 test_alarm_list
= [{"alarm_uuid":"alarm1_details"},{"alarm_uuid":"alarm2_details"}]
151 msg
.value
= json
.dumps({"alarm_list_request":"alarm_details"})
152 m_list_alarms
.return_value
= test_alarm_list
154 list_alarms_info
= json
.loads(msg
.value
)
156 # Call the consume method of plugin_receiver and check delete_alarm request
157 self
.plugin_receiver
.consume(msg
)
158 m_list_alarms
.assert_called_with("alarm_details")
160 # Check if publish method called with correct parameters
161 m_publish_list_alarm_response
.assert_called_with(test_alarm_list
, list_alarms_info
)
164 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_access_update_response')
165 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_access_credentials')
166 def test_consume_vim_access_request_key(self
, m_update_access_credentials
, m_publish_access_update_response
):
167 """Test functionality of consume for vim_access_credentials request key"""
171 msg
.topic
= "access_credentials"
172 msg
.key
= "vim_access_credentials"
174 msg
.value
= json
.dumps({"access_config":"access_details"})
175 # set return value to mocked method
176 m_update_access_credentials
.return_value
= True
178 access_info
= json
.loads(msg
.value
)
180 # Call the consume method of plugin_receiver
181 self
.plugin_receiver
.consume(msg
)
183 # check if mocked method called with required parameters
184 m_update_access_credentials
.assert_called_with("access_details")
186 # Check if publish method called with correct parameters
187 m_publish_access_update_response
.assert_called_with(True, access_info
)
190 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_alarm_status')
191 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'create_alarm')
192 def test_consume_invalid_alarm_request_key(self
, m_create_alarm
, m_publish_create_alarm_status
):
193 """Test functionality of consume for vim_access_credentials invalid request key"""
195 # Mock a message with invalid alarm request key
197 msg
.topic
= "alarm_request"
198 msg
.key
= "invalid_alarm_request" # invalid key
200 # Call the consume method of plugin_receiver
201 self
.plugin_receiver
.consume(msg
)
203 # verify that create_alarm and publish_create_alarm_status methods not called
204 m_create_alarm
.assert_not_called()
205 m_publish_create_alarm_status
.assert_not_called()
208 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
209 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
210 def test_consume_invalid_metric_request_key(self
, m_get_metrics_data
, m_publish_metric_data_status
):
211 """Test functionality of invalid metric key request"""
213 # Mock a message with invalid metric request key
215 msg
.topic
= "metric_request"
216 msg
.key
= "invalid_metric_data_request" #invalid key
218 # Call the consume method of plugin_receiver
219 self
.plugin_receiver
.consume(msg
)
221 # verify that get martics data and publish methods not called
222 m_get_metrics_data
.assert_not_called()
223 m_publish_metric_data_status
.assert_not_called()
226 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
227 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
228 def test_consume_read_metric_data_request_key(self
, m_get_metrics_data
, m_publish_metric_data_status
):
229 """Test functionality of consume for read_metric_data_request key"""
233 msg
.topic
= "metric_request"
234 msg
.key
= "read_metric_data_request"
236 msg
.value
= json
.dumps({"metric_name":"metric_details"})
237 m_get_metrics_data
.return_value
= {"metrics_data":"metrics_details"}
239 metric_request_info
= json
.loads(msg
.value
)
241 # Call the consume method of plugin_receiver
242 self
.plugin_receiver
.consume(msg
)
243 m_get_metrics_data
.assert_called_with(metric_request_info
)
245 # Check if publish method called with correct parameters
246 m_publish_metric_data_status
.assert_called_with({"metrics_data":"metrics_details"})
249 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_metric_response')
250 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
251 def test_consume_create_metric_request_key(self
, m_verify_metric
, m_publish_create_metric_response
):
252 """Test functionality of consume for create_metric_request key"""
256 msg
.topic
= "metric_request"
257 msg
.key
= "create_metric_request"
259 msg
.value
= json
.dumps({"metric_create_request":"metric_details"})
261 # set the return value
262 m_verify_metric
.return_value
= True
264 metric_info
= json
.loads(msg
.value
)
266 # Call the consume method of plugin_receiver
267 self
.plugin_receiver
.consume(msg
)
268 m_verify_metric
.assert_called_with("metric_details")
270 # Check if publish method called with correct parameters
271 m_publish_create_metric_response
.assert_called_with(metric_info
, True)
274 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_metric_response')
275 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
276 def test_consume_update_metric_request_key(self
, m_verify_metric
, m_publish_update_metric_response
):
277 """Test functionality of update metric request key"""
281 msg
.topic
= "metric_request"
282 msg
.key
= "update_metric_request"
284 msg
.value
= json
.dumps({"metric_create_request":"metric_details"})
286 # set the return value
287 m_verify_metric
.return_value
= True
289 metric_info
= json
.loads(msg
.value
)
291 # Call the consume method of plugin_receiver
292 self
.plugin_receiver
.consume(msg
)
294 # verify mocked methods called with correct parameters
295 m_verify_metric
.assert_called_with("metric_details")
296 m_publish_update_metric_response
.assert_called_with(metric_info
, True)
299 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_metric_response')
300 def test_consume_delete_metric_request_key(self
, m_publish_delete_metric_response
):
301 """Test functionality of consume for delete_metric_request key"""
303 # Note: vROPS doesn't support deleting metric data
306 msg
.topic
= "metric_request"
307 msg
.key
= "delete_metric_request"
309 msg
.value
= json
.dumps({"metric_name":"metric_details"})
311 metric_info
= json
.loads(msg
.value
)
313 # Call the consume method of plugin_receiver
314 self
.plugin_receiver
.consume(msg
)
316 # Check if publish method called with correct parameters
317 m_publish_delete_metric_response
.assert_called_with(metric_info
)
320 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
321 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
322 def test_create_alarm_successful(self
, m_configure_rest_plugin
, m_configure_alarm
):
323 """ Test functionality of create alarm method-positive case"""
325 # Mock config_alarm_info
326 config_alarm_info
= {"correlation_id": 1,
327 "alarm_name": "CPU_Utilize_Threshold",
328 "metric_name": "CPU_UTILIZATION",
329 "tenant_uuid": "tenant_uuid",
330 "resource_uuid": "resource_uuid",
331 "description": "test_create_alarm",
332 "severity": "CRITICAL",
334 "threshold_value": 10,
336 "statistic": "AVERAGE"}
338 # set return value to plugin uuid
339 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
340 m_configure_alarm
.return_value
= "alarm_uuid"
342 # call create alarm method under test
343 self
.plugin_receiver
.create_alarm(config_alarm_info
)
345 # verify mocked methods get called with correct params
346 m_configure_rest_plugin
.assert_called_with()
347 m_configure_alarm
.assert_called_with(config_alarm_info
)
350 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
351 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
352 def test_create_alarm_failed(self
, m_configure_rest_plugin
, m_configure_alarm
):
353 """ Test functionality of create alarm method negative case"""
355 # Mock config_alarm_info
356 config_alarm_info
= {"correlation_id": 1,
357 "alarm_name": "CPU_Utilize_Threshold",
358 "metric_name": "CPU_UTILIZATION",
359 "tenant_uuid": "tenant_uuid",
360 "resource_uuid": "resource_uuid",
361 "description": "test_create_alarm",
362 "severity": "CRITICAL",
364 "threshold_value": 10,
366 "statistic": "AVERAGE"}
368 # set return value to plugin uuid and alarm_uuid to None
369 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
370 m_configure_alarm
.return_value
= None
372 # call create alarm method under test
373 alarm_uuid
= self
.plugin_receiver
.create_alarm(config_alarm_info
)
375 # verify mocked method called with correct params
376 m_configure_rest_plugin
.assert_called_with()
377 m_configure_alarm
.assert_called_with(config_alarm_info
)
379 # verify create alarm method returns None when failed
380 self
.assertEqual(alarm_uuid
, None)
383 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
384 def test_update_alarm_successful(self
, m_update_alarm_configuration
):
385 """ Test functionality of update alarm method-positive case"""
387 # Mock update_alarm_info
388 update_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
390 # set return value to mocked method
391 m_update_alarm_configuration
.return_value
= "alarm_uuid"
393 # check update alarm gets called and returned correct value
394 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
396 # check mocked method get called with correct param
397 m_update_alarm_configuration
.assert_called_with(update_alarm_info
)
399 # check return value and passed values are correct
400 self
.assertEqual(ret_value
, "alarm_uuid")
403 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
404 def test_update_alarm_failed(self
, m_update_alarm_configuration
):
405 """ Test functionality of update alarm method negative case"""
407 # Mock update_alarm_info
408 update_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
410 # set return value to mocked method
411 m_update_alarm_configuration
.return_value
= None
413 # check update alarm gets called and returned correct value
414 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
416 # check mocked method get called with correct param
417 m_update_alarm_configuration
.assert_called_with(update_alarm_info
)
419 # check return value and passed values are correct
420 self
.assertEqual(ret_value
, None)
423 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
424 def test_delete_alarm_successful(self
, m_delete_alarm_configuration
):
425 """ Test functionality of delete alarm method-positive case"""
427 # Mock delete_alarm_info
428 delete_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
430 # set return value to mocked method
431 m_delete_alarm_configuration
.return_value
= "alarm_uuid"
433 # check delete alarm gets called and returned correct value
434 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
436 # check mocked method get called with correct param
437 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
)
439 # check return value and passed values are correct
440 self
.assertEqual(ret_value
, "alarm_uuid")
443 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
444 def test_delete_alarm_failed(self
, m_delete_alarm_configuration
):
445 """ Test functionality of delete alarm method-negative case"""
447 # Mock update_alarm_info
448 delete_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
450 # set return value to mocked method
451 m_delete_alarm_configuration
.return_value
= None
453 # check delete alarm gets called and returned correct value
454 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
456 # check mocked method get called with correct param
457 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
)
459 # check return value to check failed status
460 self
.assertEqual(ret_value
, None)
463 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
464 def test_publish_create_alarm_status(self
, m_publish
):
465 """ Test functionality of publish create alarm status method"""
467 # Mock config_alarm_info
468 config_alarm_info
= {'vim_type': 'VMware',
469 'alarm_create_request': {'threshold_value': 0,
470 'severity': 'CRITICAL',
471 'alarm_name': 'CPU_Utilization_Above_Threshold',
472 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
473 'correlation_id': 1234,
474 'statistic': 'AVERAGE',
475 'metric_name': 'CPU_UTILIZATION'}
480 # call publish create status method under test
481 self
.plugin_receiver
.publish_create_alarm_status(alarm_uuid
, config_alarm_info
)
483 # verify mocked method called with correct params
484 m_publish
.assert_called_with(key
='create_alarm_response', value
=mock
.ANY
, topic
='alarm_response')
487 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
488 def test_publish_update_alarm_status(self
, m_publish
):
489 """ Test functionality of publish update alarm status method"""
491 # Mock update_alarm_info
492 update_alarm_info
= {'vim_type' : 'VMware',
493 'alarm_update_request':{'alarm_uuid': '6486e69',
494 'correlation_id': 14203,
497 'schema_type': 'update_alarm_request'
502 # call publish update alarm status method under test
503 self
.plugin_receiver
.publish_update_alarm_status(alarm_uuid
, update_alarm_info
)
505 # verify mocked method called with correct params
506 m_publish
.assert_called_with(key
='update_alarm_response', value
=mock
.ANY
, topic
='alarm_response')
509 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
510 def test_publish_delete_alarm_status(self
, m_publish
):
511 """ Test functionality of publish delete alarm status method"""
513 # Mock delete_alarm_info
514 delete_alarm_info
= {'vim_type' : 'VMware',
515 'alarm_delete_request':{'alarm_uuid': '6486e69',
516 'correlation_id': 14203,
519 'schema_type': 'delete_alarm_request'
524 # call publish delete alarm status method under test
525 self
.plugin_receiver
.publish_delete_alarm_status(alarm_uuid
, delete_alarm_info
)
527 # verify mocked method called with correct params
528 m_publish
.assert_called_with(key
='delete_alarm_response', value
=mock
.ANY
, topic
='alarm_response')
531 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
532 def test_publish_metrics_data_status(self
, m_publish
):
533 """ Test functionality of publish metrics data status method"""
537 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
538 'resource_uuid': 'e14b20', 'correlation_id': 'e14b2',
539 'metrics_data': {'time_series': [15162011, 15162044],
540 'metrics_series': [0.1166666671, 0.1266666650]},
541 'tenant_uuid': 123, 'unit': '%'
544 # call publish metrics data status method under test
545 self
.plugin_receiver
.publish_metrics_data_status(metrics_data
)
547 # verify mocked method called with correct params
548 m_publish
.assert_called_with(key
='read_metric_data_response', value
=mock
.ANY
, topic
='metric_response')
551 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
552 def test_verify_metric_supported_metric(self
, m_verify_metric_support
):
553 """ Test functionality of verify matric method"""
556 metric_info
= {'metric_unit': '%', 'metric_name': 'CPU_UTILIZATION', 'resource_uuid': 'e14b203'}
558 # set mocked function retrun value to true
559 m_verify_metric_support
.return_value
= True
561 # call verify_metric method under test
562 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
564 # verify mocked method called with correct params
565 m_verify_metric_support
.assert_called_with(metric_info
)
567 # verify the return value
568 self
.assertEqual(ret_value
, True)
571 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
572 def test_verify_metric_unsupported_metric(self
, m_verify_metric_support
):
573 """ Test functionality of verify matric method-negative case"""
575 # mock metric_info with unsupported matrics name
576 metric_info
= {'metric_unit': '%', 'metric_name': 'Invalid', 'resource_uuid': 'e14b203'}
578 # set mocked function retrun value to true
579 m_verify_metric_support
.return_value
= False
581 # call verify_metric method under test
582 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
584 # verify mocked method called with correct params
585 m_verify_metric_support
.assert_called_with(metric_info
)
587 # verify the return value
588 self
.assertEqual(ret_value
, False)
591 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
592 def test_publish_create_metric_response(self
, m_publish
):
593 """ Test functionality of publish create metric response method"""
596 metric_info
= {'vim_type' : 'VMware','correlation_id': 'e14b203c',
597 'metric_create_request':{
598 'resource_uuid': '6486e69',
599 'metric_name': 'CPU_UTILIZATION',
602 'schema_type': 'create_metric_request'
607 # call publish create metric method under test
608 self
.plugin_receiver
.publish_create_metric_response(metric_info
, metric_status
)
610 # verify mocked method called with correct params
611 m_publish
.assert_called_with(key
='create_metric_response', value
=mock
.ANY
, topic
='metric_response')
614 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
615 def test_publish_update_metric_response(self
, m_publish
):
616 """ Test functionality of publish update metric response method"""
619 metric_info
= {'vim_type' : 'VMware','correlation_id': 'e14b203c',
620 'metric_create_request':{
621 'resource_uuid': '6486e69',
622 'metric_name': 'CPU_UTILIZATION',
625 'schema_type': 'update_metric_request'
630 # call publish update metric method under test
631 self
.plugin_receiver
.publish_update_metric_response(metric_info
, metric_status
)
633 # verify mocked method called with correct params
634 m_publish
.assert_called_with(key
='update_metric_response', value
=mock
.ANY
, topic
='metric_response')
637 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
638 def test_publish_delete_metric_response(self
, m_publish
):
639 """ Test functionality of publish delete metric response method"""
642 metric_info
= {'vim_type' : 'VMware','correlation_id': 'e14b203c',
643 'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69',
644 'metric_name': 'CPU_UTILIZATION',
645 'schema_type': 'delete_metric_request'}
649 # call publish delete metric method under test-vROPS doesn't support
650 # delete metric,just returns responce with success
651 self
.plugin_receiver
.publish_delete_metric_response(metric_info
)
653 # verify mocked method called with correct params
654 m_publish
.assert_called_with(key
='delete_metric_response', value
=mock
.ANY
, topic
='metric_response')
657 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_triggered_alarms_list')
658 def test_list_alarms(self
, m_get_triggered_alarms_list
):
659 """ Test functionality of list alarms method"""
661 # Mock list alarm input
662 list_alarm_input
= {'severity': 'CRITICAL',
663 'correlation_id': 'e14b203c',
664 'alarm_name': 'CPU_Utilization_Above_Threshold',
665 'resource_uuid': 'd14b203c'}
667 # set return value to mocked method
668 m_return
= m_get_triggered_alarms_list
.return_value
= [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
669 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
670 'cancel_date': '0000-00-00T00:00:00','alarm_instance_uuid': 'd9e3bc84',
671 'alarm_uuid': '5714977d', 'vim_type': 'VMware',
672 'start_date': '2018-01-12T08:34:05'},
673 {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57',
674 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
675 'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6',
676 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware',
677 'start_date': '2017-12-20T09:37:57'}]
679 # call list alarms method under test
680 return_value
= self
.plugin_receiver
.list_alarms(list_alarm_input
)
682 # verify mocked method called with correct params
683 m_get_triggered_alarms_list
.assert_called_with(list_alarm_input
)
685 # verify list alarm method returns correct list
686 self
.assertEqual(return_value
, m_return
)
689 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
690 def test_publish_list_alarm_response(self
, m_publish
):
691 """ Test functionality of publish list alarm response method"""
693 # Mock list alarm input
694 msg_key
= 'list_alarm_response'
695 topic
= 'alarm_response'
696 list_alarm_input
= {'alarm_list_request': {'severity': 'CRITICAL',
697 'correlation_id': 'e14b203c',
698 'alarm_name': 'CPU_Utilization_Above_Threshold',
699 'resource_uuid': 'd14b203c'},'vim_type' : 'VMware'}
701 triggered_alarm_list
= [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05', 'severity': 'CRITICAL',
702 'resource_uuid': 'e14b203c', 'cancel_date': '0000-00-00T00:00:00','alarm_instance_uuid': 'd9e3bc84',
703 'alarm_uuid': '5714977d', 'vim_type': 'VMware', 'start_date': '2018-01-12T08:34:05'}]
705 # call publish list alarm response method under test
706 self
.plugin_receiver
.publish_list_alarm_response(triggered_alarm_list
, list_alarm_input
)
708 # verify mocked method called with correct params
709 m_publish
.assert_called_with(key
=msg_key
,value
=mock
.ANY
, topic
=topic
)
712 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
713 def test_publish_access_update_response(self
, m_publish
):
714 """ Test functionality of publish access update response method"""
716 # Mock required inputs
717 access_update_status
= True
718 msg_key
= 'vim_access_credentials_response'
719 topic
= 'access_credentials'
720 access_info_req
= {'access_config': {'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.105',
721 'vrops_user': 'Admin', 'correlation_id': 'e14b203c', 'tenant_id': 'Org2'}, 'vim_type': u
'VMware'}
723 # call publish access update response method under test
724 self
.plugin_receiver
.publish_access_update_response(access_update_status
, access_info_req
)
726 # verify mocked method called with correct params
727 m_publish
.assert_called_with(key
=msg_key
,value
=mock
.ANY
, topic
=topic
)
730 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
731 def test_update_access_credentials_successful(self
, m_write_access_config
):
732 """ Test functionality of update access credentials-positive case"""
735 access_info
= {'vrops_site':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware',
736 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware',
737 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin','vcenter_password':'vmware',
738 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
741 expected_status
= m_write_access_config
.return_value
= True
743 # call publish update acccess credentials method under test
744 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
746 # check write_access_config called with correct params
747 m_write_access_config
.assert_called_with(access_info
)
749 # verify update access credentials returns correct status
750 self
.assertEqual(expected_status
, actual_status
)
753 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
754 def test_update_access_credentials_less_config_params(self
, m_write_access_config
):
755 """ Test functionality of update access credentials-negative case"""
758 access_info
= {'vrops_site':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware',
759 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware',
760 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin',
761 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
764 expected_status
= m_write_access_config
.return_value
= False
766 # call publish update acccess credentials method under test
767 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
769 # check if mocked method not called
770 m_write_access_config
.assert_not_called()
772 # verify update access credentials returns correct status
773 self
.assertEqual(expected_status
, actual_status
)
776 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'write_access_config')
777 def test_update_access_credentials_failed(self
, m_write_access_config
):
778 """ Test functionality of update access credentials-failed case """
781 access_info
= {'vrops_site':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware',
782 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware',
783 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin','vcenter_password':'vmware',
784 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
787 expected_status
= m_write_access_config
.return_value
= False
789 # call publish update acccess credentials method under test
790 actual_status
= self
.plugin_receiver
.update_access_credentials(access_info
)
792 # check write_access_config called with correct params
793 m_write_access_config
.assert_called_with(access_info
)
795 # verify update access credentials returns correct status
796 self
.assertEqual(expected_status
, actual_status
)
799 def test_write_access_config_successful(self
):
800 """ Test functionality of write access config method-positive case"""
803 access_info
= {'vrops_sit':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware',
804 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware',
805 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin','vcenter_password':'vmware',
806 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'}
808 # call write acccess config method under test
809 actual_status
= self
.plugin_receiver
.write_access_config(access_info
)
811 # verify write access config returns correct status
812 self
.assertEqual(True, actual_status
)
815 def test_write_access_config_failed(self
):
816 """ Test functionality of write access config method-negative case"""
819 access_info
= [] # provided incorrect info to generate error
821 # call write acccess config method under test
822 actual_status
= self
.plugin_receiver
.write_access_config(access_info
)
824 # verify write access config returns correct status
825 self
.assertEqual(False, actual_status
)
828 # For testing purpose
829 #if __name__ == '__main__':