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