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 })
 854             time.sleep(20)
 855             self.assertEqual(type(self.__class__.image_id),str)
 856             self.assertIsInstance(uuid.UUID(self.__class__.image_id),uuid.UUID)
 857         else:
 858             self.skipTest("Skipping test as image file not present at RO container")
 859
 860     def test_010_new_image_negative(self):
 861         Non_exist_image_path = '/temp1/cirros.ovf'
 862
 863         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 864                                                             self.__class__.test_index,
 865                                                 inspect.currentframe().f_code.co_name)
 866         self.__class__.test_index += 1
 867
 868         with self.assertRaises(Exception) as context:
 869             test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path })
 870
 871         self.assertEqual((context.exception).http_code, 400)
 872
 873     def test_020_delete_image(self):
 874         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 875                                                             self.__class__.test_index,
 876                                                 inspect.currentframe().f_code.co_name)
 877         self.__class__.test_index += 1
 878
 879         image_id = test_config["vim_conn"].delete_image(self.__class__.image_id)
 880         self.assertEqual(type(image_id),str)
 881
 882     def test_030_delete_image_negative(self):
 883         Non_exist_image_id = str(uuid.uuid4())
 884
 885         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 886                                                             self.__class__.test_index,
 887                                                 inspect.currentframe().f_code.co_name)
 888         self.__class__.test_index += 1
 889
 890         with self.assertRaises(Exception) as context:
 891             test_config["vim_conn"].delete_image(Non_exist_image_id)
 892
 893         self.assertEqual((context.exception).http_code, 404)
 894
 895 class test_vimconn_get_image_id_from_path(test_base):
 896
 897     def test_000_get_image_id_from_path(self):
 898         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 899                                                             self.__class__.test_index,
 900                                                 inspect.currentframe().f_code.co_name)
 901         self.__class__.test_index += 1
 902
 903         image_path = test_config['image_path']
 904         if image_path:
 905             image_id = test_config["vim_conn"].get_image_id_from_path( image_path )
 906             self.assertEqual(type(image_id),str)
 907         else:
 908             self.skipTest("Skipping test as image file not present at RO container")
 909
 910     def test_010_get_image_id_from_path_negative(self):
 911         Non_exist_image_path = '/temp1/cirros.ovf'
 912
 913         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 914                                                             self.__class__.test_index,
 915                                                 inspect.currentframe().f_code.co_name)
 916         self.__class__.test_index += 1
 917
 918         with self.assertRaises(Exception) as context:
 919             test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path })
 920
 921         self.assertEqual((context.exception).http_code, 400)
 922
 923 class test_vimconn_get_image_list(test_base):
 924     image_name = None
 925     image_id = None
 926
 927     def test_000_get_image_list(self):
 928         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 929                                                             self.__class__.test_index,
 930                                                 inspect.currentframe().f_code.co_name)
 931         self.__class__.test_index += 1
 932         image_list = test_config["vim_conn"].get_image_list()
 933
 934         for item in image_list:
 935             if 'name' in item:
 936                 self.__class__.image_name = item['name']
 937                 self.__class__.image_id = item['id']
 938                 self.assertEqual(type(self.__class__.image_name),str)
 939                 self.assertEqual(type(self.__class__.image_id),str)
 940
 941     def test_010_get_image_list_by_name(self):
 942         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 943                                                             self.__class__.test_index,
 944                                                 inspect.currentframe().f_code.co_name)
 945         self.__class__.test_index += 1
 946
 947         image_list = test_config["vim_conn"].get_image_list({'name': self.__class__.image_name})
 948
 949         for item in image_list:
 950             self.assertEqual(type(item['id']), str)
 951             self.assertEqual(item['id'], self.__class__.image_id)
 952             self.assertEqual(type(item['name']), str)
 953             self.assertEqual(item['name'], self.__class__.image_name)
 954
 955     def test_020_get_image_list_by_id(self):
 956         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 957                                                             self.__class__.test_index,
 958                                                 inspect.currentframe().f_code.co_name)
 959         self.__class__.test_index += 1
 960
 961         filter_image_list = test_config["vim_conn"].get_image_list({'id': self.__class__.image_id})
 962
 963         for item1 in filter_image_list:
 964             self.assertEqual(type(item1.get('id')), str)
 965             self.assertEqual(item1.get('id'), self.__class__.image_id)
 966             self.assertEqual(type(item1.get('name')), str)
 967             self.assertEqual(item1.get('name'), self.__class__.image_name)
 968
 969     def test_030_get_image_list_negative(self):
 970         Non_exist_image_id = uuid.uuid4()
 971         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
 972                                                             self.__class__.test_index,
 973                                                 inspect.currentframe().f_code.co_name)
 974         self.__class__.test_index += 1
 975         image_list = test_config["vim_conn"].get_image_list({'name': 'Unknown_name', 'id': Non_exist_image_id})
 976
 977         self.assertIsNotNone(image_list, None)
 978         self.assertEqual(image_list, [])
 979
 980 class test_vimconn_new_vminstance(test_base):
 981     network_name = None
 982     net_type = None
 983     network_id = None
 984     image_id = None
 985     instance_id = None
 986
 987     def setUp(self):
 988         # create network
 989         self.__class__.network_name = _get_random_string(20)
 990         self.__class__.net_type = 'bridge'
 991
 992         self.__class__.network_id = test_config["vim_conn"].new_network(net_name=self.__class__.network_name,
 993                                                                             net_type=self.__class__.net_type)
 994
 995     def tearDown(self):
 996         test_base.tearDown(self)
 997         # Deleting created network
 998         result = test_config["vim_conn"].delete_network(self.__class__.network_id)
 999         if result:
1000             logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id))
1001         else:
1002             logger.info("Failed to delete network id {}".format(self.__class__.network_id))
1003
1004     def test_000_new_vminstance(self):
1005         vpci = "0000:00:11.0"
1006         name = "eth0"
1007
1008         flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1009
1010         # create new flavor
1011         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1012
1013         # find image name and image id
1014         if test_config['image_name']:
1015             image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']})
1016             if len(image_list) == 0:
1017                 raise Exception("Image {} is not found at VIM".format(test_config['image_name']))
1018             else:
1019                 self.__class__.image_id = image_list[0]['id']
1020         else:
1021             image_list = test_config['vim_conn'].get_image_list()
1022             if len(image_list) == 0:
1023                 raise Exception("Not found any image at VIM")
1024             else:
1025                 self.__class__.image_id = image_list[0]['id']
1026
1027         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1028                                                             self.__class__.test_index,
1029                                                 inspect.currentframe().f_code.co_name)
1030         self.__class__.test_index += 1
1031
1032         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}]
1033
1034         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)
1035
1036         self.assertIsInstance(self.__class__.instance_id, (str, unicode))
1037
1038     def test_010_new_vminstance_by_model(self):
1039         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1040         model_name = 'e1000'
1041         name = 'eth0'
1042
1043         # create new flavor
1044         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1045
1046         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1047                                                             self.__class__.test_index,
1048                                                 inspect.currentframe().f_code.co_name)
1049         self.__class__.test_index += 1
1050
1051         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}]
1052
1053         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)
1054
1055         self.assertIsInstance(instance_id, (str, unicode))
1056
1057         # Deleting created vm instance
1058         logger.info("Deleting created vm intance")
1059         test_config["vim_conn"].delete_vminstance(instance_id)
1060         time.sleep(10)
1061
1062     def test_020_new_vminstance_by_net_use(self):
1063         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1064         net_use = 'data'
1065         name = 'eth0'
1066
1067         # create new flavor
1068         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1069
1070         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1071                                                             self.__class__.test_index,
1072                                                 inspect.currentframe().f_code.co_name)
1073         self.__class__.test_index += 1
1074
1075         net_list = [{'use': net_use, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1076
1077         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id,disk_list=None,
1078                                                                                            flavor_id=flavor_id,
1079                                                                                              net_list=net_list)
1080         self.assertIsInstance(instance_id, (str, unicode))
1081
1082         # Deleting created vm instance
1083         logger.info("Deleting created vm intance")
1084         test_config["vim_conn"].delete_vminstance(instance_id)
1085         time.sleep(10)
1086
1087     def test_030_new_vminstance_by_net_type(self):
1088         flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1089         _type = 'VF'
1090         name = 'eth0'
1091
1092         # create new flavor
1093         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1094
1095         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1096                                                             self.__class__.test_index,
1097                                                 inspect.currentframe().f_code.co_name)
1098         self.__class__.test_index += 1
1099
1100         if test_config['vimtype'] == 'vmware':
1101             net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1102                          'type': _type, 'net_id': self.__class__.network_id}]
1103
1104             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id,
1105                                                                     flavor_id=flavor_id,
1106                                                                     net_list=net_list)
1107             self.assertEqual(type(instance_id),str)
1108
1109         if test_config['vimtype'] == 'openstack':
1110             # create network of type data
1111             network_name = _get_random_string(20)
1112             net_type = 'data'
1113
1114             network_id = test_config["vim_conn"].new_network(net_name=network_name,
1115                                                                             net_type=net_type)
1116             net_list = [{'use': net_type, 'name': name, 'floating_ip': False, 'port_security': True,
1117                          'type': _type, 'net_id': network_id}]
1118
1119             instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False,
1120                                                                     image_id=self.__class__.image_id, disk_list=None,
1121                                                                     flavor_id=flavor_id,
1122                                                                     net_list=net_list)
1123
1124             self.assertEqual(type(instance_id), unicode)
1125
1126             # delete created network
1127             result = test_config["vim_conn"].delete_network(network_id)
1128             if result:
1129                 logger.info("Network id {} sucessfully deleted".format(network_id))
1130             else:
1131                 logger.info("Failed to delete network id {}".format(network_id))
1132
1133         # Deleting created vm instance
1134         logger.info("Deleting created vm intance")
1135         test_config["vim_conn"].delete_vminstance(instance_id)
1136         time.sleep(10)
1137
1138     def test_040_new_vminstance_by_cloud_config(self):
1139         flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1140         name = 'eth0'
1141         user_name = 'test_user'
1142
1143         key_pairs = ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy2w9GHMKKNkpCmrDK2ovc3XBYDETuLWwaW24S+feHhLBQiZlzh3gSQoINlA+2ycM9zYbxl4BGzEzpTVyCQFZv5PidG4m6ox7LR+KYkDcITMyjsVuQJKDvt6oZvRt6KbChcCi0n2JJD/oUiJbBFagDBlRslbaFI2mmqmhLlJ5TLDtmYxzBLpjuX4m4tv+pdmQVfg7DYHsoy0hllhjtcDlt1nn05WgWYRTu7mfQTWfVTavu+OjIX3e0WN6NW7yIBWZcE/Q9lC0II3W7PZDE3QaT55se4SPIO2JTdqsx6XGbekdG1n6adlduOI27sOU5m4doiyJ8554yVbuDB/z5lRBD alfonso.tiernosepulveda@telefonica.com']
1144
1145         users_data = [{'key-pairs': ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy2w9GHMKKNkpCmrDK2ovc3XBYDETuLWwaW24S+feHhLBQiZlzh3gSQoINlA+2ycM9zYbxl4BGzEzpTVyCQFZv5PidG4m6ox7LR+KYkDcITMyjsVuQJKDvt6oZvRt6KbChcCi0n2JJD/oUiJbBFagDBlRslbaFI2mmqmhLlJ5TLDtmYxzBLpjuX4m4tv+pdmQVfg7DYHsoy0hllhjtcDlt1nn05WgWYRTu7mfQTWfVTavu+OjIX3e0WN6NW7yIBWZcE/Q9lC0II3W7PZDE3QaT55se4SPIO2JTdqsx6XGbekdG1n6adlduOI27sOU5m4doiyJ8554yVbuDB/z5lRBD alfonso.tiernosepulveda@telefonica.com'], 'name': user_name}]
1146
1147         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 }
1148
1149         # create new flavor
1150         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1151
1152         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1153                                                             self.__class__.test_index,
1154                                                 inspect.currentframe().f_code.co_name)
1155         self.__class__.test_index += 1
1156
1157         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1158
1159         instance_id, _ = test_config["vim_conn"].new_vminstance(name='Cloud_vm', description='', start=False,
1160                                                                 image_id=self.__class__.image_id, flavor_id=flavor_id,net_list=net_list,cloud_config=cloud_data)
1161
1162         self.assertIsInstance(instance_id, (str, unicode))
1163
1164         # Deleting created vm instance
1165         logger.info("Deleting created vm intance")
1166         test_config["vim_conn"].delete_vminstance(instance_id)
1167         time.sleep(10)
1168
1169     def test_050_new_vminstance_by_disk_list(self):
1170         flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1171         name = 'eth0'
1172
1173         device_data = [{'image_id': self.__class__.image_id, 'size': '10'}]
1174
1175         # create new flavor
1176         flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1177
1178         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1179                                                             self.__class__.test_index,
1180                                                 inspect.currentframe().f_code.co_name)
1181         self.__class__.test_index += 1
1182
1183         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1184
1185         instance_id, _ = test_config["vim_conn"].new_vminstance(name='VM_test1', description='', start=False, image_id=self.__class__.image_id,
1186                                                                                            flavor_id=flavor_id,
1187                                                                                              net_list=net_list,
1188                                                                                          disk_list=device_data)
1189
1190         self.assertIsInstance(instance_id, (str, unicode))
1191         # Deleting created vm instance
1192         logger.info("Deleting created vm intance")
1193         test_config["vim_conn"].delete_vminstance(instance_id)
1194         time.sleep(10)
1195
1196     def test_060_new_vminstance_negative(self):
1197         unknown_flavor_id = str(uuid.uuid4())
1198         unknown_image_id = str(uuid.uuid4())
1199         name = 'eth2'
1200
1201         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1202                                                             self.__class__.test_index,
1203                                                 inspect.currentframe().f_code.co_name)
1204         self.__class__.test_index += 1
1205
1206         net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}]
1207
1208         with self.assertRaises(Exception) as context:
1209             test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=unknown_image_id,
1210                                                                   flavor_id=unknown_flavor_id,
1211                                                                             net_list=net_list)
1212
1213         self.assertIn((context.exception).http_code, (400, 404))
1214
1215
1216     def test_070_get_vminstance(self):
1217         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1218                                                             self.__class__.test_index,
1219                                                 inspect.currentframe().f_code.co_name)
1220         self.__class__.test_index += 1
1221
1222         # Get instance by its id
1223         vm_info = test_config["vim_conn"].get_vminstance(self.__class__.instance_id)
1224
1225         if test_config['vimtype'] == 'vmware':
1226             for attr in vm_info:
1227                 if attr == 'status':
1228                     self.assertEqual(vm_info[attr], 'ACTIVE')
1229                 if attr == 'hostId':
1230                     self.assertEqual(type(vm_info[attr]), str)
1231                 if attr == 'interfaces':
1232                     self.assertEqual(type(vm_info[attr]), list)
1233                     self.assertEqual(vm_info[attr][0]['IsConnected'], 'true')
1234                 if attr == 'IsEnabled':
1235                     self.assertEqual(vm_info[attr], 'true')
1236
1237     def test_080_get_vminstance_negative(self):
1238         unknown_instance_id = str(uuid.uuid4())
1239
1240         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1241                                                             self.__class__.test_index,
1242                                                 inspect.currentframe().f_code.co_name)
1243         self.__class__.test_index += 1
1244
1245         with self.assertRaises(Exception) as context:
1246             test_config["vim_conn"].get_vminstance(unknown_instance_id)
1247
1248         self.assertEqual((context.exception).http_code, 404)
1249
1250     def test_090_refresh_vms_status(self):
1251         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1252                                                             self.__class__.test_index,
1253                                                 inspect.currentframe().f_code.co_name)
1254         self.__class__.test_index += 1
1255
1256         if test_config['vimtype'] == 'vmware':
1257             vm_list = []
1258             vm_list.append(self.__class__.instance_id)
1259
1260             # refresh vm status
1261             vm_info = test_config["vim_conn"].refresh_vms_status(vm_list)
1262             for attr in vm_info[self.__class__.instance_id]:
1263                 if attr == 'status':
1264                     self.assertEqual(vm_info[self.__class__.instance_id][attr], 'ACTIVE')
1265                 if attr == 'interfaces':
1266                     self.assertEqual(type(vm_info[self.__class__.instance_id][attr]), list)
1267
1268         if test_config['vimtype'] == 'openstack':
1269             vpci = "0000:00:11.0"
1270             name = "eth0"
1271
1272             flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1273
1274             # create new flavor
1275             flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1276              # create new vm instance
1277             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}]
1278
1279             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)
1280
1281             time.sleep(30)
1282             vm_list = []
1283             vm_list.append(instance_id)
1284
1285             # refresh vm status
1286             vm_info = test_config["vim_conn"].refresh_vms_status(vm_list)
1287             for attr in vm_info[instance_id]:
1288                 if attr == 'status':
1289                     self.assertEqual(vm_info[instance_id][attr], 'ACTIVE')
1290                 if attr == 'interfaces':
1291                     self.assertEqual(type(vm_info[instance_id][attr]), list)
1292
1293             #Deleting created vm instance
1294             logger.info("Deleting created vm intance")
1295             test_config["vim_conn"].delete_vminstance(instance_id)
1296             time.sleep(10)
1297
1298
1299     def test_100_refresh_vms_status_negative(self):
1300         unknown_id = str(uuid.uuid4())
1301
1302         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1303                                                             self.__class__.test_index,
1304                                                 inspect.currentframe().f_code.co_name)
1305         self.__class__.test_index += 1
1306
1307         vm_dict = test_config["vim_conn"].refresh_vms_status([unknown_id])
1308
1309         if test_config['vimtype'] == 'vmware':
1310             self.assertEqual(vm_dict,{})
1311
1312         if test_config['vimtype'] == 'openstack':
1313             self.assertEqual(vm_dict[unknown_id]['status'], 'DELETED')
1314
1315     def test_110_action_vminstance(self):
1316         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1317                                                             self.__class__.test_index,
1318                                                 inspect.currentframe().f_code.co_name)
1319         self.__class__.test_index += 1
1320
1321         if test_config['vimtype'] == 'vmware':
1322             action_list = ['shutdown', 'start', 'shutoff', 'rebuild', 'pause', 'resume']
1323             # various action on vminstace
1324             for action in action_list:
1325                 instance_id = test_config["vim_conn"].action_vminstance(self.__class__.instance_id,
1326                                                                         {action: None})
1327                 self.assertEqual(instance_id, self.__class__.instance_id)
1328
1329         if test_config['vimtype'] == 'openstack':
1330             # create new vm instance
1331             vpci = "0000:00:11.0"
1332             name = "eth0"
1333
1334             flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1335
1336             # create new flavor
1337             flavor_id = test_config["vim_conn"].new_flavor(flavor_data)
1338
1339             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}]
1340
1341             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)
1342
1343             action_list =  ['shutdown','start','shutoff','rebuild','start','pause','start']
1344
1345             # various action on vminstace
1346             for action in action_list:
1347                 # sleep for sometime till status is changed
1348                 time.sleep(25)
1349                 instance_id = test_config["vim_conn"].action_vminstance(new_instance_id,
1350                                                                                    { action: None})
1351
1352             self.assertTrue(instance_id is None)
1353
1354             # Deleting created vm instance
1355             logger.info("Deleting created vm intance")
1356             test_config["vim_conn"].delete_vminstance(new_instance_id)
1357             time.sleep(10)
1358
1359     def test_120_action_vminstance_negative(self):
1360         non_exist_id = str(uuid.uuid4())
1361         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1362                                                             self.__class__.test_index,
1363                                                 inspect.currentframe().f_code.co_name)
1364         self.__class__.test_index += 1
1365
1366         action = 'start'
1367         with self.assertRaises(Exception) as context:
1368             test_config["vim_conn"].action_vminstance(non_exist_id, { action: None})
1369
1370         self.assertEqual((context.exception).http_code, 404)
1371
1372
1373     def test_130_delete_vminstance(self):
1374         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1375                                                             self.__class__.test_index,
1376                                                 inspect.currentframe().f_code.co_name)
1377         self.__class__.test_index += 1
1378
1379         # Deleting created vm instance
1380         logger.info("Deleting created vm instance")
1381         test_config["vim_conn"].delete_vminstance(self.__class__.instance_id)
1382         time.sleep(10)
1383
1384 class test_vimconn_get_tenant_list(test_base):
1385     tenant_id = None
1386
1387     def test_000_get_tenant_list(self):
1388         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1389                                                             self.__class__.test_index,
1390                                                 inspect.currentframe().f_code.co_name)
1391         self.__class__.test_index += 1
1392
1393         # Getting tenant list
1394         tenant_list = test_config["vim_conn"].get_tenant_list()
1395
1396         for item in tenant_list:
1397             if test_config['tenant'] == item['name']:
1398                 self.__class__.tenant_id = item['id']
1399                 self.assertEqual(type(item['name']), str)
1400                 self.assertEqual(type(item['id']), str)
1401
1402     def test_010_get_tenant_list_by_id(self):
1403         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1404                                                             self.__class__.test_index,
1405                                                 inspect.currentframe().f_code.co_name)
1406         self.__class__.test_index += 1
1407
1408         # Getting filter tenant list by its id
1409         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'id': self.__class__.tenant_id})
1410
1411         for item in filter_tenant_list:
1412             self.assertEqual(type(item['id']), str)
1413             self.assertEqual(item['id'], self.__class__.tenant_id)
1414
1415     def test_020_get_tenant_list_by_name(self):
1416         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1417                                                             self.__class__.test_index,
1418                                                 inspect.currentframe().f_code.co_name)
1419         self.__class__.test_index += 1
1420
1421         # Getting filter tenant list by its name
1422         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant']})
1423
1424         for item in filter_tenant_list:
1425             self.assertEqual(type(item['name']), str)
1426             self.assertEqual(item['name'], test_config['tenant'])
1427
1428     def test_030_get_tenant_list_by_name_and_id(self):
1429         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1430                                                             self.__class__.test_index,
1431                                                 inspect.currentframe().f_code.co_name)
1432         self.__class__.test_index += 1
1433
1434         # Getting filter tenant list by its name and id
1435         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant'],
1436                                                                     'id': self.__class__.tenant_id})
1437
1438         for item in filter_tenant_list:
1439             self.assertEqual(type(item['name']), str)
1440             self.assertEqual(type(item['id']), str)
1441             self.assertEqual(item['name'], test_config['tenant'])
1442             self.assertEqual(item['id'], self.__class__.tenant_id)
1443
1444     def test_040_get_tenant_list_negative(self):
1445         non_exist_tenant_name = "Tenant_123"
1446         non_exist_tenant_id = "kjhgrt456-45345kjhdfgnbdk-34dsfjdfg"
1447         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1448                                                             self.__class__.test_index,
1449                                                 inspect.currentframe().f_code.co_name)
1450         self.__class__.test_index += 1
1451
1452         filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': non_exist_tenant_name,
1453                                                                          'id': non_exist_tenant_id})
1454
1455         self.assertEqual(filter_tenant_list, [])
1456
1457 class test_vimconn_new_tenant(test_base):
1458     tenant_id = None
1459
1460     def test_000_new_tenant(self):
1461         tenant_name = _get_random_string(20)
1462         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1463                                                             self.__class__.test_index,
1464                                                 inspect.currentframe().f_code.co_name)
1465         self.__class__.test_index += 1
1466
1467         self.__class__.tenant_id = test_config["vim_conn"].new_tenant(tenant_name)
1468         time.sleep(15)
1469
1470         self.assertEqual(type(self.__class__.tenant_id), str)
1471
1472     def test_010_new_tenant_negative(self):
1473         Invalid_tenant_name = 10121
1474         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1475                                                             self.__class__.test_index,
1476                                                 inspect.currentframe().f_code.co_name)
1477         self.__class__.test_index += 1
1478
1479         with self.assertRaises(Exception) as context:
1480             test_config["vim_conn"].new_tenant(Invalid_tenant_name)
1481
1482         self.assertEqual((context.exception).http_code, 400)
1483
1484     def test_020_delete_tenant(self):
1485         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1486                                                             self.__class__.test_index,
1487                                                 inspect.currentframe().f_code.co_name)
1488         self.__class__.test_index += 1
1489
1490         tenant_id = test_config["vim_conn"].delete_tenant(self.__class__.tenant_id)
1491         self.assertEqual(type(tenant_id), str)
1492
1493     def test_030_delete_tenant_negative(self):
1494         Non_exist_tenant_name = 'Test_30_tenant'
1495         self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
1496                                                             self.__class__.test_index,
1497                                                 inspect.currentframe().f_code.co_name)
1498         self.__class__.test_index += 1
1499
1500         with self.assertRaises(Exception) as context:
1501             test_config["vim_conn"].delete_tenant(Non_exist_tenant_name)
1502
1503         self.assertEqual((context.exception).http_code, 404)
1504
1505
1506 '''
1507 IMPORTANT NOTE
1508 The following unittest class does not have the 'test_' on purpose. This test is the one used for the
1509 scenario based tests.
1510 '''
1511 class descriptor_based_scenario_test(test_base):
1512     test_index = 0
1513     scenario_test_path = None
1514
1515     @classmethod
1516     def setUpClass(cls):
1517         cls.test_index = 1
1518         cls.to_delete_list = []
1519         cls.scenario_uuids = []
1520         cls.instance_scenario_uuids = []
1521         cls.scenario_test_path = test_config["test_directory"] + '/' + test_config["test_folder"]
1522         logger.info("{}. {} {}".format(test_config["test_number"], cls.__name__, test_config["test_folder"]))
1523
1524     @classmethod
1525     def tearDownClass(cls):
1526          test_config["test_number"] += 1
1527
1528     def test_000_load_scenario(self):
1529         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1530                                                            inspect.currentframe().f_code.co_name,
1531                                                            test_config["test_folder"])
1532         self.__class__.test_index += 1
1533         # load VNFD and NSD
1534         descriptor_files = glob.glob(self.__class__.scenario_test_path+'/*.yaml')
1535         vnf_descriptors = []
1536         scenario_descriptors = []
1537         for descriptor_file in descriptor_files:
1538             with open(descriptor_file, 'r') as stream:
1539                 descriptor = yaml.load(stream)
1540                 if "vnf" in descriptor or "vnfd:vnfd-catalog" in descriptor or "vnfd-catalog" in descriptor:
1541                     vnf_descriptors.append(descriptor)
1542                 else:
1543                     scenario_descriptors.append(descriptor)
1544
1545         scenario_file = glob.glob(self.__class__.scenario_test_path + '/scenario_*.yaml')
1546         if not vnf_descriptors or not scenario_descriptors or len(scenario_descriptors) > 1:
1547             raise Exception("Test '{}' not valid. It must contain an scenario file and at least one vnfd file'".format(
1548                 test_config["test_folder"]))
1549
1550         # load all vnfd
1551         for vnf_descriptor in vnf_descriptors:
1552             logger.debug("VNF descriptor: {}".format(vnf_descriptor))
1553             vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor, image_name=test_config["image_name"])
1554             logger.debug(vnf)
1555             if 'vnf' in vnf:
1556                 vnf_uuid = vnf['vnf']['uuid']
1557             else:
1558                 vnf_uuid = vnf['vnfd'][0]['uuid']
1559             self.__class__.to_delete_list.insert(0, {"item": "vnf", "function": test_config["client"].delete_vnf,
1560                                                      "params": {"uuid": vnf_uuid}})
1561
1562         # load the scenario definition
1563         for scenario_descriptor in scenario_descriptors:
1564             # networks = scenario_descriptor['scenario']['networks']
1565             # networks[test_config["mgmt_net"]] = networks.pop('mgmt')
1566             logger.debug("Scenario descriptor: {}".format(scenario_descriptor))
1567             scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor)
1568             logger.debug(scenario)
1569             if 'scenario' in scenario:
1570                 scenario_uuid = scenario['scenario']['uuid']
1571             else:
1572                 scenario_uuid = scenario['nsd'][0]['uuid']
1573             self.__class__.to_delete_list.insert(0, {"item": "scenario",
1574                                                      "function": test_config["client"].delete_scenario,
1575                                                      "params": {"uuid": scenario_uuid}})
1576             self.__class__.scenario_uuids.append(scenario_uuid)
1577
1578     def test_010_instantiate_scenario(self):
1579         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1580                                                            inspect.currentframe().f_code.co_name,
1581                                                            test_config["test_folder"])
1582         self.__class__.test_index += 1
1583         for scenario_uuid in self.__class__.scenario_uuids:
1584             instance_descriptor = {
1585                 "instance":{
1586                     "name": self.__class__.test_text,
1587                     "scenario": scenario_uuid,
1588                     "networks":{
1589                         "mgmt": {"sites": [ { "netmap-use": test_config["mgmt_net"]} ]}
1590                     }
1591                 }
1592             }
1593             instance = test_config["client"].create_instance(instance_descriptor)
1594             self.__class__.instance_scenario_uuids.append(instance['uuid'])
1595             logger.debug(instance)
1596             self.__class__.to_delete_list.insert(0, {"item": "instance",
1597                                                      "function": test_config["client"].delete_instance,
1598                                                      "params": {"uuid": instance['uuid']}})
1599
1600     def test_020_check_deployent(self):
1601         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1602                                                            inspect.currentframe().f_code.co_name,
1603                                                            test_config["test_folder"])
1604         self.__class__.test_index += 1
1605
1606         if test_config["manual"]:
1607             raw_input('Scenario has been deployed. Perform manual check and press any key to resume')
1608             return
1609
1610         keep_waiting = test_config["timeout"]
1611         pending_instance_scenario_uuids = list(self.__class__.instance_scenario_uuids)   # make a copy
1612         while pending_instance_scenario_uuids:
1613             index = 0
1614             while index < len(pending_instance_scenario_uuids):
1615                 result = check_instance_scenario_active(pending_instance_scenario_uuids[index])
1616                 if result[0]:
1617                     del pending_instance_scenario_uuids[index]
1618                     break
1619                 elif 'ERROR' in result[1]:
1620                     msg = 'Got error while waiting for the instance to get active: '+result[1]
1621                     logging.error(msg)
1622                     raise Exception(msg)
1623                 index += 1
1624
1625             if keep_waiting >= 5:
1626                 time.sleep(5)
1627                 keep_waiting -= 5
1628             elif keep_waiting > 0:
1629                 time.sleep(keep_waiting)
1630                 keep_waiting = 0
1631             else:
1632                 msg = 'Timeout reached while waiting instance scenario to get active'
1633                 logging.error(msg)
1634                 raise Exception(msg)
1635
1636     def test_030_clean_deployment(self):
1637         self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index,
1638                                                               inspect.currentframe().f_code.co_name,
1639                                                               test_config["test_folder"])
1640         self.__class__.test_index += 1
1641         #At the moment if you delete an scenario right after creating it, in openstack datacenters
1642         #sometimes scenario ports get orphaned. This sleep is just a dirty workaround
1643         time.sleep(5)
1644         for item in self.__class__.to_delete_list:
1645             response = item["function"](**item["params"])
1646             logger.debug(response)
1647
1648
1649 def _get_random_string(maxLength):
1650     '''generates a string with random characters string.letters and string.digits
1651     with a random length up to maxLength characters. If maxLength is <15 it will be changed automatically to 15
1652     '''
1653     prefix = 'testing_'
1654     min_string = 15
1655     minLength = min_string - len(prefix)
1656     if maxLength < min_string: maxLength = min_string
1657     maxLength -= len(prefix)
1658     length = random.randint(minLength,maxLength)
1659     return 'testing_'+"".join([random.choice(string.letters+string.digits) for i in xrange(length)])
1660
1661
1662 def test_vimconnector(args):
1663     global test_config
1664     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
1665     test_config['vimtype'] = args.vimtype
1666     if args.vimtype == "vmware":
1667         import vimconn_vmware as vim
1668
1669         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
1670
1671         tenant_name = args.tenant_name
1672         test_config['tenant'] = tenant_name
1673         config_params = yaml.load(args.config_param)
1674         org_name = config_params.get('orgname')
1675         org_user = config_params.get('user')
1676         org_passwd = config_params.get('passwd')
1677         vim_url = args.endpoint_url
1678         test_config['image_path'] = args.image_path
1679         test_config['image_name'] = args.image_name
1680
1681         # vmware connector obj
1682         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)
1683
1684     elif args.vimtype == "aws":
1685         import vimconn_aws as vim
1686     elif args.vimtype == "openstack":
1687         import vimconn_openstack as vim
1688
1689         test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
1690
1691         tenant_name = args.tenant_name
1692         test_config['tenant'] = tenant_name
1693         config_params = yaml.load(args.config_param)
1694         os_user = config_params.get('user')
1695         os_passwd = config_params.get('passwd')
1696         vim_url = args.endpoint_url
1697         test_config['image_path'] = args.image_path
1698         test_config['image_name'] = args.image_name
1699
1700         # openstack connector obj
1701         vim_persistent_info = {}
1702         test_config['vim_conn'] = vim.vimconnector(
1703             uuid="test-uuid-1", name="VIO-openstack",
1704             tenant_id=None, tenant_name=tenant_name,
1705             url=vim_url, url_admin=None,
1706             user=os_user, passwd=os_passwd,
1707             config=config_params, persistent_info=vim_persistent_info
1708         )
1709         test_config['vim_conn'].debug = "true"
1710
1711     elif args.vimtype == "openvim":
1712         import vimconn_openvim as vim
1713     else:
1714         logger.critical("vimtype '{}' not supported".format(args.vimtype))
1715         sys.exit(1)
1716     executed = 0
1717     failed = 0
1718     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
1719     # If only want to obtain a tests list print it and exit
1720     if args.list_tests:
1721         tests_names = []
1722         for cls in clsmembers:
1723             if cls[0].startswith('test_vimconn'):
1724                 tests_names.append(cls[0])
1725
1726         msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names))
1727         print(msg)
1728         logger.info(msg)
1729         sys.exit(0)
1730
1731     # Create the list of tests to be run
1732     code_based_tests = []
1733     if args.tests:
1734         for test in args.tests:
1735             for t in test.split(','):
1736                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
1737                 if len(matches_code_based_tests) > 0:
1738                     code_based_tests.append(matches_code_based_tests[0][1])
1739                 else:
1740                     logger.critical("Test '{}' is not among the possible ones".format(t))
1741                     sys.exit(1)
1742     if not code_based_tests:
1743         # include all tests
1744         for cls in clsmembers:
1745             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
1746             if cls[0].startswith('test_vimconn'):
1747                 code_based_tests.append(cls[1])
1748
1749     logger.debug("tests to be executed: {}".format(code_based_tests))
1750
1751     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
1752     # This is handled in the tests using logging.
1753     stream = open('/dev/null', 'w')
1754
1755     # Run code based tests
1756     basic_tests_suite = unittest.TestSuite()
1757     for test in code_based_tests:
1758         basic_tests_suite.addTest(unittest.makeSuite(test))
1759     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
1760     executed += result.testsRun
1761     failed += len(result.failures) + len(result.errors)
1762     if failfast and failed:
1763         sys.exit(1)
1764     if len(result.failures) > 0:
1765         logger.debug("failures : {}".format(result.failures))
1766     if len(result.errors) > 0:
1767         logger.debug("errors : {}".format(result.errors))
1768     return executed, failed
1769
1770
1771 def test_vim(args):
1772     global test_config
1773     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
1774     import openmanoclient
1775     executed = 0
1776     failed = 0
1777     test_config["client"] = openmanoclient.openmanoclient(
1778         endpoint_url=args.endpoint_url,
1779         tenant_name=args.tenant_name,
1780         datacenter_name=args.datacenter,
1781         debug=args.debug, logger=test_config["logger_name"])
1782     clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
1783     # If only want to obtain a tests list print it and exit
1784     if args.list_tests:
1785         tests_names = []
1786         for cls in clsmembers:
1787             if cls[0].startswith('test_VIM'):
1788                 tests_names.append(cls[0])
1789
1790         msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names)) +\
1791               "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \
1792               "unless RO has access to the admin endpoint. Therefore this test is excluded by default"
1793         print(msg)
1794         logger.info(msg)
1795         sys.exit(0)
1796
1797     # Create the list of tests to be run
1798     code_based_tests = []
1799     if args.tests:
1800         for test in args.tests:
1801             for t in test.split(','):
1802                 matches_code_based_tests = [item for item in clsmembers if item[0] == t]
1803                 if len(matches_code_based_tests) > 0:
1804                     code_based_tests.append(matches_code_based_tests[0][1])
1805                 else:
1806                     logger.critical("Test '{}' is not among the possible ones".format(t))
1807                     sys.exit(1)
1808     if not code_based_tests:
1809         # include all tests
1810         for cls in clsmembers:
1811             # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
1812             if cls[0].startswith('test_VIM') and cls[0] != 'test_VIM_tenant_operations':
1813                 code_based_tests.append(cls[1])
1814
1815     logger.debug("tests to be executed: {}".format(code_based_tests))
1816
1817     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
1818     # This is handled in the tests using logging.
1819     stream = open('/dev/null', 'w')
1820
1821     # Run code based tests
1822     basic_tests_suite = unittest.TestSuite()
1823     for test in code_based_tests:
1824         basic_tests_suite.addTest(unittest.makeSuite(test))
1825     result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite)
1826     executed += result.testsRun
1827     failed += len(result.failures) + len(result.errors)
1828     if failfast and failed:
1829         sys.exit(1)
1830     if len(result.failures) > 0:
1831         logger.debug("failures : {}".format(result.failures))
1832     if len(result.errors) > 0:
1833         logger.debug("errors : {}".format(result.errors))
1834     return executed, failed
1835
1836
1837 def test_deploy(args):
1838     global test_config
1839     sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro")
1840     import openmanoclient
1841     executed = 0
1842     failed = 0
1843     test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests"
1844     test_config["image_name"] = args.image_name
1845     test_config["mgmt_net"] = args.mgmt_net
1846     test_config["manual"] = args.manual
1847     test_directory_content = os.listdir(test_config["test_directory"])
1848     # If only want to obtain a tests list print it and exit
1849     if args.list_tests:
1850         msg = "the 'deploy' set tests are:\n\t" + ', '.join(sorted(test_directory_content))
1851         print(msg)
1852         # logger.info(msg)
1853         sys.exit(0)
1854
1855     descriptor_based_tests = []
1856     # Create the list of tests to be run
1857     code_based_tests = []
1858     if args.tests:
1859         for test in args.tests:
1860             for t in test.split(','):
1861                 if t in test_directory_content:
1862                     descriptor_based_tests.append(t)
1863                 else:
1864                     logger.critical("Test '{}' is not among the possible ones".format(t))
1865                     sys.exit(1)
1866     if not descriptor_based_tests:
1867         # include all tests
1868         descriptor_based_tests = test_directory_content
1869
1870     logger.debug("tests to be executed: {}".format(code_based_tests))
1871
1872     # import openmanoclient from relative path
1873     test_config["client"] = openmanoclient.openmanoclient(
1874         endpoint_url=args.endpoint_url,
1875         tenant_name=args.tenant_name,
1876         datacenter_name=args.datacenter,
1877         debug=args.debug, logger=test_config["logger_name"])
1878
1879     # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
1880     # This is handled in the tests using logging.
1881     stream = open('/dev/null', 'w')
1882     # This scenario based tests are defined as directories inside the directory defined in 'test_directory'
1883     for test in descriptor_based_tests:
1884         test_config["test_folder"] = test
1885         test_suite = unittest.TestSuite()
1886         test_suite.addTest(unittest.makeSuite(descriptor_based_scenario_test))
1887         result = unittest.TextTestRunner(stream=stream, failfast=False).run(test_suite)
1888         executed += result.testsRun
1889         failed += len(result.failures) + len(result.errors)
1890         if failfast and failed:
1891             sys.exit(1)
1892         if len(result.failures) > 0:
1893             logger.debug("failures : {}".format(result.failures))
1894         if len(result.errors) > 0:
1895             logger.debug("errors : {}".format(result.errors))
1896
1897     return executed, failed
1898
1899 if __name__=="__main__":
1900
1901     parser = ArgumentParser(description='Test RO module')
1902     parser.add_argument('-v','--version', action='version', help="Show current version",
1903                              version='%(prog)s version ' + __version__  + ' ' + version_date)
1904
1905     # Common parameters
1906     parent_parser = ArgumentParser(add_help=False)
1907     parent_parser.add_argument('--failfast', help='Stop when a test fails rather than execute all tests',
1908                       dest='failfast', action="store_true", default=False)
1909     parent_parser.add_argument('--failed', help='Set logs to show only failed tests. --debug disables this option',
1910                       dest='failed', action="store_true", default=False)
1911     default_logger_file = os.path.dirname(__file__)+'/'+os.path.splitext(os.path.basename(__file__))[0]+'.log'
1912     parent_parser.add_argument('--list-tests', help='List all available tests', dest='list_tests', action="store_true",
1913                       default=False)
1914     parent_parser.add_argument('--logger_file', dest='logger_file', default=default_logger_file,
1915                                help='Set the logger file. By default '+default_logger_file)
1916     parent_parser.add_argument("-t", '--tenant', dest='tenant_name', default="osm",
1917                                help="Set the openmano tenant to use for the test. By default 'osm'")
1918     parent_parser.add_argument('--debug', help='Set logs to debug level', dest='debug', action="store_true")
1919     parent_parser.add_argument('--timeout', help='Specify the instantiation timeout in seconds. By default 300',
1920                           dest='timeout', type=int, default=300)
1921     parent_parser.add_argument('--test', '--tests', help='Specify the tests to run', dest='tests', action="append")
1922
1923     subparsers = parser.add_subparsers(help='test sets')
1924
1925     # Deployment test set
1926     # -------------------
1927     deploy_parser = subparsers.add_parser('deploy', parents=[parent_parser],
1928                                           help="test deployment using descriptors at RO_test folder ")
1929     deploy_parser.set_defaults(func=test_deploy)
1930
1931     # Mandatory arguments
1932     mandatory_arguments = deploy_parser.add_argument_group('mandatory arguments')
1933     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
1934     mandatory_arguments.add_argument("-i", '--image-name', required=True, dest="image_name",
1935                                      help='Image name available at datacenter used for the tests')
1936     mandatory_arguments.add_argument("-n", '--mgmt-net-name', required=True, dest='mgmt_net',
1937                                      help='Set the vim management network to use for tests')
1938
1939     # Optional arguments
1940     deploy_parser.add_argument('-m', '--manual-check', dest='manual', action="store_true", default=False,
1941                                help='Pause execution once deployed to allow manual checking of the '
1942                                     'deployed instance scenario')
1943     deploy_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
1944                                help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
1945
1946     # Vimconn test set
1947     # -------------------
1948     vimconn_parser = subparsers.add_parser('vimconn', parents=[parent_parser], help="test vimconnector plugin")
1949     vimconn_parser.set_defaults(func=test_vimconnector)
1950     # Mandatory arguments
1951     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
1952     mandatory_arguments.add_argument('--vimtype', choices=['vmware', 'aws', 'openstack', 'openvim'], required=True,
1953                                      help='Set the vimconnector type to test')
1954     mandatory_arguments.add_argument('-c', '--config', dest='config_param', required=True,
1955                                     help='Set the vimconnector specific config parameters in dictionary format')
1956     mandatory_arguments.add_argument('-u', '--url', dest='endpoint_url',required=True, help="Set the vim connector url or Host IP")
1957     # Optional arguments
1958     vimconn_parser.add_argument('-i', '--image-path', dest='image_path', help="Provide image path present at RO container")
1959     vimconn_parser.add_argument('-n', '--image-name', dest='image_name', help="Provide image name for test")
1960     # TODO add optional arguments for vimconn tests
1961     # vimconn_parser.add_argument("-i", '--image-name', dest='image_name', help='<HELP>'))
1962
1963     # Datacenter test set
1964     # -------------------
1965     vimconn_parser = subparsers.add_parser('vim', parents=[parent_parser], help="test vim")
1966     vimconn_parser.set_defaults(func=test_vim)
1967
1968     # Mandatory arguments
1969     mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments')
1970     mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test')
1971
1972     # Optional arguments
1973     vimconn_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano',
1974                                help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
1975
1976     argcomplete.autocomplete(parser)
1977     args = parser.parse_args()
1978     # print str(args)
1979     test_config = {}
1980
1981     # default logger level is INFO. Options --debug and --failed override this, being --debug prioritary
1982     logger_level = 'INFO'
1983     if args.debug:
1984         logger_level = 'DEBUG'
1985     elif args.failed:
1986         logger_level = 'WARNING'
1987     logger_name = os.path.basename(__file__)
1988     test_config["logger_name"] = logger_name
1989     logger = logging.getLogger(logger_name)
1990     logger.setLevel(logger_level)
1991     failfast = args.failfast
1992
1993     # Configure a logging handler to store in a logging file
1994     if args.logger_file:
1995         fileHandler = logging.FileHandler(args.logger_file)
1996         formatter_fileHandler = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
1997         fileHandler.setFormatter(formatter_fileHandler)
1998         logger.addHandler(fileHandler)
1999
2000     # Configure a handler to print to stdout
2001     consoleHandler = logging.StreamHandler(sys.stdout)
2002     formatter_consoleHandler = logging.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2003     consoleHandler.setFormatter(formatter_consoleHandler)
2004     logger.addHandler(consoleHandler)
2005
2006     logger.debug('Program started with the following arguments: ' + str(args))
2007
2008     # set test config parameters
2009     test_config["timeout"] = args.timeout
2010     test_config["test_number"] = 1
2011
2012     executed, failed = args.func(args)
2013
2014     # Log summary
2015     logger.warning("Total number of tests: {}; Total number of failures/errors: {}".format(executed, failed))
2016     sys.exit(1 if failed else 0)