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