osm_mon/test/OpenStack/integration/test_metric_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 metric requests."""
  24
  25 import json
  26
  27 import logging
  28 import unittest
  29
  30 from kafka.errors import KafkaError
  31
  32 from osm_mon.core.auth import AuthManager
  33 from osm_mon.core.database import VimCredentials
  34
  35 from kafka import KafkaConsumer
  36 from kafka import KafkaProducer
  37
  38 import mock
  39
  40 from osm_mon.plugins.OpenStack import response
  41
  42 from osm_mon.plugins.OpenStack.Gnocchi import metric_handler
  43
  44 from osm_mon.plugins.OpenStack.common import Common
  45
  46 log = logging.getLogger(__name__)
  47
  48 mock_creds = VimCredentials()
  49 mock_creds.config = '{}'
  50
  51
  52 @mock.patch.object(Common, "get_auth_token", mock.Mock())
  53 @mock.patch.object(Common, "get_endpoint", mock.Mock())
  54 class MetricIntegrationTest(unittest.TestCase):
  55     def setUp(self):
  56         # Set up common and alarming class instances
  57         self.metric_req = metric_handler.OpenstackMetricHandler()
  58         self.openstack_auth = Common()
  59
  60         try:
  61             self.producer = KafkaProducer(bootstrap_servers='localhost:9092',
  62                                           key_serializer=str.encode,
  63                                           value_serializer=str.encode
  64                                           )
  65             self.req_consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
  66                                               key_deserializer=bytes.decode,
  67                                               value_deserializer=bytes.decode,
  68                                               auto_offset_reset='earliest',
  69                                               consumer_timeout_ms=60000)
  70             self.req_consumer.subscribe(['metric_request'])
  71         except KafkaError:
  72             self.skipTest('Kafka server not present.')
  73
  74     @mock.patch.object(Common, "perform_request")
  75     @mock.patch.object(AuthManager, 'get_credentials')
  76     @mock.patch.object(metric_handler.OpenstackMetricHandler, "configure_metric")
  77     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
  78     def test_create_metric_req(self, resp, config_metric, get_creds, perf_req):
  79         """Test Gnocchi create metric request message from producer."""
  80         # Set-up message, producer and consumer for tests
  81         payload = {"metric_create_request": {"correlation_id": 123,
  82                                              "metric_name": "cpu_utilization",
  83                                              "resource_uuid": "resource_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('metric_request', key="create_metric_request",
  90                            value=json.dumps(payload))
  91
  92         for message in self.req_consumer:
  93             if message.key == "create_metric_request":
  94                 # A valid metric is created
  95                 config_metric.return_value = "metric_id", "resource_id"
  96                 self.metric_req.handle_request(message, 'test_id')
  97
  98                 # A response message is generated and sent by MON's producer
  99                 resp.assert_called_with(
 100                     'create_metric_response', status=True, cor_id=123,
 101                     metric_id="metric_id", resource_id="resource_id")
 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(metric_handler.OpenstackMetricHandler, "delete_metric")
 109     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 110     def test_delete_metric_req(self, resp, del_metric, get_creds, perf_req):
 111         """Test Gnocchi delete metric request message from producer."""
 112         # Set-up message, producer and consumer for tests
 113         payload = {"vim_type": "OpenSTACK",
 114                    "vim_uuid": "1",
 115                    "correlation_id": 123,
 116                    "metric_name": "cpu_utilization",
 117                    "resource_uuid": "resource_id"}
 118
 119         get_creds.return_value = mock_creds
 120         perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
 121         resp.return_value = ''
 122
 123         self.producer.send('metric_request', key="delete_metric_request",
 124                            value=json.dumps(payload))
 125
 126         for message in self.req_consumer:
 127             if message.key == "delete_metric_request":
 128                 # Metric has been deleted
 129                 del_metric.return_value = True
 130                 self.metric_req.handle_request(message, 'test_id')
 131
 132                 # A response message is generated and sent by MON's producer
 133                 resp.assert_called_with(
 134                     'delete_metric_response', metric_id='1',
 135                     metric_name="cpu_utilization", status=True, resource_id="resource_id",
 136                     cor_id=123)
 137
 138                 return
 139         self.fail("No message received in consumer")
 140
 141     @mock.patch.object(Common, "perform_request")
 142     @mock.patch.object(AuthManager, 'get_credentials')
 143     @mock.patch.object(metric_handler.OpenstackMetricHandler, "read_metric_data")
 144     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 145     def test_read_metric_data_req(self, resp, read_data, get_creds, perf_req):
 146         """Test Gnocchi read metric data request message from producer."""
 147         # Set-up message, producer and consumer for tests
 148         payload = {"vim_type": "OpenSTACK",
 149                    "vim_uuid": "test_id",
 150                    "correlation_id": 123,
 151                    "metric_name": "cpu_utilization",
 152                    "resource_uuid": "resource_id"}
 153
 154         get_creds.return_value = mock_creds
 155         perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
 156         resp.return_value = ''
 157
 158         self.producer.send('metric_request', key="read_metric_data_request",
 159                            value=json.dumps(payload))
 160
 161         for message in self.req_consumer:
 162             # Check the vim desired by the message
 163             if message.key == "read_metric_data_request":
 164                 # Mock empty lists generated by the request message
 165                 read_data.return_value = [], []
 166                 self.metric_req.handle_request(message, 'test_id')
 167
 168                 # A response message is generated and sent by MON's producer
 169                 resp.assert_called_with(
 170                     'read_metric_data_response', metric_id='1',
 171                     metric_name="cpu_utilization", resource_id="resource_id", cor_id=123, times=[],
 172                     metrics=[], status=True)
 173
 174                 return
 175         self.fail("No message received in consumer")
 176
 177     @mock.patch.object(Common, "perform_request")
 178     @mock.patch.object(AuthManager, 'get_credentials')
 179     @mock.patch.object(metric_handler.OpenstackMetricHandler, "list_metrics")
 180     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 181     def test_list_metrics_req(self, resp, list_metrics, get_creds, perf_req):
 182         """Test Gnocchi list metrics request message from producer."""
 183         # Set-up message, producer and consumer for tests
 184         payload = {"vim_type": "OpenSTACK",
 185                    "vim_uuid": "1",
 186                    "metrics_list_request":
 187                        {"correlation_id": 123, }}
 188
 189         get_creds.return_value = mock_creds
 190         perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
 191         resp.return_value = ''
 192
 193         self.producer.send('metric_request', key="list_metric_request",
 194                            value=json.dumps(payload))
 195
 196         for message in self.req_consumer:
 197             # Check the vim desired by the message
 198             if message.key == "list_metric_request":
 199                 # Mock an empty list generated by the request
 200                 list_metrics.return_value = []
 201                 self.metric_req.handle_request(message, 'test_id')
 202
 203                 # A response message is generated and sent by MON's producer
 204                 resp.assert_called_with(
 205                     'list_metric_response', metric_list=[], cor_id=123, status=True)
 206
 207                 return
 208         self.fail("No message received in consumer")
 209
 210     @mock.patch.object(Common, "perform_request")
 211     @mock.patch.object(AuthManager, 'get_credentials')
 212     @mock.patch.object(metric_handler.OpenstackMetricHandler, "get_metric_id")
 213     @mock.patch.object(response.OpenStackResponseBuilder, "generate_response")
 214     def test_update_metrics_req(self, resp, get_id, get_creds, perf_req):
 215         """Test Gnocchi update metric request message from KafkaProducer."""
 216         # Set-up message, producer and consumer for tests
 217         payload = {"metric_update_request": {"metric_name": "my_metric",
 218                                              "correlation_id": 123,
 219                                              "resource_uuid": "resource_id", }}
 220
 221         get_creds.return_value = mock_creds
 222         perf_req.return_value = type('obj', (object,), {'text': json.dumps({"metrics": {"cpu_util": "1"}})})
 223         resp.return_value = ''
 224
 225         self.producer.send('metric_request', key="update_metric_request",
 226                            value=json.dumps(payload))
 227
 228         for message in self.req_consumer:
 229             # Check the vim desired by the message
 230             if message.key == "update_metric_request":
 231                 # Gnocchi doesn't support metric updates
 232                 get_id.return_value = "metric_id"
 233                 self.metric_req.handle_request(message, 'test_id')
 234
 235                 # Response message is generated and sent via MON's producer
 236                 # No metric update has taken place
 237                 resp.assert_called_with(
 238                     'update_metric_response', status=False, cor_id=123,
 239                     resource_id="resource_id", metric_id="metric_id")
 240
 241                 return
 242         self.fail("No message received in consumer")