1 # Copyright 2017 Intel Research and Development Ireland Limited
2 # *************************************************************
4 # This file is part of OSM Monitoring module
5 # All Rights Reserved to Intel Corporation
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
11 # http://www.apache.org/licenses/LICENSE-2.0
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
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
22 # __author__ = "Helena McGough"
23 """Test an end to end Openstack metric requests."""
30 from kafka
.errors
import KafkaError
32 from osm_mon
.core
.auth
import AuthManager
33 from osm_mon
.core
.database
import VimCredentials
35 from kafka
import KafkaConsumer
36 from kafka
import KafkaProducer
40 from osm_mon
.plugins
.OpenStack
import response
42 from osm_mon
.plugins
.OpenStack
.Gnocchi
import metric_handler
44 from osm_mon
.plugins
.OpenStack
.common
import Common
46 log
= logging
.getLogger(__name__
)
48 mock_creds
= VimCredentials()
49 mock_creds
.config
= '{}'
52 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
53 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
54 class MetricIntegrationTest(unittest
.TestCase
):
56 # Set up common and alarming class instances
57 self
.metric_req
= metric_handler
.OpenstackMetricHandler()
58 self
.openstack_auth
= Common()
61 self
.producer
= KafkaProducer(bootstrap_servers
='localhost:9092',
62 key_serializer
=str.encode
,
63 value_serializer
=str.encode
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'])
72 self
.skipTest('Kafka server not present.')
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"}}
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
= ''
89 self
.producer
.send('metric_request', key
="create_metric_request",
90 value
=json
.dumps(payload
))
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')
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")
104 self
.fail("No message received in consumer")
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",
115 "correlation_id": 123,
116 "metric_name": "cpu_utilization",
117 "resource_uuid": "resource_id"}
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
= ''
123 self
.producer
.send('metric_request', key
="delete_metric_request",
124 value
=json
.dumps(payload
))
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')
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",
139 self
.fail("No message received in consumer")
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"}
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
= ''
158 self
.producer
.send('metric_request', key
="read_metric_data_request",
159 value
=json
.dumps(payload
))
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')
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)
175 self
.fail("No message received in consumer")
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",
186 "metrics_list_request":
187 {"correlation_id": 123, }}
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
= ''
193 self
.producer
.send('metric_request', key
="list_metric_request",
194 value
=json
.dumps(payload
))
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')
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)
208 self
.fail("No message received in consumer")
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", }}
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
= ''
225 self
.producer
.send('metric_request', key
="update_metric_request",
226 value
=json
.dumps(payload
))
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')
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")
242 self
.fail("No message received in consumer")