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