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 import os
  40
  41 log = logging.getLogger(__name__)
  42
  43 sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)),"..","..",".."))
  44
  45 from osm_mon.plugins.vRealiseOps import plugin_receiver as monPluginRec
  46
  47
  48 class Message(object):
  49     """A class to mock a message object value for alarm and matric requests"""
  50
  51     def __init__(self):
  52         """Initialize a mocked message instance"""
  53         self.topic = "alarm_or_metric_request"
  54         self.key = None
  55         self.value = json.dumps({"mock_value": "mock_details"})
  56         self.partition = 1
  57         self.offset = 100
  58
  59
  60 class TestPluginReceiver(unittest.TestCase):
  61     """Test class for Plugin Receiver class methods"""
  62
  63     def setUp(self):
  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()
  68
  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"""
  73
  74         # Mock a message
  75         msg = Message()
  76         msg.topic = "alarm_request"
  77         msg.key = "create_alarm_request"
  78
  79         msg.value = json.dumps({"alarm_create_request":"alarm_details"})
  80         m_create_alarm.return_value = "test_alarm_id"
  81
  82         config_alarm_info = json.loads(msg.value)
  83
  84         # Call the consume method of plugin_receiver
  85         self.plugin_receiver.consume(msg)
  86
  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)
  90
  91
  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"""
  96
  97         # Mock a message
  98         msg = Message()
  99         msg.topic = "alarm_request"
 100         msg.key = "update_alarm_request"
 101
 102         msg.value = json.dumps({"alarm_update_request":"alarm_details"})
 103
 104         # set return value to mocked method
 105         m_update_alarm.return_value = "test_alarm_id"
 106
 107         update_alarm_info = json.loads(msg.value)
 108
 109         # Call the consume method of plugin_receiver
 110         self.plugin_receiver.consume(msg)
 111
 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)
 115
 116
 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"""
 121
 122         # Mock a message
 123         msg = Message()
 124         msg.topic = "alarm_request"
 125         msg.key = "delete_alarm_request"
 126
 127         msg.value = json.dumps({"alarm_delete_request":"alarm_details"})
 128         m_delete_alarm.return_value = "test_alarm_id"
 129
 130         delete_alarm_info = json.loads(msg.value)
 131
 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")
 135
 136         # Check if publish method called with correct parameters
 137         m_publish_delete_alarm_status.assert_called_with("test_alarm_id", delete_alarm_info)
 138
 139
 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"""
 144
 145         # Mock a message
 146         msg = Message()
 147         msg.topic = "alarm_request"
 148         msg.key = "list_alarm_request"
 149         test_alarm_list = [{"alarm_uuid":"alarm1_details"},{"alarm_uuid":"alarm2_details"}]
 150
 151         msg.value = json.dumps({"alarm_list_request":"alarm_details"})
 152         m_list_alarms.return_value = test_alarm_list
 153
 154         list_alarms_info = json.loads(msg.value)
 155
 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")
 159
 160         # Check if publish method called with correct parameters
 161         m_publish_list_alarm_response.assert_called_with(test_alarm_list, list_alarms_info)
 162
 163
 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"""
 168
 169         # Mock a message
 170         msg = Message()
 171         msg.topic = "access_credentials"
 172         msg.key = "vim_access_credentials"
 173
 174         msg.value = json.dumps({"access_config":"access_details"})
 175         # set return value to mocked method
 176         m_update_access_credentials.return_value = True
 177
 178         access_info = json.loads(msg.value)
 179
 180         # Call the consume method of plugin_receiver
 181         self.plugin_receiver.consume(msg)
 182
 183         # check if mocked method called with required parameters
 184         m_update_access_credentials.assert_called_with("access_details")
 185
 186         # Check if publish method called with correct parameters
 187         m_publish_access_update_response.assert_called_with(True, access_info)
 188
 189
 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"""
 194
 195         # Mock a message with invalid alarm request key
 196         msg = Message()
 197         msg.topic = "alarm_request"
 198         msg.key = "invalid_alarm_request" # invalid key
 199
 200         # Call the consume method of plugin_receiver
 201         self.plugin_receiver.consume(msg)
 202
 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()
 206
 207
 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"""
 212
 213         # Mock a message with invalid metric request key
 214         msg = Message()
 215         msg.topic = "metric_request"
 216         msg.key = "invalid_metric_data_request" #invalid key
 217
 218         # Call the consume method of plugin_receiver
 219         self.plugin_receiver.consume(msg)
 220
 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()
 224
 225
 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"""
 230
 231         # Mock a message
 232         msg = Message()
 233         msg.topic = "metric_request"
 234         msg.key = "read_metric_data_request"
 235
 236         msg.value = json.dumps({"metric_name":"metric_details"})
 237         m_get_metrics_data.return_value = {"metrics_data":"metrics_details"}
 238
 239         metric_request_info = json.loads(msg.value)
 240
 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)
 244
 245         # Check if publish method called with correct parameters
 246         m_publish_metric_data_status.assert_called_with({"metrics_data":"metrics_details"})
 247
 248
 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"""
 253
 254         # Mock a message
 255         msg = Message()
 256         msg.topic = "metric_request"
 257         msg.key = "create_metric_request"
 258
 259         msg.value = json.dumps({"metric_create":"metric_details"})
 260
 261         # set the return value
 262         m_verify_metric.return_value = True
 263
 264         metric_info = json.loads(msg.value)
 265
 266         # Call the consume method of plugin_receiver
 267         self.plugin_receiver.consume(msg)
 268         m_verify_metric.assert_called_with("metric_details")
 269
 270         # Check if publish method called with correct parameters
 271         m_publish_create_metric_response.assert_called_with(metric_info, True)
 272
 273
 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"""
 278
 279         # Mock a message
 280         msg = Message()
 281         msg.topic = "metric_request"
 282         msg.key = "update_metric_request"
 283
 284         msg.value = json.dumps({"metric_create":"metric_details"})
 285
 286         # set the return value
 287         m_verify_metric.return_value = True
 288
 289         metric_info = json.loads(msg.value)
 290
 291         # Call the consume method of plugin_receiver
 292         self.plugin_receiver.consume(msg)
 293
 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)
 297
 298
 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"""
 302
 303         # Note: vROPS doesn't support deleting metric data
 304         # Mock a message
 305         msg = Message()
 306         msg.topic = "metric_request"
 307         msg.key = "delete_metric_request"
 308
 309         msg.value = json.dumps({"metric_name":"metric_details"})
 310
 311         metric_info = json.loads(msg.value)
 312
 313         # Call the consume method of plugin_receiver
 314         self.plugin_receiver.consume(msg)
 315
 316         # Check if publish method called with correct parameters
 317         m_publish_delete_metric_response.assert_called_with(metric_info)
 318
 319
 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"""
 324
 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",
 333                              "operation": "GT",
 334                              "threshold_value": 10,
 335                              "unit": "%",
 336                              "statistic": "AVERAGE"}
 337
 338         # set return value to plugin uuid
 339         m_configure_rest_plugin.retrun_value = "plugin_uuid"
 340         m_configure_alarm.return_value = "alarm_uuid"
 341
 342         # call create alarm method under test
 343         self.plugin_receiver.create_alarm(config_alarm_info)
 344
 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)
 348
 349
 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"""
 354
 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",
 363                              "operation": "GT",
 364                              "threshold_value": 10,
 365                              "unit": "%",
 366                              "statistic": "AVERAGE"}
 367
 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
 371
 372         # call create alarm method under test
 373         alarm_uuid = self.plugin_receiver.create_alarm(config_alarm_info)
 374
 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)
 378
 379         # verify create alarm method returns None when failed
 380         self.assertEqual(alarm_uuid, None)
 381
 382
 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"""
 386
 387         # Mock update_alarm_info
 388         update_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 389
 390         # set return value to mocked method
 391         m_update_alarm_configuration.return_value = "alarm_uuid"
 392
 393         # check update alarm gets called and returned correct value
 394         ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
 395
 396         # check mocked method get called with correct param
 397         m_update_alarm_configuration.assert_called_with(update_alarm_info)
 398
 399         # check return value and passed values are correct
 400         self.assertEqual(ret_value, "alarm_uuid")
 401
 402
 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"""
 406
 407         # Mock update_alarm_info
 408         update_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 409
 410         # set return value to mocked method
 411         m_update_alarm_configuration.return_value = None
 412
 413         # check update alarm gets called and returned correct value
 414         ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
 415
 416         # check mocked method get called with correct param
 417         m_update_alarm_configuration.assert_called_with(update_alarm_info)
 418
 419         # check return value and passed values are correct
 420         self.assertEqual(ret_value, None)
 421
 422
 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"""
 426
 427         # Mock delete_alarm_info
 428         delete_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 429
 430         # set return value to mocked method
 431         m_delete_alarm_configuration.return_value = "alarm_uuid"
 432
 433         # check delete alarm gets called and returned correct value
 434         ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
 435
 436         # check mocked method get called with correct param
 437         m_delete_alarm_configuration.assert_called_with(delete_alarm_info)
 438
 439         # check return value and passed values are correct
 440         self.assertEqual(ret_value, "alarm_uuid")
 441
 442
 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"""
 446
 447         # Mock update_alarm_info
 448         delete_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203}
 449
 450         # set return value to mocked method
 451         m_delete_alarm_configuration.return_value = None
 452
 453         # check delete alarm gets called and returned correct value
 454         ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
 455
 456         # check mocked method get called with correct param
 457         m_delete_alarm_configuration.assert_called_with(delete_alarm_info)
 458
 459         # check return value to check failed status
 460         self.assertEqual(ret_value, None)
 461
 462
 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"""
 466
 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'}
 476                             }
 477
 478         alarm_uuid = "xyz"
 479
 480         # call publish create status method under test
 481         self.plugin_receiver.publish_create_alarm_status(alarm_uuid, config_alarm_info)
 482
 483         # verify mocked method called with correct params
 484         m_publish.assert_called_with(key='create_alarm_response', value=mock.ANY, topic='alarm_response')
 485
 486
 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"""
 490
 491         # Mock update_alarm_info
 492         update_alarm_info = {'vim_type' : 'VMware',
 493                              'alarm_update_request':{'alarm_uuid': '6486e69',
 494                                                      'correlation_id': 14203,
 495                                                      'operation': 'GT'
 496                                                      },
 497                              'schema_type': 'update_alarm_request'
 498                             }
 499
 500         alarm_uuid = "xyz"
 501
 502         # call publish update alarm status method under test
 503         self.plugin_receiver.publish_update_alarm_status(alarm_uuid, update_alarm_info)
 504
 505         # verify mocked method called with correct params
 506         m_publish.assert_called_with(key='update_alarm_response', value=mock.ANY, topic='alarm_response')
 507
 508
 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"""
 512
 513         # Mock delete_alarm_info
 514         delete_alarm_info = {'vim_type' : 'VMware',
 515                              'alarm_delete_request':{'alarm_uuid': '6486e69',
 516                                                      'correlation_id': 14203,
 517                                                      'operation': 'GT'
 518                                                      },
 519                              'schema_type': 'delete_alarm_request'
 520                             }
 521
 522         alarm_uuid = "xyz"
 523
 524         # call publish delete alarm status method under test
 525         self.plugin_receiver.publish_delete_alarm_status(alarm_uuid, delete_alarm_info)
 526
 527         # verify mocked method called with correct params
 528         m_publish.assert_called_with(key='delete_alarm_response', value=mock.ANY, topic='alarm_response')
 529
 530
 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"""
 534
 535         # Mock metrics data
 536         metrics_data = {
 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': '%'
 542                        }
 543
 544         # call publish metrics data status method under test
 545         self.plugin_receiver.publish_metrics_data_status(metrics_data)
 546
 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')
 549
 550
 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"""
 554
 555         # mock metric_info
 556         metric_info = {'metric_unit': '%', 'metric_name': 'CPU_UTILIZATION', 'resource_uuid': 'e14b203'}
 557
 558         # set mocked function retrun value to true
 559         m_verify_metric_support.return_value = True
 560
 561         # call verify_metric method under test
 562         ret_value = self.plugin_receiver.verify_metric(metric_info)
 563
 564         # verify mocked method called with correct params
 565         m_verify_metric_support.assert_called_with(metric_info)
 566
 567         # verify the return value
 568         self.assertEqual(ret_value, True)
 569
 570
 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"""
 574
 575         # mock metric_info with unsupported matrics name
 576         metric_info = {'metric_unit': '%', 'metric_name': 'Invalid', 'resource_uuid': 'e14b203'}
 577
 578         # set mocked function retrun value to true
 579         m_verify_metric_support.return_value = False
 580
 581         # call verify_metric method under test
 582         ret_value = self.plugin_receiver.verify_metric(metric_info)
 583
 584         # verify mocked method called with correct params
 585         m_verify_metric_support.assert_called_with(metric_info)
 586
 587         # verify the return value
 588         self.assertEqual(ret_value, False)
 589
 590
 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"""
 594
 595         # Mock metric_info
 596         metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c',
 597                        'metric_create':{
 598                                         'resource_uuid': '6486e69',
 599                                         'metric_name': 'CPU_UTILIZATION',
 600                                         'metric_unit': '%'
 601                                         },
 602                         'schema_type': 'create_metric_request'
 603                        }
 604
 605         metric_status = True
 606
 607         # call publish create metric method under test
 608         self.plugin_receiver.publish_create_metric_response(metric_info, metric_status)
 609
 610         # verify mocked method called with correct params
 611         m_publish.assert_called_with(key='create_metric_response', value=mock.ANY, topic='metric_response')
 612
 613
 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"""
 617
 618         # Mock metric_info
 619         metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c',
 620                        'metric_create':{
 621                                         'resource_uuid': '6486e69',
 622                                         'metric_name': 'CPU_UTILIZATION',
 623                                         'metric_unit': '%'
 624                                         },
 625                         'schema_type': 'update_metric_request'
 626                        }
 627
 628         metric_status = True
 629
 630         # call publish update metric method under test
 631         self.plugin_receiver.publish_update_metric_response(metric_info, metric_status)
 632
 633         # verify mocked method called with correct params
 634         m_publish.assert_called_with(key='update_metric_response', value=mock.ANY, topic='metric_response')
 635
 636
 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"""
 640
 641         # Mock metric_info
 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'}
 646
 647         metric_status = True
 648
 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)
 652
 653         # verify mocked method called with correct params
 654         m_publish.assert_called_with(key='delete_metric_response', value=mock.ANY, topic='metric_response')
 655
 656
 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"""
 660
 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'}
 666
 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'}]
 678
 679         # call list alarms method under test
 680         return_value = self.plugin_receiver.list_alarms(list_alarm_input)
 681
 682         # verify mocked method called with correct params
 683         m_get_triggered_alarms_list.assert_called_with(list_alarm_input)
 684
 685         # verify list alarm method returns correct list
 686         self.assertEqual(return_value, m_return)
 687
 688
 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"""
 692
 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'}
 700
 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'}]
 704
 705         # call publish list alarm response method under test
 706         self.plugin_receiver.publish_list_alarm_response(triggered_alarm_list, list_alarm_input)
 707
 708         # verify mocked method called with correct params
 709         m_publish.assert_called_with(key=msg_key,value=mock.ANY, topic=topic)
 710
 711
 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"""
 715
 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'}
 722
 723         # call publish access update response method under test
 724         self.plugin_receiver.publish_access_update_response(access_update_status, access_info_req)
 725
 726         # verify mocked method called with correct params
 727         m_publish.assert_called_with(key=msg_key ,value=mock.ANY, topic=topic)
 728
 729
 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"""
 733
 734         # Mock access_info
 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'}
 739
 740         # Mock return values
 741         expected_status = m_write_access_config.return_value = True
 742
 743         # call publish update acccess credentials method under test
 744         actual_status = self.plugin_receiver.update_access_credentials(access_info)
 745
 746         # check write_access_config called with correct params
 747         m_write_access_config.assert_called_with(access_info)
 748
 749         # verify update access credentials returns correct status
 750         self.assertEqual(expected_status, actual_status)
 751
 752
 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"""
 756
 757         # Mock access_info
 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'}
 762
 763         # Mock return values
 764         expected_status = m_write_access_config.return_value = False
 765
 766         # call publish update acccess credentials method under test
 767         actual_status = self.plugin_receiver.update_access_credentials(access_info)
 768
 769         # check if mocked method not called
 770         m_write_access_config.assert_not_called()
 771
 772         # verify update access credentials returns correct status
 773         self.assertEqual(expected_status, actual_status)
 774
 775
 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 """
 779
 780         # Mock access_info
 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'}
 785
 786         # Mock return values
 787         expected_status = m_write_access_config.return_value = False
 788
 789         # call publish update acccess credentials method under test
 790         actual_status = self.plugin_receiver.update_access_credentials(access_info)
 791
 792         # check write_access_config called with correct params
 793         m_write_access_config.assert_called_with(access_info)
 794
 795         # verify update access credentials returns correct status
 796         self.assertEqual(expected_status, actual_status)
 797
 798
 799     def test_write_access_config_successful(self):
 800         """ Test functionality of write access config method-positive case"""
 801
 802         # Mock access_info
 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'}
 807
 808         # call write acccess config method under test
 809         actual_status = self.plugin_receiver.write_access_config(access_info)
 810
 811         # verify write access config returns correct status
 812         self.assertEqual(True, actual_status)
 813
 814
 815     def test_write_access_config_failed(self):
 816         """ Test functionality of write access config method-negative case"""
 817
 818         # Mock access_info
 819         access_info = [] # provided incorrect info to generate error
 820
 821         # call write acccess config method under test
 822         actual_status = self.plugin_receiver.write_access_config(access_info)
 823
 824         # verify write access config returns correct status
 825         self.assertEqual(False, actual_status)
 826
 827
 828 # For testing purpose
 829 #if __name__ == '__main__':
 830
 831 #    unittest.main()
 832