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 alarm requests."""
30 from kafka
import KafkaConsumer
31 from kafka
import KafkaProducer
32 from kafka
.errors
import KafkaError
34 from osm_mon
.core
.auth
import AuthManager
35 from osm_mon
.core
.database
import DatabaseManager
, VimCredentials
36 from osm_mon
.plugins
.OpenStack
import response
37 from osm_mon
.plugins
.OpenStack
.Aodh
import alarm_handler
38 from osm_mon
.plugins
.OpenStack
.common
import Common
40 log
= logging
.getLogger(__name__
)
42 mock_creds
= VimCredentials()
43 mock_creds
.config
= '{}'
46 @mock.patch
.object(DatabaseManager
, "save_alarm", mock
.Mock())
47 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
48 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
49 class AlarmIntegrationTest(unittest
.TestCase
):
52 self
.producer
= KafkaProducer(bootstrap_servers
='localhost:9092',
53 key_serializer
=str.encode
,
54 value_serializer
=str.encode
56 self
.req_consumer
= KafkaConsumer(bootstrap_servers
='localhost:9092',
57 key_deserializer
=bytes
.decode
,
58 value_deserializer
=bytes
.decode
,
59 auto_offset_reset
='earliest',
60 consumer_timeout_ms
=60000)
61 self
.req_consumer
.subscribe(['alarm_request'])
63 self
.skipTest('Kafka server not present.')
64 # Set up common and alarming class instances
65 self
.alarms
= alarm_handler
.OpenstackAlarmHandler()
66 self
.openstack_auth
= Common()
70 self
.req_consumer
.close()
72 @mock.patch
.object(Common
, "perform_request")
73 @mock.patch
.object(AuthManager
, 'get_credentials')
74 @mock.patch
.object(alarm_handler
.OpenstackAlarmHandler
, "update_alarm")
75 @mock.patch
.object(response
.OpenStackResponseBuilder
, "generate_response")
76 def test_update_alarm_req(self
, resp
, update_alarm
, get_creds
, perf_req
):
77 """Test Aodh update alarm request message from KafkaProducer."""
78 # Set-up message, producer and consumer for tests
79 payload
= {"alarm_update_request": {"correlation_id": 123,
80 "alarm_uuid": "alarm_id",
81 "metric_uuid": "metric_id"}}
83 get_creds
.return_value
= mock_creds
84 perf_req
.return_value
= type('obj', (object,), {'text': json
.dumps({"metrics": {"cpu_util": "1"}})})
85 resp
.return_value
= ''
87 self
.producer
.send('alarm_request', key
="update_alarm_request",
88 value
=json
.dumps(payload
))
90 for message
in self
.req_consumer
:
91 if message
.key
== "update_alarm_request":
92 # Mock a valid alarm update
93 update_alarm
.return_value
= "alarm_id"
94 self
.alarms
.handle_message(message
, 'test_id')
96 # A response message is generated and sent via MON's producer
97 resp
.assert_called_with(
98 'update_alarm_response', alarm_id
="alarm_id", cor_id
=123,
102 self
.fail("No message received in consumer")
104 @mock.patch
.object(Common
, "perform_request")
105 @mock.patch
.object(AuthManager
, 'get_credentials')
106 @mock.patch
.object(alarm_handler
.OpenstackAlarmHandler
, "configure_alarm")
107 @mock.patch
.object(response
.OpenStackResponseBuilder
, "generate_response")
108 def test_create_alarm_req(self
, resp
, config_alarm
, get_creds
, perf_req
):
109 """Test Aodh create alarm request message from KafkaProducer."""
110 # Set-up message, producer and consumer for tests
111 payload
= {"alarm_create_request": {"correlation_id": 123,
112 "alarm_name": "my_alarm",
113 "metric_name": "cpu_utilization",
114 "resource_uuid": "my_resource",
115 "severity": "WARNING",
116 "threshold_value": 60,
119 "vnf_member_index": "1",
122 get_creds
.return_value
= mock_creds
123 perf_req
.return_value
= type('obj', (object,), {'text': json
.dumps({"metrics": {"cpu_util": "1"}})})
124 resp
.return_value
= ''
125 self
.producer
.send('alarm_request', key
="create_alarm_request",
126 value
=json
.dumps(payload
))
128 for message
in self
.req_consumer
:
129 if message
.key
== "create_alarm_request":
130 # Mock a valid alarm creation
131 config_alarm
.return_value
= "alarm_id"
132 self
.alarms
.handle_message(message
, 'test_id')
134 # A response message is generated and sent via MON's produce
135 resp
.assert_called_with(
136 'create_alarm_response', status
=True, alarm_id
="alarm_id",
140 self
.fail("No message received in consumer")
142 @mock.patch
.object(Common
, "perform_request")
143 @mock.patch
.object(AuthManager
, 'get_credentials')
144 @mock.patch
.object(alarm_handler
.OpenstackAlarmHandler
, "list_alarms")
145 @mock.patch
.object(response
.OpenStackResponseBuilder
, "generate_response")
146 def test_list_alarm_req(self
, resp
, list_alarm
, get_creds
, perf_req
):
147 """Test Aodh list alarm request message from KafkaProducer."""
148 # Set-up message, producer and consumer for tests
149 payload
= {"alarm_list_request": {"correlation_id": 123,
150 "resource_uuid": "resource_id", }}
152 self
.producer
.send('alarm_request', key
="list_alarm_request",
153 value
=json
.dumps(payload
))
155 get_creds
.return_value
= mock_creds
156 perf_req
.return_value
= type('obj', (object,), {'text': json
.dumps([])})
157 resp
.return_value
= ''
159 for message
in self
.req_consumer
:
160 if message
.key
== "list_alarm_request":
161 # Mock an empty list generated by the request
162 list_alarm
.return_value
= []
163 self
.alarms
.handle_message(message
, 'test_id')
165 # Response message is generated
166 resp
.assert_called_with(
167 'list_alarm_response', alarm_list
=[],
171 self
.fail("No message received in consumer")
173 @mock.patch
.object(Common
, "perform_request")
174 @mock.patch
.object(AuthManager
, 'get_credentials')
175 @mock.patch
.object(alarm_handler
.OpenstackAlarmHandler
, "delete_alarm")
176 @mock.patch
.object(response
.OpenStackResponseBuilder
, "generate_response")
177 def test_delete_alarm_req(self
, resp
, del_alarm
, get_creds
, perf_req
):
178 """Test Aodh delete alarm request message from KafkaProducer."""
179 # Set-up message, producer and consumer for tests
180 payload
= {"alarm_delete_request": {"correlation_id": 123,
181 "alarm_uuid": "alarm_id", }}
183 self
.producer
.send('alarm_request', key
="delete_alarm_request",
184 value
=json
.dumps(payload
))
186 get_creds
.return_value
= mock_creds
187 perf_req
.return_value
= type('obj', (object,), {'text': json
.dumps([])})
188 resp
.return_value
= ''
190 for message
in self
.req_consumer
:
191 if message
.key
== "delete_alarm_request":
192 self
.alarms
.handle_message(message
, 'test_id')
194 # Response message is generated and sent by MON's producer
195 resp
.assert_called_with(
196 'delete_alarm_response', alarm_id
="alarm_id",
197 status
=True, cor_id
=123)
200 self
.fail("No message received in consumer")
202 @mock.patch
.object(AuthManager
, 'get_credentials')
203 @mock.patch
.object(alarm_handler
.OpenstackAlarmHandler
, "update_alarm_state")
204 def test_ack_alarm_req(self
, ack_alarm
, get_creds
):
205 """Test Aodh acknowledge alarm request message from KafkaProducer."""
206 # Set-up message, producer and consumer for tests
207 payload
= {"ack_details": {"alarm_uuid": "alarm_id", }}
209 self
.producer
.send('alarm_request', key
="acknowledge_alarm",
210 value
=json
.dumps(payload
))
212 get_creds
.return_value
= mock_creds
213 ack_alarm
.return_value
= True
215 for message
in self
.req_consumer
:
216 if message
.key
== "acknowledge_alarm":
217 self
.alarms
.handle_message(message
, 'test_id')
218 ack_alarm
.assert_called_with(mock
.ANY
, mock
.ANY
, 'alarm_id', True)
221 self
.fail("No message received in consumer")