osm_mon/test/plugins/CloudWatch/unit_tests_alarms.py

   1 from connection import Connection
   2 import unittest
   3 import sys
   4 import jsmin
   5 import json
   6 import os
   7 import time
   8 from jsmin import jsmin
   9 sys.path.append("../../test/core/")
  10 from test_producer import KafkaProducer
  11 from kafka import KafkaConsumer
  12 try:
  13     import boto
  14     import boto.ec2
  15     import boto.vpc
  16     import boto.ec2.cloudwatch
  17     import boto.ec2.connection
  18 except:
  19     exit("Boto not avialable. Try activating your virtualenv OR `pip install boto`")
  20
  21 #--------------------------------------------------------------------------------------------------------------------------------------
  22
  23 # Test Producer object to generate request
  24
  25 producer = KafkaProducer('create_alarm_request')
  26 obj = Connection()
  27 connections = obj.setEnvironment()
  28 connections_res = obj.connection_instance()
  29 cloudwatch_conn = connections_res['cloudwatch_connection']
  30
  31 #--------------------------------------------------------------------------------------------------------------------------------------
  32
  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.
  40 '''
  41
  42 class config_alarm_name_test(unittest.TestCase):
  43
  44
  45     def setUp(self):
  46         pass
  47     #To generate a request of testing new alarm name and new instance id in create alarm request
  48     def test_differentName_differentInstance(self):
  49         time.sleep(2)
  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'}
  52
  53         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
  54         _consumer.subscribe(['alarm_response'])
  55
  56         for message in _consumer:
  57             if message.key == "create_alarm_response":
  58                 info = json.loads(json.loads(message.value))
  59                 print(info)
  60                 time.sleep(1)
  61                 self.assertTrue(info['alarm_create_response']['status'])
  62                 return
  63
  64     #To generate a request of testing new alarm name and existing instance id in create alarm request
  65     def test_differentName_sameInstance(self):
  66         time.sleep(2)
  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'}
  69
  70         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
  71         _consumer.subscribe(['alarm_response'])
  72
  73         for message in _consumer:
  74             if message.key == "create_alarm_response":
  75                 info = json.loads(json.loads(message.value))
  76                 print(info)
  77                 time.sleep(1)
  78                 producer.request("test_schemas/delete_alarm/name_valid_delete1.json",'delete_alarm_request','','alarm_request')
  79                 self.assertTrue(info['alarm_create_response']['status'])
  80                 return
  81
  82     #To generate a request of testing existing alarm name and new instance id in create alarm request
  83     def test_sameName_differentInstance(self):
  84         time.sleep(2)
  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'}
  87
  88         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
  89         _consumer.subscribe(['alarm_response'])
  90
  91         for message in _consumer:
  92             if message.key == "create_alarm_response":
  93                 info = json.loads(json.loads(message.value))
  94                 print(info)
  95                 time.sleep(1)
  96                 producer.request("test_schemas/delete_alarm/name_valid_delete2.json",'delete_alarm_request', '','alarm_request')
  97                 self.assertTrue(info['alarm_create_response']['status'])
  98                 return
  99
 100     #To generate a request of testing existing alarm name and existing instance id in create alarm request
 101     def test_sameName_sameInstance(self):
 102         time.sleep(2)
 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'}
 105
 106         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 107         _consumer.subscribe(['alarm_response'])
 108
 109         for message in _consumer:
 110             if message.key == "create_alarm_response":
 111                 info = json.loads(json.loads(message.value))
 112                 print(info, "---")
 113                 time.sleep(1)
 114                 producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
 115                 self.assertEqual(info, None)
 116                 return
 117
 118     #To generate a request of testing valid statistics in create alarm request
 119     def test_statisticValid(self):
 120         time.sleep(2)
 121         producer.request("test_schemas/create_alarm/statistic_valid.json",'create_alarm_request', '','alarm_request')
 122         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 123
 124         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 125         _consumer.subscribe(['alarm_response'])
 126
 127         for message in _consumer:
 128             if message.key == "create_alarm_response":
 129                 info = json.loads(json.loads(message.value))
 130                 print(info)
 131                 time.sleep(1)
 132                 producer.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
 133                 self.assertTrue(info['alarm_create_response']['status'])
 134                 return
 135
 136     #To generate a request of testing Invalid statistics in create alarm request
 137     def test_statisticValidNot(self):
 138         time.sleep(2)
 139         producer.request("test_schemas/create_alarm/statistic_invalid.json",'create_alarm_request', '','alarm_request')
 140         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 141
 142         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 143         _consumer.subscribe(['alarm_response'])
 144
 145         for message in _consumer:
 146             if message.key == "create_alarm_response":
 147                 info = json.loads(json.loads(message.value))
 148                 print(info, "---")
 149                 time.sleep(1)
 150                 producer.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
 151                 self.assertEqual(info, None)
 152                 return
 153
 154     #To generate a request of testing valid operation in create alarm request
 155     def test_operationValid(self):
 156         time.sleep(2)
 157         producer.request("test_schemas/create_alarm/operation_valid.json",'create_alarm_request', '','alarm_request')
 158         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 159
 160         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 161         _consumer.subscribe(['alarm_response'])
 162
 163         for message in _consumer:
 164             if message.key == "create_alarm_response":
 165                 info = json.loads(json.loads(message.value))
 166                 print(info)
 167                 time.sleep(1)
 168                 producer.request("test_schemas/delete_alarm/name_valid_delete3.json",'delete_alarm_request', '','alarm_request')
 169                 self.assertTrue(info['alarm_create_response']['status'])
 170                 return
 171
 172     #To generate a request of testing Invalid operation in create alarm request
 173     def test_operationValidNot(self):
 174         time.sleep(2)
 175         producer.request("test_schemas/create_alarm/operation_invalid.json",'create_alarm_request', '','alarm_request')
 176         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 177
 178         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 179         _consumer.subscribe(['alarm_response'])
 180
 181         for message in _consumer:
 182             if message.key == "create_alarm_response":
 183                 info = json.loads(json.loads(message.value))
 184                 print(info)
 185                 time.sleep(1)
 186                 self.assertEqual(info,None)
 187                 return
 188
 189
 190 #--------------------------------------------------------------------------------------------------------------------------------------
 191 class update_alarm_name_test(unittest.TestCase):
 192
 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')
 196         time.sleep(2)
 197         producer.request("test_schemas/update_alarm/name_valid.json",'update_alarm_request', '','alarm_request')
 198         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 199
 200         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 201         _consumer.subscribe(['alarm_response'])
 202
 203         for message in _consumer:
 204             if message.key == "update_alarm_response":
 205                 info = json.loads(json.loads(json.loads(message.value)))
 206                 print(info)
 207                 time.sleep(1)
 208                 producer.request("test_schemas/delete_alarm/name_valid_delete4.json",'delete_alarm_request', '','alarm_request')
 209                 self.assertTrue(info['alarm_update_response']['status'])
 210                 return
 211
 212     #To generate a request of testing invalid alarm_id in update alarm request
 213     def test_nameInvalid(self):
 214         time.sleep(2)
 215         producer.request("test_schemas/update_alarm/name_invalid.json",'update_alarm_request', '','alarm_request')
 216         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 217
 218         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 219         _consumer.subscribe(['alarm_response'])
 220
 221         for message in _consumer:
 222             if message.key == "update_alarm_response":
 223                 info = json.loads(json.loads(json.loads(message.value)))
 224                 print(info)
 225                 time.sleep(1)
 226                 self.assertEqual(info,None)
 227                 return
 228
 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')
 232         time.sleep(2)
 233         producer.request("test_schemas/update_alarm/statistic_valid.json",'update_alarm_request', '','alarm_request')
 234         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 235
 236         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 237         _consumer.subscribe(['alarm_response'])
 238
 239         for message in _consumer:
 240             if message.key == "update_alarm_response":
 241                 info = json.loads(json.loads(json.loads(message.value)))
 242                 print(info)
 243                 time.sleep(1)
 244                 producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
 245                 self.assertTrue(info['alarm_update_response']['status'])
 246                 return
 247
 248     #To generate a request of testing Invalid statistics in update alarm request
 249     def test_statisticInvalid(self):
 250         time.sleep(2)
 251         producer.request("test_schemas/update_alarm/statistic_invalid.json",'update_alarm_request', '','alarm_request')
 252         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 253
 254         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 255         _consumer.subscribe(['alarm_response'])
 256
 257         for message in _consumer:
 258             if message.key == "update_alarm_response":
 259                 info = json.loads(json.loads(json.loads(message.value)))
 260                 print(info)
 261                 time.sleep(1)
 262                 self.assertEqual(info,None)
 263                 return
 264
 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')
 268         time.sleep(2)
 269         producer.request("test_schemas/update_alarm/operation_valid.json",'update_alarm_request', '','alarm_request')
 270         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 271
 272         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 273         _consumer.subscribe(['alarm_response'])
 274
 275         for message in _consumer:
 276             if message.key == "update_alarm_response":
 277                 info = json.loads(json.loads(json.loads(message.value)))
 278                 print(info)
 279                 time.sleep(1)
 280                 producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
 281                 self.assertTrue(info['alarm_update_response']['status'])
 282                 return
 283
 284 #--------------------------------------------------------------------------------------------------------------------------------------
 285 class delete_alarm_test(unittest.TestCase):
 286
 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')
 290         time.sleep(2)
 291         producer.request("test_schemas/delete_alarm/name_valid.json",'delete_alarm_request', '','alarm_request')
 292         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 293
 294         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 295         _consumer.subscribe(['alarm_response'])
 296
 297         for message in _consumer:
 298             if message.key == "delete_alarm_response":
 299                 info = json.loads(json.loads(json.loads(message.value)))
 300                 print(info)
 301                 time.sleep(1)
 302                 self.assertTrue(info['alarm_deletion_response']['status'])
 303                 return
 304
 305     #To generate a request of testing Invalid alarm_id in delete alarm request
 306     def test_nameInvalid(self):
 307         time.sleep(2)
 308         producer.request("test_schemas/delete_alarm/name_invalid.json",'delete_alarm_request', '','alarm_request')
 309         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 310
 311         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 312         _consumer.subscribe(['alarm_response'])
 313
 314         for message in _consumer:
 315             if message.key == "delete_alarm_response":
 316                 info = json.loads(json.loads(json.loads(message.value)))
 317                 print(info)
 318                 time.sleep(1)
 319                 self.assertEqual(info,None)
 320                 return
 321
 322 #--------------------------------------------------------------------------------------------------------------------------------------
 323 class list_alarm_test(unittest.TestCase):
 324
 325     #To generate a request of testing valid input fields in alarm list request
 326     def test_valid_no_arguments(self):
 327         time.sleep(2)
 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'}
 330
 331         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 332         _consumer.subscribe(['alarm_response'])
 333
 334         for message in _consumer:
 335             if message.key == "list_alarm_response":
 336                 info = json.loads(json.loads(json.loads(message.value)))
 337                 print(info)
 338                 time.sleep(1)
 339                 self.assertEqual(type(info),dict)
 340                 return
 341
 342     #To generate a request of testing valid input fields in alarm list request
 343     def test_valid_one_arguments(self):
 344         time.sleep(2)
 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'}
 347
 348         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 349         _consumer.subscribe(['alarm_response'])
 350
 351         for message in _consumer:
 352             if message.key == "list_alarm_response":
 353                 info = json.loads(json.loads(json.loads(message.value)))
 354                 print(info)
 355                 time.sleep(1)
 356                 self.assertEqual(type(info),dict)
 357                 return
 358
 359     #To generate a request of testing valid input fields in alarm list request
 360     def test_valid_two_arguments(self):
 361         time.sleep(2)
 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'}
 364
 365         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 366         _consumer.subscribe(['alarm_response'])
 367
 368         for message in _consumer:
 369             if message.key == "list_alarm_response":
 370                 info = json.loads(json.loads(json.loads(message.value)))
 371                 print(info)
 372                 time.sleep(1)
 373                 self.assertEqual(type(info),dict)
 374                 return
 375
 376
 377 #--------------------------------------------------------------------------------------------------------------------------------------
 378 class alarm_details_test(unittest.TestCase):
 379
 380     #To generate a request of testing valid input fields in acknowledge alarm
 381     def test_Valid(self):
 382         time.sleep(2)
 383         producer.request("test_schemas/alarm_details/acknowledge_alarm.json",'acknowledge_alarm', '','alarm_request')
 384         server = {'server': 'localhost:9092', 'topic': 'alarm_request'}
 385
 386         _consumer = KafkaConsumer(bootstrap_servers=server['server'])
 387         _consumer.subscribe(['alarm_response'])
 388
 389         for message in _consumer:
 390             if message.key == "notify_alarm":
 391                 info = json.loads(json.loads(json.loads(message.value)))
 392                 print(info)
 393                 time.sleep(1)
 394                 self.assertEqual(type(info),dict)
 395                 return
 396
 397 if __name__ == '__main__':
 398
 399     # Saving test reults in Log file
 400
 401     log_file = 'log_file.txt'
 402     f = open(log_file, "w")
 403     runner = unittest.TextTestRunner(f)
 404     unittest.main(testRunner=runner)
 405     f.close()
 406
 407     # For printing results on Console
 408     # unittest.main()