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