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
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
40 from keystoneclient
.v3
import client
42 log
= logging
.getLogger(__name__
)
45 class AlarmIntegrationTest(unittest
.TestCase
):
48 self
.producer
= KafkaProducer(bootstrap_servers
='localhost:9092')
49 self
.req_consumer
= KafkaConsumer(bootstrap_servers
='localhost:9092',
50 auto_offset_reset
='earliest',
51 consumer_timeout_ms
=60000)
52 self
.req_consumer
.subscribe(['alarm_request'])
54 self
.skipTest('Kafka server not present.')
55 # Set up common and alarming class instances
56 self
.alarms
= alarming
.Alarming()
57 self
.openstack_auth
= Common()
59 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
60 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
61 @mock.patch
.object(prod
, "update_alarm_response")
62 @mock.patch
.object(alarming
.Alarming
, "update_alarm")
63 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
64 def test_update_alarm_req(self
, resp
, update_alarm
, update_resp
):
65 """Test Aodh update alarm request message from KafkaProducer."""
66 # Set-up message, producer and consumer for tests
67 payload
= {"vim_type": "OpenSTACK",
68 "vim_uuid": "test_id",
69 "alarm_update_request":
70 {"correlation_id": 123,
71 "alarm_uuid": "alarm_id",
72 "metric_uuid": "metric_id"}}
74 self
.producer
.send('alarm_request', key
="update_alarm_request",
75 value
=json
.dumps(payload
))
77 for message
in self
.req_consumer
:
78 # Check the vim desired by the message
79 if message
.key
== "update_alarm_request":
80 # Mock a valid alarm update
81 update_alarm
.return_value
= "alarm_id", True
82 self
.alarms
.alarming(message
)
84 # A response message is generated and sent via MON's producer
85 resp
.assert_called_with(
86 'update_alarm_response', alarm_id
="alarm_id", cor_id
=123,
88 update_resp
.assert_called_with(
89 'update_alarm_response', resp
.return_value
, 'alarm_response')
92 self
.fail("No message received in consumer")
94 @mock.patch
.object(DatabaseManager
, "save_alarm", mock
.Mock())
95 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
96 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
97 @mock.patch
.object(prod
, "create_alarm_response")
98 @mock.patch
.object(alarming
.Alarming
, "configure_alarm")
99 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
100 def test_create_alarm_req(self
, resp
, config_alarm
, create_resp
):
101 """Test Aodh create alarm request message from KafkaProducer."""
102 # Set-up message, producer and consumer for tests
103 payload
= {"vim_type": "OpenSTACK",
104 "vim_uuid": "test_id",
105 "alarm_create_request":
106 {"correlation_id": 123,
107 "alarm_name": "my_alarm",
108 "metric_name": "my_metric",
109 "resource_uuid": "my_resource",
110 "severity": "WARNING"}}
112 self
.producer
.send('alarm_request', key
="create_alarm_request",
113 value
=json
.dumps(payload
))
115 for message
in self
.req_consumer
:
116 # Check the vim desired by the message
117 if message
.key
== "create_alarm_request":
118 # Mock a valid alarm creation
119 config_alarm
.return_value
= "alarm_id", True
120 self
.alarms
.alarming(message
)
122 # A response message is generated and sent via MON's produce
123 resp
.assert_called_with(
124 'create_alarm_response', status
=True, alarm_id
="alarm_id",
126 create_resp
.assert_called_with(
127 'create_alarm_response', resp
.return_value
, 'alarm_response')
130 self
.fail("No message received in consumer")
132 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
133 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
134 @mock.patch
.object(prod
, "list_alarm_response")
135 @mock.patch
.object(alarming
.Alarming
, "list_alarms")
136 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
137 def test_list_alarm_req(self
, resp
, list_alarm
, list_resp
):
138 """Test Aodh list alarm request message from KafkaProducer."""
139 # Set-up message, producer and consumer for tests
140 payload
= {"vim_type": "OpenSTACK",
141 "vim_uuid": "test_id",
142 "alarm_list_request":
143 {"correlation_id": 123,
144 "resource_uuid": "resource_id", }}
146 self
.producer
.send('alarm_request', key
="list_alarm_request",
147 value
=json
.dumps(payload
))
149 for message
in self
.req_consumer
:
150 # Check the vim desired by the message
151 if message
.key
== "list_alarm_request":
152 # Mock an empty list generated by the request
153 list_alarm
.return_value
= []
154 self
.alarms
.alarming(message
)
156 # Response message is generated
157 resp
.assert_called_with(
158 'list_alarm_response', alarm_list
=[],
160 # Producer attempts to send the response message back to the SO
161 list_resp
.assert_called_with(
162 'list_alarm_response', resp
.return_value
, 'alarm_response')
165 self
.fail("No message received in consumer")
167 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
168 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
169 @mock.patch
.object(alarming
.Alarming
, "delete_alarm")
170 @mock.patch
.object(prod
, "delete_alarm_response")
171 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
172 def test_delete_alarm_req(self
, resp
, del_resp
, del_alarm
):
173 """Test Aodh delete alarm request message from KafkaProducer."""
174 # Set-up message, producer and consumer for tests
175 payload
= {"vim_type": "OpenSTACK",
176 "vim_uuid": "test_id",
177 "alarm_delete_request":
178 {"correlation_id": 123,
179 "alarm_uuid": "alarm_id", }}
181 self
.producer
.send('alarm_request', key
="delete_alarm_request",
182 value
=json
.dumps(payload
))
184 for message
in self
.req_consumer
:
185 # Check the vim desired by the message
186 if message
.key
== "delete_alarm_request":
187 self
.alarms
.alarming(message
)
189 # Response message is generated and sent by MON's producer
190 resp
.assert_called_with(
191 'delete_alarm_response', alarm_id
="alarm_id",
192 status
=del_alarm
.return_value
, cor_id
=123)
193 del_resp
.assert_called_with(
194 'delete_alarm_response', resp
.return_value
, 'alarm_response')
197 self
.fail("No message received in consumer")
199 @mock.patch
.object(Common
, "get_auth_token", mock
.Mock())
200 @mock.patch
.object(Common
, "get_endpoint", mock
.Mock())
201 @mock.patch
.object(alarming
.Alarming
, "update_alarm_state")
202 def test_ack_alarm_req(self
, ack_alarm
):
203 """Test Aodh acknowledge alarm request message from KafkaProducer."""
204 # Set-up message, producer and consumer for tests
205 payload
= {"vim_type": "OpenSTACK",
206 "vim_uuid": "test_id",
208 {"alarm_uuid": "alarm_id", }}
210 self
.producer
.send('alarm_request', key
="acknowledge_alarm",
211 value
=json
.dumps(payload
))
213 for message
in self
.req_consumer
:
214 # Check the vim desired by the message
215 if message
.key
== "acknowledge_alarm":
216 self
.alarms
.alarming(message
)
219 self
.fail("No message received in consumer")