osm_mon/test/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.core.message_bus.producer import KafkaProducer as prod
  37 from osm_mon.plugins.OpenStack import response
  38 from osm_mon.plugins.OpenStack.Aodh import alarming
  39 from osm_mon.plugins.OpenStack.common import Common
  40
  41 log = logging.getLogger(__name__)
  42
  43 mock_creds = VimCredentials()
  44 mock_creds.config = '{}'
  45
  46
  47 class AlarmIntegrationTest(unittest.TestCase):
  48     def setUp(self):
  49         try:
  50             self.producer = KafkaProducer(bootstrap_servers='localhost:9092',
  51                                           key_serializer=str.encode,
  52                                           value_serializer=str.encode
  53                                           )
  54             self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
  55                                               key_deserializer=bytes.decode,
  56                                               value_deserializer=bytes.decode,
  57                                               auto_offset_reset='earliest',
  58                                               consumer_timeout_ms=60000)
  59             self.req_consumer.subscribe(['alarm_request'])
  60         except KafkaError:
  61             self.skipTest('Kafka server not present.')
  62         # Set up common and alarming class instances
  63         self.alarms = alarming.Alarming()
  64         self.openstack_auth = Common()
  65
  66     @mock.patch.object(Common, "get_auth_token", mock.Mock())
  67     @mock.patch.object(Common, "get_endpoint", mock.Mock())
  68     @mock.patch.object(AuthManager, 'get_credentials')
  69     @mock.patch.object(prod, "update_alarm_response")
  70     @mock.patch.object(alarming.Alarming, "update_alarm")
  71     @mock.patch.object(response.OpenStack_Response, "generate_response")
  72     def test_update_alarm_req(self, resp, update_alarm, update_resp, get_creds):
  73         """Test Aodh update alarm request message from KafkaProducer."""
  74         # Set-up message, producer and consumer for tests
  75         payload = {"vim_type": "OpenSTACK",
  76                    "vim_uuid": "test_id",
  77                    "alarm_update_request":
  78                        {"correlation_id": 123,
  79                         "alarm_uuid": "alarm_id",
  80                         "metric_uuid": "metric_id"}}
  81
  82         get_creds.return_value = mock_creds
  83
  84         self.producer.send('alarm_request', key="update_alarm_request",
  85                            value=json.dumps(payload))
  86
  87         for message in self.req_consumer:
  88             # Check the vim desired by the message
  89             if message.key == "update_alarm_request":
  90                 # Mock a valid alarm update
  91                 update_alarm.return_value = "alarm_id", True
  92                 self.alarms.alarming(message)
  93
  94                 # A response message is generated and sent via MON's producer
  95                 resp.assert_called_with(
  96                     'update_alarm_response', alarm_id="alarm_id", cor_id=123,
  97                     status=True)
  98                 update_resp.assert_called_with(
  99                     'update_alarm_response', resp.return_value)
 100
 101                 return
 102         self.fail("No message received in consumer")
 103
 104     @mock.patch.object(DatabaseManager, "save_alarm", mock.Mock())
 105     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 106     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 107     @mock.patch.object(AuthManager, 'get_credentials')
 108     @mock.patch.object(prod, "create_alarm_response")
 109     @mock.patch.object(alarming.Alarming, "configure_alarm")
 110     @mock.patch.object(response.OpenStack_Response, "generate_response")
 111     def test_create_alarm_req(self, resp, config_alarm, create_resp, get_creds):
 112         """Test Aodh create alarm request message from KafkaProducer."""
 113         # Set-up message, producer and consumer for tests
 114         payload = {"vim_type": "OpenSTACK",
 115                    "vim_uuid": "test_id",
 116                    "alarm_create_request":
 117                        {"correlation_id": 123,
 118                         "alarm_name": "my_alarm",
 119                         "metric_name": "my_metric",
 120                         "resource_uuid": "my_resource",
 121                         "severity": "WARNING"}}
 122
 123         get_creds.return_value = mock_creds
 124
 125         self.producer.send('alarm_request', key="create_alarm_request",
 126                            value=json.dumps(payload))
 127
 128         for message in self.req_consumer:
 129             # Check the vim desired by the message
 130             if message.key == "create_alarm_request":
 131                 # Mock a valid alarm creation
 132                 config_alarm.return_value = "alarm_id", True
 133                 self.alarms.alarming(message)
 134
 135                 # A response message is generated and sent via MON's produce
 136                 resp.assert_called_with(
 137                     'create_alarm_response', status=True, alarm_id="alarm_id",
 138                     cor_id=123)
 139                 create_resp.assert_called_with(
 140                     'create_alarm_response', resp.return_value)
 141
 142                 return
 143         self.fail("No message received in consumer")
 144
 145     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 146     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 147     @mock.patch.object(AuthManager, 'get_credentials')
 148     @mock.patch.object(prod, "list_alarm_response")
 149     @mock.patch.object(alarming.Alarming, "list_alarms")
 150     @mock.patch.object(response.OpenStack_Response, "generate_response")
 151     def test_list_alarm_req(self, resp, list_alarm, list_resp, get_creds):
 152         """Test Aodh list alarm request message from KafkaProducer."""
 153         # Set-up message, producer and consumer for tests
 154         payload = {"vim_type": "OpenSTACK",
 155                    "vim_uuid": "test_id",
 156                    "alarm_list_request":
 157                        {"correlation_id": 123,
 158                         "resource_uuid": "resource_id", }}
 159
 160         self.producer.send('alarm_request', key="list_alarm_request",
 161                            value=json.dumps(payload))
 162
 163         get_creds.return_value = mock_creds
 164
 165         for message in self.req_consumer:
 166             # Check the vim desired by the message
 167             if message.key == "list_alarm_request":
 168                 # Mock an empty list generated by the request
 169                 list_alarm.return_value = []
 170                 self.alarms.alarming(message)
 171
 172                 # Response message is generated
 173                 resp.assert_called_with(
 174                     'list_alarm_response', alarm_list=[],
 175                     cor_id=123)
 176                 # Producer attempts to send the response message back to the SO
 177                 list_resp.assert_called_with(
 178                     'list_alarm_response', resp.return_value)
 179
 180                 return
 181         self.fail("No message received in consumer")
 182
 183     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 184     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 185     @mock.patch.object(AuthManager, 'get_credentials')
 186     @mock.patch.object(alarming.Alarming, "delete_alarm")
 187     @mock.patch.object(prod, "delete_alarm_response")
 188     @mock.patch.object(response.OpenStack_Response, "generate_response")
 189     def test_delete_alarm_req(self, resp, del_resp, del_alarm, get_creds):
 190         """Test Aodh delete alarm request message from KafkaProducer."""
 191         # Set-up message, producer and consumer for tests
 192         payload = {"vim_type": "OpenSTACK",
 193                    "vim_uuid": "test_id",
 194                    "alarm_delete_request":
 195                        {"correlation_id": 123,
 196                         "alarm_uuid": "alarm_id", }}
 197
 198         self.producer.send('alarm_request', key="delete_alarm_request",
 199                            value=json.dumps(payload))
 200
 201         get_creds.return_value = mock_creds
 202
 203         for message in self.req_consumer:
 204             # Check the vim desired by the message
 205             if message.key == "delete_alarm_request":
 206                 self.alarms.alarming(message)
 207
 208                 # Response message is generated and sent by MON's producer
 209                 resp.assert_called_with(
 210                     'delete_alarm_response', alarm_id="alarm_id",
 211                     status=del_alarm.return_value, cor_id=123)
 212                 del_resp.assert_called_with(
 213                     'delete_alarm_response', resp.return_value)
 214
 215                 return
 216         self.fail("No message received in consumer")
 217
 218     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 219     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 220     @mock.patch.object(AuthManager, 'get_credentials')
 221     @mock.patch.object(alarming.Alarming, "update_alarm_state")
 222     def test_ack_alarm_req(self, ack_alarm, get_creds):
 223         """Test Aodh acknowledge alarm request message from KafkaProducer."""
 224         # Set-up message, producer and consumer for tests
 225         payload = {"vim_type": "OpenSTACK",
 226                    "vim_uuid": "test_id",
 227                    "ack_details":
 228                        {"alarm_uuid": "alarm_id", }}
 229
 230         self.producer.send('alarm_request', key="acknowledge_alarm",
 231                            value=json.dumps(payload))
 232
 233         get_creds.return_value = mock_creds
 234
 235         for message in self.req_consumer:
 236             # Check the vim desired by the message
 237             if message.key == "acknowledge_alarm":
 238                 self.alarms.alarming(message)
 239                 return
 240
 241         self.fail("No message received in consumer")