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
.core
.message_bus
.producer
import KafkaProducer
as prod
37 from osm_mon
.plugins
.OpenStack
import response
38 from osm_mon
.plugins
.OpenStack
.Aodh
import alarming
39 from osm_mon
.plugins
.OpenStack
.common
import Common
41 log
= logging
.getLogger(__name__
)
43 mock_creds
= VimCredentials()
44 mock_creds
.config
= '{}'
47 class AlarmIntegrationTest(unittest
.TestCase
):
50 self
.producer
= KafkaProducer(bootstrap_servers
='localhost:9092',
51 key_serializer
=str.encode
,
52 value_serializer
=str.encode
54 self
.req_consumer
= KafkaConsumer(bootstrap_servers
='localhost:9092',
55 key_deserializer
=bytes
.decode
,
56 value_deserializer
=bytes
.decode
,
57 auto_offset_reset
='earliest',
58 consumer_timeout_ms
=60000)
59 self
.req_consumer
.subscribe(['alarm_request'])
61 self
.skipTest('Kafka server not present.')
62 # Set up common and alarming class instances
63 self
.alarms
= alarming
.Alarming()
64 self
.openstack_auth
= Common()
66 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
67 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
68 @mock.patch
.object(AuthManager
, 'get_credentials')
69 @mock.patch
.object(prod
, "update_alarm_response")
70 @mock.patch
.object(alarming
.Alarming
, "update_alarm")
71 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
72 def test_update_alarm_req(self
, resp
, update_alarm
, update_resp
, get_creds
):
73 """Test Aodh update alarm request message from KafkaProducer."""
74 # Set-up message, producer and consumer for tests
75 payload
= {"vim_type": "OpenSTACK",
76 "vim_uuid": "test_id",
77 "alarm_update_request":
78 {"correlation_id": 123,
79 "alarm_uuid": "alarm_id",
80 "metric_uuid": "metric_id"}}
82 get_creds
.return_value
= mock_creds
84 self
.producer
.send('alarm_request', key
="update_alarm_request",
85 value
=json
.dumps(payload
))
87 for message
in self
.req_consumer
:
88 # Check the vim desired by the message
89 if message
.key
== "update_alarm_request":
90 # Mock a valid alarm update
91 update_alarm
.return_value
= "alarm_id", True
92 self
.alarms
.alarming(message
)
94 # A response message is generated and sent via MON's producer
95 resp
.assert_called_with(
96 'update_alarm_response', alarm_id
="alarm_id", cor_id
=123,
98 update_resp
.assert_called_with(
99 'update_alarm_response', resp
.return_value
)
102 self
.fail("No message received in consumer")
104 @mock.patch
.object(DatabaseManager
, "save_alarm", mock
.Mock())
105 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
106 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
107 @mock.patch
.object(AuthManager
, 'get_credentials')
108 @mock.patch
.object(prod
, "create_alarm_response")
109 @mock.patch
.object(alarming
.Alarming
, "configure_alarm")
110 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
111 def test_create_alarm_req(self
, resp
, config_alarm
, create_resp
, get_creds
):
112 """Test Aodh create alarm request message from KafkaProducer."""
113 # Set-up message, producer and consumer for tests
114 payload
= {"vim_type": "OpenSTACK",
115 "vim_uuid": "test_id",
116 "alarm_create_request":
117 {"correlation_id": 123,
118 "alarm_name": "my_alarm",
119 "metric_name": "my_metric",
120 "resource_uuid": "my_resource",
121 "severity": "WARNING"}}
123 get_creds
.return_value
= mock_creds
125 self
.producer
.send('alarm_request', key
="create_alarm_request",
126 value
=json
.dumps(payload
))
128 for message
in self
.req_consumer
:
129 # Check the vim desired by the message
130 if message
.key
== "create_alarm_request":
131 # Mock a valid alarm creation
132 config_alarm
.return_value
= "alarm_id", True
133 self
.alarms
.alarming(message
)
135 # A response message is generated and sent via MON's produce
136 resp
.assert_called_with(
137 'create_alarm_response', status
=True, alarm_id
="alarm_id",
139 create_resp
.assert_called_with(
140 'create_alarm_response', resp
.return_value
)
143 self
.fail("No message received in consumer")
145 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
146 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
147 @mock.patch
.object(AuthManager
, 'get_credentials')
148 @mock.patch
.object(prod
, "list_alarm_response")
149 @mock.patch
.object(alarming
.Alarming
, "list_alarms")
150 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
151 def test_list_alarm_req(self
, resp
, list_alarm
, list_resp
, get_creds
):
152 """Test Aodh list alarm request message from KafkaProducer."""
153 # Set-up message, producer and consumer for tests
154 payload
= {"vim_type": "OpenSTACK",
155 "vim_uuid": "test_id",
156 "alarm_list_request":
157 {"correlation_id": 123,
158 "resource_uuid": "resource_id", }}
160 self
.producer
.send('alarm_request', key
="list_alarm_request",
161 value
=json
.dumps(payload
))
163 get_creds
.return_value
= mock_creds
165 for message
in self
.req_consumer
:
166 # Check the vim desired by the message
167 if message
.key
== "list_alarm_request":
168 # Mock an empty list generated by the request
169 list_alarm
.return_value
= []
170 self
.alarms
.alarming(message
)
172 # Response message is generated
173 resp
.assert_called_with(
174 'list_alarm_response', alarm_list
=[],
176 # Producer attempts to send the response message back to the SO
177 list_resp
.assert_called_with(
178 'list_alarm_response', resp
.return_value
)
181 self
.fail("No message received in consumer")
183 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
184 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
185 @mock.patch
.object(AuthManager
, 'get_credentials')
186 @mock.patch
.object(alarming
.Alarming
, "delete_alarm")
187 @mock.patch
.object(prod
, "delete_alarm_response")
188 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
189 def test_delete_alarm_req(self
, resp
, del_resp
, del_alarm
, get_creds
):
190 """Test Aodh delete alarm request message from KafkaProducer."""
191 # Set-up message, producer and consumer for tests
192 payload
= {"vim_type": "OpenSTACK",
193 "vim_uuid": "test_id",
194 "alarm_delete_request":
195 {"correlation_id": 123,
196 "alarm_uuid": "alarm_id", }}
198 self
.producer
.send('alarm_request', key
="delete_alarm_request",
199 value
=json
.dumps(payload
))
201 get_creds
.return_value
= mock_creds
203 for message
in self
.req_consumer
:
204 # Check the vim desired by the message
205 if message
.key
== "delete_alarm_request":
206 self
.alarms
.alarming(message
)
208 # Response message is generated and sent by MON's producer
209 resp
.assert_called_with(
210 'delete_alarm_response', alarm_id
="alarm_id",
211 status
=del_alarm
.return_value
, cor_id
=123)
212 del_resp
.assert_called_with(
213 'delete_alarm_response', resp
.return_value
)
216 self
.fail("No message received in consumer")
218 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
219 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
220 @mock.patch
.object(AuthManager
, 'get_credentials')
221 @mock.patch
.object(alarming
.Alarming
, "update_alarm_state")
222 def test_ack_alarm_req(self
, ack_alarm
, get_creds
):
223 """Test Aodh acknowledge alarm request message from KafkaProducer."""
224 # Set-up message, producer and consumer for tests
225 payload
= {"vim_type": "OpenSTACK",
226 "vim_uuid": "test_id",
228 {"alarm_uuid": "alarm_id", }}
230 self
.producer
.send('alarm_request', key
="acknowledge_alarm",
231 value
=json
.dumps(payload
))
233 get_creds
.return_value
= mock_creds
235 for message
in self
.req_consumer
:
236 # Check the vim desired by the message
237 if message
.key
== "acknowledge_alarm":
238 self
.alarms
.alarming(message
)
241 self
.fail("No message received in consumer")