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
.message_bus
.producer
import KafkaProducer
as prod
35 from osm_mon
.plugins
.OpenStack
import response
36 from osm_mon
.plugins
.OpenStack
.Aodh
import alarming
37 from osm_mon
.plugins
.OpenStack
.common
import Common
39 log
= logging
.getLogger(__name__
)
42 class AlarmIntegrationTest(unittest
.TestCase
):
44 # Set up common and alarming class instances
45 self
.alarms
= alarming
.Alarming()
46 self
.openstack_auth
= Common()
49 self
.producer
= KafkaProducer(bootstrap_servers
='localhost:9092')
50 self
.req_consumer
= KafkaConsumer(bootstrap_servers
='localhost:9092',
52 consumer_timeout_ms
=2000)
53 self
.req_consumer
.subscribe(['alarm_request'])
55 self
.skipTest('Kafka server not present.')
57 @mock.patch
.object(prod
, "update_alarm_response")
58 @mock.patch
.object(alarming
.Alarming
, "update_alarm")
59 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
60 def test_update_alarm_req(self
, resp
, update_alarm
, update_resp
):
61 """Test Aodh update alarm request message from KafkaProducer."""
62 # Set-up message, producer and consumer for tests
63 payload
= {"vim_type": "OpenSTACK",
64 "alarm_update_request":
65 {"correlation_id": 123,
66 "alarm_uuid": "alarm_id",
67 "metric_uuid": "metric_id"}}
69 self
.producer
.send('alarm_request', key
="update_alarm_request",
70 value
=json
.dumps(payload
))
72 for message
in self
.req_consumer
:
73 # Check the vim desired by the message
74 vim_type
= json
.loads(message
.value
)["vim_type"].lower()
75 if vim_type
== "openstack":
76 # Mock a valid alarm update
77 update_alarm
.return_value
= "alarm_id", True
78 self
.alarms
.alarming(message
, self
.openstack_auth
, None)
80 # A response message is generated and sent via MON's producer
81 resp
.assert_called_with(
82 'update_alarm_response', alarm_id
="alarm_id", cor_id
=123,
84 update_resp
.assert_called_with(
85 'update_alarm_response', resp
.return_value
, 'alarm_response')
88 self
.fail("No message received in consumer")
90 @mock.patch
.object(prod
, "create_alarm_response")
91 @mock.patch
.object(alarming
.Alarming
, "configure_alarm")
92 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
93 def test_create_alarm_req(self
, resp
, config_alarm
, create_resp
):
94 """Test Aodh create alarm request message from KafkaProducer."""
95 # Set-up message, producer and consumer for tests
96 payload
= {"vim_type": "OpenSTACK",
97 "alarm_create_request":
98 {"correlation_id": 123,
99 "alarm_name": "my_alarm",
100 "metric_name": "my_metric",
101 "resource_uuid": "my_resource",
102 "severity": "WARNING"}}
104 self
.producer
.send('alarm_request', key
="create_alarm_request",
105 value
=json
.dumps(payload
))
107 for message
in self
.req_consumer
:
108 # Check the vim desired by the message
109 vim_type
= json
.loads(message
.value
)["vim_type"].lower()
110 if vim_type
== "openstack":
111 # Mock a valid alarm creation
112 config_alarm
.return_value
= "alarm_id", True
113 self
.alarms
.alarming(message
, self
.openstack_auth
, None)
115 # A response message is generated and sent via MON's produce
116 resp
.assert_called_with(
117 'create_alarm_response', status
=True, alarm_id
="alarm_id",
119 create_resp
.assert_called_with(
120 'create_alarm_response', resp
.return_value
, 'alarm_response')
123 self
.fail("No message received in consumer")
125 @mock.patch
.object(prod
, "list_alarm_response")
126 @mock.patch
.object(alarming
.Alarming
, "list_alarms")
127 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
128 def test_list_alarm_req(self
, resp
, list_alarm
, list_resp
):
129 """Test Aodh list alarm request message from KafkaProducer."""
130 # Set-up message, producer and consumer for tests
131 payload
= {"vim_type": "OpenSTACK",
132 "alarm_list_request":
133 {"correlation_id": 123,
134 "resource_uuid": "resource_id", }}
136 self
.producer
.send('alarm_request', key
="list_alarm_request",
137 value
=json
.dumps(payload
))
139 for message
in self
.req_consumer
:
140 # Check the vim desired by the message
141 vim_type
= json
.loads(message
.value
)["vim_type"].lower()
142 if vim_type
== "openstack":
143 # Mock an empty list generated by the request
144 list_alarm
.return_value
= []
145 self
.alarms
.alarming(message
, self
.openstack_auth
, None)
147 # Resoonse message is generated
148 resp
.assert_called_with(
149 'list_alarm_response', alarm_list
=[],
151 # Producer attempts to send the response message back to the SO
152 list_resp
.assert_called_with(
153 'list_alarm_response', resp
.return_value
, 'alarm_response')
156 self
.fail("No message received in consumer")
158 @mock.patch
.object(alarming
.Alarming
, "delete_alarm")
159 @mock.patch
.object(prod
, "delete_alarm_response")
160 @mock.patch
.object(response
.OpenStack_Response
, "generate_response")
161 def test_delete_alarm_req(self
, resp
, del_resp
, del_alarm
):
162 """Test Aodh delete alarm request message from KafkaProducer."""
163 # Set-up message, producer and consumer for tests
164 payload
= {"vim_type": "OpenSTACK",
165 "alarm_delete_request":
166 {"correlation_id": 123,
167 "alarm_uuid": "alarm_id", }}
169 self
.producer
.send('alarm_request', key
="delete_alarm_request",
170 value
=json
.dumps(payload
))
172 for message
in self
.req_consumer
:
173 # Check the vim desired by the message
174 vim_type
= json
.loads(message
.value
)["vim_type"].lower()
175 if vim_type
== "openstack":
176 self
.alarms
.alarming(message
, self
.openstack_auth
, None)
178 # Response message is generated and sent by MON's producer
179 resp
.assert_called_with(
180 'delete_alarm_response', alarm_id
="alarm_id",
181 status
=del_alarm
.return_value
, cor_id
=123)
182 del_resp
.assert_called_with(
183 'delete_alarm_response', resp
.return_value
, 'alarm_response')
186 self
.fail("No message received in consumer")
188 @mock.patch
.object(alarming
.Alarming
, "update_alarm_state")
189 def test_ack_alarm_req(self
, ack_alarm
):
190 """Test Aodh acknowledge alarm request message from KafkaProducer."""
191 # Set-up message, producer and consumer for tests
192 payload
= {"vim_type": "OpenSTACK",
194 {"alarm_uuid": "alarm_id", }}
196 self
.producer
.send('alarm_request', key
="acknowledge_alarm",
197 value
=json
.dumps(payload
))
199 for message
in self
.req_consumer
:
200 # Check the vim desired by the message
201 vim_type
= json
.loads(message
.value
)["vim_type"].lower()
202 if vim_type
== "openstack":
203 self
.alarms
.alarming(message
, self
.openstack_auth
, None)
204 # No response message is sent for and ack request
205 # Alarm state is updated from alarm -> ok
206 ack_alarm
.assert_called_with(None, None, "alarm_id")
208 self
.fail("No message received in consumer")