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
.message_bus
.producer
import KafkaProducer
as prod
34 from kafka
import KafkaConsumer
35 from kafka
import KafkaProducer
39 from osm_mon
.plugins
.OpenStack
import response
41 from osm_mon
.plugins
.OpenStack
.Gnocchi
import metrics
43 from osm_mon
.plugins
.OpenStack
.common
import Common
45 log
= logging
.getLogger(__name__
)
48 class MetricIntegrationTest(unittest
.TestCase
):
50 # Set up common and alarming class instances
51 self
.metric_req
= metrics
.Metrics()
52 self
.openstack_auth
= Common()
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'])
61 self
.skipTest('Kafka server not present.')
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",
73 "correlation_id": 123,
75 {"metric_name": "my_metric",
76 "resource_uuid": "resource_id"}}
78 self
.producer
.send('metric_request', key
="create_metric_request",
79 value
=json
.dumps(payload
))
81 for message
in self
.req_consumer
:
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
)
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')
98 self
.fail("No message received in consumer")
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",
110 "correlation_id": 123,
111 "metric_uuid": "metric_id",
112 "metric_name": "metric_name",
113 "resource_uuid": "resource_id"}
115 self
.producer
.send('metric_request', key
="delete_metric_request",
116 value
=json
.dumps(payload
))
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
)
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",
129 del_resp
.assert_called_with(
130 'delete_metric_response', resp
.return_value
, 'metric_response')
133 self
.fail("No message received in consumer")
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"}
150 self
.producer
.send('metric_request', key
="read_metric_data_request",
151 value
=json
.dumps(payload
))
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
)
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
=[],
165 read_resp
.assert_called_with(
166 'read_metric_data_response', resp
.return_value
,
170 self
.fail("No message received in consumer")
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",
182 "metrics_list_request":
183 {"correlation_id": 123, }}
185 self
.producer
.send('metric_request', key
="list_metric_request",
186 value
=json
.dumps(payload
))
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
)
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')
202 self
.fail("No message received in consumer")
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,
216 {"metric_name": "my_metric",
217 "resource_uuid": "resource_id", }}
219 self
.producer
.send('metric_request', key
="update_metric_request",
220 value
=json
.dumps(payload
))
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
)
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')
238 self
.fail("No message received in consumer")