1 from connection
import Connection
8 from jsmin
import jsmin
9 sys
.path
.append("../../test/core/")
10 from test_producer
import KafkaProducer
11 from kafka
import KafkaConsumer
16 import boto
.ec2
.cloudwatch
17 import boto
.ec2
.connection
19 exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
21 #--------------------------------------------------------------------------------------------------------------------------------------
23 # Test Producer object to generate request
25 producer
= KafkaProducer('create_alarm_request')
27 connections
= obj
.setEnvironment()
28 connections_res
= obj
.connection_instance()
29 cloudwatch_conn
= connections_res
['cloudwatch_connection']
31 #--------------------------------------------------------------------------------------------------------------------------------------
33 '''Test E2E Flow : Test cases has been tested one at a time.
34 1) Commom Request is generated using request function in test_producer.py(/test/core)
35 2) The request is then consumed by the comsumer (plugin)
36 3) The response is sent back on the message bus in plugin_alarm.py using
37 response functions in producer.py(/core/message-bus)
38 4) The response is then again consumed by the unit_tests_alarms.py
39 and the test cases has been applied on the response.
42 class config_alarm_name_test(unittest
.TestCase
):
47 #To generate a request of testing new alarm name and new instance id in create alarm request
48 def test_differentName_differentInstance(self
):
50 producer
.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
51 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
53 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
54 _consumer
.subscribe(['alarm_response'])
56 for message
in _consumer
:
57 if message
.key
== "create_alarm_response":
58 info
= json
.loads(json
.loads(message
.value
))
61 self
.assertTrue(info
['alarm_create_response']['status'])
64 #To generate a request of testing new alarm name and existing instance id in create alarm request
65 def test_differentName_sameInstance(self
):
67 producer
.request("test_schemas/create_alarm/create_alarm_differentName_sameInstance.json",'create_alarm_request', '','alarm_request')
68 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
70 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
71 _consumer
.subscribe(['alarm_response'])
73 for message
in _consumer
:
74 if message
.key
== "create_alarm_response":
75 info
= json
.loads(json
.loads(message
.value
))
78 producer
.request("test_schemas/delete_alarm/name_valid_delete1.json",'delete_alarm_request','','alarm_request')
79 self
.assertTrue(info
['alarm_create_response']['status'])
82 #To generate a request of testing existing alarm name and new instance id in create alarm request
83 def test_sameName_differentInstance(self
):
85 producer
.request("test_schemas/create_alarm/create_alarm_sameName_differentInstance.json",'create_alarm_request', '','alarm_request')
86 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
88 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
89 _consumer
.subscribe(['alarm_response'])
91 for message
in _consumer
:
92 if message
.key
== "create_alarm_response":
93 info
= json
.loads(json
.loads(message
.value
))
96 producer
.request("test_schemas/delete_alarm/name_valid_delete2.json",'delete_alarm_request', '','alarm_request')
97 self
.assertTrue(info
['alarm_create_response']['status'])
100 #To generate a request of testing existing alarm name and existing instance id in create alarm request
101 def test_sameName_sameInstance(self
):
103 producer
.request("test_schemas/create_alarm/create_alarm_sameName_sameInstance.json",'create_alarm_request', '','alarm_request')
104 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
106 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
107 _consumer
.subscribe(['alarm_response'])
109 for message
in _consumer
:
110 if message
.key
== "create_alarm_response":
111 info
= json
.loads(json
.loads(message
.value
))
114 producer
.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
115 self
.assertEqual(info
, None)
118 #To generate a request of testing valid statistics in create alarm request
119 def test_statisticValid(self
):
121 producer
.request("test_schemas/create_alarm/statistic_valid.json",'create_alarm_request', '','alarm_request')
122 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
124 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
125 _consumer
.subscribe(['alarm_response'])
127 for message
in _consumer
:
128 if message
.key
== "create_alarm_response":
129 info
= json
.loads(json
.loads(message
.value
))
132 producer
.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
133 self
.assertTrue(info
['alarm_create_response']['status'])
136 #To generate a request of testing Invalid statistics in create alarm request
137 def test_statisticValidNot(self
):
139 producer
.request("test_schemas/create_alarm/statistic_invalid.json",'create_alarm_request', '','alarm_request')
140 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
142 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
143 _consumer
.subscribe(['alarm_response'])
145 for message
in _consumer
:
146 if message
.key
== "create_alarm_response":
147 info
= json
.loads(json
.loads(message
.value
))
150 producer
.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
151 self
.assertEqual(info
, None)
154 #To generate a request of testing valid operation in create alarm request
155 def test_operationValid(self
):
157 producer
.request("test_schemas/create_alarm/operation_valid.json",'create_alarm_request', '','alarm_request')
158 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
160 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
161 _consumer
.subscribe(['alarm_response'])
163 for message
in _consumer
:
164 if message
.key
== "create_alarm_response":
165 info
= json
.loads(json
.loads(message
.value
))
168 producer
.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
169 self
.assertTrue(info
['alarm_create_response']['status'])
172 #To generate a request of testing Invalid operation in create alarm request
173 def test_operationValidNot(self
):
175 producer
.request("test_schemas/create_alarm/operation_invalid.json",'create_alarm_request', '','alarm_request')
176 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
178 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
179 _consumer
.subscribe(['alarm_response'])
181 for message
in _consumer
:
182 if message
.key
== "create_alarm_response":
183 info
= json
.loads(json
.loads(message
.value
))
186 self
.assertEqual(info
,None)
190 #--------------------------------------------------------------------------------------------------------------------------------------
191 class update_alarm_name_test(unittest
.TestCase
):
193 #To generate a request of testing valid alarm_id in update alarm request
194 def test_nameValid(self
):
195 producer
.request("test_schemas/update_alarm/update_alarm_new_alarm.json",'create_alarm_request', '','alarm_request')
197 producer
.request("test_schemas/update_alarm/name_valid.json",'update_alarm_request', '','alarm_request')
198 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
200 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
201 _consumer
.subscribe(['alarm_response'])
203 for message
in _consumer
:
204 if message
.key
== "update_alarm_response":
205 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
208 producer
.request("test_schemas/delete_alarm/name_valid_delete4.json",'delete_alarm_request', '','alarm_request')
209 self
.assertTrue(info
['alarm_update_response']['status'])
212 #To generate a request of testing invalid alarm_id in update alarm request
213 def test_nameInvalid(self
):
215 producer
.request("test_schemas/update_alarm/name_invalid.json",'update_alarm_request', '','alarm_request')
216 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
218 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
219 _consumer
.subscribe(['alarm_response'])
221 for message
in _consumer
:
222 if message
.key
== "update_alarm_response":
223 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
226 self
.assertEqual(info
,None)
229 #To generate a request of testing valid statistics in update alarm request
230 def test_statisticValid(self
):
231 producer
.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
233 producer
.request("test_schemas/update_alarm/statistic_valid.json",'update_alarm_request', '','alarm_request')
234 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
236 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
237 _consumer
.subscribe(['alarm_response'])
239 for message
in _consumer
:
240 if message
.key
== "update_alarm_response":
241 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
244 producer
.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
245 self
.assertTrue(info
['alarm_update_response']['status'])
248 #To generate a request of testing Invalid statistics in update alarm request
249 def test_statisticInvalid(self
):
251 producer
.request("test_schemas/update_alarm/statistic_invalid.json",'update_alarm_request', '','alarm_request')
252 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
254 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
255 _consumer
.subscribe(['alarm_response'])
257 for message
in _consumer
:
258 if message
.key
== "update_alarm_response":
259 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
262 self
.assertEqual(info
,None)
265 #To generate a request of testing valid operation in update alarm request
266 def test_operationValid(self
):
267 producer
.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
269 producer
.request("test_schemas/update_alarm/operation_valid.json",'update_alarm_request', '','alarm_request')
270 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
272 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
273 _consumer
.subscribe(['alarm_response'])
275 for message
in _consumer
:
276 if message
.key
== "update_alarm_response":
277 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
280 producer
.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
281 self
.assertTrue(info
['alarm_update_response']['status'])
284 #--------------------------------------------------------------------------------------------------------------------------------------
285 class delete_alarm_test(unittest
.TestCase
):
287 #To generate a request of testing valid alarm_id in delete alarm request
288 def test_nameValid(self
):
289 producer
.request("test_schemas/create_alarm/create_alarm_differentName_differentInstance.json",'create_alarm_request', '','alarm_request')
291 producer
.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
292 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
294 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
295 _consumer
.subscribe(['alarm_response'])
297 for message
in _consumer
:
298 if message
.key
== "delete_alarm_response":
299 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
302 self
.assertTrue(info
['alarm_deletion_response']['status'])
305 #To generate a request of testing Invalid alarm_id in delete alarm request
306 def test_nameInvalid(self
):
308 producer
.request("test_schemas/delete_alarm/name_invalid.json",'delete_alarm_request', '','alarm_request')
309 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
311 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
312 _consumer
.subscribe(['alarm_response'])
314 for message
in _consumer
:
315 if message
.key
== "delete_alarm_response":
316 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
319 self
.assertEqual(info
,None)
322 #--------------------------------------------------------------------------------------------------------------------------------------
323 class list_alarm_test(unittest
.TestCase
):
325 #To generate a request of testing valid input fields in alarm list request
326 def test_valid_no_arguments(self
):
328 producer
.request("test_schemas/list_alarm/list_alarm_valid_no_arguments.json",'alarm_list_request', '','alarm_request')
329 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
331 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
332 _consumer
.subscribe(['alarm_response'])
334 for message
in _consumer
:
335 if message
.key
== "list_alarm_response":
336 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
339 self
.assertEqual(type(info
),dict)
342 #To generate a request of testing valid input fields in alarm list request
343 def test_valid_one_arguments(self
):
345 producer
.request("test_schemas/list_alarm/list_alarm_valid_one_arguments.json",'alarm_list_request', '','alarm_request')
346 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
348 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
349 _consumer
.subscribe(['alarm_response'])
351 for message
in _consumer
:
352 if message
.key
== "list_alarm_response":
353 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
356 self
.assertEqual(type(info
),dict)
359 #To generate a request of testing valid input fields in alarm list request
360 def test_valid_two_arguments(self
):
362 producer
.request("test_schemas/list_alarm/list_alarm_valid_two_arguments.json",'alarm_list_request', '','alarm_request')
363 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
365 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
366 _consumer
.subscribe(['alarm_response'])
368 for message
in _consumer
:
369 if message
.key
== "list_alarm_response":
370 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
373 self
.assertEqual(type(info
),dict)
377 #--------------------------------------------------------------------------------------------------------------------------------------
378 class alarm_details_test(unittest
.TestCase
):
380 #To generate a request of testing valid input fields in acknowledge alarm
381 def test_Valid(self
):
383 producer
.request("test_schemas/alarm_details/acknowledge_alarm.json",'acknowledge_alarm', '','alarm_request')
384 server
= {'server': 'localhost:9092', 'topic': 'alarm_request'}
386 _consumer
= KafkaConsumer(bootstrap_servers
=server
['server'])
387 _consumer
.subscribe(['alarm_response'])
389 for message
in _consumer
:
390 if message
.key
== "notify_alarm":
391 info
= json
.loads(json
.loads(json
.loads(message
.value
)))
394 self
.assertEqual(type(info
),dict)
397 if __name__
== '__main__':
399 # Saving test reults in Log file
401 log_file
= 'log_file.txt'
402 f
= open(log_file
, "w")
403 runner
= unittest
.TextTestRunner(f
)
404 unittest
.main(testRunner
=runner
)
407 # For printing results on Console