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                                               group_id='osm_mon',
  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(metrics.Metrics, "configure_metric")
  64     @mock.patch.object(prod, "create_metrics_resp")
  65     @mock.patch.object(response.OpenStack_Response, "generate_response")
  66     def test_create_metric_req(self, resp, create_resp, config_metric):
  67         """Test Gnocchi create metric request message from producer."""
  68         # Set-up message, producer and consumer for tests
  69         payload = {"vim_type": "OpenSTACK",
  70                    "correlation_id": 123,
  71                    "metric_create":
  72                        {"metric_name": "my_metric",
  73                         "resource_uuid": "resource_id"}}
  74
  75         self.producer.send('metric_request', key="create_metric_request",
  76                            value=json.dumps(payload))
  77
  78         for message in self.req_consumer:
  79             # Check the vim desired by the message
  80             vim_type = json.loads(message.value)["vim_type"].lower()
  81             if vim_type == "openstack":
  82                 # A valid metric is created
  83                 config_metric.return_value = "metric_id", "resource_id", True
  84                 self.metric_req.metric_calls(message, self.openstack_auth, None)
  85
  86                 # A response message is generated and sent by MON's producer
  87                 resp.assert_called_with(
  88                     'create_metric_response', status=True, cor_id=123,
  89                     metric_id="metric_id", r_id="resource_id")
  90                 create_resp.assert_called_with(
  91                     'create_metric_response', resp.return_value, 'metric_response')
  92
  93                 return
  94         self.fail("No message received in consumer")
  95
  96     @mock.patch.object(metrics.Metrics, "delete_metric")
  97     @mock.patch.object(prod, "delete_metric_response")
  98     @mock.patch.object(response.OpenStack_Response, "generate_response")
  99     def test_delete_metric_req(self, resp, del_resp, del_metric):
 100         """Test Gnocchi delete metric request message from producer."""
 101         # Set-up message, producer and consumer for tests
 102         payload = {"vim_type": "OpenSTACK",
 103                    "correlation_id": 123,
 104                    "metric_uuid": "metric_id",
 105                    "metric_name": "metric_name",
 106                    "resource_uuid": "resource_id"}
 107
 108         self.producer.send('metric_request', key="delete_metric_request",
 109                            value=json.dumps(payload))
 110
 111         for message in self.req_consumer:
 112             # Check the vim desired by the message
 113             vim_type = json.loads(message.value)["vim_type"].lower()
 114             if vim_type == "openstack":
 115                 # Metric has been deleted
 116                 del_metric.return_value = True
 117                 self.metric_req.metric_calls(message, self.openstack_auth, None)
 118
 119                 # A response message is generated and sent by MON's producer
 120                 resp.assert_called_with(
 121                     'delete_metric_response', m_id="metric_id",
 122                     m_name="metric_name", status=True, r_id="resource_id",
 123                     cor_id=123)
 124                 del_resp.assert_called_with(
 125                     'delete_metric_response', resp.return_value, 'metric_response')
 126
 127                 return
 128         self.fail("No message received in consumer")
 129
 130     @mock.patch.object(metrics.Metrics, "read_metric_data")
 131     @mock.patch.object(prod, "read_metric_data_response")
 132     @mock.patch.object(response.OpenStack_Response, "generate_response")
 133     def test_read_metric_data_req(self, resp, read_resp, read_data):
 134         """Test Gnocchi read metric data request message from producer."""
 135         # Set-up message, producer and consumer for tests
 136         payload = {"vim_type": "OpenSTACK",
 137                    "correlation_id": 123,
 138                    "metric_uuid": "metric_id",
 139                    "metric_name": "metric_name",
 140                    "resource_uuid": "resource_id"}
 141
 142         self.producer.send('metric_request', key="read_metric_data_request",
 143                            value=json.dumps(payload))
 144
 145         for message in self.req_consumer:
 146             # Check the vim desired by the message
 147             vim_type = json.loads(message.value)["vim_type"].lower()
 148             if vim_type == "openstack":
 149                 # Mock empty lists generated by the request message
 150                 read_data.return_value = [], []
 151                 self.metric_req.metric_calls(message, self.openstack_auth, None)
 152
 153                 # A response message is generated and sent by MON's producer
 154                 resp.assert_called_with(
 155                     'read_metric_data_response', m_id="metric_id",
 156                     m_name="metric_name", r_id="resource_id", cor_id=123, times=[],
 157                     metrics=[])
 158                 read_resp.assert_called_with(
 159                     'read_metric_data_response', resp.return_value,
 160                     'metric_response')
 161
 162                 return
 163         self.fail("No message received in consumer")
 164
 165     @mock.patch.object(metrics.Metrics, "list_metrics")
 166     @mock.patch.object(prod, "list_metric_response")
 167     @mock.patch.object(response.OpenStack_Response, "generate_response")
 168     def test_list_metrics_req(self, resp, list_resp, list_metrics):
 169         """Test Gnocchi list metrics request message from producer."""
 170         # Set-up message, producer and consumer for tests
 171         payload = {"vim_type": "OpenSTACK",
 172                    "metrics_list_request":
 173                        {"correlation_id": 123, }}
 174
 175         self.producer.send('metric_request', key="list_metric_request",
 176                            value=json.dumps(payload))
 177
 178         for message in self.req_consumer:
 179             # Check the vim desired by the message
 180             vim_type = json.loads(message.value)["vim_type"].lower()
 181             if vim_type == "openstack":
 182                 # Mock an empty list generated by the request
 183                 list_metrics.return_value = []
 184                 self.metric_req.metric_calls(message, self.openstack_auth, None)
 185
 186                 # A response message is generated and sent by MON's producer
 187                 resp.assert_called_with(
 188                     'list_metric_response', m_list=[], cor_id=123)
 189                 list_resp.assert_called_with(
 190                     'list_metric_response', resp.return_value, 'metric_response')
 191
 192                 return
 193         self.fail("No message received in consumer")
 194
 195     @mock.patch.object(metrics.Metrics, "get_metric_id")
 196     @mock.patch.object(prod, "update_metric_response")
 197     @mock.patch.object(response.OpenStack_Response, "generate_response")
 198     def test_update_metrics_req(self, resp, update_resp, get_id):
 199         """Test Gnocchi update metric request message from KafkaProducer."""
 200         # Set-up message, producer and consumer for tests
 201         payload = {"vim_type": "OpenSTACK",
 202                    "correlation_id": 123,
 203                    "metric_create":
 204                        {"metric_name": "my_metric",
 205                         "resource_uuid": "resource_id", }}
 206
 207         self.producer.send('metric_request', key="update_metric_request",
 208                            value=json.dumps(payload))
 209
 210         for message in self.req_consumer:
 211             # Check the vim desired by the message
 212             vim_type = json.loads(message.value)["vim_type"].lower()
 213             if vim_type == "openstack":
 214                 # Gnocchi doesn't support metric updates
 215                 get_id.return_value = "metric_id"
 216                 self.metric_req.metric_calls(message, self.openstack_auth, None)
 217
 218                 # Reponse message is generated and sent via MON's producer
 219                 # No metric update has taken place
 220                 resp.assert_called_with(
 221                     'update_metric_response', status=False, cor_id=123,
 222                     r_id="resource_id", m_id="metric_id")
 223                 update_resp.assert_called_with(
 224                     'update_metric_response', resp.return_value, 'metric_response')
 225
 226                 return
 227         self.fail("No message received in consumer")