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 = {"alarm_update_request":
  76                        {"correlation_id": 123,
  77                         "alarm_uuid": "alarm_id",
  78                         "metric_uuid": "metric_id"}}
  79
  80         get_creds.return_value = mock_creds
  81
  82         self.producer.send('alarm_request', key="update_alarm_request",
  83                            value=json.dumps(payload))
  84
  85         for message in self.req_consumer:
  86             if message.key == "update_alarm_request":
  87                 # Mock a valid alarm update
  88                 update_alarm.return_value = "alarm_id", True
  89                 self.alarms.alarming(message, 'test_id')
  90
  91                 # A response message is generated and sent via MON's producer
  92                 resp.assert_called_with(
  93                     'update_alarm_response', alarm_id="alarm_id", cor_id=123,
  94                     status=True)
  95                 update_resp.assert_called_with(
  96                     'update_alarm_response', resp.return_value)
  97
  98                 return
  99         self.fail("No message received in consumer")
 100
 101     @mock.patch.object(DatabaseManager, "save_alarm", mock.Mock())
 102     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 103     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 104     @mock.patch.object(AuthManager, 'get_credentials')
 105     @mock.patch.object(prod, "create_alarm_response")
 106     @mock.patch.object(alarming.Alarming, "configure_alarm")
 107     @mock.patch.object(response.OpenStack_Response, "generate_response")
 108     def test_create_alarm_req(self, resp, config_alarm, create_resp, get_creds):
 109         """Test Aodh create alarm request message from KafkaProducer."""
 110         # Set-up message, producer and consumer for tests
 111         payload = {"alarm_create_request":
 112                        {"correlation_id": 123,
 113                         "alarm_name": "my_alarm",
 114                         "metric_name": "my_metric",
 115                         "resource_uuid": "my_resource",
 116                         "severity": "WARNING"}}
 117
 118         get_creds.return_value = mock_creds
 119
 120         self.producer.send('alarm_request', key="create_alarm_request",
 121                            value=json.dumps(payload))
 122
 123         for message in self.req_consumer:
 124             if message.key == "create_alarm_request":
 125                 # Mock a valid alarm creation
 126                 config_alarm.return_value = "alarm_id", True
 127                 self.alarms.alarming(message, 'test_id')
 128
 129                 # A response message is generated and sent via MON's produce
 130                 resp.assert_called_with(
 131                     'create_alarm_response', status=True, alarm_id="alarm_id",
 132                     cor_id=123)
 133                 create_resp.assert_called_with(
 134                     'create_alarm_response', resp.return_value)
 135
 136                 return
 137         self.fail("No message received in consumer")
 138
 139     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 140     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 141     @mock.patch.object(AuthManager, 'get_credentials')
 142     @mock.patch.object(prod, "list_alarm_response")
 143     @mock.patch.object(alarming.Alarming, "list_alarms")
 144     @mock.patch.object(response.OpenStack_Response, "generate_response")
 145     def test_list_alarm_req(self, resp, list_alarm, list_resp, get_creds):
 146         """Test Aodh list alarm request message from KafkaProducer."""
 147         # Set-up message, producer and consumer for tests
 148         payload = {"alarm_list_request":
 149                        {"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
 157         for message in self.req_consumer:
 158             if message.key == "list_alarm_request":
 159                 # Mock an empty list generated by the request
 160                 list_alarm.return_value = []
 161                 self.alarms.alarming(message, 'test_id')
 162
 163                 # Response message is generated
 164                 resp.assert_called_with(
 165                     'list_alarm_response', alarm_list=[],
 166                     cor_id=123)
 167                 # Producer attempts to send the response message back to the SO
 168                 list_resp.assert_called_with(
 169                     'list_alarm_response', resp.return_value)
 170
 171                 return
 172         self.fail("No message received in consumer")
 173
 174     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 175     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 176     @mock.patch.object(AuthManager, 'get_credentials')
 177     @mock.patch.object(alarming.Alarming, "delete_alarm")
 178     @mock.patch.object(prod, "delete_alarm_response")
 179     @mock.patch.object(response.OpenStack_Response, "generate_response")
 180     def test_delete_alarm_req(self, resp, del_resp, del_alarm, get_creds):
 181         """Test Aodh delete alarm request message from KafkaProducer."""
 182         # Set-up message, producer and consumer for tests
 183         payload = {"alarm_delete_request":
 184                        {"correlation_id": 123,
 185                         "alarm_uuid": "alarm_id", }}
 186
 187         self.producer.send('alarm_request', key="delete_alarm_request",
 188                            value=json.dumps(payload))
 189
 190         get_creds.return_value = mock_creds
 191
 192         for message in self.req_consumer:
 193             if message.key == "delete_alarm_request":
 194                 self.alarms.alarming(message, 'test_id')
 195
 196                 # Response message is generated and sent by MON's producer
 197                 resp.assert_called_with(
 198                     'delete_alarm_response', alarm_id="alarm_id",
 199                     status=del_alarm.return_value, cor_id=123)
 200                 del_resp.assert_called_with(
 201                     'delete_alarm_response', resp.return_value)
 202
 203                 return
 204         self.fail("No message received in consumer")
 205
 206     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 207     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 208     @mock.patch.object(AuthManager, 'get_credentials')
 209     @mock.patch.object(alarming.Alarming, "update_alarm_state")
 210     def test_ack_alarm_req(self, ack_alarm, get_creds):
 211         """Test Aodh acknowledge alarm request message from KafkaProducer."""
 212         # Set-up message, producer and consumer for tests
 213         payload = {"ack_details":
 214                        {"alarm_uuid": "alarm_id", }}
 215
 216         self.producer.send('alarm_request', key="acknowledge_alarm",
 217                            value=json.dumps(payload))
 218
 219         get_creds.return_value = mock_creds
 220
 221         for message in self.req_consumer:
 222             if message.key == "acknowledge_alarm":
 223                 self.alarms.alarming(message, 'test_id')
 224                 return
 225
 226         self.fail("No message received in consumer")