osm_mon/tests/plugins/OpenStack/integration/test_alarm_integration.py

   1 # Copyright 2017 Intel Research and Development Ireland Limited
   2 # *************************************************************
   3
   4 # This file is part of OSM Monitoring module
   5 # All Rights Reserved to Intel Corporation
   6
   7 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   8 # not use this file except in compliance with the License. You may obtain
   9 # a copy of the License at
  10
  11 #         http://www.apache.org/licenses/LICENSE-2.0
  12
  13 # Unless required by applicable law or agreed to in writing, software
  14 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  16 # License for the specific language governing permissions and limitations
  17 # under the License.
  18
  19 # For those usages not covered by the Apache License, Version 2.0 please
  20 # contact: helena.mcgough@intel.com or adrian.hoban@intel.com
  21
  22 # __author__ = "Helena McGough"
  23 """Test an end to end Openstack alarm requests."""
  24
  25 import json
  26 import logging
  27 import unittest
  28
  29 import mock
  30 from kafka import KafkaConsumer
  31 from kafka import KafkaProducer
  32 from kafka.errors import KafkaError
  33
  34 from osm_mon.core.auth import AuthManager
  35 from osm_mon.core.database import DatabaseManager, VimCredentials
  36 from osm_mon.plugins.OpenStack import response
  37 from osm_mon.plugins.OpenStack.Aodh import alarm_handler
  38 from osm_mon.plugins.OpenStack.common import Common
  39
  40 log = logging.getLogger(__name__)
  41
  42 mock_creds = VimCredentials()
  43 mock_creds.config = '{}'
  44
  45
  46 @mock.patch.object(DatabaseManager, "save_alarm", mock.Mock())
  47 @mock.patch.object(Common, "get_auth_token", mock.Mock())
  48 @mock.patch.object(Common, "get_endpoint", mock.Mock())
  49 class AlarmIntegrationTest(unittest.TestCase):
  50     def setUp(self):
  51         try:
  52             self.producer = KafkaProducer(bootstrap_servers='localhost:9092',
  53                                           key_serializer=str.encode,
  54                                           value_serializer=str.encode
  55                                           )
  56             self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
  57                                               key_deserializer=bytes.decode,
  58                                               value_deserializer=bytes.decode,
  59                                               auto_offset_reset='earliest',
  60                                               consumer_timeout_ms=60000)
  61             self.req_consumer.subscribe(['alarm_request'])
  62         except KafkaError:
  63             self.skipTest('Kafka server not present.')
  64         # Set up common and alarming class instances
  65         self.alarms = alarm_handler.OpenstackAlarmHandler()
  66         self.openstack_auth = Common()
  67
  68     def tearDown(self):
  69         self.producer.close()
  70         self.req_consumer.close()
  71
  72     @mock.patch.object(Common, "perform_request")
  73     @mock.patch.object(AuthManager, 'get_credentials')
  74     @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "update_alarm")
  75     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
  76     def test_update_alarm_req(self, resp, update_alarm, get_creds, perf_req):
  77         """Test Aodh update alarm request message from KafkaProducer."""
  78         # Set-up message, producer and consumer for tests
  79         payload = {"alarm_update_request": {"correlation_id": 123,
  80                                             "alarm_uuid": "alarm_id",
  81                                             "metric_uuid": "metric_id"}}
  82
  83         get_creds.return_value = mock_creds
  84         perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
  85         resp.return_value = ''
  86
  87         self.producer.send('alarm_request', key="update_alarm_request",
  88                            value=json.dumps(payload))
  89
  90         for message in self.req_consumer:
  91             if message.key == "update_alarm_request":
  92                 # Mock a valid alarm update
  93                 update_alarm.return_value = "alarm_id"
  94                 self.alarms.handle_message(message, 'test_id')
  95
  96                 # A response message is generated and sent via MON's producer
  97                 resp.assert_called_with(
  98                     'update_alarm_response', alarm_id="alarm_id", cor_id=123,
  99                     status=True)
 100
 101                 return
 102         self.fail("No message received in consumer")
 103
 104     @mock.patch.object(Common, "perform_request")
 105     @mock.patch.object(AuthManager, 'get_credentials')
 106     @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "configure_alarm")
 107     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 108     def test_create_alarm_req(self, resp, config_alarm, get_creds, perf_req):
 109         """Test Aodh create alarm request message from KafkaProducer."""
 110         # Set-up message, producer and consumer for tests
 111         payload = {"alarm_create_request": {"correlation_id": 123,
 112                                             "alarm_name": "my_alarm",
 113                                             "metric_name": "cpu_utilization",
 114                                             "resource_uuid": "my_resource",
 115                                             "severity": "WARNING",
 116                                             "threshold_value": 60,
 117                                             "operation": "GT",
 118                                             "vdu_name": "vdu",
 119                                             "vnf_member_index": "1",
 120                                             "ns_id": "1"}}
 121
 122         get_creds.return_value = mock_creds
 123         perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
 124         resp.return_value = ''
 125         self.producer.send('alarm_request', key="create_alarm_request",
 126                            value=json.dumps(payload))
 127
 128         for message in self.req_consumer:
 129             if message.key == "create_alarm_request":
 130                 # Mock a valid alarm creation
 131                 config_alarm.return_value = "alarm_id"
 132                 self.alarms.handle_message(message, 'test_id')
 133
 134                 # A response message is generated and sent via MON's produce
 135                 resp.assert_called_with(
 136                     'create_alarm_response', status=True, alarm_id="alarm_id",
 137                     cor_id=123)
 138
 139                 return
 140         self.fail("No message received in consumer")
 141
 142     @mock.patch.object(Common, "perform_request")
 143     @mock.patch.object(AuthManager, 'get_credentials')
 144     @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "list_alarms")
 145     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 146     def test_list_alarm_req(self, resp, list_alarm, get_creds, perf_req):
 147         """Test Aodh list alarm request message from KafkaProducer."""
 148         # Set-up message, producer and consumer for tests
 149         payload = {"alarm_list_request": {"correlation_id": 123,
 150                                           "resource_uuid": "resource_id", }}
 151
 152         self.producer.send('alarm_request', key="list_alarm_request",
 153                            value=json.dumps(payload))
 154
 155         get_creds.return_value = mock_creds
 156         perf_req.return_value = type('obj', (object,), {'text': json.dumps([])})
 157         resp.return_value = ''
 158
 159         for message in self.req_consumer:
 160             if message.key == "list_alarm_request":
 161                 # Mock an empty list generated by the request
 162                 list_alarm.return_value = []
 163                 self.alarms.handle_message(message, 'test_id')
 164
 165                 # Response message is generated
 166                 resp.assert_called_with(
 167                     'list_alarm_response', alarm_list=[],
 168                     cor_id=123)
 169
 170                 return
 171         self.fail("No message received in consumer")
 172
 173     @mock.patch.object(Common, "perform_request")
 174     @mock.patch.object(AuthManager, 'get_credentials')
 175     @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "delete_alarm")
 176     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 177     def test_delete_alarm_req(self, resp, del_alarm, get_creds, perf_req):
 178         """Test Aodh delete alarm request message from KafkaProducer."""
 179         # Set-up message, producer and consumer for tests
 180         payload = {"alarm_delete_request": {"correlation_id": 123,
 181                                             "alarm_uuid": "alarm_id", }}
 182
 183         self.producer.send('alarm_request', key="delete_alarm_request",
 184                            value=json.dumps(payload))
 185
 186         get_creds.return_value = mock_creds
 187         perf_req.return_value = type('obj', (object,), {'text': json.dumps([])})
 188         resp.return_value = ''
 189
 190         for message in self.req_consumer:
 191             if message.key == "delete_alarm_request":
 192                 self.alarms.handle_message(message, 'test_id')
 193
 194                 # Response message is generated and sent by MON's producer
 195                 resp.assert_called_with(
 196                     'delete_alarm_response', alarm_id="alarm_id",
 197                     status=True, cor_id=123)
 198
 199                 return
 200         self.fail("No message received in consumer")
 201
 202     @mock.patch.object(AuthManager, 'get_credentials')
 203     @mock.patch.object(alarm_handler.OpenstackAlarmHandler, "update_alarm_state")
 204     def test_ack_alarm_req(self, ack_alarm, get_creds):
 205         """Test Aodh acknowledge alarm request message from KafkaProducer."""
 206         # Set-up message, producer and consumer for tests
 207         payload = {"ack_details": {"alarm_uuid": "alarm_id", }}
 208
 209         self.producer.send('alarm_request', key="acknowledge_alarm",
 210                            value=json.dumps(payload))
 211
 212         get_creds.return_value = mock_creds
 213         ack_alarm.return_value = True
 214
 215         for message in self.req_consumer:
 216             if message.key == "acknowledge_alarm":
 217                 self.alarms.handle_message(message, 'test_id')
 218                 ack_alarm.assert_called_with(mock.ANY, mock.ANY, 'alarm_id', True)
 219                 return
 220
 221         self.fail("No message received in consumer")