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