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 """
  24 Module for testing openmano functionality. It uses openmanoclient.py for invoking openmano
  25 """
  26
  27 import logging
  28 import os
  29 import argcomplete
  30 import unittest
  31 import string
  32 import inspect
  33 import random
  34 # import traceback
  35 import glob
  36 import yaml
  37 import sys
  38 import time
  39 import uuid
  40 from argparse import ArgumentParser
  41
  42 __author__ = "Pablo Montes, Alfonso Tierno"
  43 __date__ = "$16-Feb-2017 17:08:16$"
  44 __version__ = "0.1.0"
  45 version_date = "Oct 2017"
  46
  47 test_config = {}    # used for global variables with the test configuration
  48
  49
  50 class test_base(unittest.TestCase):
  51     test_index = 1
  52     test_text = None
  53
  54     @classmethod
  55     def setUpClass(cls):
  56         logger.info("{}. {}".format(test_config["test_number"], cls.__name__))
  57
  58     @classmethod
  59     def tearDownClass(cls):
  60         test_config["test_number"] += 1
  61
  62     def tearDown(self):
  63         exec_info = sys.exc_info()
  64         if exec_info == (None, None, None):
  65             logger.info(self.__class__.test_text+" -> TEST OK")
  66         else:
  67             logger.warning(self.__class__.test_text+" -> TEST NOK")
  68             logger.critical("Traceback error",exc_info=True)
  69
  70
  71 def check_instance_scenario_active(uuid):
  72     instance = test_config["client"].get_instance(uuid=uuid)
  73
  74     for net in instance['nets']:
  75         status = net['status']
  76         if status != 'ACTIVE':
  77             return (False, status)
  78
  79     for vnf in instance['vnfs']:
  80         for vm in vnf['vms']:
  81             status = vm['status']
  82             if status != 'ACTIVE':
  83                 return (False, status)
  84
  85     return (True, None)
  86
  87
  88 '''
  89 IMPORTANT NOTE
  90 All unittest classes for code based tests must have prefix 'test_' in order to be taken into account for tests
  91 '''
  92 class test_VIM_datacenter_tenant_operations(test_base):
  93     tenant_name = None
  94
  95     def test_000_create_RO_tenant(self):
  96         self.__class__.tenant_name = _get_random_string(20)
  97         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
  98                                                            inspect.currentframe().f_code.co_name)
  99         self.__class__.test_index += 1
 100         tenant = test_config["client"].create_tenant(name=self.__class__.tenant_name,
 101                                                      description=self.__class__.tenant_name)
 102         logger.debug("{}".format(tenant))
 103         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.tenant_name)
 104
 105     def test_010_list_RO_tenant(self):
 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"].get_tenant(name=self.__class__.tenant_name)
 110         logger.debug("{}".format(tenant))
 111         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.tenant_name)
 112
 113     def test_020_delete_RO_tenant(self):
 114         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 115                                                            inspect.currentframe().f_code.co_name)
 116         self.__class__.test_index += 1
 117         tenant = test_config["client"].delete_tenant(name=self.__class__.tenant_name)
 118         logger.debug("{}".format(tenant))
 119         assert('deleted' in tenant.get('result',""))
 120
 121
 122 class test_VIM_datacenter_operations(test_base):
 123     datacenter_name = None
 124
 125     def test_000_create_datacenter(self):
 126         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 127                                                            inspect.currentframe().f_code.co_name)
 128         self.__class__.datacenter_name = _get_random_string(20)
 129         self.__class__.test_index += 1
 130         self.datacenter = test_config["client"].create_datacenter(name=self.__class__.datacenter_name,
 131                                                                   vim_url="http://fakeurl/fake")
 132         logger.debug("{}".format(self.datacenter))
 133         self.assertEqual (self.datacenter.get('datacenter', {}).get('name',''), self.__class__.datacenter_name)
 134
 135     def test_010_list_datacenter(self):
 136         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 137                                                            inspect.currentframe().f_code.co_name)
 138
 139         self.__class__.test_index += 1
 140         self.datacenter = test_config["client"].get_datacenter(all_tenants=True, name=self.__class__.datacenter_name)
 141         logger.debug("{}".format(self.datacenter))
 142         self.assertEqual (self.datacenter.get('datacenter', {}).get('name', ''), self.__class__.datacenter_name)
 143
 144     def test_020_attach_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"].attach_datacenter(name=self.__class__.datacenter_name,
 150                                                                   vim_tenant_name='fake')
 151         logger.debug("{}".format(self.datacenter))
 152         assert ('uuid' in self.datacenter.get('datacenter', {}))
 153
 154     def test_030_list_attached_datacenter(self):
 155         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 156                                                            inspect.currentframe().f_code.co_name)
 157
 158         self.__class__.test_index += 1
 159         self.datacenter = test_config["client"].get_datacenter(all_tenants=False, name=self.__class__.datacenter_name)
 160         logger.debug("{}".format(self.datacenter))
 161         self.assertEqual (self.datacenter.get('datacenter', {}).get('name', ''), self.__class__.datacenter_name)
 162
 163     def test_040_detach_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"].detach_datacenter(name=self.__class__.datacenter_name)
 169         logger.debug("{}".format(self.datacenter))
 170         assert ('detached' in self.datacenter.get('result', ""))
 171
 172     def test_050_delete_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"].delete_datacenter(name=self.__class__.datacenter_name)
 178         logger.debug("{}".format(self.datacenter))
 179         assert('deleted' in self.datacenter.get('result',""))
 180
 181
 182 class test_VIM_network_operations(test_base):
 183     vim_network_name = None
 184     vim_network_uuid = None
 185
 186     def test_000_create_VIM_network(self):
 187         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 188                                                            inspect.currentframe().f_code.co_name)
 189         self.__class__.vim_network_name = _get_random_string(20)
 190         self.__class__.test_index += 1
 191         network = test_config["client"].vim_action("create", "networks", name=self.__class__.vim_network_name)
 192         logger.debug("{}".format(network))
 193         self.__class__.vim_network_uuid = network["network"]["id"]
 194         self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name)
 195
 196     def test_010_list_VIM_networks(self):
 197         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 198                                                            inspect.currentframe().f_code.co_name)
 199         self.__class__.test_index += 1
 200         networks = test_config["client"].vim_action("list", "networks")
 201         logger.debug("{}".format(networks))
 202
 203     def test_020_get_VIM_network_by_uuid(self):
 204         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 205                                                            inspect.currentframe().f_code.co_name)
 206
 207         self.__class__.test_index += 1
 208         network = test_config["client"].vim_action("show", "networks", uuid=self.__class__.vim_network_uuid)
 209         logger.debug("{}".format(network))
 210         self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name)
 211
 212     def test_030_delete_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("delete", "networks", uuid=self.__class__.vim_network_uuid)
 218         logger.debug("{}".format(network))
 219         assert ('deleted' in network.get('result', ""))
 220
 221
 222 class test_VIM_image_operations(test_base):
 223
 224     def test_000_list_VIM_images(self):
 225         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 226                                                            inspect.currentframe().f_code.co_name)
 227         self.__class__.test_index += 1
 228         images = test_config["client"].vim_action("list", "images")
 229         logger.debug("{}".format(images))
 230
 231 '''
 232 The following is a non critical test that will fail most of the times.
 233 In case of OpenStack datacenter these tests will only success if RO has access to the admin endpoint
 234 This test will only be executed in case it is specifically requested by the user
 235 '''
 236 class test_VIM_tenant_operations(test_base):
 237     vim_tenant_name = None
 238     vim_tenant_uuid = None
 239
 240     @classmethod
 241     def setUpClass(cls):
 242         test_base.setUpClass(cls)
 243         logger.warning("In case of OpenStack datacenter these tests will only success "
 244                        "if RO has access to the admin endpoint")
 245
 246     def test_000_create_VIM_tenant(self):
 247         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 248                                                            inspect.currentframe().f_code.co_name)
 249         self.__class__.vim_tenant_name = _get_random_string(20)
 250         self.__class__.test_index += 1
 251         tenant = test_config["client"].vim_action("create", "tenants", name=self.__class__.vim_tenant_name)
 252         logger.debug("{}".format(tenant))
 253         self.__class__.vim_tenant_uuid = tenant["tenant"]["id"]
 254         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name)
 255
 256     def test_010_list_VIM_tenants(self):
 257         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 258                                                            inspect.currentframe().f_code.co_name)
 259         self.__class__.test_index += 1
 260         tenants = test_config["client"].vim_action("list", "tenants")
 261         logger.debug("{}".format(tenants))
 262
 263     def test_020_get_VIM_tenant_by_uuid(self):
 264         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index,
 265                                                            inspect.currentframe().f_code.co_name)
 266
 267         self.__class__.test_index += 1
 268         tenant = test_config["client"].vim_action("show", "tenants", uuid=self.__class__.vim_tenant_uuid)
 269         logger.debug("{}".format(tenant))
 270         self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name)
 271
 272     def test_030_delete_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("delete", "tenants", uuid=self.__class__.vim_tenant_uuid)
 278         logger.debug("{}".format(tenant))
 279         assert ('deleted' in tenant.get('result', ""))
 280
 281
 282 class test_vimconn_connect(test_base):
 283
 284     def test_000_connect(self):
 285         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 286                                                             self.__class__.test_index,
 287                                                 inspect.currentframe().f_code.co_name)
 288
 289         self.__class__.test_index += 1
 290         if test_config['vimtype'] == 'vmware':
 291             vca_object = test_config["vim_conn"].connect()
 292             logger.debug("{}".format(vca_object))
 293             self.assertIsNotNone(vca_object)
 294         elif test_config['vimtype'] == 'openstack':
 295             test_config["vim_conn"]._reload_connection()
 296             network_list = test_config["vim_conn"].get_network_list()
 297             logger.debug("{}".format(network_list))
 298             self.assertIsNotNone(network_list)
 299
 300 class test_vimconn_new_network(test_base):
 301     network_name = None
 302
 303     def test_000_new_network(self):
 304         self.__class__.network_name = _get_random_string(20)
 305         network_type = 'bridge'
 306
 307         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 308                      self.__class__.test_index, inspect.currentframe().f_code.co_name)
 309         self.__class__.test_index += 1
 310
 311         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 312                                                           net_type=network_type)
 313         self.__class__.network_id = network
 314         logger.debug("{}".format(network))
 315
 316         network_list = test_config["vim_conn"].get_network_list()
 317         for net in network_list:
 318             if self.__class__.network_name in net.get('name'):
 319                 self.assertIn(self.__class__.network_name, net.get('name'))
 320                 self.assertEqual(net.get('type'), network_type)
 321
 322         # Deleting created network
 323         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 324         if result:
 325             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 326         else:
 327             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 328
 329     def test_010_new_network_by_types(self):
 330         delete_net_ids = []
 331         network_types = ['data','bridge','mgmt']
 332         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 333                                                             self.__class__.test_index,
 334                                                 inspect.currentframe().f_code.co_name)
 335         self.__class__.test_index += 1
 336         for net_type in network_types:
 337             self.__class__.network_name = _get_random_string(20)
 338             network_id = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 339                                                                                 net_type=net_type)
 340
 341             delete_net_ids.append(network_id)
 342             logger.debug("{}".format(network_id))
 343
 344             network_list = test_config["vim_conn"].get_network_list()
 345             for net in network_list:
 346                 if self.__class__.network_name in net.get('name'):
 347                     self.assertIn(self.__class__.network_name, net.get('name'))
 348                 if net_type in net.get('type'):
 349                     self.assertEqual(net.get('type'), net_type)
 350                 else:
 351                     self.assertNotEqual(net.get('type'), net_type)
 352
 353         # Deleting created network
 354         for net_id in delete_net_ids:
 355             result = test_config["vim_conn"].delete_network(net_id)
 356             if result:
 357                 logger.info("Network id {} sucessfully deleted".format(net_id))
 358             else:
 359                 logger.info("Failed to delete network id {}".format(net_id))
 360
 361     def test_020_new_network_by_ipprofile(self):
 362         test_directory_content = os.listdir(test_config["test_directory"])
 363
 364         for dir_name in test_directory_content:
 365             if dir_name == 'simple_multi_vnfc':
 366                 self.__class__.scenario_test_path = test_config["test_directory"] + '/'+ dir_name
 367                 vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml')
 368                 break
 369
 370         for vnfd in vnfd_files:
 371             with open(vnfd, 'r') as stream:
 372                 vnf_descriptor = yaml.load(stream)
 373
 374             internal_connections_list = vnf_descriptor['vnf']['internal-connections']
 375             for item in internal_connections_list:
 376                 if 'ip-profile' in item:
 377                     version = item['ip-profile']['ip-version']
 378                     dhcp_count = item['ip-profile']['dhcp']['count']
 379                     dhcp_enabled = item['ip-profile']['dhcp']['enabled']
 380                     dhcp_start_address = item['ip-profile']['dhcp']['start-address']
 381                     subnet_address = item['ip-profile']['subnet-address']
 382
 383
 384         self.__class__.network_name = _get_random_string(20)
 385         ip_profile = {'dhcp_count': dhcp_count,
 386                       'dhcp_enabled': dhcp_enabled,
 387                       'dhcp_start_address': dhcp_start_address,
 388                       'ip_version': version,
 389                       'subnet_address': subnet_address
 390                      }
 391         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 392                                                             self.__class__.test_index,
 393                                                 inspect.currentframe().f_code.co_name)
 394         self.__class__.test_index += 1
 395         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 396                                                                            net_type='mgmt',
 397                                                                      ip_profile=ip_profile)
 398         self.__class__.network_id = network
 399         logger.debug("{}".format(network))
 400
 401         network_list = test_config["vim_conn"].get_network_list()
 402         for net in network_list:
 403             if self.__class__.network_name in net.get('name'):
 404                 self.assertIn(self.__class__.network_name, net.get('name'))
 405
 406         # Deleting created network
 407         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 408         if result:
 409             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 410         else:
 411             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 412
 413     def test_030_new_network_by_isshared(self):
 414         self.__class__.network_name = _get_random_string(20)
 415         shared = True
 416         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 417                                                             self.__class__.test_index,
 418                                                 inspect.currentframe().f_code.co_name)
 419         self.__class__.test_index += 1
 420         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 421                                                                          net_type='bridge',
 422                                                                              shared=shared)
 423         self.__class__.network_id = network
 424         logger.debug("{}".format(network))
 425
 426         network_list = test_config["vim_conn"].get_network_list()
 427         for net in network_list:
 428             if self.__class__.network_name in net.get('name'):
 429                 self.assertIn(self.__class__.network_name, net.get('name'))
 430                 self.assertEqual(net.get('shared'), shared)
 431
 432         # Deleting created network
 433         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 434         if result:
 435             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 436         else:
 437             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 438
 439     def test_040_new_network_by_negative(self):
 440         self.__class__.network_name = _get_random_string(20)
 441         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 442                                                             self.__class__.test_index,
 443                                                 inspect.currentframe().f_code.co_name)
 444         self.__class__.test_index += 1
 445         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 446                                                                     net_type='unknowntype')
 447         self.__class__.network_id = network
 448         logger.debug("{}".format(network))
 449         network_list = test_config["vim_conn"].get_network_list()
 450         for net in network_list:
 451             if self.__class__.network_name in net.get('name'):
 452                 self.assertIn(self.__class__.network_name, net.get('name'))
 453
 454         # Deleting created network
 455         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 456         if result:
 457             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 458         else:
 459             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 460
 461     def test_050_refresh_nets_status(self):
 462         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 463                                                             self.__class__.test_index,
 464                                                 inspect.currentframe().f_code.co_name)
 465         self.__class__.test_index += 1
 466         # creating new network
 467         network_name = _get_random_string(20)
 468         net_type = 'bridge'
 469         network_id = test_config["vim_conn"].new_network(net_name=network_name,
 470                                                           net_type=net_type)
 471         # refresh net status
 472         net_dict = test_config["vim_conn"].refresh_nets_status([network_id])
 473         for attr in net_dict[network_id]:
 474             if attr == 'status':
 475                 self.assertEqual(net_dict[network_id][attr], 'ACTIVE')
 476
 477         # Deleting created network
 478         result = test_config["vim_conn"].delete_network(network_id)
 479         if result:
 480             logger.info("Network id {} sucessfully deleted".format(network_id))
 481         else:
 482             logger.info("Failed to delete network id {}".format(network_id))
 483
 484     def test_060_refresh_nets_status_negative(self):
 485         unknown_net_id = str(uuid.uuid4())
 486         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 487                                                             self.__class__.test_index,
 488                                                 inspect.currentframe().f_code.co_name)
 489         self.__class__.test_index += 1
 490
 491         # refresh net status
 492         net_dict = test_config["vim_conn"].refresh_nets_status([unknown_net_id])
 493         if test_config['vimtype'] == 'openstack':
 494             self.assertEqual(net_dict[unknown_net_id]['status'], 'DELETED')
 495         else:
 496             # TODO : Fix vmware connector to return status DELETED as per vimconn.py
 497             self.assertEqual(net_dict, {})
 498
 499 class test_vimconn_get_network_list(test_base):
 500     network_name = None
 501
 502     def setUp(self):
 503         # creating new network
 504         self.__class__.network_name = _get_random_string(20)
 505         self.__class__.net_type = 'bridge'
 506         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 507                                                           net_type=self.__class__.net_type)
 508         self.__class__.network_id = network
 509         logger.debug("{}".format(network))
 510
 511     def tearDown(self):
 512         test_base.tearDown(self)
 513
 514         # Deleting created network
 515         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 516         if result:
 517             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 518         else:
 519             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 520
 521     def test_000_get_network_list(self):
 522         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 523                                                             self.__class__.test_index,
 524                                                 inspect.currentframe().f_code.co_name)
 525         self.__class__.test_index += 1
 526
 527         network_list = test_config["vim_conn"].get_network_list()
 528         for net in network_list:
 529             if self.__class__.network_name in net.get('name'):
 530                 self.assertIn(self.__class__.network_name, net.get('name'))
 531                 self.assertEqual(net.get('type'), self.__class__.net_type)
 532                 self.assertEqual(net.get('status'), 'ACTIVE')
 533                 self.assertEqual(net.get('shared'), False)
 534
 535     def test_010_get_network_list_by_name(self):
 536         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 537                                                             self.__class__.test_index,
 538                                                 inspect.currentframe().f_code.co_name)
 539         self.__class__.test_index += 1
 540
 541         if test_config['vimtype'] == 'openstack':
 542             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 543         else:
 544             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 545
 546         # find network from list by it's name
 547         new_network_list = test_config["vim_conn"].get_network_list({'name': network_name})
 548         for list_item in new_network_list:
 549             if self.__class__.network_name in list_item.get('name'):
 550                 self.assertEqual(network_name, list_item.get('name'))
 551                 self.assertEqual(list_item.get('type'), self.__class__.net_type)
 552                 self.assertEqual(list_item.get('status'), 'ACTIVE')
 553
 554     def test_020_get_network_list_by_id(self):
 555         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 556                                                             self.__class__.test_index,
 557                                                 inspect.currentframe().f_code.co_name)
 558         self.__class__.test_index += 1
 559
 560         # find network from list by it's id
 561         new_network_list = test_config["vim_conn"].get_network_list({'id':self.__class__.network_id})
 562         for list_item in new_network_list:
 563             if self.__class__.network_id in list_item.get('id'):
 564                 self.assertEqual(self.__class__.network_id, list_item.get('id'))
 565                 self.assertEqual(list_item.get('type'), self.__class__.net_type)
 566                 self.assertEqual(list_item.get('status'), 'ACTIVE')
 567
 568     def test_030_get_network_list_by_shared(self):
 569         Shared = False
 570         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 571                                                             self.__class__.test_index,
 572                                                 inspect.currentframe().f_code.co_name)
 573         self.__class__.test_index += 1
 574
 575         if test_config['vimtype'] == 'openstack':
 576             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 577         else:
 578             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 579         # find network from list by it's shared value
 580         new_network_list = test_config["vim_conn"].get_network_list({'shared':Shared,
 581                                                                 'name':network_name})
 582         for list_item in new_network_list:
 583             if list_item.get('shared') == Shared:
 584                 self.assertEqual(list_item.get('shared'), Shared)
 585                 self.assertEqual(list_item.get('type'), self.__class__.net_type)
 586                 self.assertEqual(network_name, list_item.get('name'))
 587
 588     def test_040_get_network_list_by_tenant_id(self):
 589         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 590                                                             self.__class__.test_index,
 591                                                 inspect.currentframe().f_code.co_name)
 592         self.__class__.test_index += 1
 593
 594         tenant_list = test_config["vim_conn"].get_tenant_list()
 595         if test_config['vimtype'] == 'openstack':
 596             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 597         else:
 598             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 599
 600         for tenant_item in tenant_list:
 601             if test_config['tenant'] == tenant_item.get('name'):
 602                 # find network from list by it's tenant id
 603                 tenant_id = tenant_item.get('id')
 604                 new_network_list = test_config["vim_conn"].get_network_list({'tenant_id':tenant_id,
 605                                                                               'name':network_name})
 606                 for list_item in new_network_list:
 607                     self.assertEqual(tenant_id, list_item.get('tenant_id'))
 608                     self.assertEqual(network_name, list_item.get('name'))
 609                     self.assertEqual(list_item.get('type'), self.__class__.net_type)
 610                     self.assertEqual(list_item.get('status'), 'ACTIVE')
 611
 612     def test_050_get_network_list_by_status(self):
 613         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 614                                                             self.__class__.test_index,
 615                                                 inspect.currentframe().f_code.co_name)
 616         self.__class__.test_index += 1
 617         status = 'ACTIVE'
 618
 619         if test_config['vimtype'] == 'openstack':
 620             network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name']
 621         else:
 622             network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id)
 623
 624         # find network from list by it's status
 625         new_network_list = test_config["vim_conn"].get_network_list({'status':status,
 626                                                                'name': network_name})
 627         for list_item in new_network_list:
 628             self.assertIn(self.__class__.network_name, list_item.get('name'))
 629             self.assertEqual(list_item.get('type'), self.__class__.net_type)
 630             self.assertEqual(list_item.get('status'), status)
 631
 632     def test_060_get_network_list_by_negative(self):
 633         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 634                                                             self.__class__.test_index,
 635                                                 inspect.currentframe().f_code.co_name)
 636         self.__class__.test_index += 1
 637
 638         network_list = test_config["vim_conn"].get_network_list({'name': 'unknown_name'})
 639         self.assertEqual(network_list, [])
 640
 641 class test_vimconn_get_network(test_base):
 642     network_name = None
 643
 644     def setUp(self):
 645         # creating new network
 646         self.__class__.network_name = _get_random_string(20)
 647         self.__class__.net_type = 'bridge'
 648         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 649                                                           net_type=self.__class__.net_type)
 650         self.__class__.network_id = network
 651         logger.debug("{}".format(network))
 652
 653     def tearDown(self):
 654         test_base.tearDown(self)
 655
 656         # Deleting created network
 657         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 658         if result:
 659             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 660         else:
 661             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 662
 663     def test_000_get_network(self):
 664         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 665                                                             self.__class__.test_index,
 666                                                 inspect.currentframe().f_code.co_name)
 667         self.__class__.test_index += 1
 668
 669         network_info = test_config["vim_conn"].get_network(self.__class__.network_id)
 670         self.assertEqual(network_info.get('status'), 'ACTIVE')
 671         self.assertIn(self.__class__.network_name, network_info.get('name'))
 672         self.assertEqual(network_info.get('type'), self.__class__.net_type)
 673         self.assertEqual(network_info.get('id'), self.__class__.network_id)
 674
 675     def test_010_get_network_negative(self):
 676         Non_exist_id = str(uuid.uuid4())
 677         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 678                                                             self.__class__.test_index,
 679                                                 inspect.currentframe().f_code.co_name)
 680         self.__class__.test_index += 1
 681         with self.assertRaises(Exception) as context:
 682             test_config["vim_conn"].get_network(Non_exist_id)
 683
 684         self.assertEqual((context.exception).http_code, 404)
 685
 686 class test_vimconn_delete_network(test_base):
 687     network_name = None
 688
 689     def test_000_delete_network(self):
 690         # Creating network
 691         self.__class__.network_name = _get_random_string(20)
 692         self.__class__.net_type = 'bridge'
 693         network = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 694                                                           net_type=self.__class__.net_type)
 695         self.__class__.network_id = network
 696         logger.debug("{}".format(network))
 697
 698         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 699                                                             self.__class__.test_index,
 700                                                 inspect.currentframe().f_code.co_name)
 701         self.__class__.test_index += 1
 702
 703         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 704         if result:
 705             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
 706         else:
 707             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
 708         time.sleep(5)
 709         # after deleting network we check in network list
 710         network_list = test_config["vim_conn"].get_network_list({ 'id':self.__class__.network_id })
 711         self.assertEqual(network_list, [])
 712
 713     def test_010_delete_network_negative(self):
 714         Non_exist_id = str(uuid.uuid4())
 715
 716         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 717                                                             self.__class__.test_index,
 718                                                 inspect.currentframe().f_code.co_name)
 719         self.__class__.test_index += 1
 720
 721         with self.assertRaises(Exception) as context:
 722             test_config["vim_conn"].delete_network(Non_exist_id)
 723
 724         self.assertEqual((context.exception).http_code, 404)
 725
 726 class test_vimconn_get_flavor(test_base):
 727
 728     def test_000_get_flavor(self):
 729         test_directory_content = os.listdir(test_config["test_directory"])
 730
 731         for dir_name in test_directory_content:
 732             if dir_name == 'simple_linux':
 733                 self.__class__.scenario_test_path = test_config["test_directory"] + '/'+ dir_name
 734                 vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml')
 735                 break
 736
 737         for vnfd in vnfd_files:
 738             with open(vnfd, 'r') as stream:
 739                 vnf_descriptor = yaml.load(stream)
 740
 741             vnfc_list = vnf_descriptor['vnf']['VNFC']
 742             for item in vnfc_list:
 743                 if 'ram' in item and 'vcpus' in item and 'disk' in item:
 744                     ram = item['ram']
 745                     vcpus = item['vcpus']
 746                     disk = item['disk']
 747
 748         flavor_data = {
 749                       'name' : _get_random_string(20),
 750                       'ram': ram,
 751                       'vcpus': vcpus,
 752                       'disk': disk
 753                     }
 754
 755         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 756                                                             self.__class__.test_index,
 757                                                 inspect.currentframe().f_code.co_name)
 758         self.__class__.test_index += 1
 759         # create new flavor
 760         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
 761         # get flavor by id
 762         result = test_config["vim_conn"].get_flavor(flavor_id)
 763         self.assertEqual(ram, result['ram'])
 764         self.assertEqual(vcpus, result['vcpus'])
 765         self.assertEqual(disk, result['disk'])
 766
 767         # delete flavor
 768         result = test_config["vim_conn"].delete_flavor(flavor_id)
 769         if result:
 770             logger.info("Flavor id {} sucessfully deleted".format(result))
 771         else:
 772             logger.info("Failed to delete flavor id {}".format(result))
 773
 774     def test_010_get_flavor_negative(self):
 775         Non_exist_flavor_id = str(uuid.uuid4())
 776
 777         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 778                                                             self.__class__.test_index,
 779                                                 inspect.currentframe().f_code.co_name)
 780         self.__class__.test_index += 1
 781
 782         with self.assertRaises(Exception) as context:
 783             test_config["vim_conn"].get_flavor(Non_exist_flavor_id)
 784
 785         self.assertEqual((context.exception).http_code, 404)
 786
 787 class test_vimconn_new_flavor(test_base):
 788     flavor_id = None
 789
 790     def test_000_new_flavor(self):
 791         flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vpcus': 1, 'disk': 10}
 792
 793         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 794                                                             self.__class__.test_index,
 795                                                 inspect.currentframe().f_code.co_name)
 796         self.__class__.test_index += 1
 797
 798         # create new flavor
 799         self.__class__.flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
 800         self.assertIsInstance(self.__class__.flavor_id, (str, unicode))
 801         self.assertIsInstance(uuid.UUID(self.__class__.flavor_id), uuid.UUID)
 802
 803     def test_010_delete_flavor(self):
 804         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 805                                                             self.__class__.test_index,
 806                                                 inspect.currentframe().f_code.co_name)
 807         self.__class__.test_index += 1
 808
 809         # delete flavor
 810         result = test_config["vim_conn"].delete_flavor(self.__class__.flavor_id)
 811         if result:
 812             logger.info("Flavor id {} sucessfully deleted".format(result))
 813         else:
 814             logger.error("Failed to delete flavor id {}".format(result))
 815             raise Exception ("Failed to delete created flavor")
 816
 817     def test_020_new_flavor_negative(self):
 818         Invalid_flavor_data = {'ram': '1024', 'vcpus': 2.0, 'disk': 2.0}
 819
 820         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 821                                                             self.__class__.test_index,
 822                                                 inspect.currentframe().f_code.co_name)
 823         self.__class__.test_index += 1
 824
 825         with self.assertRaises(Exception) as context:
 826             test_config["vim_conn"].new_flavor(Invalid_flavor_data)
 827
 828         self.assertEqual((context.exception).http_code, 400)
 829
 830     def test_030_delete_flavor_negative(self):
 831         Non_exist_flavor_id = str(uuid.uuid4())
 832
 833         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 834                                                             self.__class__.test_index,
 835                                                 inspect.currentframe().f_code.co_name)
 836         self.__class__.test_index += 1
 837
 838         with self.assertRaises(Exception) as context:
 839             test_config["vim_conn"].delete_flavor(Non_exist_flavor_id)
 840
 841         self.assertEqual((context.exception).http_code, 404)
 842
 843 class test_vimconn_new_image(test_base):
 844
 845     def test_000_new_image(self):
 846         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 847                                                             self.__class__.test_index,
 848                                                 inspect.currentframe().f_code.co_name)
 849         self.__class__.test_index += 1
 850
 851         image_path = test_config['image_path']
 852         if image_path:
 853             self.__class__.image_id = test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : image_path, 'metadata': {'upload_location':None} })
 854             time.sleep(20)
 855
 856             self.assertIsInstance(self.__class__.image_id, (str, unicode))
 857             self.assertIsInstance(uuid.UUID(self.__class__.image_id), uuid.UUID)
 858         else:
 859             self.skipTest("Skipping test as image file not present at RO container")
 860
 861     def test_010_new_image_negative(self):
 862         Non_exist_image_path = '/temp1/cirros.ovf'
 863
 864         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 865                                                             self.__class__.test_index,
 866                                                 inspect.currentframe().f_code.co_name)
 867         self.__class__.test_index += 1
 868
 869         with self.assertRaises(Exception) as context:
 870             test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path})
 871
 872         self.assertEqual((context.exception).http_code, 400)
 873
 874     def test_020_delete_image(self):
 875         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 876                                                             self.__class__.test_index,
 877                                                 inspect.currentframe().f_code.co_name)
 878         self.__class__.test_index += 1
 879
 880         image_id = test_config["vim_conn"].delete_image(self.__class__.image_id)
 881
 882         self.assertIsInstance(image_id, (str, unicode))
 883
 884     def test_030_delete_image_negative(self):
 885         Non_exist_image_id = str(uuid.uuid4())
 886
 887         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 888                                                             self.__class__.test_index,
 889                                                 inspect.currentframe().f_code.co_name)
 890         self.__class__.test_index += 1
 891
 892         with self.assertRaises(Exception) as context:
 893             test_config["vim_conn"].delete_image(Non_exist_image_id)
 894
 895         self.assertEqual((context.exception).http_code, 404)
 896
 897 class test_vimconn_get_image_id_from_path(test_base):
 898
 899     def test_000_get_image_id_from_path(self):
 900         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 901                                                             self.__class__.test_index,
 902                                                 inspect.currentframe().f_code.co_name)
 903         self.__class__.test_index += 1
 904
 905         image_path = test_config['image_path']
 906         if image_path:
 907             image_id = test_config["vim_conn"].get_image_id_from_path( image_path )
 908             self.assertEqual(type(image_id),str)
 909         else:
 910             self.skipTest("Skipping test as image file not present at RO container")
 911
 912     def test_010_get_image_id_from_path_negative(self):
 913         Non_exist_image_path = '/temp1/cirros.ovf'
 914
 915         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 916                                                             self.__class__.test_index,
 917                                                 inspect.currentframe().f_code.co_name)
 918         self.__class__.test_index += 1
 919
 920         with self.assertRaises(Exception) as context:
 921             test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path })
 922
 923         self.assertEqual((context.exception).http_code, 400)
 924
 925 class test_vimconn_get_image_list(test_base):
 926     image_name = None
 927     image_id = None
 928
 929     def test_000_get_image_list(self):
 930         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 931                                                             self.__class__.test_index,
 932                                                 inspect.currentframe().f_code.co_name)
 933         self.__class__.test_index += 1
 934         image_list = test_config["vim_conn"].get_image_list()
 935
 936         for item in image_list:
 937             if 'name' in item:
 938                 self.__class__.image_name = item['name']
 939                 self.__class__.image_id = item['id']
 940                 self.assertIsInstance(self.__class__.image_name, (str, unicode))
 941                 self.assertIsInstance(self.__class__.image_id, (str, unicode))
 942
 943     def test_010_get_image_list_by_name(self):
 944         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 945                                                             self.__class__.test_index,
 946                                                 inspect.currentframe().f_code.co_name)
 947         self.__class__.test_index += 1
 948
 949         image_list = test_config["vim_conn"].get_image_list({'name': self.__class__.image_name})
 950
 951         for item in image_list:
 952             self.assertIsInstance(item['id'], (str, unicode))
 953             self.assertIsInstance(item['name'], (str, unicode))
 954             self.assertEqual(item['id'], self.__class__.image_id)
 955             self.assertEqual(item['name'], self.__class__.image_name)
 956
 957     def test_020_get_image_list_by_id(self):
 958         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 959                                                             self.__class__.test_index,
 960                                                 inspect.currentframe().f_code.co_name)
 961         self.__class__.test_index += 1
 962
 963         filter_image_list = test_config["vim_conn"].get_image_list({'id': self.__class__.image_id})
 964
 965         for item1 in filter_image_list:
 966             self.assertIsInstance(item1['id'], (str, unicode))
 967             self.assertIsInstance(item1['name'], (str, unicode))
 968             self.assertEqual(item1['id'], self.__class__.image_id)
 969             self.assertEqual(item1['name'], self.__class__.image_name)
 970
 971     def test_030_get_image_list_negative(self):
 972         Non_exist_image_id = uuid.uuid4()
 973         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 974                                                             self.__class__.test_index,
 975                                                 inspect.currentframe().f_code.co_name)
 976         self.__class__.test_index += 1
 977         image_list = test_config["vim_conn"].get_image_list({'name': 'Unknown_name', 'id': Non_exist_image_id})
 978
 979         self.assertIsNotNone(image_list, None)
 980         self.assertEqual(image_list, [])
 981
 982 class test_vimconn_new_vminstance(test_base):
 983     network_name = None
 984     net_type = None
 985     network_id = None
 986     image_id = None
 987     instance_id = None
 988
 989     def setUp(self):
 990         # create network
 991         self.__class__.network_name = _get_random_string(20)
 992         self.__class__.net_type = 'bridge'
 993
 994         self.__class__.network_id = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 995                                                                             net_type=self.__class__.net_type)
 996
 997     def tearDown(self):
 998         test_base.tearDown(self)
 999         # Deleting created network
1000         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
1001         if result:
1002             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
1003         else:
1004             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
1005
1006     def test_000_new_vminstance(self):
1007         vpci = "0000:00:11.0"
1008         name = "eth0"
1009
1010         flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1011
1012         # create new flavor
1013         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1014
1015         # find image name and image id
1016         if test_config['image_name']:
1017             image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']})
1018             if len(image_list) == 0:
1019                 raise Exception("Image {} is not found at VIM".format(test_config['image_name']))
1020             else:
1021                 self.__class__.image_id = image_list[0]['id']
1022         else:
1023             image_list = test_config['vim_conn'].get_image_list()
1024             if len(image_list) == 0:
1025                 raise Exception("Not found any image at VIM")
1026             else:
1027                 self.__class__.image_id = image_list[0]['id']
1028
1029         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1030                                                             self.__class__.test_index,
1031                                                 inspect.currentframe().f_code.co_name)
1032         self.__class__.test_index += 1
1033
1034         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1035
1036         self.__class__.instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list)
1037
1038         self.assertIsInstance(self.__class__.instance_id, (str, unicode))
1039
1040     def test_010_new_vminstance_by_model(self):
1041         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1042         model_name = 'e1000'
1043         name = 'eth0'
1044
1045         # create new flavor
1046         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1047
1048         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1049                                                             self.__class__.test_index,
1050                                                 inspect.currentframe().f_code.co_name)
1051         self.__class__.test_index += 1
1052
1053         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'model': model_name, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1054
1055         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id,flavor_id=flavor_id,net_list=net_list)
1056
1057         self.assertIsInstance(instance_id, (str, unicode))
1058
1059         # Deleting created vm instance
1060         logger.info("Deleting created vm intance")
1061         test_config["vim_conn"].delete_vminstance(instance_id)
1062         time.sleep(10)
1063
1064     def test_020_new_vminstance_by_net_use(self):
1065         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1066         net_use = 'data'
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': net_use, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1078
1079         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id,disk_list=None,
1080                                                                                            flavor_id=flavor_id,
1081                                                                                              net_list=net_list)
1082         self.assertIsInstance(instance_id, (str, unicode))
1083
1084         # Deleting created vm instance
1085         logger.info("Deleting created vm intance")
1086         test_config["vim_conn"].delete_vminstance(instance_id)
1087         time.sleep(10)
1088
1089     def test_030_new_vminstance_by_net_type(self):
1090         flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1091         _type = 'VF'
1092         name = 'eth0'
1093
1094         # create new flavor
1095         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1096
1097         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1098                                                             self.__class__.test_index,
1099                                                 inspect.currentframe().f_code.co_name)
1100         self.__class__.test_index += 1
1101
1102         if test_config['vimtype'] == 'vmware':
1103             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1104                          'type': _type, 'net_id': self.__class__.network_id}]
1105
1106             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id,
1107                                                                     flavor_id=flavor_id,
1108                                                                     net_list=net_list)
1109             self.assertEqual(type(instance_id),str)
1110
1111         if test_config['vimtype'] == 'openstack':
1112             # create network of type data
1113             network_name = _get_random_string(20)
1114             net_type = 'data'
1115
1116             network_id = test_config["vim_conn"].new_network(net_name=network_name,
1117                                                                             net_type=net_type)
1118             net_list = [{'use': net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1119                          'type': _type, 'net_id': network_id}]
1120
1121             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1122                                                                     image_id=self.__class__.image_id, disk_list=None,
1123                                                                     flavor_id=flavor_id,
1124                                                                     net_list=net_list)
1125
1126             self.assertEqual(type(instance_id), unicode)
1127
1128             # delete created network
1129             result = test_config["vim_conn"].delete_network(network_id)
1130             if result:
1131                 logger.info("Network id {} sucessfully deleted".format(network_id))
1132             else:
1133                 logger.info("Failed to delete network id {}".format(network_id))
1134
1135         # Deleting created vm instance
1136         logger.info("Deleting created vm intance")
1137         test_config["vim_conn"].delete_vminstance(instance_id)
1138         time.sleep(10)
1139
1140     def test_040_new_vminstance_by_cloud_config(self):
1141         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1142         name = 'eth0'
1143         user_name = 'test_user'
1144
1145         key_pairs = ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy2w9GHMKKNkpCmrDK2ovc3XBYDETuLWwaW24S+feHhLBQiZlzh3gSQoINlA+2ycM9zYbxl4BGzEzpTVyCQFZv5PidG4m6ox7LR+KYkDcITMyjsVuQJKDvt6oZvRt6KbChcCi0n2JJD/oUiJbBFagDBlRslbaFI2mmqmhLlJ5TLDtmYxzBLpjuX4m4tv+pdmQVfg7DYHsoy0hllhjtcDlt1nn05WgWYRTu7mfQTWfVTavu+OjIX3e0WN6NW7yIBWZcE/Q9lC0II3W7PZDE3QaT55se4SPIO2JTdqsx6XGbekdG1n6adlduOI27sOU5m4doiyJ8554yVbuDB/z5lRBD alfonso.tiernosepulveda@telefonica.com']
1146
1147         users_data = [{'key-pairs': ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy2w9GHMKKNkpCmrDK2ovc3XBYDETuLWwaW24S+feHhLBQiZlzh3gSQoINlA+2ycM9zYbxl4BGzEzpTVyCQFZv5PidG4m6ox7LR+KYkDcITMyjsVuQJKDvt6oZvRt6KbChcCi0n2JJD/oUiJbBFagDBlRslbaFI2mmqmhLlJ5TLDtmYxzBLpjuX4m4tv+pdmQVfg7DYHsoy0hllhjtcDlt1nn05WgWYRTu7mfQTWfVTavu+OjIX3e0WN6NW7yIBWZcE/Q9lC0II3W7PZDE3QaT55se4SPIO2JTdqsx6XGbekdG1n6adlduOI27sOU5m4doiyJ8554yVbuDB/z5lRBD alfonso.tiernosepulveda@telefonica.com'], 'name': user_name}]
1148
1149         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 }
1150
1151         # create new flavor
1152         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1153
1154         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1155                                                             self.__class__.test_index,
1156                                                 inspect.currentframe().f_code.co_name)
1157         self.__class__.test_index += 1
1158
1159         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1160
1161         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Cloud_vm', description='', start=False,
1162                                                                 image_id=self.__class__.image_id, flavor_id=flavor_id,net_list=net_list,cloud_config=cloud_data)
1163
1164         self.assertIsInstance(instance_id, (str, unicode))
1165
1166         # Deleting created vm instance
1167         logger.info("Deleting created vm intance")
1168         test_config["vim_conn"].delete_vminstance(instance_id)
1169         time.sleep(10)
1170
1171     def test_050_new_vminstance_by_disk_list(self):
1172         flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1173         name = 'eth0'
1174
1175         device_data = [{'image_id': self.__class__.image_id, 'size': '10'}]
1176
1177         # create new flavor
1178         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1179
1180         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1181                                                             self.__class__.test_index,
1182                                                 inspect.currentframe().f_code.co_name)
1183         self.__class__.test_index += 1
1184
1185         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1186
1187         instance_id, _ = test_config["vim_conn"].new_vminstance(name='VM_test1', description='', start=False, image_id=self.__class__.image_id,
1188                                                                                            flavor_id=flavor_id,
1189                                                                                              net_list=net_list,
1190                                                                                          disk_list=device_data)
1191
1192         self.assertIsInstance(instance_id, (str, unicode))
1193         # Deleting created vm instance
1194         logger.info("Deleting created vm intance")
1195         test_config["vim_conn"].delete_vminstance(instance_id)
1196         time.sleep(10)
1197
1198     def test_060_new_vminstance_negative(self):
1199         unknown_flavor_id = str(uuid.uuid4())
1200         unknown_image_id = str(uuid.uuid4())
1201         name = 'eth2'
1202
1203         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1204                                                             self.__class__.test_index,
1205                                                 inspect.currentframe().f_code.co_name)
1206         self.__class__.test_index += 1
1207
1208         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1209
1210         with self.assertRaises(Exception) as context:
1211             test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=unknown_image_id,
1212                                                                   flavor_id=unknown_flavor_id,
1213                                                                             net_list=net_list)
1214
1215         self.assertIn((context.exception).http_code, (400, 404))
1216
1217
1218     def test_070_get_vminstance(self):
1219         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1220                                                             self.__class__.test_index,
1221                                                 inspect.currentframe().f_code.co_name)
1222         self.__class__.test_index += 1
1223
1224         # Get instance by its id
1225         vm_info = test_config["vim_conn"].get_vminstance(self.__class__.instance_id)
1226
1227         if test_config['vimtype'] == 'vmware':
1228             for attr in vm_info:
1229                 if attr == 'status':
1230                     self.assertEqual(vm_info[attr], 'ACTIVE')
1231                 if attr == 'hostId':
1232                     self.assertEqual(type(vm_info[attr]), str)
1233                 if attr == 'interfaces':
1234                     self.assertEqual(type(vm_info[attr]), list)
1235                     self.assertEqual(vm_info[attr][0]['IsConnected'], 'true')
1236                 if attr == 'IsEnabled':
1237                     self.assertEqual(vm_info[attr], 'true')
1238
1239     def test_080_get_vminstance_negative(self):
1240         unknown_instance_id = str(uuid.uuid4())
1241
1242         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1243                                                             self.__class__.test_index,
1244                                                 inspect.currentframe().f_code.co_name)
1245         self.__class__.test_index += 1
1246
1247         with self.assertRaises(Exception) as context:
1248             test_config["vim_conn"].get_vminstance(unknown_instance_id)
1249
1250         self.assertEqual((context.exception).http_code, 404)
1251
1252     def test_090_refresh_vms_status(self):
1253         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1254                                                             self.__class__.test_index,
1255                                                 inspect.currentframe().f_code.co_name)
1256         self.__class__.test_index += 1
1257
1258         if test_config['vimtype'] == 'vmware':
1259             vm_list = []
1260             vm_list.append(self.__class__.instance_id)
1261
1262             # refresh vm status
1263             vm_info = test_config["vim_conn"].refresh_vms_status(vm_list)
1264             for attr in vm_info[self.__class__.instance_id]:
1265                 if attr == 'status':
1266                     self.assertEqual(vm_info[self.__class__.instance_id][attr], 'ACTIVE')
1267                 if attr == 'interfaces':
1268                     self.assertEqual(type(vm_info[self.__class__.instance_id][attr]), list)
1269
1270         if test_config['vimtype'] == 'openstack':
1271             vpci = "0000:00:11.0"
1272             name = "eth0"
1273
1274             flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1275
1276             # create new flavor
1277             flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1278              # create new vm instance
1279             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1280
1281             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list)
1282
1283             time.sleep(30)
1284             vm_list = []
1285             vm_list.append(instance_id)
1286
1287             # refresh vm status
1288             vm_info = test_config["vim_conn"].refresh_vms_status(vm_list)
1289             for attr in vm_info[instance_id]:
1290                 if attr == 'status':
1291                     self.assertEqual(vm_info[instance_id][attr], 'ACTIVE')
1292                 if attr == 'interfaces':
1293                     self.assertEqual(type(vm_info[instance_id][attr]), list)
1294
1295             #Deleting created vm instance
1296             logger.info("Deleting created vm intance")
1297             test_config["vim_conn"].delete_vminstance(instance_id)
1298             time.sleep(10)
1299
1300
1301     def test_100_refresh_vms_status_negative(self):
1302         unknown_id = str(uuid.uuid4())
1303
1304         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1305                                                             self.__class__.test_index,
1306                                                 inspect.currentframe().f_code.co_name)
1307         self.__class__.test_index += 1
1308
1309         vm_dict = test_config["vim_conn"].refresh_vms_status([unknown_id])
1310
1311         if test_config['vimtype'] == 'vmware':
1312             self.assertEqual(vm_dict,{})
1313
1314         if test_config['vimtype'] == 'openstack':
1315             self.assertEqual(vm_dict[unknown_id]['status'], 'DELETED')
1316
1317     def test_110_action_vminstance(self):
1318         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1319                                                             self.__class__.test_index,
1320                                                 inspect.currentframe().f_code.co_name)
1321         self.__class__.test_index += 1
1322
1323         if test_config['vimtype'] == 'vmware':
1324             action_list = ['shutdown', 'start', 'shutoff', 'rebuild', 'pause', 'resume']
1325             # various action on vminstace
1326             for action in action_list:
1327                 instance_id = test_config["vim_conn"].action_vminstance(self.__class__.instance_id,
1328                                                                         {action: None})
1329                 self.assertEqual(instance_id, self.__class__.instance_id)
1330
1331         if test_config['vimtype'] == 'openstack':
1332             # create new vm instance
1333             vpci = "0000:00:11.0"
1334             name = "eth0"
1335
1336             flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1337
1338             # create new flavor
1339             flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1340
1341             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1342
1343             new_instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list)
1344
1345             action_list =  ['shutdown','start','shutoff','rebuild','start','pause','start']
1346
1347             # various action on vminstace
1348             for action in action_list:
1349                 # sleep for sometime till status is changed
1350                 time.sleep(25)
1351                 instance_id = test_config["vim_conn"].action_vminstance(new_instance_id,
1352                                                                                    { action: None})
1353
1354             self.assertTrue(instance_id is None)
1355
1356             # Deleting created vm instance
1357             logger.info("Deleting created vm intance")
1358             test_config["vim_conn"].delete_vminstance(new_instance_id)
1359             time.sleep(10)
1360
1361     def test_120_action_vminstance_negative(self):
1362         non_exist_id = str(uuid.uuid4())
1363         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1364                                                             self.__class__.test_index,
1365                                                 inspect.currentframe().f_code.co_name)
1366         self.__class__.test_index += 1
1367
1368         action = 'start'
1369         with self.assertRaises(Exception) as context:
1370             test_config["vim_conn"].action_vminstance(non_exist_id, { action: None})
1371
1372         self.assertEqual((context.exception).http_code, 404)
1373
1374
1375     def test_130_delete_vminstance(self):
1376         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1377                                                             self.__class__.test_index,
1378                                                 inspect.currentframe().f_code.co_name)
1379         self.__class__.test_index += 1
1380
1381         # Deleting created vm instance
1382         logger.info("Deleting created vm instance")
1383         test_config["vim_conn"].delete_vminstance(self.__class__.instance_id)
1384         time.sleep(10)
1385
1386 class test_vimconn_get_tenant_list(test_base):
1387     tenant_id = None
1388
1389     def test_000_get_tenant_list(self):
1390         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1391                                                             self.__class__.test_index,
1392                                                 inspect.currentframe().f_code.co_name)
1393         self.__class__.test_index += 1
1394
1395         # Getting tenant list
1396         tenant_list = test_config["vim_conn"].get_tenant_list()
1397
1398         for item in tenant_list:
1399             if test_config['tenant'] == item['name']:
1400                 self.__class__.tenant_id = item['id']
1401                 self.assertIsInstance(item['name'], (str, unicode))
1402                 self.assertIsInstance(item['id'], (str, unicode))
1403
1404     def test_010_get_tenant_list_by_id(self):
1405         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1406                                                             self.__class__.test_index,
1407                                                 inspect.currentframe().f_code.co_name)
1408         self.__class__.test_index += 1
1409
1410         # Getting filter tenant list by its id
1411         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'id': self.__class__.tenant_id})
1412
1413         for item in filter_tenant_list:
1414             self.assertIsInstance(item['id'], (str, unicode))
1415             self.assertEqual(item['id'], self.__class__.tenant_id)
1416
1417     def test_020_get_tenant_list_by_name(self):
1418         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1419                                                             self.__class__.test_index,
1420                                                 inspect.currentframe().f_code.co_name)
1421         self.__class__.test_index += 1
1422
1423         # Getting filter tenant list by its name
1424         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant']})
1425
1426         for item in filter_tenant_list:
1427             self.assertIsInstance(item['name'], (str, unicode))
1428             self.assertEqual(item['name'], test_config['tenant'])
1429
1430     def test_030_get_tenant_list_by_name_and_id(self):
1431         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1432                                                             self.__class__.test_index,
1433                                                 inspect.currentframe().f_code.co_name)
1434         self.__class__.test_index += 1
1435
1436         # Getting filter tenant list by its name and id
1437         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant'],
1438                                                                     'id': self.__class__.tenant_id})
1439
1440         for item in filter_tenant_list:
1441             self.assertIsInstance(item['name'], (str, unicode))
1442             self.assertIsInstance(item['id'], (str, unicode))
1443             self.assertEqual(item['name'], test_config['tenant'])
1444             self.assertEqual(item['id'], self.__class__.tenant_id)
1445
1446     def test_040_get_tenant_list_negative(self):
1447         non_exist_tenant_name = "Tenant_123"
1448         non_exist_tenant_id = "kjhgrt456-45345kjhdfgnbdk-34dsfjdfg"
1449         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1450                                                             self.__class__.test_index,
1451                                                 inspect.currentframe().f_code.co_name)
1452         self.__class__.test_index += 1
1453
1454         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': non_exist_tenant_name,
1455                                                                          'id': non_exist_tenant_id})
1456
1457         self.assertEqual(filter_tenant_list, [])
1458
1459
1460 class test_vimconn_new_tenant(test_base):
1461     tenant_id = None
1462
1463     def test_000_new_tenant(self):
1464         tenant_name = _get_random_string(20)
1465         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1466                                                             self.__class__.test_index,
1467                                                 inspect.currentframe().f_code.co_name)
1468         self.__class__.test_index += 1
1469
1470         self.__class__.tenant_id = test_config["vim_conn"].new_tenant(tenant_name, "")
1471         time.sleep(15)
1472
1473         self.assertIsInstance(self.__class__.tenant_id, (str, unicode))
1474
1475
1476     def test_010_new_tenant_negative(self):
1477         Invalid_tenant_name = 10121
1478         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1479                                                             self.__class__.test_index,
1480                                                 inspect.currentframe().f_code.co_name)
1481         self.__class__.test_index += 1
1482
1483         with self.assertRaises(Exception) as context:
1484             test_config["vim_conn"].new_tenant(Invalid_tenant_name, "")
1485
1486         self.assertEqual((context.exception).http_code, 400)
1487
1488
1489     def test_020_delete_tenant(self):
1490         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1491                                                             self.__class__.test_index,
1492                                                 inspect.currentframe().f_code.co_name)
1493         self.__class__.test_index += 1
1494
1495         tenant_id = test_config["vim_conn"].delete_tenant(self.__class__.tenant_id)
1496
1497         self.assertIsInstance(tenant_id, (str, unicode))
1498
1499     def test_030_delete_tenant_negative(self):
1500         Non_exist_tenant_name = 'Test_30_tenant'
1501         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1502                                                             self.__class__.test_index,
1503                                                 inspect.currentframe().f_code.co_name)
1504         self.__class__.test_index += 1
1505
1506         with self.assertRaises(Exception) as context:
1507             test_config["vim_conn"].delete_tenant(Non_exist_tenant_name)
1508
1509         self.assertEqual((context.exception).http_code, 404)
1510
1511
1512 '''
1513 IMPORTANT NOTE
1514 The following unittest class does not have the 'test_' on purpose. This test is the one used for the
1515 scenario based tests.
1516 '''
1517 class descriptor_based_scenario_test(test_base):
1518     test_index = 0
1519     scenario_test_path = None
1520
1521     @classmethod
1522     def setUpClass(cls):
1523         cls.test_index = 1
1524         cls.to_delete_list = []
1525         cls.scenario_uuids = []
1526         cls.instance_scenario_uuids = []
1527         cls.scenario_test_path = test_config["test_directory"] + '/' + test_config["test_folder"]
1528         logger.info("{}. {} {}".format(test_config["test_number"], cls.__name__, test_config["test_folder"]))
1529
1530     @classmethod
1531     def tearDownClass(cls):
1532          test_config["test_number"] += 1
1533
1534     def test_000_load_scenario(self):
1535         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1536                                                            inspect.currentframe().f_code.co_name,
1537                                                            test_config["test_folder"])
1538         self.__class__.test_index += 1
1539         # load VNFD and NSD
1540         descriptor_files = glob.glob(self.__class__.scenario_test_path+'/*.yaml')
1541         vnf_descriptors = []
1542         scenario_descriptors = []
1543         for descriptor_file in descriptor_files:
1544             with open(descriptor_file, 'r') as stream:
1545                 descriptor = yaml.load(stream)
1546                 if "vnf" in descriptor or "vnfd:vnfd-catalog" in descriptor or "vnfd-catalog" in descriptor:
1547                     vnf_descriptors.append(descriptor)
1548                 else:
1549                     scenario_descriptors.append(descriptor)
1550
1551         scenario_file = glob.glob(self.__class__.scenario_test_path + '/scenario_*.yaml')
1552         if not vnf_descriptors or not scenario_descriptors or len(scenario_descriptors) > 1:
1553             raise Exception("Test '{}' not valid. It must contain an scenario file and at least one vnfd file'".format(
1554                 test_config["test_folder"]))
1555
1556         # load all vnfd
1557         for vnf_descriptor in vnf_descriptors:
1558             logger.debug("VNF descriptor: {}".format(vnf_descriptor))
1559             vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor, image_name=test_config["image_name"])
1560             logger.debug(vnf)
1561             if 'vnf' in vnf:
1562                 vnf_uuid = vnf['vnf']['uuid']
1563             else:
1564                 vnf_uuid = vnf['vnfd'][0]['uuid']
1565             self.__class__.to_delete_list.insert(0, {"item": "vnf", "function": test_config["client"].delete_vnf,
1566                                                      "params": {"uuid": vnf_uuid}})
1567
1568         # load the scenario definition
1569         for scenario_descriptor in scenario_descriptors:
1570             # networks = scenario_descriptor['scenario']['networks']
1571             # networks[test_config["mgmt_net"]] = networks.pop('mgmt')
1572             logger.debug("Scenario descriptor: {}".format(scenario_descriptor))
1573             scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor)
1574             logger.debug(scenario)
1575             if 'scenario' in scenario:
1576                 scenario_uuid = scenario['scenario']['uuid']
1577             else:
1578                 scenario_uuid = scenario['nsd'][0]['uuid']
1579             self.__class__.to_delete_list.insert(0, {"item": "scenario",
1580                                                      "function": test_config["client"].delete_scenario,
1581                                                      "params": {"uuid": scenario_uuid}})
1582             self.__class__.scenario_uuids.append(scenario_uuid)
1583
1584     def test_010_instantiate_scenario(self):
1585         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1586                                                            inspect.currentframe().f_code.co_name,
1587                                                            test_config["test_folder"])
1588         self.__class__.test_index += 1
1589         for scenario_uuid in self.__class__.scenario_uuids:
1590             instance_descriptor = {
1591                 "instance":{
1592                     "name": self.__class__.test_text,
1593                     "scenario": scenario_uuid,
1594                     "networks":{
1595                         "mgmt": {"sites": [ { "netmap-use": test_config["mgmt_net"]} ]}
1596                     }
1597                 }
1598             }
1599             instance = test_config["client"].create_instance(instance_descriptor)
1600             self.__class__.instance_scenario_uuids.append(instance['uuid'])
1601             logger.debug(instance)
1602             self.__class__.to_delete_list.insert(0, {"item": "instance",
1603                                                      "function": test_config["client"].delete_instance,
1604                                                      "params": {"uuid": instance['uuid']}})
1605
1606     def test_020_check_deployent(self):
1607         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1608                                                            inspect.currentframe().f_code.co_name,
1609                                                            test_config["test_folder"])
1610         self.__class__.test_index += 1
1611
1612         if test_config["manual"]:
1613             raw_input('Scenario has been deployed. Perform manual check and press any key to resume')
1614             return
1615
1616         keep_waiting = test_config["timeout"]
1617         pending_instance_scenario_uuids = list(self.__class__.instance_scenario_uuids)   # make a copy
1618         while pending_instance_scenario_uuids:
1619             index = 0
1620             while index < len(pending_instance_scenario_uuids):
1621                 result = check_instance_scenario_active(pending_instance_scenario_uuids[index])
1622                 if result[0]:
1623                     del pending_instance_scenario_uuids[index]
1624                     break
1625                 elif 'ERROR' in result[1]:
1626                     msg = 'Got error while waiting for the instance to get active: '+result[1]
1627                     logging.error(msg)
1628                     raise Exception(msg)
1629                 index += 1
1630
1631             if keep_waiting >= 5:
1632                 time.sleep(5)
1633                 keep_waiting -= 5
1634             elif keep_waiting > 0:
1635                 time.sleep(keep_waiting)
1636                 keep_waiting = 0
1637             else:
1638                 msg = 'Timeout reached while waiting instance scenario to get active'
1639                 logging.error(msg)
1640                 raise Exception(msg)
1641
1642     def test_030_clean_deployment(self):
1643         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1644                                                               inspect.currentframe().f_code.co_name,
1645                                                               test_config["test_folder"])
1646         self.__class__.test_index += 1
1647         #At the moment if you delete an scenario right after creating it, in openstack datacenters
1648         #sometimes scenario ports get orphaned. This sleep is just a dirty workaround
1649         time.sleep(5)
1650         for item in self.__class__.to_delete_list:
1651             response = item["function"](**item["params"])
1652             logger.debug(response)
1653
1654
1655 def _get_random_string(maxLength):
1656     '''generates a string with random characters string.letters and string.digits
1657     with a random length up to maxLength characters. If maxLength is <15 it will be changed automatically to 15
1658     '''
1659     prefix = 'testing_'
1660     min_string = 15
1661     minLength = min_string - len(prefix)
1662     if maxLength < min_string: maxLength = min_string
1663     maxLength -= len(prefix)
1664     length = random.randint(minLength,maxLength)
1665     return 'testing_'+"".join([random.choice(string.letters+string.digits) for i in xrange(length)])
1666
1667
1668 def test_vimconnector(args):
1669     global test_config
1670     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
1671     test_config['vimtype'] = args.vimtype
1672     if args.vimtype == "vmware":
1673         import vimconn_vmware as vim
1674
1675         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
1676
1677         tenant_name = args.tenant_name
1678         test_config['tenant'] = tenant_name
1679         config_params = yaml.load(args.config_param)
1680         org_name = config_params.get('orgname')
1681         org_user = config_params.get('user')
1682         org_passwd = config_params.get('passwd')
1683         vim_url = args.endpoint_url
1684         test_config['image_path'] = args.image_path
1685         test_config['image_name'] = args.image_name
1686
1687         # vmware connector obj
1688         test_config['vim_conn'] = vim.vimconnector(name=org_name, tenant_name=tenant_name, user=org_user,passwd=org_passwd, url=vim_url, config=config_params)
1689
1690     elif args.vimtype == "aws":
1691         import vimconn_aws as vim
1692     elif args.vimtype == "openstack":
1693         import vimconn_openstack as vim
1694
1695         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
1696
1697         tenant_name = args.tenant_name
1698         test_config['tenant'] = tenant_name
1699         config_params = yaml.load(args.config_param)
1700         os_user = config_params.get('user')
1701         os_passwd = config_params.get('passwd')
1702         vim_url = args.endpoint_url
1703         test_config['image_path'] = args.image_path
1704         test_config['image_name'] = args.image_name
1705
1706         # openstack connector obj
1707         vim_persistent_info = {}
1708         test_config['vim_conn'] = vim.vimconnector(
1709             uuid="test-uuid-1", name="VIO-openstack",
1710             tenant_id=None, tenant_name=tenant_name,
1711             url=vim_url, url_admin=None,
1712             user=os_user, passwd=os_passwd,
1713             config=config_params, persistent_info=vim_persistent_info
1714         )
1715         test_config['vim_conn'].debug = "true"
1716
1717     elif args.vimtype == "openvim":
1718         import vimconn_openvim as vim
1719     else:
1720         logger.critical("vimtype '{}' not supported".format(args.vimtype))
1721         sys.exit(1)
1722     executed = 0
1723     failed = 0
1724     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
1725     # If only want to obtain a tests list print it and exit
1726     if args.list_tests:
1727         tests_names = []
1728         for cls in clsmembers:
1729             if cls[0].startswith('test_vimconn'):
1730                 tests_names.append(cls[0])
1731
1732         msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names))
1733         print(msg)
1734         logger.info(msg)
1735         sys.exit(0)
1736
1737     # Create the list of tests to be run
1738     code_based_tests = []
1739     if args.tests:
1740         for test in args.tests:
1741             for t in test.split(','):
1742                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
1743                 if len(matches_code_based_tests) > 0:
1744                     code_based_tests.append(matches_code_based_tests[0][1])
1745                 else:
1746                     logger.critical("Test '{}' is not among the possible ones".format(t))
1747                     sys.exit(1)
1748     if not code_based_tests:
1749         # include all tests
1750         for cls in clsmembers:
1751             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
1752             if cls[0].startswith('test_vimconn'):
1753                 code_based_tests.append(cls[1])
1754
1755     logger.debug("tests to be executed: {}".format(code_based_tests))
1756
1757     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
1758     # This is handled in the tests using logging.
1759     stream = open('/dev/null', 'w')
1760
1761     # Run code based tests
1762     basic_tests_suite = unittest.TestSuite()
1763     for test in code_based_tests:
1764         basic_tests_suite.addTest(unittest.makeSuite(test))
1765     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
1766     executed += result.testsRun
1767     failed += len(result.failures) + len(result.errors)
1768     if failfast and failed:
1769         sys.exit(1)
1770     if len(result.failures) > 0:
1771         logger.debug("failures : {}".format(result.failures))
1772     if len(result.errors) > 0:
1773         logger.debug("errors : {}".format(result.errors))
1774     return executed, failed
1775
1776
1777 def test_vim(args):
1778     global test_config
1779     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
1780     import openmanoclient
1781     executed = 0
1782     failed = 0
1783     test_config["client"] = openmanoclient.openmanoclient(
1784         endpoint_url=args.endpoint_url,
1785         tenant_name=args.tenant_name,
1786         datacenter_name=args.datacenter,
1787         debug=args.debug, logger=test_config["logger_name"])
1788     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
1789     # If only want to obtain a tests list print it and exit
1790     if args.list_tests:
1791         tests_names = []
1792         for cls in clsmembers:
1793             if cls[0].startswith('test_VIM'):
1794                 tests_names.append(cls[0])
1795
1796         msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names)) +\
1797               "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \
1798               "unless RO has access to the admin endpoint. Therefore this test is excluded by default"
1799         print(msg)
1800         logger.info(msg)
1801         sys.exit(0)
1802
1803     # Create the list of tests to be run
1804     code_based_tests = []
1805     if args.tests:
1806         for test in args.tests:
1807             for t in test.split(','):
1808                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
1809                 if len(matches_code_based_tests) > 0:
1810                     code_based_tests.append(matches_code_based_tests[0][1])
1811                 else:
1812                     logger.critical("Test '{}' is not among the possible ones".format(t))
1813                     sys.exit(1)
1814     if not code_based_tests:
1815         # include all tests
1816         for cls in clsmembers:
1817             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
1818             if cls[0].startswith('test_VIM') and cls[0] != 'test_VIM_tenant_operations':
1819                 code_based_tests.append(cls[1])
1820
1821     logger.debug("tests to be executed: {}".format(code_based_tests))
1822
1823     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
1824     # This is handled in the tests using logging.
1825     stream = open('/dev/null', 'w')
1826
1827     # Run code based tests
1828     basic_tests_suite = unittest.TestSuite()
1829     for test in code_based_tests:
1830         basic_tests_suite.addTest(unittest.makeSuite(test))
1831     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
1832     executed += result.testsRun
1833     failed += len(result.failures) + len(result.errors)
1834     if failfast and failed:
1835         sys.exit(1)
1836     if len(result.failures) > 0:
1837         logger.debug("failures : {}".format(result.failures))
1838     if len(result.errors) > 0:
1839         logger.debug("errors : {}".format(result.errors))
1840     return executed, failed
1841
1842
1843 def test_deploy(args):
1844     global test_config
1845     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
1846     import openmanoclient
1847     executed = 0
1848     failed = 0
1849     test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
1850     test_config["image_name"] = args.image_name
1851     test_config["mgmt_net"] = args.mgmt_net
1852     test_config["manual"] = args.manual
1853     test_directory_content = os.listdir(test_config["test_directory"])
1854     # If only want to obtain a tests list print it and exit
1855     if args.list_tests:
1856         msg = "the 'deploy' set tests are:\n\t" + ', '.join(sorted(test_directory_content))
1857         print(msg)
1858         # logger.info(msg)
1859         sys.exit(0)
1860
1861     descriptor_based_tests = []
1862     # Create the list of tests to be run
1863     code_based_tests = []
1864     if args.tests:
1865         for test in args.tests:
1866             for t in test.split(','):
1867                 if t in test_directory_content:
1868                     descriptor_based_tests.append(t)
1869                 else:
1870                     logger.critical("Test '{}' is not among the possible ones".format(t))
1871                     sys.exit(1)
1872     if not descriptor_based_tests:
1873         # include all tests
1874         descriptor_based_tests = test_directory_content
1875
1876     logger.debug("tests to be executed: {}".format(code_based_tests))
1877
1878     # import openmanoclient from relative path
1879     test_config["client"] = openmanoclient.openmanoclient(
1880         endpoint_url=args.endpoint_url,
1881         tenant_name=args.tenant_name,
1882         datacenter_name=args.datacenter,
1883         debug=args.debug, logger=test_config["logger_name"])
1884
1885     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
1886     # This is handled in the tests using logging.
1887     stream = open('/dev/null', 'w')
1888     # This scenario based tests are defined as directories inside the directory defined in 'test_directory'
1889     for test in descriptor_based_tests:
1890         test_config["test_folder"] = test
1891         test_suite = unittest.TestSuite()
1892         test_suite.addTest(unittest.makeSuite(descriptor_based_scenario_test))
1893         result = unittest.TextTestRunner(stream=stream, failfast=False).run(test_suite)
1894         executed += result.testsRun
1895         failed += len(result.failures) + len(result.errors)
1896         if failfast and failed:
1897             sys.exit(1)
1898         if len(result.failures) > 0:
1899             logger.debug("failures : {}".format(result.failures))
1900         if len(result.errors) > 0:
1901             logger.debug("errors : {}".format(result.errors))
1902
1903     return executed, failed
1904
1905 if __name__=="__main__":
1906
1907     parser = ArgumentParser(description='Test RO module')
1908     parser.add_argument('-v','--version', action='version', help="Show current version",
1909                              version='%(prog)s version ' + __version__  + ' ' + version_date)
1910
1911     # Common parameters
1912     parent_parser = ArgumentParser(add_help=False)
1913     parent_parser.add_argument('--failfast', help='Stop when a test fails rather than execute all tests',
1914                       dest='failfast', action="store_true", default=False)
1915     parent_parser.add_argument('--failed', help='Set logs to show only failed tests. --debug disables this option',
1916                       dest='failed', action="store_true", default=False)
1917     default_logger_file = os.path.dirname(__file__)+'/'+os.path.splitext(os.path.basename(__file__))[0]+'.log'
1918     parent_parser.add_argument('--list-tests', help='List all available tests', dest='list_tests', action="store_true",
1919                       default=False)
1920     parent_parser.add_argument('--logger_file', dest='logger_file', default=default_logger_file,
1921                                help='Set the logger file. By default '+default_logger_file)
1922     parent_parser.add_argument("-t", '--tenant', dest='tenant_name', default="osm",
1923                                help="Set the openmano tenant to use for the test. By default 'osm'")
1924     parent_parser.add_argument('--debug', help='Set logs to debug level', dest='debug', action="store_true")
1925     parent_parser.add_argument('--timeout', help='Specify the instantiation timeout in seconds. By default 300',
1926                           dest='timeout', type=int, default=300)
1927     parent_parser.add_argument('--test', '--tests', help='Specify the tests to run', dest='tests', action="append")
1928
1929     subparsers = parser.add_subparsers(help='test sets')
1930
1931     # Deployment test set
1932     # -------------------
1933     deploy_parser = subparsers.add_parser('deploy', parents=[parent_parser],
1934                                           help="test deployment using descriptors at RO_test folder ")
1935     deploy_parser.set_defaults(func=test_deploy)
1936
1937     # Mandatory arguments
1938     mandatory_arguments = deploy_parser.add_argument_group('mandatory arguments')
1939     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
1940     mandatory_arguments.add_argument("-i", '--image-name', required=True, dest="image_name",
1941                                      help='Image name available at datacenter used for the tests')
1942     mandatory_arguments.add_argument("-n", '--mgmt-net-name', required=True, dest='mgmt_net',
1943                                      help='Set the vim management network to use for tests')
1944
1945     # Optional arguments
1946     deploy_parser.add_argument('-m', '--manual-check', dest='manual', action="store_true", default=False,
1947                                help='Pause execution once deployed to allow manual checking of the '
1948                                     'deployed instance scenario')
1949     deploy_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
1950                                help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
1951
1952     # Vimconn test set
1953     # -------------------
1954     vimconn_parser = subparsers.add_parser('vimconn', parents=[parent_parser], help="test vimconnector plugin")
1955     vimconn_parser.set_defaults(func=test_vimconnector)
1956     # Mandatory arguments
1957     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
1958     mandatory_arguments.add_argument('--vimtype', choices=['vmware', 'aws', 'openstack', 'openvim'], required=True,
1959                                      help='Set the vimconnector type to test')
1960     mandatory_arguments.add_argument('-c', '--config', dest='config_param', required=True,
1961                                     help='Set the vimconnector specific config parameters in dictionary format')
1962     mandatory_arguments.add_argument('-u', '--url', dest='endpoint_url',required=True, help="Set the vim connector url or Host IP")
1963     # Optional arguments
1964     vimconn_parser.add_argument('-i', '--image-path', dest='image_path', help="Provide image path present at RO container")
1965     vimconn_parser.add_argument('-n', '--image-name', dest='image_name', help="Provide image name for test")
1966     # TODO add optional arguments for vimconn tests
1967     # vimconn_parser.add_argument("-i", '--image-name', dest='image_name', help='<HELP>'))
1968
1969     # Datacenter test set
1970     # -------------------
1971     vimconn_parser = subparsers.add_parser('vim', parents=[parent_parser], help="test vim")
1972     vimconn_parser.set_defaults(func=test_vim)
1973
1974     # Mandatory arguments
1975     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
1976     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
1977
1978     # Optional arguments
1979     vimconn_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
1980                                help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
1981
1982     argcomplete.autocomplete(parser)
1983     args = parser.parse_args()
1984     # print str(args)
1985     test_config = {}
1986
1987     # default logger level is INFO. Options --debug and --failed override this, being --debug prioritary
1988     logger_level = 'INFO'
1989     if args.debug:
1990         logger_level = 'DEBUG'
1991     elif args.failed:
1992         logger_level = 'WARNING'
1993     logger_name = os.path.basename(__file__)
1994     test_config["logger_name"] = logger_name
1995     logger = logging.getLogger(logger_name)
1996     logger.setLevel(logger_level)
1997     failfast = args.failfast
1998
1999     # Configure a logging handler to store in a logging file
2000     if args.logger_file:
2001         fileHandler = logging.FileHandler(args.logger_file)
2002         formatter_fileHandler = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2003         fileHandler.setFormatter(formatter_fileHandler)
2004         logger.addHandler(fileHandler)
2005
2006     # Configure a handler to print to stdout
2007     consoleHandler = logging.StreamHandler(sys.stdout)
2008     formatter_consoleHandler = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2009     consoleHandler.setFormatter(formatter_consoleHandler)
2010     logger.addHandler(consoleHandler)
2011
2012     logger.debug('Program started with the following arguments: ' + str(args))
2013
2014     # set test config parameters
2015     test_config["timeout"] = args.timeout
2016     test_config["test_number"] = 1
2017
2018     executed, failed = args.func(args)
2019
2020     # Log summary
2021     logger.warning("Total number of tests: {}; Total number of failures/errors: {}".format(executed, failed))
2022     sys.exit(1 if failed else 0)