osm_mon/test/VMware/test_plugin_receiver.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2017-2018 VMware Inc.
   5 # This file is part of ETSI OSM
   6 # All Rights Reserved.
   7 #
   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
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  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
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact:  osslegalrouting@vmware.com
  22 ##
  23
  24 """ Mock tests for VMware vROPs plugin recevier """
  25
  26 import sys
  27 sys.path.append("/root/MON/")
  28
  29 import json
  30
  31 import logging
  32
  33 import unittest
  34
  35 import mock
  36
  37 import requests
  38
  39 from osm_mon.plugins.vRealiseOps import plugin_receiver as monPluginRec
  40
  41 log = logging.getLogger(__name__)
  42
  43
  44 class Message(object):
  45     """A class to mock a message object value for alarm and matric requests"""
  46
  47     def __init__(self):
  48         """Initialize a mocked message instance"""
  49         self.topic = "alarm_or_metric_request"
  50         self.key = None
  51         self.value = json.dumps({"mock_value": "mock_details"})
  52         self.partition = 1
  53         self.offset = 100
  54
  55
  56 class TestPluginReceiver(unittest.TestCase):
  57     """Test class for Plugin Receiver class methods"""
  58
  59     def setUp(self):
  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()
  64
  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"""
  69
  70         # Mock a message
  71         msg = Message()
  72         msg.topic = "alarm_request"
  73         msg.key = "create_alarm_request"
  74
  75         msg.value = json.dumps({"alarm_create_request":"alarm_details"})
  76         m_create_alarm.return_value = "test_alarm_id"
  77
  78         config_alarm_info = json.loads(msg.value)
  79
  80         # Call the consume method of plugin_receiver
  81         self.plugin_receiver.consume(msg)
  82
  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)
  86
  87
  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"""
  92
  93         # Mock a message
  94         msg = Message()
  95         msg.topic = "alarm_request"
  96         msg.key = "update_alarm_request"
  97
  98         msg.value = json.dumps({"alarm_update_request":"alarm_details"})
  99
 100         # set return value to mocked method
 101         m_update_alarm.return_value = "test_alarm_id"
 102
 103         update_alarm_info = json.loads(msg.value)
 104
 105         # Call the consume method of plugin_receiver
 106         self.plugin_receiver.consume(msg)
 107
 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)
 111
 112
 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"""
 117
 118         # Mock a message
 119         msg = Message()
 120         msg.topic = "alarm_request"
 121         msg.key = "delete_alarm_request"
 122
 123         msg.value = json.dumps({"alarm_delete_request":"alarm_details"})
 124         m_delete_alarm.return_value = "test_alarm_id"
 125
 126         delete_alarm_info = json.loads(msg.value)
 127
 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")
 131
 132         # Check if publish method called with correct parameters
 133         m_publish_delete_alarm_status.assert_called_with("test_alarm_id", delete_alarm_info)
 134
 135
 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"""
 140
 141         # Mock a message
 142         msg = Message()
 143         msg.topic = "alarm_request"
 144         msg.key = "list_alarm_request"
 145         test_alarm_list = [{"alarm_uuid":"alarm1_details"},{"alarm_uuid":"alarm2_details"}]
 146
 147         msg.value = json.dumps({"alarm_list_request":"alarm_details"})
 148         m_list_alarms.return_value = test_alarm_list
 149
 150         list_alarms_info = json.loads(msg.value)
 151
 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")
 155
 156         # Check if publish method called with correct parameters
 157         m_publish_list_alarm_response.assert_called_with(test_alarm_list, list_alarms_info)
 158
 159
 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"""
 164
 165         # Mock a message
 166         msg = Message()
 167         msg.topic = "access_credentials"
 168         msg.key = "vim_access_credentials"
 169
 170         msg.value = json.dumps({"access_config":"access_details"})
 171         # set return value to mocked method
 172         m_update_access_credentials.return_value = True
 173
 174         access_info = json.loads(msg.value)
 175
 176         # Call the consume method of plugin_receiver
 177         self.plugin_receiver.consume(msg)
 178
 179         # check if mocked method called with required parameters
 180         m_update_access_credentials.assert_called_with("access_details")
 181
 182         # Check if publish method called with correct parameters
 183         m_publish_access_update_response.assert_called_with(True, access_info)
 184
 185
 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"""
 190
 191         # Mock a message with invalid alarm request key
 192         msg = Message()
 193         msg.topic = "alarm_request"
 194         msg.key = "invalid_alarm_request" # invalid key
 195
 196         # Call the consume method of plugin_receiver
 197         self.plugin_receiver.consume(msg)
 198
 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()
 202
 203
 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"""
 208
 209         # Mock a message with invalid metric request key
 210         msg = Message()
 211         msg.topic = "metric_request"
 212         msg.key = "invalid_metric_data_request" #invalid key
 213
 214         # Call the consume method of plugin_receiver
 215         self.plugin_receiver.consume(msg)
 216
 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()
 220
 221
 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"""
 226
 227         # Mock a message
 228         msg = Message()
 229         msg.topic = "metric_request"
 230         msg.key = "read_metric_data_request"
 231
 232         msg.value = json.dumps({"metric_name":"metric_details"})
 233         m_get_metrics_data.return_value = {"metrics_data":"metrics_details"}
 234
 235         metric_request_info = json.loads(msg.value)
 236
 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)
 240
 241         # Check if publish method called with correct parameters
 242         m_publish_metric_data_status.assert_called_with({"metrics_data":"metrics_details"})
 243
 244
 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"""
 249
 250         # Mock a message
 251         msg = Message()
 252         msg.topic = "metric_request"
 253         msg.key = "create_metric_request"
 254
 255         msg.value = json.dumps({"metric_create":"metric_details"})
 256
 257         # set the return value
 258         m_verify_metric.return_value = True
 259
 260         metric_info = json.loads(msg.value)
 261
 262         # Call the consume method of plugin_receiver
 263         self.plugin_receiver.consume(msg)
 264         m_verify_metric.assert_called_with("metric_details")
 265
 266         # Check if publish method called with correct parameters
 267         m_publish_create_metric_response.assert_called_with(metric_info, True)
 268
 269
 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"""
 274         # Mock a message
 275         msg = Message()
 276         msg.topic = "metric_request"
 277         msg.key = "update_metric_request"
 278
 279         msg.value = json.dumps({"metric_create":"metric_details"})
 280
 281         # set the return value
 282         m_verify_metric.return_value = True
 283
 284         metric_info = json.loads(msg.value)
 285
 286         # Call the consume method of plugin_receiver
 287         self.plugin_receiver.consume(msg)
 288
 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)
 292
 293
 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"""
 297
 298         # Note: vROPS doesn't support deleting metric data
 299         # Mock a message
 300         msg = Message()
 301         msg.topic = "metric_request"
 302         msg.key = "delete_metric_request"
 303
 304         msg.value = json.dumps({"metric_name":"metric_details"})
 305
 306         metric_info = json.loads(msg.value)
 307
 308         # Call the consume method of plugin_receiver
 309         self.plugin_receiver.consume(msg)
 310
 311         # Check if publish method called with correct parameters
 312         m_publish_delete_metric_response.assert_called_with(metric_info)
 313
 314
 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"""
 319
 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",
 328                              "operation": "GT",
 329                              "threshold_value": 10,
 330                              "unit": "%",
 331                              "statistic": "AVERAGE"}
 332
 333         # set return value to plugin uuid
 334         m_configure_rest_plugin.retrun_value = "plugin_uuid"
 335         m_configure_alarm.return_value = "alarm_uuid"
 336
 337         # call create alarm method under test
 338         self.plugin_receiver.create_alarm(config_alarm_info)
 339
 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)
 343
 344
 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"""
 349
 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",
 358                              "operation": "GT",
 359                              "threshold_value": 10,
 360                              "unit": "%",
 361                              "statistic": "AVERAGE"}
 362
 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
 366
 367         # call create alarm method under test
 368         alarm_uuid = self.plugin_receiver.create_alarm(config_alarm_info)
 369
 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)
 373
 374         # verify create alarm method returns None when failed
 375         self.assertEqual(alarm_uuid, None)
 376
 377
 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"""
 381
 382         # Mock update_alarm_info
 383         update_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 384
 385         # set return value to mocked method
 386         m_update_alarm_configuration.return_value = "alarm_uuid"
 387
 388         # check update alarm gets called and returned correct value
 389         ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
 390
 391         # check mocked method get called with correct param
 392         m_update_alarm_configuration.assert_called_with(update_alarm_info)
 393
 394         # check return value and passed values are correct
 395         self.assertEqual(ret_value, "alarm_uuid")
 396
 397
 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"""
 401
 402         # Mock update_alarm_info
 403         update_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 404
 405         # set return value to mocked method
 406         m_update_alarm_configuration.return_value = None
 407
 408         # check update alarm gets called and returned correct value
 409         ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
 410
 411         # check mocked method get called with correct param
 412         m_update_alarm_configuration.assert_called_with(update_alarm_info)
 413
 414         # check return value and passed values are correct
 415         self.assertEqual(ret_value, None)
 416
 417
 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"""
 421
 422         # Mock delete_alarm_info
 423         delete_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 424
 425         # set return value to mocked method
 426         m_delete_alarm_configuration.return_value = "alarm_uuid"
 427
 428         # check delete alarm gets called and returned correct value
 429         ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
 430
 431         # check mocked method get called with correct param
 432         m_delete_alarm_configuration.assert_called_with(delete_alarm_info)
 433
 434         # check return value and passed values are correct
 435         self.assertEqual(ret_value, "alarm_uuid")
 436
 437
 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"""
 441
 442         # Mock update_alarm_info
 443         delete_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 444
 445         # set return value to mocked method
 446         m_delete_alarm_configuration.return_value = None
 447
 448         # check delete alarm gets called and returned correct value
 449         ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
 450
 451         # check mocked method get called with correct param
 452         m_delete_alarm_configuration.assert_called_with(delete_alarm_info)
 453
 454         # check return value to check failed status
 455         self.assertEqual(ret_value, None)
 456
 457
 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"""
 461
 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'}
 471                             }
 472
 473         alarm_uuid = "xyz"
 474
 475         # call publish create status method under test
 476         self.plugin_receiver.publish_create_alarm_status(alarm_uuid, config_alarm_info)
 477
 478         # verify mocked method called with correct params
 479         m_publish.assert_called_with(key='create_alarm_response', value=mock.ANY, topic='alarm_response')
 480
 481
 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"""
 485
 486         # Mock update_alarm_info
 487         update_alarm_info = {'vim_type' : 'VMware',
 488                              'alarm_update_request':{'alarm_uuid': '6486e69',
 489                                                      'correlation_id': 14203,
 490                                                      'operation': 'GT'
 491                                                      },
 492                              'schema_type': 'update_alarm_request'
 493                             }
 494
 495         alarm_uuid = "xyz"
 496
 497         # call publish update alarm status method under test
 498         self.plugin_receiver.publish_update_alarm_status(alarm_uuid, update_alarm_info)
 499
 500         # verify mocked method called with correct params
 501         m_publish.assert_called_with(key='update_alarm_response', value=mock.ANY, topic='alarm_response')
 502
 503
 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"""
 507
 508         # Mock delete_alarm_info
 509         delete_alarm_info = {'vim_type' : 'VMware',
 510                              'alarm_delete_request':{'alarm_uuid': '6486e69',
 511                                                      'correlation_id': 14203,
 512                                                      'operation': 'GT'
 513                                                      },
 514                              'schema_type': 'delete_alarm_request'
 515                             }
 516
 517         alarm_uuid = "xyz"
 518
 519         # call publish delete alarm status method under test
 520         self.plugin_receiver.publish_delete_alarm_status(alarm_uuid, delete_alarm_info)
 521
 522         # verify mocked method called with correct params
 523         m_publish.assert_called_with(key='delete_alarm_response', value=mock.ANY, topic='alarm_response')
 524
 525
 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"""
 529
 530         # Mock metrics data
 531         metrics_data = {
 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': '%'
 537                        }
 538
 539         # call publish metrics data status method under test
 540         self.plugin_receiver.publish_metrics_data_status(metrics_data)
 541
 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')
 544
 545
 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"""
 549
 550         # mock metric_info
 551         metric_info = {'metric_unit': '%', 'metric_name': 'CPU_UTILIZATION', 'resource_uuid': 'e14b203'}
 552
 553         # set mocked function retrun value to true
 554         m_verify_metric_support.return_value = True
 555
 556         # call verify_metric method under test
 557         ret_value = self.plugin_receiver.verify_metric(metric_info)
 558
 559         # verify mocked method called with correct params
 560         m_verify_metric_support.assert_called_with(metric_info)
 561
 562         # verify the return value
 563         self.assertEqual(ret_value, True)
 564
 565
 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"""
 569
 570         # mock metric_info with unsupported matrics name
 571         metric_info = {'metric_unit': '%', 'metric_name': 'Invalid', 'resource_uuid': 'e14b203'}
 572
 573         # set mocked function retrun value to true
 574         m_verify_metric_support.return_value = False
 575
 576         # call verify_metric method under test
 577         ret_value = self.plugin_receiver.verify_metric(metric_info)
 578
 579         # verify mocked method called with correct params
 580         m_verify_metric_support.assert_called_with(metric_info)
 581
 582         # verify the return value
 583         self.assertEqual(ret_value, False)
 584
 585
 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"""
 589
 590         # Mock metric_info
 591         metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c',
 592                        'metric_create':{
 593                                         'resource_uuid': '6486e69',
 594                                         'metric_name': 'CPU_UTILIZATION',
 595                                         'metric_unit': '%'
 596                                         },
 597                         'schema_type': 'create_metric_request'
 598                        }
 599
 600         metric_status = True
 601
 602         # call publish create metric method under test
 603         self.plugin_receiver.publish_create_metric_response(metric_info, metric_status)
 604
 605         # verify mocked method called with correct params
 606         m_publish.assert_called_with(key='create_metric_response', value=mock.ANY, topic='metric_response')
 607
 608
 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"""
 612
 613         # Mock metric_info
 614         metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c',
 615                        'metric_create':{
 616                                         'resource_uuid': '6486e69',
 617                                         'metric_name': 'CPU_UTILIZATION',
 618                                         'metric_unit': '%'
 619                                         },
 620                         'schema_type': 'update_metric_request'
 621                        }
 622
 623         metric_status = True
 624
 625         # call publish update metric method under test
 626         self.plugin_receiver.publish_update_metric_response(metric_info, metric_status)
 627
 628         # verify mocked method called with correct params
 629         m_publish.assert_called_with(key='update_metric_response', value=mock.ANY, topic='metric_response')
 630
 631
 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"""
 635
 636         # Mock metric_info
 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'}
 641
 642         metric_status = True
 643
 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)
 647
 648         # verify mocked method called with correct params
 649         m_publish.assert_called_with(key='delete_metric_response', value=mock.ANY, topic='metric_response')
 650
 651
 652 # For testing purpose
 653 #if __name__ == '__main__':
 654
 655 #    unittest.main()