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