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/")
39 from osm_mon
.plugins
.vRealiseOps
import plugin_receiver
as monPluginRec
41 log
= logging
.getLogger(__name__
)
44 class Message(object):
45 """A class to mock a message object value for alarm and matric requests"""
48 """Initialize a mocked message instance"""
49 self
.topic
= "alarm_or_metric_request"
51 self
.value
= json
.dumps({"mock_value": "mock_details"})
56 class TestPluginReceiver(unittest
.TestCase
):
57 """Test class for Plugin Receiver class methods"""
60 """Setup the tests for plugin_receiver class methods"""
61 super(TestPluginReceiver
, self
).setUp()
62 self
.plugin_receiver
= monPluginRec
.PluginReceiver()
63 #self.mon_plugin = monPlugin.MonPlugin()
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"""
72 msg
.topic
= "alarm_request"
73 msg
.key
= "create_alarm_request"
75 msg
.value
= json
.dumps({"alarm_create_request":"alarm_details"})
76 m_create_alarm
.return_value
= "test_alarm_id"
78 config_alarm_info
= json
.loads(msg
.value
)
80 # Call the consume method of plugin_receiver
81 self
.plugin_receiver
.consume(msg
)
83 # verify if create_alarm and publish methods called with correct params
84 m_create_alarm
.assert_called_with("alarm_details")
85 m_publish_create_alarm_status
.assert_called_with("test_alarm_id", config_alarm_info
)
88 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_alarm_status')
89 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_alarm')
90 def test_consume_update_alarm_request_key(self
, m_update_alarm
, m_publish_update_alarm_status
):
91 """Test functionality of consume for update_alarm_request key"""
95 msg
.topic
= "alarm_request"
96 msg
.key
= "update_alarm_request"
98 msg
.value
= json
.dumps({"alarm_update_request":"alarm_details"})
100 # set return value to mocked method
101 m_update_alarm
.return_value
= "test_alarm_id"
103 update_alarm_info
= json
.loads(msg
.value
)
105 # Call the consume method of plugin_receiver
106 self
.plugin_receiver
.consume(msg
)
108 # verify update_alarm and publish method called with correct params
109 m_update_alarm
.assert_called_with("alarm_details")
110 m_publish_update_alarm_status
.assert_called_with("test_alarm_id", update_alarm_info
)
113 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_alarm_status')
114 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'delete_alarm')
115 def test_consume_delete_alarm_request_key(self
, m_delete_alarm
, m_publish_delete_alarm_status
):
116 """Test functionality of consume for delete_alarm_request key"""
120 msg
.topic
= "alarm_request"
121 msg
.key
= "delete_alarm_request"
123 msg
.value
= json
.dumps({"alarm_delete_request":"alarm_details"})
124 m_delete_alarm
.return_value
= "test_alarm_id"
126 delete_alarm_info
= json
.loads(msg
.value
)
128 # Call the consume method of plugin_receiver and check delete_alarm request
129 self
.plugin_receiver
.consume(msg
)
130 m_delete_alarm
.assert_called_with("alarm_details")
132 # Check if publish method called with correct parameters
133 m_publish_delete_alarm_status
.assert_called_with("test_alarm_id", delete_alarm_info
)
136 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_list_alarm_response')
137 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'list_alarms')
138 def test_consume_list_alarm_request_key(self
, m_list_alarms
, m_publish_list_alarm_response
):
139 """ Test functionality of list alarm request key"""
143 msg
.topic
= "alarm_request"
144 msg
.key
= "list_alarm_request"
145 test_alarm_list
= [{"alarm_uuid":"alarm1_details"},{"alarm_uuid":"alarm2_details"}]
147 msg
.value
= json
.dumps({"alarm_list_request":"alarm_details"})
148 m_list_alarms
.return_value
= test_alarm_list
150 list_alarms_info
= json
.loads(msg
.value
)
152 # Call the consume method of plugin_receiver and check delete_alarm request
153 self
.plugin_receiver
.consume(msg
)
154 m_list_alarms
.assert_called_with("alarm_details")
156 # Check if publish method called with correct parameters
157 m_publish_list_alarm_response
.assert_called_with(test_alarm_list
, list_alarms_info
)
160 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_access_update_response')
161 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'update_access_credentials')
162 def test_consume_vim_access_request_key(self
, m_update_access_credentials
, m_publish_access_update_response
):
163 """Test functionality of consume for vim_access_credentials request key"""
167 msg
.topic
= "access_credentials"
168 msg
.key
= "vim_access_credentials"
170 msg
.value
= json
.dumps({"access_config":"access_details"})
171 # set return value to mocked method
172 m_update_access_credentials
.return_value
= True
174 access_info
= json
.loads(msg
.value
)
176 # Call the consume method of plugin_receiver
177 self
.plugin_receiver
.consume(msg
)
179 # check if mocked method called with required parameters
180 m_update_access_credentials
.assert_called_with("access_details")
182 # Check if publish method called with correct parameters
183 m_publish_access_update_response
.assert_called_with(True, access_info
)
186 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_alarm_status')
187 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'create_alarm')
188 def test_consume_invalid_alarm_request_key(self
, m_create_alarm
, m_publish_create_alarm_status
):
189 """Test functionality of consume for vim_access_credentials invalid request key"""
191 # Mock a message with invalid alarm request key
193 msg
.topic
= "alarm_request"
194 msg
.key
= "invalid_alarm_request" # invalid key
196 # Call the consume method of plugin_receiver
197 self
.plugin_receiver
.consume(msg
)
199 # verify that create_alarm and publish_create_alarm_status methods not called
200 m_create_alarm
.assert_not_called()
201 m_publish_create_alarm_status
.assert_not_called()
204 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
205 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
206 def test_consume_invalid_metric_request_key(self
, m_get_metrics_data
, m_publish_metric_data_status
):
207 """Test functionality of invalid metric key request"""
209 # Mock a message with invalid metric request key
211 msg
.topic
= "metric_request"
212 msg
.key
= "invalid_metric_data_request" #invalid key
214 # Call the consume method of plugin_receiver
215 self
.plugin_receiver
.consume(msg
)
217 # verify that get martics data and publish methods not called
218 m_get_metrics_data
.assert_not_called()
219 m_publish_metric_data_status
.assert_not_called()
222 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_metrics_data_status')
223 @mock.patch
.object(monPluginRec
.MonPlugin
, 'get_metrics_data')
224 def test_consume_read_metric_data_request_key(self
, m_get_metrics_data
, m_publish_metric_data_status
):
225 """Test functionality of consume for read_metric_data_request key"""
229 msg
.topic
= "metric_request"
230 msg
.key
= "read_metric_data_request"
232 msg
.value
= json
.dumps({"metric_name":"metric_details"})
233 m_get_metrics_data
.return_value
= {"metrics_data":"metrics_details"}
235 metric_request_info
= json
.loads(msg
.value
)
237 # Call the consume method of plugin_receiver
238 self
.plugin_receiver
.consume(msg
)
239 m_get_metrics_data
.assert_called_with(metric_request_info
)
241 # Check if publish method called with correct parameters
242 m_publish_metric_data_status
.assert_called_with({"metrics_data":"metrics_details"})
245 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_create_metric_response')
246 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
247 def test_consume_create_metric_request_key(self
, m_verify_metric
, m_publish_create_metric_response
):
248 """Test functionality of consume for create_metric_request key"""
252 msg
.topic
= "metric_request"
253 msg
.key
= "create_metric_request"
255 msg
.value
= json
.dumps({"metric_create":"metric_details"})
257 # set the return value
258 m_verify_metric
.return_value
= True
260 metric_info
= json
.loads(msg
.value
)
262 # Call the consume method of plugin_receiver
263 self
.plugin_receiver
.consume(msg
)
264 m_verify_metric
.assert_called_with("metric_details")
266 # Check if publish method called with correct parameters
267 m_publish_create_metric_response
.assert_called_with(metric_info
, True)
270 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_update_metric_response')
271 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'verify_metric')
272 def test_consume_update_metric_request_key(self
, m_verify_metric
, m_publish_update_metric_response
):
273 """Test functionality of update metric request key"""
276 msg
.topic
= "metric_request"
277 msg
.key
= "update_metric_request"
279 msg
.value
= json
.dumps({"metric_create":"metric_details"})
281 # set the return value
282 m_verify_metric
.return_value
= True
284 metric_info
= json
.loads(msg
.value
)
286 # Call the consume method of plugin_receiver
287 self
.plugin_receiver
.consume(msg
)
289 # verify mocked methods called with correct parameters
290 m_verify_metric
.assert_called_with("metric_details")
291 m_publish_update_metric_response
.assert_called_with(metric_info
, True)
294 @mock.patch
.object(monPluginRec
.PluginReceiver
, 'publish_delete_metric_response')
295 def test_consume_delete_metric_request_key(self
, m_publish_delete_metric_response
):
296 """Test functionality of consume for delete_metric_request key"""
298 # Note: vROPS doesn't support deleting metric data
301 msg
.topic
= "metric_request"
302 msg
.key
= "delete_metric_request"
304 msg
.value
= json
.dumps({"metric_name":"metric_details"})
306 metric_info
= json
.loads(msg
.value
)
308 # Call the consume method of plugin_receiver
309 self
.plugin_receiver
.consume(msg
)
311 # Check if publish method called with correct parameters
312 m_publish_delete_metric_response
.assert_called_with(metric_info
)
315 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
316 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
317 def test_create_alarm_successful(self
, m_configure_rest_plugin
, m_configure_alarm
):
318 """ Test functionality of create alarm method-positive case"""
320 # Mock config_alarm_info
321 config_alarm_info
= {"correlation_id": 1,
322 "alarm_name": "CPU_Utilize_Threshold",
323 "metric_name": "CPU_UTILIZATION",
324 "tenant_uuid": "tenant_uuid",
325 "resource_uuid": "resource_uuid",
326 "description": "test_create_alarm",
327 "severity": "CRITICAL",
329 "threshold_value": 10,
331 "statistic": "AVERAGE"}
333 # set return value to plugin uuid
334 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
335 m_configure_alarm
.return_value
= "alarm_uuid"
337 # call create alarm method under test
338 self
.plugin_receiver
.create_alarm(config_alarm_info
)
340 # verify mocked methods get called with correct params
341 m_configure_rest_plugin
.assert_called_with()
342 m_configure_alarm
.assert_called_with(config_alarm_info
)
345 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_alarm')
346 @mock.patch
.object(monPluginRec
.MonPlugin
, 'configure_rest_plugin')
347 def test_create_alarm_failed(self
, m_configure_rest_plugin
, m_configure_alarm
):
348 """ Test functionality of create alarm method negative case"""
350 # Mock config_alarm_info
351 config_alarm_info
= {"correlation_id": 1,
352 "alarm_name": "CPU_Utilize_Threshold",
353 "metric_name": "CPU_UTILIZATION",
354 "tenant_uuid": "tenant_uuid",
355 "resource_uuid": "resource_uuid",
356 "description": "test_create_alarm",
357 "severity": "CRITICAL",
359 "threshold_value": 10,
361 "statistic": "AVERAGE"}
363 # set return value to plugin uuid and alarm_uuid to None
364 m_configure_rest_plugin
.retrun_value
= "plugin_uuid"
365 m_configure_alarm
.return_value
= None
367 # call create alarm method under test
368 alarm_uuid
= self
.plugin_receiver
.create_alarm(config_alarm_info
)
370 # verify mocked method called with correct params
371 m_configure_rest_plugin
.assert_called_with()
372 m_configure_alarm
.assert_called_with(config_alarm_info
)
374 # verify create alarm method returns None when failed
375 self
.assertEqual(alarm_uuid
, None)
378 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
379 def test_update_alarm_successful(self
, m_update_alarm_configuration
):
380 """ Test functionality of update alarm method-positive case"""
382 # Mock update_alarm_info
383 update_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
385 # set return value to mocked method
386 m_update_alarm_configuration
.return_value
= "alarm_uuid"
388 # check update alarm gets called and returned correct value
389 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
391 # check mocked method get called with correct param
392 m_update_alarm_configuration
.assert_called_with(update_alarm_info
)
394 # check return value and passed values are correct
395 self
.assertEqual(ret_value
, "alarm_uuid")
398 @mock.patch
.object(monPluginRec
.MonPlugin
, 'update_alarm_configuration')
399 def test_update_alarm_failed(self
, m_update_alarm_configuration
):
400 """ Test functionality of update alarm method negative case"""
402 # Mock update_alarm_info
403 update_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
405 # set return value to mocked method
406 m_update_alarm_configuration
.return_value
= None
408 # check update alarm gets called and returned correct value
409 ret_value
= self
.plugin_receiver
.update_alarm(update_alarm_info
)
411 # check mocked method get called with correct param
412 m_update_alarm_configuration
.assert_called_with(update_alarm_info
)
414 # check return value and passed values are correct
415 self
.assertEqual(ret_value
, None)
418 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
419 def test_delete_alarm_successful(self
, m_delete_alarm_configuration
):
420 """ Test functionality of delete alarm method-positive case"""
422 # Mock delete_alarm_info
423 delete_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
425 # set return value to mocked method
426 m_delete_alarm_configuration
.return_value
= "alarm_uuid"
428 # check delete alarm gets called and returned correct value
429 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
431 # check mocked method get called with correct param
432 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
)
434 # check return value and passed values are correct
435 self
.assertEqual(ret_value
, "alarm_uuid")
438 @mock.patch
.object(monPluginRec
.MonPlugin
, 'delete_alarm_configuration')
439 def test_delete_alarm_failed(self
, m_delete_alarm_configuration
):
440 """ Test functionality of delete alarm method-negative case"""
442 # Mock update_alarm_info
443 delete_alarm_info
= {'alarm_uuid': 'abc', 'correlation_id': 14203}
445 # set return value to mocked method
446 m_delete_alarm_configuration
.return_value
= None
448 # check delete alarm gets called and returned correct value
449 ret_value
= self
.plugin_receiver
.delete_alarm(delete_alarm_info
)
451 # check mocked method get called with correct param
452 m_delete_alarm_configuration
.assert_called_with(delete_alarm_info
)
454 # check return value to check failed status
455 self
.assertEqual(ret_value
, None)
458 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
459 def test_publish_create_alarm_status(self
, m_publish
):
460 """ Test functionality of publish create alarm status method"""
462 # Mock config_alarm_info
463 config_alarm_info
= {'vim_type': 'VMware',
464 'alarm_create_request': {'threshold_value': 0,
465 'severity': 'CRITICAL',
466 'alarm_name': 'CPU_Utilization_Above_Threshold',
467 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
468 'correlation_id': 1234,
469 'statistic': 'AVERAGE',
470 'metric_name': 'CPU_UTILIZATION'}
475 # call publish create status method under test
476 self
.plugin_receiver
.publish_create_alarm_status(alarm_uuid
, config_alarm_info
)
478 # verify mocked method called with correct params
479 m_publish
.assert_called_with(key
='create_alarm_response', value
=mock
.ANY
, topic
='alarm_response')
482 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
483 def test_publish_update_alarm_status(self
, m_publish
):
484 """ Test functionality of publish update alarm status method"""
486 # Mock update_alarm_info
487 update_alarm_info
= {'vim_type' : 'VMware',
488 'alarm_update_request':{'alarm_uuid': '6486e69',
489 'correlation_id': 14203,
492 'schema_type': 'update_alarm_request'
497 # call publish update alarm status method under test
498 self
.plugin_receiver
.publish_update_alarm_status(alarm_uuid
, update_alarm_info
)
500 # verify mocked method called with correct params
501 m_publish
.assert_called_with(key
='update_alarm_response', value
=mock
.ANY
, topic
='alarm_response')
504 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
505 def test_publish_delete_alarm_status(self
, m_publish
):
506 """ Test functionality of publish delete alarm status method"""
508 # Mock delete_alarm_info
509 delete_alarm_info
= {'vim_type' : 'VMware',
510 'alarm_delete_request':{'alarm_uuid': '6486e69',
511 'correlation_id': 14203,
514 'schema_type': 'delete_alarm_request'
519 # call publish delete alarm status method under test
520 self
.plugin_receiver
.publish_delete_alarm_status(alarm_uuid
, delete_alarm_info
)
522 # verify mocked method called with correct params
523 m_publish
.assert_called_with(key
='delete_alarm_response', value
=mock
.ANY
, topic
='alarm_response')
526 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
527 def test_publish_metrics_data_status(self
, m_publish
):
528 """ Test functionality of publish metrics data status method"""
532 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
533 'resource_uuid': 'e14b20', 'correlation_id': 'e14b2',
534 'metrics_data': {'time_series': [15162011, 15162044],
535 'metrics_series': [0.1166666671, 0.1266666650]},
536 'tenant_uuid': 123, 'unit': '%'
539 # call publish metrics data status method under test
540 self
.plugin_receiver
.publish_metrics_data_status(metrics_data
)
542 # verify mocked method called with correct params
543 m_publish
.assert_called_with(key
='read_metric_data_response', value
=mock
.ANY
, topic
='metric_response')
546 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
547 def test_verify_metric_supported_metric(self
, m_verify_metric_support
):
548 """ Test functionality of verify matric method"""
551 metric_info
= {'metric_unit': '%', 'metric_name': 'CPU_UTILIZATION', 'resource_uuid': 'e14b203'}
553 # set mocked function retrun value to true
554 m_verify_metric_support
.return_value
= True
556 # call verify_metric method under test
557 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
559 # verify mocked method called with correct params
560 m_verify_metric_support
.assert_called_with(metric_info
)
562 # verify the return value
563 self
.assertEqual(ret_value
, True)
566 @mock.patch
.object(monPluginRec
.MonPlugin
, 'verify_metric_support')
567 def test_verify_metric_unsupported_metric(self
, m_verify_metric_support
):
568 """ Test functionality of verify matric method-negative case"""
570 # mock metric_info with unsupported matrics name
571 metric_info
= {'metric_unit': '%', 'metric_name': 'Invalid', 'resource_uuid': 'e14b203'}
573 # set mocked function retrun value to true
574 m_verify_metric_support
.return_value
= False
576 # call verify_metric method under test
577 ret_value
= self
.plugin_receiver
.verify_metric(metric_info
)
579 # verify mocked method called with correct params
580 m_verify_metric_support
.assert_called_with(metric_info
)
582 # verify the return value
583 self
.assertEqual(ret_value
, False)
586 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
587 def test_publish_create_metric_response(self
, m_publish
):
588 """ Test functionality of publish create metric response method"""
591 metric_info
= {'vim_type' : 'VMware','correlation_id': 'e14b203c',
593 'resource_uuid': '6486e69',
594 'metric_name': 'CPU_UTILIZATION',
597 'schema_type': 'create_metric_request'
602 # call publish create metric method under test
603 self
.plugin_receiver
.publish_create_metric_response(metric_info
, metric_status
)
605 # verify mocked method called with correct params
606 m_publish
.assert_called_with(key
='create_metric_response', value
=mock
.ANY
, topic
='metric_response')
609 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
610 def test_publish_update_metric_response(self
, m_publish
):
611 """ Test functionality of publish update metric response method"""
614 metric_info
= {'vim_type' : 'VMware','correlation_id': 'e14b203c',
616 'resource_uuid': '6486e69',
617 'metric_name': 'CPU_UTILIZATION',
620 'schema_type': 'update_metric_request'
625 # call publish update metric method under test
626 self
.plugin_receiver
.publish_update_metric_response(metric_info
, metric_status
)
628 # verify mocked method called with correct params
629 m_publish
.assert_called_with(key
='update_metric_response', value
=mock
.ANY
, topic
='metric_response')
632 @mock.patch
.object(monPluginRec
.KafkaProducer
, 'publish')
633 def test_publish_delete_metric_response(self
, m_publish
):
634 """ Test functionality of publish delete metric response method"""
637 metric_info
= {'vim_type' : 'VMware','correlation_id': 'e14b203c',
638 'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69',
639 'metric_name': 'CPU_UTILIZATION',
640 'schema_type': 'delete_metric_request'}
644 # call publish delete metric method under test-vROPS doesn't support
645 # delete metric,just returns responce with success
646 self
.plugin_receiver
.publish_delete_metric_response(metric_info
)
648 # verify mocked method called with correct params
649 m_publish
.assert_called_with(key
='delete_metric_response', value
=mock
.ANY
, topic
='metric_response')
652 # For testing purpose
653 #if __name__ == '__main__':