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