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=60000)
  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             if message.key == "delete_metric_request":
 120                 # Metric has been deleted
 121                 del_metric.return_value = True
 122                 self.metric_req.metric_calls(message)
 123
 124                 # A response message is generated and sent by MON's producer
 125                 resp.assert_called_with(
 126                     'delete_metric_response', m_id="metric_id",
 127                     m_name="metric_name", status=True, r_id="resource_id",
 128                     cor_id=123)
 129                 del_resp.assert_called_with(
 130                     'delete_metric_response', resp.return_value, 'metric_response')
 131
 132                 return
 133         self.fail("No message received in consumer")
 134
 135     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 136     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 137     @mock.patch.object(metrics.Metrics, "read_metric_data")
 138     @mock.patch.object(prod, "read_metric_data_response")
 139     @mock.patch.object(response.OpenStack_Response, "generate_response")
 140     def test_read_metric_data_req(self, resp, read_resp, read_data):
 141         """Test Gnocchi read metric data request message from producer."""
 142         # Set-up message, producer and consumer for tests
 143         payload = {"vim_type": "OpenSTACK",
 144                    "vim_uuid": "test_id",
 145                    "correlation_id": 123,
 146                    "metric_uuid": "metric_id",
 147                    "metric_name": "metric_name",
 148                    "resource_uuid": "resource_id"}
 149
 150         self.producer.send('metric_request', key="read_metric_data_request",
 151                            value=json.dumps(payload))
 152
 153         for message in self.req_consumer:
 154             # Check the vim desired by the message
 155             if message.key == "read_metric_data_request":
 156                 # Mock empty lists generated by the request message
 157                 read_data.return_value = [], []
 158                 self.metric_req.metric_calls(message)
 159
 160                 # A response message is generated and sent by MON's producer
 161                 resp.assert_called_with(
 162                     'read_metric_data_response', m_id="metric_id",
 163                     m_name="metric_name", r_id="resource_id", cor_id=123, times=[],
 164                     metrics=[])
 165                 read_resp.assert_called_with(
 166                     'read_metric_data_response', resp.return_value,
 167                     'metric_response')
 168
 169                 return
 170         self.fail("No message received in consumer")
 171
 172     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 173     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 174     @mock.patch.object(metrics.Metrics, "list_metrics")
 175     @mock.patch.object(prod, "list_metric_response")
 176     @mock.patch.object(response.OpenStack_Response, "generate_response")
 177     def test_list_metrics_req(self, resp, list_resp, list_metrics):
 178         """Test Gnocchi list metrics request message from producer."""
 179         # Set-up message, producer and consumer for tests
 180         payload = {"vim_type": "OpenSTACK",
 181                    "vim_uuid": "1",
 182                    "metrics_list_request":
 183                        {"correlation_id": 123, }}
 184
 185         self.producer.send('metric_request', key="list_metric_request",
 186                            value=json.dumps(payload))
 187
 188         for message in self.req_consumer:
 189             # Check the vim desired by the message
 190             if message.key == "list_metric_request":
 191                 # Mock an empty list generated by the request
 192                 list_metrics.return_value = []
 193                 self.metric_req.metric_calls(message)
 194
 195                 # A response message is generated and sent by MON's producer
 196                 resp.assert_called_with(
 197                     'list_metric_response', m_list=[], cor_id=123)
 198                 list_resp.assert_called_with(
 199                     'list_metric_response', resp.return_value, 'metric_response')
 200
 201                 return
 202         self.fail("No message received in consumer")
 203
 204     @mock.patch.object(Common, "get_auth_token", mock.Mock())
 205     @mock.patch.object(Common, "get_endpoint", mock.Mock())
 206     @mock.patch.object(metrics.Metrics, "get_metric_id")
 207     @mock.patch.object(prod, "update_metric_response")
 208     @mock.patch.object(response.OpenStack_Response, "generate_response")
 209     def test_update_metrics_req(self, resp, update_resp, get_id):
 210         """Test Gnocchi update metric request message from KafkaProducer."""
 211         # Set-up message, producer and consumer for tests
 212         payload = {"vim_type": "OpenSTACK",
 213                    "vim_uuid": "test_id",
 214                    "correlation_id": 123,
 215                    "metric_create":
 216                        {"metric_name": "my_metric",
 217                         "resource_uuid": "resource_id", }}
 218
 219         self.producer.send('metric_request', key="update_metric_request",
 220                            value=json.dumps(payload))
 221
 222         for message in self.req_consumer:
 223             # Check the vim desired by the message
 224             if message.key == "update_metric_request":
 225                 # Gnocchi doesn't support metric updates
 226                 get_id.return_value = "metric_id"
 227                 self.metric_req.metric_calls(message)
 228
 229                 # Response message is generated and sent via MON's producer
 230                 # No metric update has taken place
 231                 resp.assert_called_with(
 232                     'update_metric_response', status=False, cor_id=123,
 233                     r_id="resource_id", m_id="metric_id")
 234                 update_resp.assert_called_with(
 235                     'update_metric_response', resp.return_value, 'metric_response')
 236
 237                 return
 238         self.fail("No message received in consumer")