test/test_RO.py

   1 #!/usr/bin/env python2
   2 # -*- coding: utf-8 -*-
   3
   4 ##
   5 # Copyright 2017
   6 # This file is part of openmano
   7 # All Rights Reserved.
   8 #
   9 # Licensed under the Apache License, Version 2.0 (the "License"); you may
  10 # not use this file except in compliance with the License. You may obtain
  11 # a copy of the License at
  12 #
  13 #         http://www.apache.org/licenses/LICENSE-2.0
  14 #
  15 # Unless required by applicable law or agreed to in writing, software
  16 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  17 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  18 # License for the specific language governing permissions and limitations
  19 # under the License.
  20 #
  21 ##
  22
  23 # DEBUG WITH PDB
  24 from os import getenv
  25 if getenv('OSMRO_PDB_DEBUG'):
  26     import sys
  27     print(sys.path)
  28     import pdb
  29     pdb.set_trace()
  30
  31
  32 """
  33 Module for testing openmano functionality. It uses openmanoclient.py for invoking openmano
  34 """
  35
  36 import logging
  37 import os
  38 import argcomplete
  39 import unittest
  40 import string
  41 import inspect
  42 import random
  43 # import traceback
  44 import glob
  45 import yaml
  46 import sys
  47 import time
  48 import uuid
  49 from argparse import ArgumentParser
  50
  51 __author__ = "Pablo Montes, Alfonso Tierno"
  52 __date__ = "$16-Feb-2017 17:08:16$"
  53 __version__ = "0.1.0"
  54 version_date = "Oct 2017"
  55
  56 test_config = {}    # used for global variables with the test configuration
  57
  58
  59 class test_base(unittest.TestCase):
  60     test_index = 1
  61     test_text = None
  62
  63     @classmethod
  64     def setUpClass(cls):
  65         logger.info("{}. {}".format(test_config["test_number"], cls.__name__))
  66
  67     @classmethod
  68     def tearDownClass(cls):
  69         test_config["test_number"] += 1
  70
  71     def tearDown(self):
  72         exec_info = sys.exc_info()
  73         if exec_info == (None, None, None):
  74             logger.info(self.__class__.test_text+" -> TEST OK")
  75         else:
  76             logger.warning(self.__class__.test_text+" -> TEST NOK")
  77             logger.critical("Traceback error",exc_info=True)
  78
  79
  80 def check_instance_scenario_active(uuid):
  81     instance = test_config["client"].get_instance(uuid=uuid)
  82
  83     for net in instance['nets']:
  84         status = net['status']
  85         if status != 'ACTIVE':
  86             return (False, status)
  87
  88     for vnf in instance['vnfs']:
  89         for vm in vnf['vms']:
  90             status = vm['status']
  91             if status != 'ACTIVE':
  92                 return (False, status)
  93
  94     return (True, None)
  95
  96
  97 '''
  98 IMPORTANT NOTE
  99 All unittest classes for code based tests must have prefix 'test_' in order to be taken into account for tests
 100 '''
 101 class test_VIM_datacenter_tenant_operations(test_base):
 102     tenant_name = None
 103
 104     def test_000_create_RO_tenant(self):
 105         self.__class__.tenant_name = _get_random_string(20)
 106         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 107                                                            inspect.currentframe().f_code.co_name)
 108         self.__class__.test_index += 1
 109         tenant = test_config["client"].create_tenant(name=self.__class__.tenant_name,
 110                                                      description=self.__class__.tenant_name)
 111         logger.debug("{}".format(tenant))
 112         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.tenant_name)
 113
 114     def test_010_list_RO_tenant(self):
 115         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 116                                                            inspect.currentframe().f_code.co_name)
 117         self.__class__.test_index += 1
 118         tenant = test_config["client"].get_tenant(name=self.__class__.tenant_name)
 119         logger.debug("{}".format(tenant))
 120         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.tenant_name)
 121
 122     def test_020_delete_RO_tenant(self):
 123         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 124                                                            inspect.currentframe().f_code.co_name)
 125         self.__class__.test_index += 1
 126         tenant = test_config["client"].delete_tenant(name=self.__class__.tenant_name)
 127         logger.debug("{}".format(tenant))
 128         assert('deleted' in tenant.get('result',""))
 129
 130
 131 class test_VIM_datacenter_operations(test_base):
 132     datacenter_name = None
 133
 134     def test_000_create_datacenter(self):
 135         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 136                                                            inspect.currentframe().f_code.co_name)
 137         self.__class__.datacenter_name = _get_random_string(20)
 138         self.__class__.test_index += 1
 139         self.datacenter = test_config["client"].create_datacenter(name=self.__class__.datacenter_name,
 140                                                                   vim_url="http://fakeurl/fake")
 141         logger.debug("{}".format(self.datacenter))
 142         self.assertEqual (self.datacenter.get('datacenter', {}).get('name',''), self.__class__.datacenter_name)
 143
 144     def test_010_list_datacenter(self):
 145         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 146                                                            inspect.currentframe().f_code.co_name)
 147
 148         self.__class__.test_index += 1
 149         self.datacenter = test_config["client"].get_datacenter(all_tenants=True, name=self.__class__.datacenter_name)
 150         logger.debug("{}".format(self.datacenter))
 151         self.assertEqual (self.datacenter.get('datacenter', {}).get('name', ''), self.__class__.datacenter_name)
 152
 153     def test_020_attach_datacenter(self):
 154         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 155                                                            inspect.currentframe().f_code.co_name)
 156
 157         self.__class__.test_index += 1
 158         self.datacenter = test_config["client"].attach_datacenter(name=self.__class__.datacenter_name,
 159                                                                   vim_tenant_name='fake')
 160         logger.debug("{}".format(self.datacenter))
 161         assert ('uuid' in self.datacenter.get('datacenter', {}))
 162
 163     def test_030_list_attached_datacenter(self):
 164         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 165                                                            inspect.currentframe().f_code.co_name)
 166
 167         self.__class__.test_index += 1
 168         self.datacenter = test_config["client"].get_datacenter(all_tenants=False, name=self.__class__.datacenter_name)
 169         logger.debug("{}".format(self.datacenter))
 170         self.assertEqual (self.datacenter.get('datacenter', {}).get('name', ''), self.__class__.datacenter_name)
 171
 172     def test_040_detach_datacenter(self):
 173         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 174                                                            inspect.currentframe().f_code.co_name)
 175
 176         self.__class__.test_index += 1
 177         self.datacenter = test_config["client"].detach_datacenter(name=self.__class__.datacenter_name)
 178         logger.debug("{}".format(self.datacenter))
 179         assert ('detached' in self.datacenter.get('result', ""))
 180
 181     def test_050_delete_datacenter(self):
 182         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 183                                                            inspect.currentframe().f_code.co_name)
 184
 185         self.__class__.test_index += 1
 186         self.datacenter = test_config["client"].delete_datacenter(name=self.__class__.datacenter_name)
 187         logger.debug("{}".format(self.datacenter))
 188         assert('deleted' in self.datacenter.get('result',""))
 189
 190
 191 class test_VIM_network_operations(test_base):
 192     vim_network_name = None
 193     vim_network_uuid = None
 194
 195     def test_000_create_VIM_network(self):
 196         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 197                                                            inspect.currentframe().f_code.co_name)
 198         self.__class__.vim_network_name = _get_random_string(20)
 199         self.__class__.test_index += 1
 200         network = test_config["client"].vim_action("create", "networks", name=self.__class__.vim_network_name)
 201         logger.debug("{}".format(network))
 202         self.__class__.vim_network_uuid = network["network"]["id"]
 203         self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name)
 204
 205     def test_010_list_VIM_networks(self):
 206         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 207                                                            inspect.currentframe().f_code.co_name)
 208         self.__class__.test_index += 1
 209         networks = test_config["client"].vim_action("list", "networks")
 210         logger.debug("{}".format(networks))
 211
 212     def test_020_get_VIM_network_by_uuid(self):
 213         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 214                                                            inspect.currentframe().f_code.co_name)
 215
 216         self.__class__.test_index += 1
 217         network = test_config["client"].vim_action("show", "networks", uuid=self.__class__.vim_network_uuid)
 218         logger.debug("{}".format(network))
 219         self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name)
 220
 221     def test_030_delete_VIM_network_by_uuid(self):
 222         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 223                                                            inspect.currentframe().f_code.co_name)
 224
 225         self.__class__.test_index += 1
 226         network = test_config["client"].vim_action("delete", "networks", uuid=self.__class__.vim_network_uuid)
 227         logger.debug("{}".format(network))
 228         assert ('deleted' in network.get('result', ""))
 229
 230
 231 class test_VIM_image_operations(test_base):
 232
 233     def test_000_list_VIM_images(self):
 234         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 235                                                            inspect.currentframe().f_code.co_name)
 236         self.__class__.test_index += 1
 237         images = test_config["client"].vim_action("list", "images")
 238         logger.debug("{}".format(images))
 239
 240 '''
 241 The following is a non critical test that will fail most of the times.
 242 In case of OpenStack datacenter these tests will only success if RO has access to the admin endpoint
 243 This test will only be executed in case it is specifically requested by the user
 244 '''
 245 class test_VIM_tenant_operations(test_base):
 246     vim_tenant_name = None
 247     vim_tenant_uuid = None
 248
 249     @classmethod
 250     def setUpClass(cls):
 251         test_base.setUpClass(cls)
 252         logger.warning("In case of OpenStack datacenter these tests will only success "
 253                        "if RO has access to the admin endpoint")
 254
 255     def test_000_create_VIM_tenant(self):
 256         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 257                                                            inspect.currentframe().f_code.co_name)
 258         self.__class__.vim_tenant_name = _get_random_string(20)
 259         self.__class__.test_index += 1
 260         tenant = test_config["client"].vim_action("create", "tenants", name=self.__class__.vim_tenant_name)
 261         logger.debug("{}".format(tenant))
 262         self.__class__.vim_tenant_uuid = tenant["tenant"]["id"]
 263         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name)
 264
 265     def test_010_list_VIM_tenants(self):
 266         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 267                                                            inspect.currentframe().f_code.co_name)
 268         self.__class__.test_index += 1
 269         tenants = test_config["client"].vim_action("list", "tenants")
 270         logger.debug("{}".format(tenants))
 271
 272     def test_020_get_VIM_tenant_by_uuid(self):
 273         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 274                                                            inspect.currentframe().f_code.co_name)
 275
 276         self.__class__.test_index += 1
 277         tenant = test_config["client"].vim_action("show", "tenants", uuid=self.__class__.vim_tenant_uuid)
 278         logger.debug("{}".format(tenant))
 279         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name)
 280
 281     def test_030_delete_VIM_tenant_by_uuid(self):
 282         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 283                                                            inspect.currentframe().f_code.co_name)
 284
 285         self.__class__.test_index += 1
 286         tenant = test_config["client"].vim_action("delete", "tenants", uuid=self.__class__.vim_tenant_uuid)
 287         logger.debug("{}".format(tenant))
 288         assert ('deleted' in tenant.get('result', ""))
 289
 290
 291 class test_vimconn_connect(test_base):
 292
 293     def test_000_connect(self):
 294         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 295                                                             self.__class__.test_index,
 296                                                 inspect.currentframe().f_code.co_name)
 297
 298         self.__class__.test_index += 1
 299         if test_config['vimtype'] == 'vmware':
 300             vca_object = test_config["vim_conn"].connect()
 301             logger.debug("{}".format(vca_object))
 302             self.assertIsNotNone(vca_object)
 303         elif test_config['vimtype'] in ('openstack', 'azure'):
 304             test_config["vim_conn"]._reload_connection()
 305             network_list = test_config["vim_conn"].get_network_list()
 306             logger.debug("{}".format(network_list))
 307             self.assertIsNotNone(network_list)
 308
 309 class test_vimconn_new_network(test_base):
 310     network_name = None
 311
 312     def test_000_new_network(self):
 313         self.__class__.network_name = _get_random_string(20)
 314         network_type = 'bridge'
 315
 316         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 317                      self.__class__.test_index, inspect.currentframe().f_code.co_name)
 318         self.__class__.test_index += 1
 319
 320         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 321                                                           net_type=network_type)
 322         self.__class__.network_id = network
 323         logger.debug("{}".format(network))
 324
 325         network_list = test_config["vim_conn"].get_network_list()
 326         for net in network_list:
 327             if self.__class__.network_name in net.get('name'):
 328                 self.assertIn(self.__class__.network_name, net.get('name'))
 329                 self.assertEqual(net.get('type'), network_type)
 330
 331         # Deleting created network
 332         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 333         if result:
 334             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 335         else:
 336             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 337
 338     def test_010_new_network_by_types(self):
 339         delete_net_ids = []
 340         network_types = ['data','bridge','mgmt']
 341         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 342                                                             self.__class__.test_index,
 343                                                 inspect.currentframe().f_code.co_name)
 344         self.__class__.test_index += 1
 345         for net_type in network_types:
 346             self.__class__.network_name = _get_random_string(20)
 347             network_id, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 348                                                                                 net_type=net_type)
 349
 350             delete_net_ids.append(network_id)
 351             logger.debug("{}".format(network_id))
 352
 353             network_list = test_config["vim_conn"].get_network_list()
 354             for net in network_list:
 355                 if self.__class__.network_name in net.get('name'):
 356                     self.assertIn(self.__class__.network_name, net.get('name'))
 357                 if net_type in net.get('type'):
 358                     self.assertEqual(net.get('type'), net_type)
 359                 else:
 360                     self.assertNotEqual(net.get('type'), net_type)
 361
 362         # Deleting created network
 363         for net_id in delete_net_ids:
 364             result = test_config["vim_conn"].delete_network(net_id)
 365             if result:
 366                 logger.info("Network id {} sucessfully deleted".format(net_id))
 367             else:
 368                 logger.info("Failed to delete network id {}".format(net_id))
 369
 370     def test_020_new_network_by_ipprofile(self):
 371         test_directory_content = os.listdir(test_config["test_directory"])
 372
 373         for dir_name in test_directory_content:
 374             if dir_name == 'simple_multi_vnfc':
 375                 self.__class__.scenario_test_path = test_config["test_directory"] + '/'+ dir_name
 376                 vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml')
 377                 break
 378
 379         for vnfd in vnfd_files:
 380             with open(vnfd, 'r') as stream:
 381                 vnf_descriptor = yaml.load(stream)
 382
 383             internal_connections_list = vnf_descriptor['vnf']['internal-connections']
 384             for item in internal_connections_list:
 385                 if 'ip-profile' in item:
 386                     version = item['ip-profile']['ip-version']
 387                     dhcp_count = item['ip-profile']['dhcp']['count']
 388                     dhcp_enabled = item['ip-profile']['dhcp']['enabled']
 389                     dhcp_start_address = item['ip-profile']['dhcp']['start-address']
 390                     subnet_address = item['ip-profile']['subnet-address']
 391
 392
 393         self.__class__.network_name = _get_random_string(20)
 394         ip_profile = {'dhcp_count': dhcp_count,
 395                       'dhcp_enabled': dhcp_enabled,
 396                       'dhcp_start_address': dhcp_start_address,
 397                       'ip_version': version,
 398                       'subnet_address': subnet_address
 399                      }
 400         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 401                                                             self.__class__.test_index,
 402                                                 inspect.currentframe().f_code.co_name)
 403         self.__class__.test_index += 1
 404         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 405                                                                            net_type='mgmt',
 406                                                                      ip_profile=ip_profile)
 407         self.__class__.network_id = network
 408         logger.debug("{}".format(network))
 409
 410         network_list = test_config["vim_conn"].get_network_list()
 411         for net in network_list:
 412             if self.__class__.network_name in net.get('name'):
 413                 self.assertIn(self.__class__.network_name, net.get('name'))
 414
 415         # Deleting created network
 416         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 417         if result:
 418             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 419         else:
 420             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 421
 422     def test_030_new_network_by_isshared(self):
 423         self.__class__.network_name = _get_random_string(20)
 424         shared = True
 425         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 426                                                             self.__class__.test_index,
 427                                                 inspect.currentframe().f_code.co_name)
 428         self.__class__.test_index += 1
 429         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 430                                                                          net_type='bridge',
 431                                                                              shared=shared)
 432         self.__class__.network_id = network
 433         logger.debug("{}".format(network))
 434
 435         network_list = test_config["vim_conn"].get_network_list()
 436         for net in network_list:
 437             if self.__class__.network_name in net.get('name'):
 438                 self.assertIn(self.__class__.network_name, net.get('name'))
 439                 self.assertEqual(net.get('shared'), shared)
 440
 441         # Deleting created network
 442         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 443         if result:
 444             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 445         else:
 446             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 447
 448     def test_040_new_network_by_negative(self):
 449         self.__class__.network_name = _get_random_string(20)
 450         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 451                                                             self.__class__.test_index,
 452                                                 inspect.currentframe().f_code.co_name)
 453         self.__class__.test_index += 1
 454         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 455                                                                     net_type='unknowntype')
 456         self.__class__.network_id = network
 457         logger.debug("{}".format(network))
 458         network_list = test_config["vim_conn"].get_network_list()
 459         for net in network_list:
 460             if self.__class__.network_name in net.get('name'):
 461                 self.assertIn(self.__class__.network_name, net.get('name'))
 462
 463         # Deleting created network
 464         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 465         if result:
 466             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 467         else:
 468             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 469
 470     def test_050_refresh_nets_status(self):
 471         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 472                                                             self.__class__.test_index,
 473                                                 inspect.currentframe().f_code.co_name)
 474         self.__class__.test_index += 1
 475         # creating new network
 476         network_name = _get_random_string(20)
 477         net_type = 'bridge'
 478         network_id, _ = test_config["vim_conn"].new_network(net_name=network_name,
 479                                                           net_type=net_type)
 480         # refresh net status
 481         net_dict = test_config["vim_conn"].refresh_nets_status([network_id])
 482         for attr in net_dict[network_id]:
 483             if attr == 'status':
 484                 self.assertEqual(net_dict[network_id][attr], 'ACTIVE')
 485
 486         # Deleting created network
 487         result = test_config["vim_conn"].delete_network(network_id)
 488         if result:
 489             logger.info("Network id {} sucessfully deleted".format(network_id))
 490         else:
 491             logger.info("Failed to delete network id {}".format(network_id))
 492
 493     def test_060_refresh_nets_status_negative(self):
 494         unknown_net_id = str(uuid.uuid4())
 495         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 496                                                             self.__class__.test_index,
 497                                                 inspect.currentframe().f_code.co_name)
 498         self.__class__.test_index += 1
 499
 500         # refresh net status
 501         net_dict = test_config["vim_conn"].refresh_nets_status([unknown_net_id])
 502         if test_config['vimtype'] in ('openstack', 'azure'):
 503             self.assertEqual(net_dict[unknown_net_id]['status'], 'DELETED')
 504         else:
 505             # TODO : Fix vmware connector to return status DELETED as per vimconn.py
 506             self.assertEqual(net_dict, {})
 507
 508 class test_vimconn_get_network_list(test_base):
 509     network_name = None
 510
 511     def setUp(self):
 512         # creating new network
 513         self.__class__.network_name = _get_random_string(20)
 514         self.__class__.net_type = 'bridge'
 515         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 516                                                           net_type=self.__class__.net_type)
 517         self.__class__.network_id = network
 518         logger.debug("{}".format(network))
 519
 520     def tearDown(self):
 521         test_base.tearDown(self)
 522
 523         # Deleting created network
 524         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 525         if result:
 526             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 527         else:
 528             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 529
 530     def test_000_get_network_list(self):
 531         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 532                                                             self.__class__.test_index,
 533                                                 inspect.currentframe().f_code.co_name)
 534         self.__class__.test_index += 1
 535
 536         network_list = test_config["vim_conn"].get_network_list()
 537         for net in network_list:
 538             if self.__class__.network_name in net.get('name'):
 539                 self.assertIn(self.__class__.network_name, net.get('name'))
 540                 self.assertEqual(net.get('type'), self.__class__.net_type)
 541                 self.assertEqual(net.get('status'), 'ACTIVE')
 542                 if test_config['vimtype'] != 'azure':
 543                     self.assertEqual(net.get('shared'), False)
 544
 545     def test_010_get_network_list_by_name(self):
 546         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 547                                                             self.__class__.test_index,
 548                                                 inspect.currentframe().f_code.co_name)
 549         self.__class__.test_index += 1
 550
 551         if test_config['vimtype'] in ('openstack', 'azure'):
 552             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 553         else:
 554             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 555
 556         # find network from list by it's name
 557         new_network_list = test_config["vim_conn"].get_network_list({'name': network_name})
 558         for list_item in new_network_list:
 559             if self.__class__.network_name in list_item.get('name'):
 560                 self.assertEqual(network_name, list_item.get('name'))
 561                 self.assertEqual(list_item.get('type'), self.__class__.net_type)
 562                 self.assertEqual(list_item.get('status'), 'ACTIVE')
 563
 564     def test_020_get_network_list_by_id(self):
 565         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 566                                                             self.__class__.test_index,
 567                                                 inspect.currentframe().f_code.co_name)
 568         self.__class__.test_index += 1
 569
 570         # find network from list by it's id
 571         new_network_list = test_config["vim_conn"].get_network_list({'id':self.__class__.network_id})
 572         for list_item in new_network_list:
 573             if self.__class__.network_id in list_item.get('id'):
 574                 self.assertEqual(self.__class__.network_id, list_item.get('id'))
 575                 self.assertEqual(list_item.get('type'), self.__class__.net_type)
 576                 self.assertEqual(list_item.get('status'), 'ACTIVE')
 577
 578     def test_030_get_network_list_by_shared(self):
 579         Shared = False
 580         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 581                                                             self.__class__.test_index,
 582                                                 inspect.currentframe().f_code.co_name)
 583         self.__class__.test_index += 1
 584
 585         if test_config['vimtype'] in ('openstack', 'azure'):
 586             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 587         else:
 588             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 589         # find network from list by it's shared value
 590         new_network_list = test_config["vim_conn"].get_network_list({'shared':Shared,
 591                                                                 'name':network_name})
 592         for list_item in new_network_list:
 593             if list_item.get('shared') == Shared:
 594                 self.assertEqual(list_item.get('shared'), Shared)
 595                 self.assertEqual(list_item.get('type'), self.__class__.net_type)
 596                 self.assertEqual(network_name, list_item.get('name'))
 597
 598     def test_040_get_network_list_by_tenant_id(self):
 599         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 600                                                             self.__class__.test_index,
 601                                                 inspect.currentframe().f_code.co_name)
 602         self.__class__.test_index += 1
 603
 604         tenant_list = test_config["vim_conn"].get_tenant_list()
 605         if test_config['vimtype'] in ('openstack', 'azure'):
 606             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 607         else:
 608             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 609
 610         for tenant_item in tenant_list:
 611             if test_config['tenant'] == tenant_item.get('name'):
 612                 # find network from list by it's tenant id
 613                 tenant_id = tenant_item.get('id')
 614                 new_network_list = test_config["vim_conn"].get_network_list({'tenant_id':tenant_id,
 615                                                                               'name':network_name})
 616                 for list_item in new_network_list:
 617                     self.assertEqual(tenant_id, list_item.get('tenant_id'))
 618                     self.assertEqual(network_name, list_item.get('name'))
 619                     self.assertEqual(list_item.get('type'), self.__class__.net_type)
 620                     self.assertEqual(list_item.get('status'), 'ACTIVE')
 621
 622     def test_050_get_network_list_by_status(self):
 623         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 624                                                             self.__class__.test_index,
 625                                                 inspect.currentframe().f_code.co_name)
 626         self.__class__.test_index += 1
 627         status = 'ACTIVE'
 628
 629         if test_config['vimtype'] in ('openstack', 'azure'):
 630             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 631         else:
 632             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 633
 634         # find network from list by it's status
 635         new_network_list = test_config["vim_conn"].get_network_list({'status':status,
 636                                                                'name': network_name})
 637         for list_item in new_network_list:
 638             self.assertIn(self.__class__.network_name, list_item.get('name'))
 639             self.assertEqual(list_item.get('type'), self.__class__.net_type)
 640             self.assertEqual(list_item.get('status'), status)
 641
 642     def test_060_get_network_list_by_negative(self):
 643         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 644                                                             self.__class__.test_index,
 645                                                 inspect.currentframe().f_code.co_name)
 646         self.__class__.test_index += 1
 647
 648         network_list = test_config["vim_conn"].get_network_list({'name': 'unknown_name'})
 649         self.assertEqual(network_list, [])
 650
 651 class test_vimconn_get_network(test_base):
 652     network_name = None
 653
 654     def setUp(self):
 655         # creating new network
 656         self.__class__.network_name = _get_random_string(20)
 657         self.__class__.net_type = 'bridge'
 658         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 659                                                           net_type=self.__class__.net_type)
 660         self.__class__.network_id = network
 661         logger.debug("{}".format(network))
 662
 663     def tearDown(self):
 664         test_base.tearDown(self)
 665
 666         # Deleting created network
 667         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 668         if result:
 669             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 670         else:
 671             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 672
 673     def test_000_get_network(self):
 674         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 675                                                             self.__class__.test_index,
 676                                                 inspect.currentframe().f_code.co_name)
 677         self.__class__.test_index += 1
 678
 679         network_info = test_config["vim_conn"].get_network(self.__class__.network_id)
 680         self.assertEqual(network_info.get('status'), 'ACTIVE')
 681         self.assertIn(self.__class__.network_name, network_info.get('name'))
 682         self.assertEqual(network_info.get('type'), self.__class__.net_type)
 683         self.assertEqual(network_info.get('id'), self.__class__.network_id)
 684
 685     def test_010_get_network_negative(self):
 686         Non_exist_id = str(uuid.uuid4())
 687         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 688                                                             self.__class__.test_index,
 689                                                 inspect.currentframe().f_code.co_name)
 690         self.__class__.test_index += 1
 691         with self.assertRaises(Exception) as context:
 692             test_config["vim_conn"].get_network(Non_exist_id)
 693
 694         self.assertEqual((context.exception).http_code, 404)
 695
 696 class test_vimconn_delete_network(test_base):
 697     network_name = None
 698
 699     def test_000_delete_network(self):
 700         # Creating network
 701         self.__class__.network_name = _get_random_string(20)
 702         self.__class__.net_type = 'bridge'
 703         network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 704                                                           net_type=self.__class__.net_type)
 705         self.__class__.network_id = network
 706         logger.debug("{}".format(network))
 707
 708         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 709                                                             self.__class__.test_index,
 710                                                 inspect.currentframe().f_code.co_name)
 711         self.__class__.test_index += 1
 712
 713         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 714         if result:
 715             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 716         else:
 717             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 718         time.sleep(5)
 719         # after deleting network we check in network list
 720         network_list = test_config["vim_conn"].get_network_list({ 'id':self.__class__.network_id })
 721         self.assertEqual(network_list, [])
 722
 723     def test_010_delete_network_negative(self):
 724         Non_exist_id = str(uuid.uuid4())
 725
 726         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 727                                                             self.__class__.test_index,
 728                                                 inspect.currentframe().f_code.co_name)
 729         self.__class__.test_index += 1
 730
 731         with self.assertRaises(Exception) as context:
 732             test_config["vim_conn"].delete_network(Non_exist_id)
 733
 734         self.assertEqual((context.exception).http_code, 404)
 735
 736 class test_vimconn_get_flavor(test_base):
 737
 738     def test_000_get_flavor(self):
 739         test_directory_content = os.listdir(test_config["test_directory"])
 740
 741         for dir_name in test_directory_content:
 742             if dir_name == 'simple_linux':
 743                 self.__class__.scenario_test_path = test_config["test_directory"] + '/'+ dir_name
 744                 vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml')
 745                 break
 746
 747         for vnfd in vnfd_files:
 748             with open(vnfd, 'r') as stream:
 749                 vnf_descriptor = yaml.load(stream)
 750
 751             vnfc_list = vnf_descriptor['vnf']['VNFC']
 752             for item in vnfc_list:
 753                 if 'ram' in item and 'vcpus' in item and 'disk' in item:
 754                     ram = item['ram']
 755                     vcpus = item['vcpus']
 756                     disk = item['disk']
 757
 758         flavor_data = {
 759                       'name' : _get_random_string(20),
 760                       'ram': ram,
 761                       'vcpus': vcpus,
 762                       'disk': disk
 763                     }
 764
 765         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 766                                                             self.__class__.test_index,
 767                                                 inspect.currentframe().f_code.co_name)
 768         self.__class__.test_index += 1
 769         # create new flavor
 770         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
 771         # get flavor by id
 772         result = test_config["vim_conn"].get_flavor(flavor_id)
 773         self.assertEqual(ram, result['ram'])
 774         self.assertEqual(vcpus, result['vcpus'])
 775         self.assertEqual(disk, result['disk'])
 776
 777         # delete flavor
 778         result = test_config["vim_conn"].delete_flavor(flavor_id)
 779         if result:
 780             logger.info("Flavor id {} sucessfully deleted".format(result))
 781         else:
 782             logger.info("Failed to delete flavor id {}".format(result))
 783
 784     def test_010_get_flavor_negative(self):
 785         Non_exist_flavor_id = str(uuid.uuid4())
 786
 787         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 788                                                             self.__class__.test_index,
 789                                                 inspect.currentframe().f_code.co_name)
 790         self.__class__.test_index += 1
 791
 792         with self.assertRaises(Exception) as context:
 793             test_config["vim_conn"].get_flavor(Non_exist_flavor_id)
 794
 795         self.assertEqual((context.exception).http_code, 404)
 796
 797 class test_vimconn_new_flavor(test_base):
 798     flavor_id = None
 799
 800     def test_000_new_flavor(self):
 801         flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
 802
 803         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 804                                                             self.__class__.test_index,
 805                                                 inspect.currentframe().f_code.co_name)
 806         self.__class__.test_index += 1
 807
 808         # create new flavor
 809         self.__class__.flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
 810         self.assertIsInstance(self.__class__.flavor_id, (str, unicode))
 811         self.assertIsInstance(uuid.UUID(self.__class__.flavor_id), uuid.UUID)
 812
 813     def test_010_delete_flavor(self):
 814         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 815                                                             self.__class__.test_index,
 816                                                 inspect.currentframe().f_code.co_name)
 817         self.__class__.test_index += 1
 818
 819         # delete flavor
 820         if test_config['vimtype'] == 'azure':
 821             with self.assertRaises(Exception) as context:
 822                 test_config["vim_conn"].delete_flavor(self.__class__.flavor_id)
 823
 824             self.assertEqual((context.exception).http_code, 401)
 825         else:
 826             result = test_config["vim_conn"].delete_flavor(self.__class__.flavor_id)
 827             if result:
 828                 logger.info("Flavor id {} sucessfully deleted".format(result))
 829             else:
 830                 logger.error("Failed to delete flavor id {}".format(result))
 831                 raise Exception ("Failed to delete created flavor")
 832
 833     def test_020_new_flavor_negative(self):
 834         Invalid_flavor_data = {'ram': '1024', 'vcpus': 2.0, 'disk': 2.0}
 835
 836         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 837                                                             self.__class__.test_index,
 838                                                 inspect.currentframe().f_code.co_name)
 839         self.__class__.test_index += 1
 840
 841         with self.assertRaises(Exception) as context:
 842             test_config["vim_conn"].new_flavor(Invalid_flavor_data)
 843
 844         self.assertEqual((context.exception).http_code, 400)
 845
 846     def test_030_delete_flavor_negative(self):
 847         Non_exist_flavor_id = str(uuid.uuid4())
 848
 849         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 850                                                             self.__class__.test_index,
 851                                                 inspect.currentframe().f_code.co_name)
 852         self.__class__.test_index += 1
 853
 854         with self.assertRaises(Exception) as context:
 855             test_config["vim_conn"].delete_flavor(Non_exist_flavor_id)
 856
 857         self.assertEqual((context.exception).http_code, 404)
 858
 859 # class test_vimconn_new_image(test_base):
 860 #
 861 #     def test_000_new_image(self):
 862 #         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 863 #                                                             self.__class__.test_index,
 864 #                                                 inspect.currentframe().f_code.co_name)
 865 #         self.__class__.test_index += 1
 866 #
 867 #         image_path = test_config['image_path']
 868 #         if image_path:
 869 #             self.__class__.image_id = test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : image_path, 'metadata': {'upload_location':None} })
 870 #             time.sleep(20)
 871 #
 872 #             self.assertIsInstance(self.__class__.image_id, (str, unicode))
 873 #             self.assertIsInstance(uuid.UUID(self.__class__.image_id), uuid.UUID)
 874 #         else:
 875 #             self.skipTest("Skipping test as image file not present at RO container")
 876 #
 877 #     def test_010_new_image_negative(self):
 878 #         Non_exist_image_path = '/temp1/cirros.ovf'
 879 #
 880 #         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 881 #                                                             self.__class__.test_index,
 882 #                                                 inspect.currentframe().f_code.co_name)
 883 #         self.__class__.test_index += 1
 884 #
 885 #         with self.assertRaises(Exception) as context:
 886 #             test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path})
 887 #
 888 #         self.assertEqual((context.exception).http_code, 400)
 889 #
 890 #     def test_020_delete_image(self):
 891 #         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 892 #                                                             self.__class__.test_index,
 893 #                                                 inspect.currentframe().f_code.co_name)
 894 #         self.__class__.test_index += 1
 895 #
 896 #         image_id = test_config["vim_conn"].delete_image(self.__class__.image_id)
 897 #
 898 #         self.assertIsInstance(image_id, (str, unicode))
 899 #
 900 #     def test_030_delete_image_negative(self):
 901 #         Non_exist_image_id = str(uuid.uuid4())
 902 #
 903 #         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 904 #                                                             self.__class__.test_index,
 905 #                                                 inspect.currentframe().f_code.co_name)
 906 #         self.__class__.test_index += 1
 907 #
 908 #         with self.assertRaises(Exception) as context:
 909 #             test_config["vim_conn"].delete_image(Non_exist_image_id)
 910 #
 911 #         self.assertEqual((context.exception).http_code, 404)
 912
 913 # class test_vimconn_get_image_id_from_path(test_base):
 914 #
 915 #     def test_000_get_image_id_from_path(self):
 916 #         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 917 #                                                             self.__class__.test_index,
 918 #                                                 inspect.currentframe().f_code.co_name)
 919 #         self.__class__.test_index += 1
 920 #
 921 #         image_path = test_config['image_path']
 922 #         if image_path:
 923 #             image_id = test_config["vim_conn"].get_image_id_from_path( image_path )
 924 #             self.assertEqual(type(image_id),str)
 925 #         else:
 926 #             self.skipTest("Skipping test as image file not present at RO container")
 927 #
 928 #     def test_010_get_image_id_from_path_negative(self):
 929 #         Non_exist_image_path = '/temp1/cirros.ovf'
 930 #
 931 #         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 932 #                                                             self.__class__.test_index,
 933 #                                                 inspect.currentframe().f_code.co_name)
 934 #         self.__class__.test_index += 1
 935 #
 936 #         with self.assertRaises(Exception) as context:
 937 #             test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path })
 938 #
 939 #         self.assertEqual((context.exception).http_code, 400)
 940
 941 class test_vimconn_get_image_list(test_base):
 942     image_name = None
 943     image_id = None
 944
 945     def test_000_get_image_list(self):
 946         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 947                                                             self.__class__.test_index,
 948                                                 inspect.currentframe().f_code.co_name)
 949         self.__class__.test_index += 1
 950
 951         # if test_config['image_name']:
 952         #     image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']})
 953         # else:
 954         image_list = test_config["vim_conn"].get_image_list()
 955
 956         for item in image_list:
 957             if 'name' in item:
 958                 self.__class__.image_name = item['name']
 959                 self.__class__.image_id = item['id']
 960                 self.assertIsInstance(self.__class__.image_name, (str, unicode))
 961                 self.assertIsInstance(self.__class__.image_id, (str, unicode))
 962
 963     def test_010_get_image_list_by_name(self):
 964         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 965                                                             self.__class__.test_index,
 966                                                 inspect.currentframe().f_code.co_name)
 967         self.__class__.test_index += 1
 968
 969         image_list = test_config["vim_conn"].get_image_list({'name': self.__class__.image_name})
 970
 971         for item in image_list:
 972             self.assertIsInstance(item['id'], (str, unicode))
 973             self.assertIsInstance(item['name'], (str, unicode))
 974             self.assertEqual(item['id'], self.__class__.image_id)
 975             self.assertEqual(item['name'], self.__class__.image_name)
 976
 977     def test_020_get_image_list_by_id(self):
 978         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 979                                                             self.__class__.test_index,
 980                                                 inspect.currentframe().f_code.co_name)
 981         self.__class__.test_index += 1
 982
 983         filter_image_list = test_config["vim_conn"].get_image_list({'id': self.__class__.image_id})
 984
 985         for item1 in filter_image_list:
 986             self.assertIsInstance(item1['id'], (str, unicode))
 987             self.assertIsInstance(item1['name'], (str, unicode))
 988             self.assertEqual(item1['id'], self.__class__.image_id)
 989             self.assertEqual(item1['name'], self.__class__.image_name)
 990
 991     def test_030_get_image_list_negative(self):
 992         Non_exist_image_id = uuid.uuid4()
 993         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 994                                                             self.__class__.test_index,
 995                                                 inspect.currentframe().f_code.co_name)
 996         self.__class__.test_index += 1
 997         image_list = test_config["vim_conn"].get_image_list({'name': 'Unknown_name', 'id': Non_exist_image_id})
 998
 999         self.assertIsNotNone(image_list, None)
1000         self.assertEqual(image_list, [])
1001
1002 class test_vimconn_new_vminstance(test_base):
1003     network_name = None
1004     net_type = None
1005     network_id = None
1006     image_id = None
1007     instance_id = None
1008
1009     def setUp(self):
1010         # create network
1011         self.__class__.network_name = _get_random_string(20)
1012         self.__class__.net_type = 'bridge'
1013
1014         self.__class__.network_id, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
1015                                                                             net_type=self.__class__.net_type)
1016         # find image name and image id
1017         if test_config['image_name']:
1018             image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']})
1019             if len(image_list) == 0:
1020                 raise Exception("Image {} is not found at VIM".format(test_config['image_name']))
1021             else:
1022                 self.__class__.image_id = image_list[0]['id']
1023         else:
1024             image_list = test_config['vim_conn'].get_image_list()
1025             if len(image_list) == 0:
1026                 raise Exception("Not found any image at VIM")
1027             else:
1028                 self.__class__.image_id = image_list[0]['id']
1029
1030     def tearDown(self):
1031         test_base.tearDown(self)
1032         # Deleting created network
1033         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
1034         if result:
1035             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
1036         else:
1037             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
1038
1039     def test_000_new_vminstance(self):
1040         vpci = "0000:00:11.0"
1041         name = "eth0"
1042
1043         flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1044
1045         # create new flavor
1046         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1047
1048
1049         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1050                                                             self.__class__.test_index,
1051                                                 inspect.currentframe().f_code.co_name)
1052         self.__class__.test_index += 1
1053
1054         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci,
1055                      'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1056
1057         self.__class__.instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='',
1058                                                                                start=False,
1059                                                                                image_id=self.__class__.image_id,
1060                                                                                flavor_id=flavor_id, net_list=net_list)
1061
1062         self.assertIsInstance(self.__class__.instance_id, (str, unicode))
1063
1064     def test_010_new_vminstance_by_model(self):
1065         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1066         model_name = 'e1000'
1067         name = 'eth0'
1068
1069         # create new flavor
1070         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1071
1072         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1073                                                             self.__class__.test_index,
1074                                                 inspect.currentframe().f_code.co_name)
1075         self.__class__.test_index += 1
1076
1077         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1078                      'model': model_name, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1079
1080         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1081                                                                 image_id=self.__class__.image_id,
1082                                                                 flavor_id=flavor_id,net_list=net_list)
1083
1084         self.assertIsInstance(instance_id, (str, unicode))
1085
1086         # Deleting created vm instance
1087         logger.info("Deleting created vm intance")
1088         test_config["vim_conn"].delete_vminstance(instance_id)
1089         time.sleep(10)
1090
1091     def test_020_new_vminstance_by_net_use(self):
1092         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1093         net_use = 'data'
1094         name = 'eth0'
1095
1096         # create new flavor
1097         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1098
1099         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1100                                                             self.__class__.test_index,
1101                                                 inspect.currentframe().f_code.co_name)
1102         self.__class__.test_index += 1
1103
1104         net_list = [{'use': net_use, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1105                      'net_id': self.__class__.network_id}]
1106
1107         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1108                                                                 image_id=self.__class__.image_id,disk_list=None,
1109                                                                 flavor_id=flavor_id, net_list=net_list)
1110         self.assertIsInstance(instance_id, (str, unicode))
1111
1112         # Deleting created vm instance
1113         logger.info("Deleting created vm intance")
1114         test_config["vim_conn"].delete_vminstance(instance_id)
1115         time.sleep(10)
1116
1117     def test_030_new_vminstance_by_net_type(self):
1118         flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1119         _type = 'VF'
1120         name = 'eth0'
1121
1122         # create new flavor
1123         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1124
1125         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1126                                                             self.__class__.test_index,
1127                                                 inspect.currentframe().f_code.co_name)
1128         self.__class__.test_index += 1
1129
1130         if test_config['vimtype'] == 'vmware':
1131             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1132                          'type': _type, 'net_id': self.__class__.network_id}]
1133
1134             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id,
1135                                                                     flavor_id=flavor_id,
1136                                                                     net_list=net_list)
1137             self.assertEqual(type(instance_id),str)
1138
1139         if test_config['vimtype'] in ('openstack', 'azure'):
1140             # create network of type data
1141             network_name = _get_random_string(20)
1142             net_type = 'data'
1143
1144             network_id, _ = test_config["vim_conn"].new_network(net_name=network_name,
1145                                                                             net_type=net_type)
1146             net_list = [{'use': net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1147                          'type': _type, 'net_id': network_id}]
1148
1149             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1150                                                                    image_id=self.__class__.image_id, disk_list=None,
1151                                                                    flavor_id=flavor_id,
1152                                                                    net_list=net_list)
1153
1154             self.assertEqual(type(instance_id), unicode)
1155
1156             # delete created network
1157             result = test_config["vim_conn"].delete_network(network_id)
1158             if result:
1159                 logger.info("Network id {} sucessfully deleted".format(network_id))
1160             else:
1161                 logger.info("Failed to delete network id {}".format(network_id))
1162
1163         # Deleting created vm instance
1164         logger.info("Deleting created vm intance")
1165         test_config["vim_conn"].delete_vminstance(instance_id)
1166         time.sleep(10)
1167
1168     def test_040_new_vminstance_by_cloud_config(self):
1169         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1170         name = 'eth0'
1171         user_name = 'test_user'
1172
1173         key_pairs = ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDtAjl5R+GSKP3gFrdFxgizKEUzhXKQbyjaxJH9thsK     0/fDiYlaNEjvijgPgiVZkfwvqgWeLprPcpzL2j4jvmmSJ3+7C8ihCwObWP0VUiuewmbIINBPAR0RqusjMRyPsa+q0asFBPOoZLx3Cv3vzmC1AA3mKuCNeT     EuA0rlWhDIOVwMcU5sP1grnmuexQB8HcR7BdKcA9y08pTwnCQR8vmtW77SRkaxEGXm4Gnw5qw8Z27mHdk2wWS2SnbVH7aFwWvDXc6jjf5TpEWypdr/EAPC     +eJipeS2Oa4FsntEqAu3Fz6gp/9ub8uNqgCgHfMzs6FhYpZpipwS0hXYyF6eVsSx osm@osm']
1174
1175         users_data = [{'key-pairs': ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDtAjl5R+GSKP3gFrdFxgizKEUzhXKQbyjaxJH9thsK0/fDiYlaNEjvijgPgiVZkfwvqgWeLprPcpzL2j4jvmmSJ3+7C8ihCwObWP0VUiuewmbIINBPAR0RqusjMRyPsa+q0asFBPOoZLx3Cv3vzmC1AA3mKuCNeTEuA0rlWhDIOVwMcU5sP1grnmuexQB8HcR7BdKcA9y08pTwnCQR8vmtW77SRkaxEGXm4Gnw5qw8Z27mHdk2wWS2SnbVH7aFwWvDXc6jjf5TpEWypdr/EAPC+eJipeS2Oa4FsntEqAu3Fz6gp/9ub8uNqgCgHfMzs6FhYpZpipwS0hXYyF6eVsSx osm@osm'], 'name': 'cloudinit'}]
1176
1177         cloud_data = {'config-files': [{'content': 'auto enp0s3\niface enp0s3 inet dhcp\n', 'dest': '/etc/network/interfaces.d/enp0s3.cfg', 'owner': 'root:root', 'permissions': '0644'}, {'content': '#! /bin/bash\nls -al >> /var/log/osm.log\n', 'dest': '/etc/rc.local', 'permissions': '0755'}, {'content': 'file content', 'dest': '/etc/test_delete'}], 'boot-data-drive': True, 'key-pairs': key_pairs, 'users': users_data }
1178         #cloud_data = {'users': users_data }
1179
1180         # create new flavor
1181         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1182
1183         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1184                                                             self.__class__.test_index,
1185                                                 inspect.currentframe().f_code.co_name)
1186         self.__class__.test_index += 1
1187
1188         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1189                      'type': 'virtual', 'net_id': self.__class__.network_id}]
1190
1191         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Cloud_vm', description='', start=False,
1192                                                                 image_id=self.__class__.image_id,
1193                                                                 flavor_id=flavor_id,net_list=net_list,
1194                                                                 cloud_config=cloud_data)
1195
1196         self.assertIsInstance(instance_id, (str, unicode))
1197
1198         # Deleting created vm instance
1199         logger.info("Deleting created vm intance")
1200         test_config["vim_conn"].delete_vminstance(instance_id)
1201         time.sleep(10)
1202
1203     def test_050_new_vminstance_by_disk_list(self):
1204         flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1205         name = 'eth0'
1206
1207         device_data = [{'image_id': self.__class__.image_id, 'size': '10'}]
1208
1209         # create new flavor
1210         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1211
1212         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1213                                                             self.__class__.test_index,
1214                                                 inspect.currentframe().f_code.co_name)
1215         self.__class__.test_index += 1
1216
1217         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1218                      'type': 'virtual', 'net_id': self.__class__.network_id}]
1219
1220         instance_id, _ = test_config["vim_conn"].new_vminstance(name='VM_test1', description='', start=False,
1221                                                                 image_id=self.__class__.image_id,
1222                                                                 flavor_id=flavor_id, net_list=net_list,
1223                                                                 disk_list=device_data)
1224
1225         self.assertIsInstance(instance_id, (str, unicode))
1226         # Deleting created vm instance
1227         logger.info("Deleting created vm intance")
1228         test_config["vim_conn"].delete_vminstance(instance_id)
1229         time.sleep(10)
1230
1231     def test_060_new_vminstance_negative(self):
1232         unknown_flavor_id = str(uuid.uuid4())
1233         unknown_image_id = str(uuid.uuid4())
1234         name = 'eth2'
1235
1236         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1237                                                             self.__class__.test_index,
1238                                                 inspect.currentframe().f_code.co_name)
1239         self.__class__.test_index += 1
1240
1241         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1242                      'type': 'virtual', 'net_id': self.__class__.network_id}]
1243
1244         with self.assertRaises(Exception) as context:
1245             test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1246                                                    image_id=unknown_image_id,
1247                                                    flavor_id=unknown_flavor_id,
1248                                                    net_list=net_list)
1249
1250         self.assertIn((context.exception).http_code, (400, 404))
1251
1252
1253     def test_070_get_vminstance(self):
1254         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1255                                                             self.__class__.test_index,
1256                                                 inspect.currentframe().f_code.co_name)
1257         self.__class__.test_index += 1
1258
1259         # Get instance by its id
1260         vm_info = test_config["vim_conn"].get_vminstance(self.__class__.instance_id)
1261
1262         if test_config['vimtype'] == 'vmware':
1263             for attr in vm_info:
1264                 if attr == 'status':
1265                     self.assertEqual(vm_info[attr], 'ACTIVE')
1266                 if attr == 'hostId':
1267                     self.assertEqual(type(vm_info[attr]), str)
1268                 if attr == 'interfaces':
1269                     self.assertEqual(type(vm_info[attr]), list)
1270                     self.assertEqual(vm_info[attr][0]['IsConnected'], 'true')
1271                 if attr == 'IsEnabled':
1272                     self.assertEqual(vm_info[attr], 'true')
1273
1274     def test_080_get_vminstance_negative(self):
1275         unknown_instance_id = str(uuid.uuid4())
1276
1277         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1278                                                             self.__class__.test_index,
1279                                                 inspect.currentframe().f_code.co_name)
1280         self.__class__.test_index += 1
1281
1282         with self.assertRaises(Exception) as context:
1283             test_config["vim_conn"].get_vminstance(unknown_instance_id)
1284
1285         self.assertEqual((context.exception).http_code, 404)
1286
1287     def test_090_refresh_vms_status(self):
1288         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1289                                                             self.__class__.test_index,
1290                                                 inspect.currentframe().f_code.co_name)
1291         self.__class__.test_index += 1
1292
1293         if test_config['vimtype'] == 'vmware':
1294             vm_list = []
1295             vm_list.append(self.__class__.instance_id)
1296
1297             # refresh vm status
1298             vm_info = test_config["vim_conn"].refresh_vms_status(vm_list)
1299             for attr in vm_info[self.__class__.instance_id]:
1300                 if attr == 'status':
1301                     self.assertEqual(vm_info[self.__class__.instance_id][attr], 'ACTIVE')
1302                 if attr == 'interfaces':
1303                     self.assertEqual(type(vm_info[self.__class__.instance_id][attr]), list)
1304
1305         if test_config['vimtype'] in ('openstack', 'azure'):
1306             vpci = "0000:00:11.0"
1307             name = "eth0"
1308
1309             flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1310
1311             # create new flavor
1312             flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1313              # create new vm instance
1314             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci,
1315                          'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1316
1317             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1318                                                                     image_id=self.__class__.image_id,
1319                                                                     flavor_id=flavor_id, net_list=net_list)
1320
1321             time.sleep(30)
1322             vm_list = []
1323             vm_list.append(instance_id)
1324
1325             # refresh vm status
1326             vm_info = test_config["vim_conn"].refresh_vms_status(vm_list)
1327             for attr in vm_info[instance_id]:
1328                 if attr == 'status':
1329                     self.assertEqual(vm_info[instance_id][attr], 'ACTIVE')
1330                 if attr == 'interfaces':
1331                     self.assertEqual(type(vm_info[instance_id][attr]), list)
1332
1333             #Deleting created vm instance
1334             logger.info("Deleting created vm intance")
1335             test_config["vim_conn"].delete_vminstance(instance_id)
1336             time.sleep(10)
1337
1338
1339     def test_100_refresh_vms_status_negative(self):
1340         unknown_id = str(uuid.uuid4())
1341
1342         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1343                                                             self.__class__.test_index,
1344                                                 inspect.currentframe().f_code.co_name)
1345         self.__class__.test_index += 1
1346
1347         vm_dict = test_config["vim_conn"].refresh_vms_status([unknown_id])
1348
1349         if test_config['vimtype'] == 'vmware':
1350             self.assertEqual(vm_dict,{})
1351
1352         if test_config['vimtype'] in ('openstack', 'azure'):
1353             self.assertEqual(vm_dict[unknown_id]['status'], 'DELETED')
1354
1355     def test_110_action_vminstance(self):
1356         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1357                                                             self.__class__.test_index,
1358                                                 inspect.currentframe().f_code.co_name)
1359         self.__class__.test_index += 1
1360
1361         if test_config['vimtype'] == 'vmware':
1362             action_list = ['shutdown', 'start', 'shutoff', 'rebuild', 'pause', 'resume']
1363             # various action on vminstace
1364             for action in action_list:
1365                 instance_id = test_config["vim_conn"].action_vminstance(self.__class__.instance_id,
1366                                                                         {action: None})
1367                 self.assertEqual(instance_id, self.__class__.instance_id)
1368
1369         if test_config['vimtype'] in ('openstack', 'azure'):
1370             # create new vm instance
1371             vpci = "0000:00:11.0"
1372             name = "eth0"
1373
1374             flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1375
1376             # create new flavor
1377             flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1378
1379             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci,
1380                          'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1381
1382             new_instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='',
1383                                                                         start=False, image_id=self.__class__.image_id,
1384                                                                         flavor_id=flavor_id, net_list=net_list)
1385
1386             if test_config['vimtype'] == 'openstack':
1387                 action_list =  ['shutdown','start','shutoff','rebuild','start','pause','start']
1388             else:
1389                 action_list =  ['shutdown','start','stop','start','shutoff','start','reboot']
1390
1391             # various action on vminstace
1392             for action in action_list:
1393                 # sleep for sometime till status is changed
1394                 time.sleep(25)
1395                 instance_id = test_config["vim_conn"].action_vminstance(new_instance_id,
1396                                                                                    { action: None})
1397
1398             self.assertTrue(instance_id is None)
1399
1400             # Deleting created vm instance
1401             logger.info("Deleting created vm intance")
1402             test_config["vim_conn"].delete_vminstance(new_instance_id)
1403             time.sleep(10)
1404
1405     def test_120_action_vminstance_negative(self):
1406         non_exist_id = str(uuid.uuid4())
1407         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1408                                                             self.__class__.test_index,
1409                                                 inspect.currentframe().f_code.co_name)
1410         self.__class__.test_index += 1
1411
1412         action = 'start'
1413         with self.assertRaises(Exception) as context:
1414             test_config["vim_conn"].action_vminstance(non_exist_id, { action: None})
1415
1416         self.assertEqual((context.exception).http_code, 404)
1417
1418
1419     def test_130_delete_vminstance(self):
1420         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1421                                                             self.__class__.test_index,
1422                                                 inspect.currentframe().f_code.co_name)
1423         self.__class__.test_index += 1
1424
1425         # Deleting created vm instance
1426         logger.info("Deleting created vm instance")
1427         test_config["vim_conn"].delete_vminstance(self.__class__.instance_id)
1428         time.sleep(10)
1429
1430     def test_140_new_vminstance_sriov(self):
1431         logger.info("Testing creation of sriov vm instance using {}".format(test_config['sriov_net_name']))
1432         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1433         name = 'eth0'
1434
1435         # create new flavor
1436         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1437
1438         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1439                                                             self.__class__.test_index,
1440                                                 inspect.currentframe().f_code.co_name)
1441         self.__class__.test_index += 1
1442
1443         sriov_net_name = test_config['sriov_net_name']
1444         new_network_list = test_config["vim_conn"].get_network_list({'name': sriov_net_name})
1445         for list_item in new_network_list:
1446             self.assertEqual(sriov_net_name, list_item.get('name'))
1447             self.__class__.sriov_network_id = list_item.get('id')
1448
1449         net_list = [{'use': 'data', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'VF',
1450                      'net_id': self.__class__.sriov_network_id}]
1451
1452         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_sriov_vm', description='', start=False,
1453                                                                 image_id=self.__class__.image_id, flavor_id=flavor_id,
1454                                                                 net_list=net_list)
1455
1456         self.assertIsInstance(instance_id, (str, unicode))
1457
1458         logger.info("Waiting for created sriov-vm intance")
1459         time.sleep(10)
1460         # Deleting created vm instance
1461         logger.info("Deleting created sriov-vm intance")
1462         test_config["vim_conn"].delete_vminstance(instance_id)
1463         time.sleep(10)
1464
1465 class test_vimconn_get_tenant_list(test_base):
1466     tenant_id = None
1467
1468     def test_000_get_tenant_list(self):
1469         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1470                                                             self.__class__.test_index,
1471                                                 inspect.currentframe().f_code.co_name)
1472         self.__class__.test_index += 1
1473
1474         # Getting tenant list
1475         tenant_list = test_config["vim_conn"].get_tenant_list()
1476
1477         for item in tenant_list:
1478             if test_config['tenant'] == item['name']:
1479                 self.__class__.tenant_id = item['id']
1480                 self.assertIsInstance(item['name'], (str, unicode))
1481                 self.assertIsInstance(item['id'], (str, unicode))
1482
1483     def test_010_get_tenant_list_by_id(self):
1484         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1485                                                             self.__class__.test_index,
1486                                                 inspect.currentframe().f_code.co_name)
1487         self.__class__.test_index += 1
1488
1489         # Getting filter tenant list by its id
1490         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'id': self.__class__.tenant_id})
1491
1492         for item in filter_tenant_list:
1493             self.assertIsInstance(item['id'], (str, unicode))
1494             self.assertEqual(item['id'], self.__class__.tenant_id)
1495
1496     def test_020_get_tenant_list_by_name(self):
1497         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1498                                                             self.__class__.test_index,
1499                                                 inspect.currentframe().f_code.co_name)
1500         self.__class__.test_index += 1
1501
1502         # Getting filter tenant list by its name
1503         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant']})
1504
1505         for item in filter_tenant_list:
1506             self.assertIsInstance(item['name'], (str, unicode))
1507             self.assertEqual(item['name'], test_config['tenant'])
1508
1509     def test_030_get_tenant_list_by_name_and_id(self):
1510         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1511                                                             self.__class__.test_index,
1512                                                 inspect.currentframe().f_code.co_name)
1513         self.__class__.test_index += 1
1514
1515         # Getting filter tenant list by its name and id
1516         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant'],
1517                                                                     'id': self.__class__.tenant_id})
1518
1519         for item in filter_tenant_list:
1520             self.assertIsInstance(item['name'], (str, unicode))
1521             self.assertIsInstance(item['id'], (str, unicode))
1522             self.assertEqual(item['name'], test_config['tenant'])
1523             self.assertEqual(item['id'], self.__class__.tenant_id)
1524
1525     def test_040_get_tenant_list_negative(self):
1526         non_exist_tenant_name = "Tenant_123"
1527         non_exist_tenant_id = "kjhgrt456-45345kjhdfgnbdk-34dsfjdfg"
1528         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1529                                                             self.__class__.test_index,
1530                                                 inspect.currentframe().f_code.co_name)
1531         self.__class__.test_index += 1
1532
1533         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': non_exist_tenant_name,
1534                                                                          'id': non_exist_tenant_id})
1535
1536         self.assertEqual(filter_tenant_list, [])
1537
1538
1539 class test_vimconn_new_tenant(test_base):
1540     tenant_id = None
1541
1542     def test_000_new_tenant(self):
1543         tenant_name = _get_random_string(20)
1544         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1545                                                             self.__class__.test_index,
1546                                                 inspect.currentframe().f_code.co_name)
1547         self.__class__.test_index += 1
1548
1549         if test_config['vimtype'] != 'azure':
1550             self.__class__.tenant_id = test_config["vim_conn"].new_tenant(tenant_name, "")
1551             time.sleep(15)
1552
1553             self.assertIsInstance(self.__class__.tenant_id, (str, unicode))
1554         else:
1555             with self.assertRaises(Exception) as context:
1556                 test_config["vim_conn"].new_tenant(self.__class__.tenant_id)
1557             self.assertEqual((context.exception).http_code, 401)
1558
1559
1560     def test_010_new_tenant_negative(self):
1561         Invalid_tenant_name = 10121
1562         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1563                                                             self.__class__.test_index,
1564                                                 inspect.currentframe().f_code.co_name)
1565         self.__class__.test_index += 1
1566
1567         with self.assertRaises(Exception) as context:
1568             test_config["vim_conn"].new_tenant(Invalid_tenant_name, "")
1569
1570         if test_config['vimtype'] != 'azure':
1571             self.assertEqual((context.exception).http_code, 400)
1572         else:
1573             self.assertEqual((context.exception).http_code, 401)
1574
1575
1576     def test_020_delete_tenant(self):
1577         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1578                                                             self.__class__.test_index,
1579                                                 inspect.currentframe().f_code.co_name)
1580         self.__class__.test_index += 1
1581
1582         if test_config['vimtype'] != 'azure':
1583             tenant_id = test_config["vim_conn"].delete_tenant(self.__class__.tenant_id)
1584             self.assertIsInstance(tenant_id, (str, unicode))
1585         else:
1586             with self.assertRaises(Exception) as context:
1587                 test_config["vim_conn"].delete_tenant(self.__class__.tenant_id)
1588             self.assertEqual((context.exception).http_code, 401)
1589
1590     def test_030_delete_tenant_negative(self):
1591         Non_exist_tenant_name = 'Test_30_tenant'
1592         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1593                                                             self.__class__.test_index,
1594                                                 inspect.currentframe().f_code.co_name)
1595         self.__class__.test_index += 1
1596
1597         with self.assertRaises(Exception) as context:
1598             test_config["vim_conn"].delete_tenant(Non_exist_tenant_name)
1599
1600         self.assertEqual((context.exception).http_code, 404)
1601
1602
1603 def get_image_id():
1604     if test_config['image_name']:
1605         image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']})
1606         if len(image_list) == 0:
1607             raise Exception("Image {} is not found at VIM".format(test_config['image_name']))
1608         else:
1609             image_id = image_list[0]['id']
1610     else:
1611         image_list = test_config['vim_conn'].get_image_list()
1612         if len(image_list) == 0:
1613             raise Exception("Not found any image at VIM")
1614         else:
1615             image_id = image_list[0]['id']
1616     return image_id
1617
1618
1619 class test_vimconn_vminstance_by_ip_address(test_base):
1620     network_name = None
1621     network_id = None
1622
1623     def setUp(self):
1624         # create network
1625         self.network_name = _get_random_string(20)
1626
1627         self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name,
1628                                                                        net_type='bridge')
1629
1630     def tearDown(self):
1631         test_base.tearDown(self)
1632         # Deleting created network
1633         result = test_config["vim_conn"].delete_network(self.network_id)
1634         if result:
1635             logger.info("Network id {} sucessfully deleted".format(self.network_id))
1636         else:
1637             logger.info("Failed to delete network id {}".format(self.network_id))
1638
1639
1640     def test_000_vminstance_by_ip_address(self):
1641         """
1642            This test case will deploy VM with provided IP address
1643            Pre-requesite: provided IP address should be from IP pool range which has used for network creation
1644         """
1645         name = "eth0"
1646         # provide ip address
1647         ip_address = ''
1648
1649         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1650
1651         # create new flavor
1652         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1653
1654         # find image id
1655         image_id = get_image_id()
1656
1657         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1658                                                             self.__class__.test_index,
1659                                                 inspect.currentframe().f_code.co_name)
1660         self.__class__.test_index += 1
1661
1662         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1663                                                     'net_id': self.network_id, 'ip_address': ip_address}]
1664
1665         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id,
1666                                                             flavor_id=flavor_id, net_list=net_list)
1667
1668         self.assertEqual(type(instance_id),str)
1669         logger.info("Deleting created vm instance")
1670         test_config["vim_conn"].delete_vminstance(instance_id)
1671         time.sleep(10)
1672
1673     def test_010_vminstance_by_ip_address_negative(self):
1674         name = "eth1"
1675         # IP address not from subnet range
1676         invalid_ip_address = '10.10.12.1'
1677
1678         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1679
1680         # create new flavor
1681         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1682
1683         # find image name and image id
1684         image_id = get_image_id()
1685
1686         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1687                                                             self.__class__.test_index,
1688                                                 inspect.currentframe().f_code.co_name)
1689         self.__class__.test_index += 1
1690
1691         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1692                                                       'net_id': self.network_id, 'ip_address': invalid_ip_address}]
1693
1694         with self.assertRaises(Exception) as context:
1695             test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id,
1696                                                                   flavor_id=flavor_id,
1697                                                                     net_list=net_list)
1698         self.assertEqual((context.exception).http_code, 400)
1699
1700     def test_020_vminstance_by_floating_ip(self):
1701         name = "eth1"
1702         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1703
1704         # create new flavor
1705         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1706
1707         # find image name and image id
1708         image_id = get_image_id()
1709
1710         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1711                                                             self.__class__.test_index,
1712                                                 inspect.currentframe().f_code.co_name)
1713         self.__class__.test_index += 1
1714
1715         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': True, 'port_security': True, 'type': 'virtual',
1716                                                                                        'net_id': self.network_id}]
1717
1718         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id,
1719                                                             flavor_id=flavor_id, net_list=net_list)
1720
1721         self.assertEqual(type(instance_id),str)
1722         logger.info("Deleting created vm instance")
1723         test_config["vim_conn"].delete_vminstance(instance_id)
1724         time.sleep(10)
1725
1726     def test_030_vminstance_by_mac_address(self):
1727         name = "eth1"
1728         mac_address = "74:54:2f:21:da:8c"
1729         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1730
1731         # create new flavor
1732         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1733
1734         # find image name and image id
1735         image_id = get_image_id()
1736
1737         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1738                                                             self.__class__.test_index,
1739                                                 inspect.currentframe().f_code.co_name)
1740         self.__class__.test_index += 1
1741
1742         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1743                                                              'net_id': self.network_id,'mac_address': mac_address}]
1744
1745         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id,
1746                                                             flavor_id=flavor_id, net_list=net_list)
1747
1748         self.assertEqual(type(instance_id),str)
1749         logger.info("Deleting created vm instance")
1750         test_config["vim_conn"].delete_vminstance(instance_id)
1751         time.sleep(10)
1752
1753 class test_vimconn_vminstance_by_adding_10_nics(test_base):
1754     network_name = None
1755     net_ids = []
1756
1757     def setUp(self):
1758         # create network
1759         i = 0
1760         for i in range(10):
1761             self.network_name = _get_random_string(20)
1762             network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name,
1763                                                                       net_type='bridge')
1764             self.net_ids.append(network_id)
1765
1766     def tearDown(self):
1767         test_base.tearDown(self)
1768         # Deleting created network
1769         for net_id in self.net_ids:
1770             result = test_config["vim_conn"].delete_network(net_id)
1771             if result:
1772                 logger.info("Network id {} sucessfully deleted".format(net_id))
1773             else:
1774                 logger.info("Failed to delete network id {}".format(net_id))
1775
1776     def test_000_vminstance_by_adding_10_nics(self):
1777         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1778
1779         # create new flavor
1780         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1781
1782         # find image name and image id
1783         image_id = get_image_id()
1784
1785         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1786                                                             self.__class__.test_index,
1787                                                 inspect.currentframe().f_code.co_name)
1788         self.__class__.test_index += 1
1789
1790         net_list = []
1791         c = 1
1792         for net_id in self.net_ids:
1793             name = "eth{}".format(c)
1794             net_list.append({'use': 'bridge', 'name': name, 'floating_ip': False,
1795                                     'port_security': True, 'type': 'virtual', 'net_id': net_id})
1796             c = c+1
1797
1798         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id,
1799                                                             flavor_id=flavor_id, net_list=net_list)
1800
1801         self.assertEqual(type(instance_id),str)
1802         logger.info("Deleting created vm instance")
1803         test_config["vim_conn"].delete_vminstance(instance_id)
1804         time.sleep(10)
1805
1806
1807 class test_vimconn_vminstance_by_existing_disk(test_base):
1808     network_name = None
1809     network_id = None
1810
1811     def setUp(self):
1812         # create network
1813         self.network_name = _get_random_string(20)
1814         self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name,
1815                                                                        net_type='bridge')
1816
1817     def tearDown(self):
1818         test_base.tearDown(self)
1819         # Deleting created network
1820         result = test_config["vim_conn"].delete_network(self.network_id)
1821         if result:
1822             logger.info("Network id {} sucessfully deleted".format(self.network_id))
1823         else:
1824             logger.info("Failed to delete network id {}".format(self.network_id))
1825
1826
1827     def test_000_vminstance_by_existing_disk(self):
1828         """ This testcase will add existing disk only if given catalog/image is free
1829             means not used by any other VM
1830         """
1831
1832         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1833         name = "eth10"
1834
1835         # create new flavor
1836         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1837
1838         # find image name and image id
1839         image_id = get_image_id()
1840         cirros_image = test_config["vim_conn"].get_image_list({'name': 'cirros'})
1841         disk_list = [{'image_id': cirros_image[0]['id'],'size': 5}]
1842
1843         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1844                                                             self.__class__.test_index,
1845                                                 inspect.currentframe().f_code.co_name)
1846         self.__class__.test_index += 1
1847
1848         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True,
1849                                         'type': 'virtual', 'net_id': self.network_id}]
1850
1851         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1852                                         image_id=image_id,
1853                                         flavor_id=flavor_id, net_list=net_list,disk_list=disk_list)
1854
1855         self.assertEqual(type(instance_id),str)
1856         logger.info("Deleting created vm instance")
1857         test_config["vim_conn"].delete_vminstance(instance_id)
1858         time.sleep(10)
1859
1860     def test_010_vminstance_by_new_disk(self):
1861         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1862         name = "eth10"
1863
1864         # create new flavor
1865         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1866
1867         # find image name and image id
1868         image_id = get_image_id()
1869         disk_list = [{'size': '5'}]
1870
1871         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1872                                                             self.__class__.test_index,
1873                                                 inspect.currentframe().f_code.co_name)
1874         self.__class__.test_index += 1
1875
1876         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True,
1877                                                   'type': 'virtual', 'net_id': self.network_id}]
1878
1879         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1880                                         image_id=image_id,
1881                                         flavor_id=flavor_id, net_list=net_list,disk_list=disk_list)
1882
1883         self.assertEqual(type(instance_id),str)
1884         logger.info("Deleting created vm instance")
1885         test_config["vim_conn"].delete_vminstance(instance_id)
1886         time.sleep(10)
1887
1888     def test_020_vminstance_by_CDROM(self):
1889         """ This testcase will insert media file only if provided catalog
1890             has pre-created ISO media file into vCD
1891         """
1892         flavor_data ={'ram': 1024, 'vcpus': 1, 'disk': 10}
1893         name = "eth10"
1894         image_list = test_config["vim_conn"].get_image_list({'name':'Ubuntu'})
1895         disk_list = [{'image_id':image_list[0]['id'],'device_type':'cdrom'}]
1896
1897         # create new flavor
1898         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1899
1900         # find image name and image id
1901         image_id = get_image_id()
1902
1903         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1904                                                             self.__class__.test_index,
1905                                                 inspect.currentframe().f_code.co_name)
1906         self.__class__.test_index += 1
1907
1908         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True,
1909                                                   'type': 'virtual', 'net_id': self.network_id}]
1910
1911         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1912                                        image_id=image_id,
1913                                        flavor_id=flavor_id, net_list=net_list,disk_list=disk_list )
1914
1915         self.assertEqual(type(instance_id),str)
1916         logger.info("Deleting created vm instance")
1917         test_config["vim_conn"].delete_vminstance(instance_id)
1918         time.sleep(10)
1919
1920
1921 class test_vimconn_vminstance_by_affinity_anti_affinity(test_base):
1922     network_name = None
1923     network_id = None
1924
1925     def setUp(self):
1926         # create network
1927         self.network_name = _get_random_string(20)
1928         self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name,
1929                                                                        net_type='bridge')
1930
1931     def tearDown(self):
1932         test_base.tearDown(self)
1933         # Deleting created network
1934         result = test_config["vim_conn"].delete_network(self.network_id)
1935         if result:
1936             logger.info("Network id {} sucessfully deleted".format(self.network_id))
1937         else:
1938             logger.info("Failed to delete network id {}".format(self.network_id))
1939
1940     def test_000_vminstance_by_affinity_anti_affinity(self):
1941         """ This testcase will deploy VM into provided HOSTGROUP in VIM config
1942             Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used
1943             While creating VIM account user has to pass the Host Group names in availability_zone list
1944         """
1945         flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10}
1946         name = "eth10"
1947
1948         # create new flavor
1949         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1950
1951         # find image name and image id
1952         image_id = get_image_id()
1953
1954         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1955                                                             self.__class__.test_index,
1956                                                 inspect.currentframe().f_code.co_name)
1957         self.__class__.test_index += 1
1958
1959         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True,
1960                                         'type': 'virtual', 'net_id': self.network_id}]
1961
1962         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1963                                   image_id=image_id,
1964                                   flavor_id=flavor_id, net_list=net_list,availability_zone_index=1,
1965                                                         availability_zone_list=['HG_174','HG_175'])
1966
1967         self.assertEqual(type(instance_id),str)
1968         time.sleep(10)
1969         logger.info("Deleting created vm instance")
1970         test_config["vim_conn"].delete_vminstance(instance_id)
1971
1972 class test_vimconn_vminstance_by_numa_affinity(test_base):
1973     network_name = None
1974     network_id = None
1975
1976     def setUp(self):
1977         # create network
1978         self.network_name = _get_random_string(20)
1979         self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name,
1980                                                                        net_type='bridge')
1981
1982     def tearDown(self):
1983         test_base.tearDown(self)
1984         # Deleting created network
1985         result = test_config["vim_conn"].delete_network(self.network_id)
1986         if result:
1987             logger.info("Network id {} sucessfully deleted".format(self.network_id))
1988         else:
1989             logger.info("Failed to delete network id {}".format(self.network_id))
1990
1991     def test_000_vminstance_by_numa_affinity(self):
1992         flavor_data = {'extended': {'numas': [{'paired-threads-id': [['1', '3'], ['2', '4']],
1993                                                ' paired-threads': 2, 'memory': 1}]},
1994                                                'ram': 1024, 'vcpus': 1, 'disk': 10}
1995         name = "eth10"
1996
1997         # create new flavor
1998         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1999
2000         # find image name and image id
2001         image_id = get_image_id()
2002
2003         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
2004                                                             self.__class__.test_index,
2005                                                 inspect.currentframe().f_code.co_name)
2006         self.__class__.test_index += 1
2007
2008         net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True,
2009                                         'type': 'virtual', 'net_id': self.network_id}]
2010
2011         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
2012                                                             image_id=image_id,
2013                                                             flavor_id=flavor_id, net_list=net_list)
2014
2015         self.assertEqual(type(instance_id),str)
2016         logger.info("Deleting created vm instance")
2017         test_config["vim_conn"].delete_vminstance(instance_id)
2018         time.sleep(10)
2019
2020
2021 '''
2022 IMPORTANT NOTE
2023 The following unittest class does not have the 'test_' on purpose. This test is the one used for the
2024 scenario based tests.
2025 '''
2026 class descriptor_based_scenario_test(test_base):
2027     test_index = 0
2028     scenario_test_path = None
2029
2030     @classmethod
2031     def setUpClass(cls):
2032         cls.test_index = 1
2033         cls.to_delete_list = []
2034         cls.scenario_uuids = []
2035         cls.instance_scenario_uuids = []
2036         cls.scenario_test_path = test_config["test_directory"] + '/' + test_config["test_folder"]
2037         logger.info("{}. {} {}".format(test_config["test_number"], cls.__name__, test_config["test_folder"]))
2038
2039     @classmethod
2040     def tearDownClass(cls):
2041          test_config["test_number"] += 1
2042
2043     def test_000_load_scenario(self):
2044         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
2045                                                            inspect.currentframe().f_code.co_name,
2046                                                            test_config["test_folder"])
2047         self.__class__.test_index += 1
2048         # load VNFD and NSD
2049         descriptor_files = glob.glob(self.__class__.scenario_test_path+'/*.yaml')
2050         vnf_descriptors = []
2051         scenario_descriptors = []
2052         for descriptor_file in descriptor_files:
2053             with open(descriptor_file, 'r') as stream:
2054                 descriptor = yaml.load(stream)
2055                 if "vnf" in descriptor or "vnfd:vnfd-catalog" in descriptor or "vnfd-catalog" in descriptor:
2056                     vnf_descriptors.append(descriptor)
2057                 else:
2058                     scenario_descriptors.append(descriptor)
2059
2060         scenario_file = glob.glob(self.__class__.scenario_test_path + '/scenario_*.yaml')
2061         if not vnf_descriptors or not scenario_descriptors or len(scenario_descriptors) > 1:
2062             raise Exception("Test '{}' not valid. It must contain an scenario file and at least one vnfd file'".format(
2063                 test_config["test_folder"]))
2064
2065         # load all vnfd
2066         for vnf_descriptor in vnf_descriptors:
2067             logger.debug("VNF descriptor: {}".format(vnf_descriptor))
2068             vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor, image_name=test_config["image_name"])
2069             logger.debug(vnf)
2070             if 'vnf' in vnf:
2071                 vnf_uuid = vnf['vnf']['uuid']
2072             else:
2073                 vnf_uuid = vnf['vnfd'][0]['uuid']
2074             self.__class__.to_delete_list.insert(0, {"item": "vnf", "function": test_config["client"].delete_vnf,
2075                                                      "params": {"uuid": vnf_uuid}})
2076
2077         # load the scenario definition
2078         for scenario_descriptor in scenario_descriptors:
2079             # networks = scenario_descriptor['scenario']['networks']
2080             # networks[test_config["mgmt_net"]] = networks.pop('mgmt')
2081             logger.debug("Scenario descriptor: {}".format(scenario_descriptor))
2082             scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor)
2083             logger.debug(scenario)
2084             if 'scenario' in scenario:
2085                 scenario_uuid = scenario['scenario']['uuid']
2086             else:
2087                 scenario_uuid = scenario['nsd'][0]['uuid']
2088             self.__class__.to_delete_list.insert(0, {"item": "scenario",
2089                                                      "function": test_config["client"].delete_scenario,
2090                                                      "params": {"uuid": scenario_uuid}})
2091             self.__class__.scenario_uuids.append(scenario_uuid)
2092
2093     def test_010_instantiate_scenario(self):
2094         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
2095                                                            inspect.currentframe().f_code.co_name,
2096                                                            test_config["test_folder"])
2097         self.__class__.test_index += 1
2098         for scenario_uuid in self.__class__.scenario_uuids:
2099             instance_descriptor = {
2100                 "instance":{
2101                     "name": self.__class__.test_text,
2102                     "scenario": scenario_uuid,
2103                     "networks":{
2104                         "mgmt": {"sites": [ { "netmap-use": test_config["mgmt_net"]} ]}
2105                     }
2106                 }
2107             }
2108             instance = test_config["client"].create_instance(instance_descriptor)
2109             self.__class__.instance_scenario_uuids.append(instance['uuid'])
2110             logger.debug(instance)
2111             self.__class__.to_delete_list.insert(0, {"item": "instance",
2112                                                      "function": test_config["client"].delete_instance,
2113                                                      "params": {"uuid": instance['uuid']}})
2114
2115     def test_020_check_deployent(self):
2116         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
2117                                                            inspect.currentframe().f_code.co_name,
2118                                                            test_config["test_folder"])
2119         self.__class__.test_index += 1
2120
2121         if test_config["manual"]:
2122             raw_input('Scenario has been deployed. Perform manual check and press any key to resume')
2123             return
2124
2125         keep_waiting = test_config["timeout"]
2126         pending_instance_scenario_uuids = list(self.__class__.instance_scenario_uuids)   # make a copy
2127         while pending_instance_scenario_uuids:
2128             index = 0
2129             while index < len(pending_instance_scenario_uuids):
2130                 result = check_instance_scenario_active(pending_instance_scenario_uuids[index])
2131                 if result[0]:
2132                     del pending_instance_scenario_uuids[index]
2133                     break
2134                 elif 'ERROR' in result[1]:
2135                     msg = 'Got error while waiting for the instance to get active: '+result[1]
2136                     logging.error(msg)
2137                     raise Exception(msg)
2138                 index += 1
2139
2140             if keep_waiting >= 5:
2141                 time.sleep(5)
2142                 keep_waiting -= 5
2143             elif keep_waiting > 0:
2144                 time.sleep(keep_waiting)
2145                 keep_waiting = 0
2146             else:
2147                 msg = 'Timeout reached while waiting instance scenario to get active'
2148                 logging.error(msg)
2149                 raise Exception(msg)
2150
2151     def test_030_clean_deployment(self):
2152         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
2153                                                               inspect.currentframe().f_code.co_name,
2154                                                               test_config["test_folder"])
2155         self.__class__.test_index += 1
2156         #At the moment if you delete an scenario right after creating it, in openstack datacenters
2157         #sometimes scenario ports get orphaned. This sleep is just a dirty workaround
2158         time.sleep(5)
2159         for item in self.__class__.to_delete_list:
2160             response = item["function"](**item["params"])
2161             logger.debug(response)
2162
2163
2164 def _get_random_string(maxLength):
2165     '''generates a string with random characters string.letters and string.digits
2166     with a random length up to maxLength characters. If maxLength is <15 it will be changed automatically to 15
2167     '''
2168     prefix = 'testing_'
2169     min_string = 15
2170     minLength = min_string - len(prefix)
2171     if maxLength < min_string: maxLength = min_string
2172     maxLength -= len(prefix)
2173     length = random.randint(minLength,maxLength)
2174     return 'testing_'+"".join([random.choice(string.letters+string.digits) for i in xrange(length)])
2175
2176
2177 def test_vimconnector(args):
2178     global test_config
2179     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
2180     test_config['vimtype'] = args.vimtype
2181     if args.vimtype == "vmware":
2182         import vimconn_vmware as vim
2183
2184         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
2185
2186         tenant_name = args.tenant_name
2187         test_config['tenant'] = tenant_name
2188         config_params = yaml.load(args.config_param)
2189         org_name = config_params.get('orgname')
2190         org_user = config_params.get('user')
2191         org_passwd = config_params.get('passwd')
2192         vim_url = args.endpoint_url
2193         test_config['image_path'] = args.image_path
2194         test_config['image_name'] = args.image_name
2195         test_config['sriov_net_name'] = args.sriov_net_name
2196
2197         # vmware connector obj
2198         test_config['vim_conn'] = vim.vimconnector(name=org_name, tenant_name=tenant_name, user=org_user,
2199                                                    passwd=org_passwd, url=vim_url, config=config_params)
2200
2201     elif args.vimtype == "aws":
2202         import vimconn_aws as vim
2203     elif args.vimtype == "openstack":
2204         import vimconn_openstack as vim
2205
2206         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
2207
2208         tenant_name = args.tenant_name
2209         test_config['tenant'] = tenant_name
2210         config_params = yaml.load(args.config_param)
2211         os_user = config_params.get('user')
2212         os_passwd = config_params.get('passwd')
2213         vim_url = args.endpoint_url
2214         test_config['image_path'] = args.image_path
2215         test_config['image_name'] = args.image_name
2216         test_config['sriov_net_name'] = args.sriov_net_name
2217
2218         # openstack connector obj
2219         vim_persistent_info = {}
2220         test_config['vim_conn'] = vim.vimconnector(
2221             uuid="test-uuid-1", name="VIO-openstack",
2222             tenant_id=None, tenant_name=tenant_name,
2223             url=vim_url, url_admin=None,
2224             user=os_user, passwd=os_passwd,
2225             config=config_params, persistent_info=vim_persistent_info
2226         )
2227         test_config['vim_conn'].debug = "true"
2228
2229     elif args.vimtype == "openvim":
2230         import vimconn_openvim as vim
2231     elif args.vimtype == "azure":
2232         import vimconn_azure as vim
2233
2234         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
2235
2236         tenant_name = args.tenant_name
2237         test_config['tenant'] = tenant_name
2238         config_params = yaml.load(args.config_param)
2239         os_user = config_params.get('user')
2240         os_passwd = config_params.get('passwd')
2241         vim_url = args.endpoint_url
2242         test_config['image_path'] = args.image_path
2243         test_config['image_name'] = args.image_name
2244         #test_config['sriov_net_name'] = args.sriov_net_name
2245
2246         # azure connector obj
2247         vim_persistent_info = {}
2248         test_config['vim_conn'] = vim.vimconnector(
2249             uuid="test-uuid-1", name="VIO-azure",
2250             tenant_id=None, tenant_name=tenant_name,
2251             url=vim_url, url_admin=None,
2252             user=os_user, passwd=os_passwd,
2253             config=config_params, persistent_info=vim_persistent_info
2254         )
2255         test_config['vim_conn'].debug = "true"
2256
2257     else:
2258         logger.critical("vimtype '{}' not supported".format(args.vimtype))
2259         sys.exit(1)
2260     executed = 0
2261     failed = 0
2262     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
2263     # If only want to obtain a tests list print it and exit
2264     if args.list_tests:
2265         tests_names = []
2266         for cls in clsmembers:
2267             if cls[0].startswith('test_vimconn'):
2268                 tests_names.append(cls[0])
2269
2270         msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names))
2271         print(msg)
2272         logger.info(msg)
2273         sys.exit(0)
2274
2275     # Create the list of tests to be run
2276     code_based_tests = []
2277     if args.tests:
2278         for test in args.tests:
2279             for t in test.split(','):
2280                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
2281                 if len(matches_code_based_tests) > 0:
2282                     code_based_tests.append(matches_code_based_tests[0][1])
2283                 else:
2284                     logger.critical("Test '{}' is not among the possible ones".format(t))
2285                     sys.exit(1)
2286     if not code_based_tests:
2287         # include all tests
2288         for cls in clsmembers:
2289             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
2290             if cls[0].startswith('test_vimconn'):
2291                 code_based_tests.append(cls[1])
2292
2293     logger.debug("tests to be executed: {}".format(code_based_tests))
2294
2295     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2296     # This is handled in the tests using logging.
2297     stream = open('/dev/null', 'w')
2298
2299     # Run code based tests
2300     basic_tests_suite = unittest.TestSuite()
2301     for test in code_based_tests:
2302         basic_tests_suite.addTest(unittest.makeSuite(test))
2303     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
2304     executed += result.testsRun
2305     failed += len(result.failures) + len(result.errors)
2306     if failfast and failed:
2307         sys.exit(1)
2308     if len(result.failures) > 0:
2309         logger.debug("failures : {}".format(result.failures))
2310     if len(result.errors) > 0:
2311         logger.debug("errors : {}".format(result.errors))
2312     return executed, failed
2313
2314
2315 def test_vim(args):
2316     global test_config
2317     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
2318     import openmanoclient
2319     executed = 0
2320     failed = 0
2321     test_config["client"] = openmanoclient.openmanoclient(
2322         endpoint_url=args.endpoint_url,
2323         tenant_name=args.tenant_name,
2324         datacenter_name=args.datacenter,
2325         debug=args.debug, logger=test_config["logger_name"])
2326     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
2327     # If only want to obtain a tests list print it and exit
2328     if args.list_tests:
2329         tests_names = []
2330         for cls in clsmembers:
2331             if cls[0].startswith('test_VIM'):
2332                 tests_names.append(cls[0])
2333
2334         msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names)) +\
2335               "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \
2336               "unless RO has access to the admin endpoint. Therefore this test is excluded by default"
2337         print(msg)
2338         logger.info(msg)
2339         sys.exit(0)
2340
2341     # Create the list of tests to be run
2342     code_based_tests = []
2343     if args.tests:
2344         for test in args.tests:
2345             for t in test.split(','):
2346                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
2347                 if len(matches_code_based_tests) > 0:
2348                     code_based_tests.append(matches_code_based_tests[0][1])
2349                 else:
2350                     logger.critical("Test '{}' is not among the possible ones".format(t))
2351                     sys.exit(1)
2352     if not code_based_tests:
2353         # include all tests
2354         for cls in clsmembers:
2355             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
2356             if cls[0].startswith('test_VIM') and cls[0] != 'test_VIM_tenant_operations':
2357                 code_based_tests.append(cls[1])
2358
2359     logger.debug("tests to be executed: {}".format(code_based_tests))
2360
2361     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2362     # This is handled in the tests using logging.
2363     stream = open('/dev/null', 'w')
2364
2365     # Run code based tests
2366     basic_tests_suite = unittest.TestSuite()
2367     for test in code_based_tests:
2368         basic_tests_suite.addTest(unittest.makeSuite(test))
2369     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
2370     executed += result.testsRun
2371     failed += len(result.failures) + len(result.errors)
2372     if failfast and failed:
2373         sys.exit(1)
2374     if len(result.failures) > 0:
2375         logger.debug("failures : {}".format(result.failures))
2376     if len(result.errors) > 0:
2377         logger.debug("errors : {}".format(result.errors))
2378     return executed, failed
2379
2380
2381 def test_wim(args):
2382     global test_config
2383     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
2384     import openmanoclient
2385     executed = 0
2386     failed = 0
2387     test_config["client"] = openmanoclient.openmanoclient(
2388         endpoint_url=args.endpoint_url,
2389         tenant_name=args.tenant_name,
2390         datacenter_name=args.datacenter,
2391         debug=args.debug, logger=test_config["logger_name"])
2392     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
2393     # If only want to obtain a tests list print it and exit
2394     if args.list_tests:
2395         tests_names = []
2396         for cls in clsmembers:
2397             if cls[0].startswith('test_WIM'):
2398                 tests_names.append(cls[0])
2399
2400         msg = "The 'wim' set tests are:\n\t" + ', '.join(sorted(tests_names)) +\
2401               "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \
2402               "unless RO has access to the admin endpoint. Therefore this test is excluded by default"
2403         print(msg)
2404         logger.info(msg)
2405         sys.exit(0)
2406
2407     # Create the list of tests to be run
2408     code_based_tests = []
2409     if args.tests:
2410         for test in args.tests:
2411             for t in test.split(','):
2412                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
2413                 if len(matches_code_based_tests) > 0:
2414                     code_based_tests.append(matches_code_based_tests[0][1])
2415                 else:
2416                     logger.critical("Test '{}' is not among the possible ones".format(t))
2417                     sys.exit(1)
2418     if not code_based_tests:
2419         # include all tests
2420         for cls in clsmembers:
2421             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
2422             if cls[0].startswith('test_VIM') and cls[0] != 'test_VIM_tenant_operations':
2423                 code_based_tests.append(cls[1])
2424
2425     logger.debug("tests to be executed: {}".format(code_based_tests))
2426
2427     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2428     # This is handled in the tests using logging.
2429     stream = open('/dev/null', 'w')
2430
2431     # Run code based tests
2432     basic_tests_suite = unittest.TestSuite()
2433     for test in code_based_tests:
2434         basic_tests_suite.addTest(unittest.makeSuite(test))
2435     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
2436     executed += result.testsRun
2437     failed += len(result.failures) + len(result.errors)
2438     if failfast and failed:
2439         sys.exit(1)
2440     if len(result.failures) > 0:
2441         logger.debug("failures : {}".format(result.failures))
2442     if len(result.errors) > 0:
2443         logger.debug("errors : {}".format(result.errors))
2444     return executed, failed
2445
2446
2447 def test_deploy(args):
2448     global test_config
2449     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
2450     import openmanoclient
2451     executed = 0
2452     failed = 0
2453     test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
2454     test_config["image_name"] = args.image_name
2455     test_config["mgmt_net"] = args.mgmt_net
2456     test_config["manual"] = args.manual
2457     test_directory_content = os.listdir(test_config["test_directory"])
2458     # If only want to obtain a tests list print it and exit
2459     if args.list_tests:
2460         msg = "the 'deploy' set tests are:\n\t" + ', '.join(sorted(test_directory_content))
2461         print(msg)
2462         # logger.info(msg)
2463         sys.exit(0)
2464
2465     descriptor_based_tests = []
2466     # Create the list of tests to be run
2467     code_based_tests = []
2468     if args.tests:
2469         for test in args.tests:
2470             for t in test.split(','):
2471                 if t in test_directory_content:
2472                     descriptor_based_tests.append(t)
2473                 else:
2474                     logger.critical("Test '{}' is not among the possible ones".format(t))
2475                     sys.exit(1)
2476     if not descriptor_based_tests:
2477         # include all tests
2478         descriptor_based_tests = test_directory_content
2479
2480     logger.debug("tests to be executed: {}".format(code_based_tests))
2481
2482     # import openmanoclient from relative path
2483     test_config["client"] = openmanoclient.openmanoclient(
2484         endpoint_url=args.endpoint_url,
2485         tenant_name=args.tenant_name,
2486         datacenter_name=args.datacenter,
2487         debug=args.debug, logger=test_config["logger_name"])
2488
2489     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2490     # This is handled in the tests using logging.
2491     stream = open('/dev/null', 'w')
2492     # This scenario based tests are defined as directories inside the directory defined in 'test_directory'
2493     for test in descriptor_based_tests:
2494         test_config["test_folder"] = test
2495         test_suite = unittest.TestSuite()
2496         test_suite.addTest(unittest.makeSuite(descriptor_based_scenario_test))
2497         result = unittest.TextTestRunner(stream=stream, failfast=False).run(test_suite)
2498         executed += result.testsRun
2499         failed += len(result.failures) + len(result.errors)
2500         if failfast and failed:
2501             sys.exit(1)
2502         if len(result.failures) > 0:
2503             logger.debug("failures : {}".format(result.failures))
2504         if len(result.errors) > 0:
2505             logger.debug("errors : {}".format(result.errors))
2506
2507     return executed, failed
2508
2509 if __name__=="__main__":
2510
2511     parser = ArgumentParser(description='Test RO module')
2512     parser.add_argument('-v','--version', action='version', help="Show current version",
2513                              version='%(prog)s version ' + __version__  + ' ' + version_date)
2514
2515     # Common parameters
2516     parent_parser = ArgumentParser(add_help=False)
2517     parent_parser.add_argument('--failfast', help='Stop when a test fails rather than execute all tests',
2518                       dest='failfast', action="store_true", default=False)
2519     parent_parser.add_argument('--failed', help='Set logs to show only failed tests. --debug disables this option',
2520                       dest='failed', action="store_true", default=False)
2521     default_logger_file = os.path.dirname(__file__)+'/'+os.path.splitext(os.path.basename(__file__))[0]+'.log'
2522     parent_parser.add_argument('--list-tests', help='List all available tests', dest='list_tests', action="store_true",
2523                       default=False)
2524     parent_parser.add_argument('--logger_file', dest='logger_file', default=default_logger_file,
2525                                help='Set the logger file. By default '+default_logger_file)
2526     parent_parser.add_argument("-t", '--tenant', dest='tenant_name', default="osm",
2527                                help="Set the openmano tenant to use for the test. By default 'osm'")
2528     parent_parser.add_argument('--debug', help='Set logs to debug level', dest='debug', action="store_true")
2529     parent_parser.add_argument('--timeout', help='Specify the instantiation timeout in seconds. By default 300',
2530                           dest='timeout', type=int, default=300)
2531     parent_parser.add_argument('--test', '--tests', help='Specify the tests to run', dest='tests', action="append")
2532
2533     subparsers = parser.add_subparsers(help='test sets')
2534
2535     # Deployment test set
2536     # -------------------
2537     deploy_parser = subparsers.add_parser('deploy', parents=[parent_parser],
2538                                           help="test deployment using descriptors at RO_test folder ")
2539     deploy_parser.set_defaults(func=test_deploy)
2540
2541     # Mandatory arguments
2542     mandatory_arguments = deploy_parser.add_argument_group('mandatory arguments')
2543     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
2544     mandatory_arguments.add_argument("-i", '--image-name', required=True, dest="image_name",
2545                                      help='Image name available at datacenter used for the tests')
2546     mandatory_arguments.add_argument("-n", '--mgmt-net-name', required=True, dest='mgmt_net',
2547                                      help='Set the vim management network to use for tests')
2548
2549     # Optional arguments
2550     deploy_parser.add_argument('-m', '--manual-check', dest='manual', action="store_true", default=False,
2551                                help='Pause execution once deployed to allow manual checking of the '
2552                                     'deployed instance scenario')
2553     deploy_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
2554                                help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
2555
2556     # Vimconn test set
2557     # -------------------
2558     vimconn_parser = subparsers.add_parser('vimconn', parents=[parent_parser], help="test vimconnector plugin")
2559     vimconn_parser.set_defaults(func=test_vimconnector)
2560     # Mandatory arguments
2561     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
2562     mandatory_arguments.add_argument('--vimtype', choices=['vmware', 'aws', 'openstack', 'openvim','azure'], required=True,
2563                                      help='Set the vimconnector type to test')
2564     mandatory_arguments.add_argument('-c', '--config', dest='config_param', required=True,
2565                                     help='Set the vimconnector specific config parameters in dictionary format')
2566     mandatory_arguments.add_argument('-u', '--url', dest='endpoint_url',required=True, help="Set the vim connector url or Host IP")
2567     # Optional arguments
2568     vimconn_parser.add_argument('-i', '--image-path', dest='image_path', help="Provide image path present at RO container")
2569     vimconn_parser.add_argument('-n', '--image-name', dest='image_name', help="Provide image name for test")
2570     # TODO add optional arguments for vimconn tests
2571     # vimconn_parser.add_argument("-i", '--image-name', dest='image_name', help='<HELP>'))
2572     vimconn_parser.add_argument('-s', '--sriov-net-name', dest='sriov_net_name', help="Provide SRIOV network name for test")
2573
2574     # Datacenter test set
2575     # -------------------
2576     vimconn_parser = subparsers.add_parser('vim', parents=[parent_parser], help="test vim")
2577     vimconn_parser.set_defaults(func=test_vim)
2578
2579     # Mandatory arguments
2580     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
2581     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
2582
2583     # Optional arguments
2584     vimconn_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
2585                                help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
2586
2587     # WIM test set
2588     # -------------------
2589     vimconn_parser = subparsers.add_parser('wim', parents=[parent_parser], help="test wim")
2590     vimconn_parser.set_defaults(func=test_wim)
2591
2592     # Mandatory arguments
2593     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
2594     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
2595
2596     # Optional arguments
2597     vimconn_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
2598                                 help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
2599
2600     argcomplete.autocomplete(parser)
2601     args = parser.parse_args()
2602     # print str(args)
2603     test_config = {}
2604
2605     # default logger level is INFO. Options --debug and --failed override this, being --debug prioritary
2606     logger_level = 'INFO'
2607     if args.debug:
2608         logger_level = 'DEBUG'
2609     elif args.failed:
2610         logger_level = 'WARNING'
2611     logger_name = os.path.basename(__file__)
2612     test_config["logger_name"] = logger_name
2613     logger = logging.getLogger(logger_name)
2614     logger.setLevel(logger_level)
2615     failfast = args.failfast
2616
2617     # Configure a logging handler to store in a logging file
2618     if args.logger_file:
2619         fileHandler = logging.FileHandler(args.logger_file)
2620         formatter_fileHandler = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2621         fileHandler.setFormatter(formatter_fileHandler)
2622         logger.addHandler(fileHandler)
2623
2624     # Configure a handler to print to stdout
2625     consoleHandler = logging.StreamHandler(sys.stdout)
2626     formatter_consoleHandler = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2627     consoleHandler.setFormatter(formatter_consoleHandler)
2628     logger.addHandler(consoleHandler)
2629
2630     logger.debug('Program started with the following arguments: ' + str(args))
2631
2632     # set test config parameters
2633     test_config["timeout"] = args.timeout
2634     test_config["test_number"] = 1
2635
2636     executed, failed = args.func(args)
2637
2638     # Log summary
2639     logger.warning("Total number of tests: {}; Total number of failures/errors: {}".format(executed, failed))
2640     sys.exit(1 if failed else 0)