X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=test%2Ftest_RO.py;h=932853c5037411cb7879dbe78074a3f535545366;hb=0aa0e2fcec7f5c7dcd6d56e2a38f72db327cee50;hp=26a7c94e695d21f0771f80742223eb9cb81c398c;hpb=b36e75da99170c650c999ab2b985a14f3b9a7b5a;p=osm%2FRO.git diff --git a/test/test_RO.py b/test/test_RO.py index 26a7c94e..932853c5 100755 --- a/test/test_RO.py +++ b/test/test_RO.py @@ -20,30 +20,52 @@ # ## -''' +""" Module for testing openmano functionality. It uses openmanoclient.py for invoking openmano -''' -__author__="Pablo Montes, Alfonso Tierno" -__date__ ="$16-Feb-2017 17:08:16$" -__version__="0.0.3" -version_date="May 2017" +""" import logging import os -from argparse import ArgumentParser import argcomplete import unittest import string import inspect import random -import traceback +# import traceback import glob import yaml import sys import time +import uuid +from argparse import ArgumentParser + +__author__ = "Pablo Montes, Alfonso Tierno" +__date__ = "$16-Feb-2017 17:08:16$" +__version__ = "0.1.0" +version_date = "Oct 2017" + +test_config = {} # used for global variables with the test configuration + + +class test_base(unittest.TestCase): + test_index = 1 + test_text = None + + @classmethod + def setUpClass(cls): + logger.info("{}. {}".format(test_config["test_number"], cls.__name__)) + + @classmethod + def tearDownClass(cls): + test_config["test_number"] += 1 -global test_config # used for global variables with the test configuration -test_config = {} + def tearDown(self): + exec_info = sys.exc_info() + if exec_info == (None, None, None): + logger.info(self.__class__.test_text+" -> TEST OK") + else: + logger.warning(self.__class__.test_text+" -> TEST NOK") + logger.critical("Traceback error",exc_info=True) def check_instance_scenario_active(uuid): @@ -67,30 +89,8 @@ def check_instance_scenario_active(uuid): IMPORTANT NOTE All unittest classes for code based tests must have prefix 'test_' in order to be taken into account for tests ''' -class test_VIM_datacenter_tenant_operations(unittest.TestCase): - test_index = 1 +class test_VIM_datacenter_tenant_operations(test_base): tenant_name = None - test_text = None - - @classmethod - def setUpClass(cls): - logger.info("{}. {}".format(test_config["test_number"], cls.__name__)) - - @classmethod - def tearDownClass(cls): - test_config["test_number"] += 1 - - def tearDown(self): - exec_info = sys.exc_info() - if exec_info == (None, None, None): - logger.info(self.__class__.test_text+" -> TEST OK") - else: - logger.warning(self.__class__.test_text+" -> TEST NOK") - error_trace = traceback.format_exception(exec_info[0], exec_info[1], exec_info[2]) - msg = "" - for line in error_trace: - msg = msg + line - logger.critical("{}".format(msg)) def test_000_create_RO_tenant(self): self.__class__.tenant_name = _get_random_string(20) @@ -119,30 +119,8 @@ class test_VIM_datacenter_tenant_operations(unittest.TestCase): assert('deleted' in tenant.get('result',"")) -class test_VIM_datacenter_operations(unittest.TestCase): - test_index = 1 +class test_VIM_datacenter_operations(test_base): datacenter_name = None - test_text = None - - @classmethod - def setUpClass(cls): - logger.info("{}. {}".format(test_config["test_number"], cls.__name__)) - - @classmethod - def tearDownClass(cls): - test_config["test_number"] += 1 - - def tearDown(self): - exec_info = sys.exc_info() - if exec_info == (None, None, None): - logger.info(self.__class__.test_text+" -> TEST OK") - else: - logger.warning(self.__class__.test_text+" -> TEST NOK") - error_trace = traceback.format_exception(exec_info[0], exec_info[1], exec_info[2]) - msg = "" - for line in error_trace: - msg = msg + line - logger.critical("{}".format(msg)) def test_000_create_datacenter(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, @@ -168,217 +146,1829 @@ class test_VIM_datacenter_operations(unittest.TestCase): inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - self.datacenter = test_config["client"].attach_datacenter(name=self.__class__.datacenter_name, - vim_tenant_name='fake') - logger.debug("{}".format(self.datacenter)) - assert ('vim_tenants' in self.datacenter.get('datacenter', {})) + self.datacenter = test_config["client"].attach_datacenter(name=self.__class__.datacenter_name, + vim_tenant_name='fake') + logger.debug("{}".format(self.datacenter)) + assert ('uuid' in self.datacenter.get('datacenter', {})) + + def test_030_list_attached_datacenter(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + self.datacenter = test_config["client"].get_datacenter(all_tenants=False, name=self.__class__.datacenter_name) + logger.debug("{}".format(self.datacenter)) + self.assertEqual (self.datacenter.get('datacenter', {}).get('name', ''), self.__class__.datacenter_name) + + def test_040_detach_datacenter(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + self.datacenter = test_config["client"].detach_datacenter(name=self.__class__.datacenter_name) + logger.debug("{}".format(self.datacenter)) + assert ('detached' in self.datacenter.get('result', "")) + + def test_050_delete_datacenter(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + self.datacenter = test_config["client"].delete_datacenter(name=self.__class__.datacenter_name) + logger.debug("{}".format(self.datacenter)) + assert('deleted' in self.datacenter.get('result',"")) + + +class test_VIM_network_operations(test_base): + vim_network_name = None + vim_network_uuid = None + + def test_000_create_VIM_network(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.vim_network_name = _get_random_string(20) + self.__class__.test_index += 1 + network = test_config["client"].vim_action("create", "networks", name=self.__class__.vim_network_name) + logger.debug("{}".format(network)) + self.__class__.vim_network_uuid = network["network"]["id"] + self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name) + + def test_010_list_VIM_networks(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + networks = test_config["client"].vim_action("list", "networks") + logger.debug("{}".format(networks)) + + def test_020_get_VIM_network_by_uuid(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + network = test_config["client"].vim_action("show", "networks", uuid=self.__class__.vim_network_uuid) + logger.debug("{}".format(network)) + self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name) + + def test_030_delete_VIM_network_by_uuid(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + network = test_config["client"].vim_action("delete", "networks", uuid=self.__class__.vim_network_uuid) + logger.debug("{}".format(network)) + assert ('deleted' in network.get('result', "")) + + +class test_VIM_image_operations(test_base): + + def test_000_list_VIM_images(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + images = test_config["client"].vim_action("list", "images") + logger.debug("{}".format(images)) + +''' +The following is a non critical test that will fail most of the times. +In case of OpenStack datacenter these tests will only success if RO has access to the admin endpoint +This test will only be executed in case it is specifically requested by the user +''' +class test_VIM_tenant_operations(test_base): + vim_tenant_name = None + vim_tenant_uuid = None + + @classmethod + def setUpClass(cls): + test_base.setUpClass(cls) + logger.warning("In case of OpenStack datacenter these tests will only success " + "if RO has access to the admin endpoint") + + def test_000_create_VIM_tenant(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.vim_tenant_name = _get_random_string(20) + self.__class__.test_index += 1 + tenant = test_config["client"].vim_action("create", "tenants", name=self.__class__.vim_tenant_name) + logger.debug("{}".format(tenant)) + self.__class__.vim_tenant_uuid = tenant["tenant"]["id"] + self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name) + + def test_010_list_VIM_tenants(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + tenants = test_config["client"].vim_action("list", "tenants") + logger.debug("{}".format(tenants)) + + def test_020_get_VIM_tenant_by_uuid(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + tenant = test_config["client"].vim_action("show", "tenants", uuid=self.__class__.vim_tenant_uuid) + logger.debug("{}".format(tenant)) + self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name) + + def test_030_delete_VIM_tenant_by_uuid(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + tenant = test_config["client"].vim_action("delete", "tenants", uuid=self.__class__.vim_tenant_uuid) + logger.debug("{}".format(tenant)) + assert ('deleted' in tenant.get('result', "")) + + +class test_vimconn_connect(test_base): + + def test_000_connect(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + + self.__class__.test_index += 1 + if test_config['vimtype'] == 'vmware': + vca_object = test_config["vim_conn"].connect() + logger.debug("{}".format(vca_object)) + self.assertIsNotNone(vca_object) + elif test_config['vimtype'] == 'openstack': + test_config["vim_conn"]._reload_connection() + network_list = test_config["vim_conn"].get_network_list() + logger.debug("{}".format(network_list)) + self.assertIsNotNone(network_list) + +class test_vimconn_new_network(test_base): + network_name = None + + def test_000_new_network(self): + self.__class__.network_name = _get_random_string(20) + network_type = 'bridge' + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type=network_type) + self.__class__.network_id = network + logger.debug("{}".format(network)) + + network_list = test_config["vim_conn"].get_network_list() + for net in network_list: + if self.__class__.network_name in net.get('name'): + self.assertIn(self.__class__.network_name, net.get('name')) + self.assertEqual(net.get('type'), network_type) + + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_010_new_network_by_types(self): + delete_net_ids = [] + network_types = ['data','bridge','mgmt'] + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + for net_type in network_types: + self.__class__.network_name = _get_random_string(20) + network_id, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type=net_type) + + delete_net_ids.append(network_id) + logger.debug("{}".format(network_id)) + + network_list = test_config["vim_conn"].get_network_list() + for net in network_list: + if self.__class__.network_name in net.get('name'): + self.assertIn(self.__class__.network_name, net.get('name')) + if net_type in net.get('type'): + self.assertEqual(net.get('type'), net_type) + else: + self.assertNotEqual(net.get('type'), net_type) + + # Deleting created network + for net_id in delete_net_ids: + result = test_config["vim_conn"].delete_network(net_id) + if result: + logger.info("Network id {} sucessfully deleted".format(net_id)) + else: + logger.info("Failed to delete network id {}".format(net_id)) + + def test_020_new_network_by_ipprofile(self): + test_directory_content = os.listdir(test_config["test_directory"]) + + for dir_name in test_directory_content: + if dir_name == 'simple_multi_vnfc': + self.__class__.scenario_test_path = test_config["test_directory"] + '/'+ dir_name + vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml') + break + + for vnfd in vnfd_files: + with open(vnfd, 'r') as stream: + vnf_descriptor = yaml.load(stream) + + internal_connections_list = vnf_descriptor['vnf']['internal-connections'] + for item in internal_connections_list: + if 'ip-profile' in item: + version = item['ip-profile']['ip-version'] + dhcp_count = item['ip-profile']['dhcp']['count'] + dhcp_enabled = item['ip-profile']['dhcp']['enabled'] + dhcp_start_address = item['ip-profile']['dhcp']['start-address'] + subnet_address = item['ip-profile']['subnet-address'] + + + self.__class__.network_name = _get_random_string(20) + ip_profile = {'dhcp_count': dhcp_count, + 'dhcp_enabled': dhcp_enabled, + 'dhcp_start_address': dhcp_start_address, + 'ip_version': version, + 'subnet_address': subnet_address + } + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type='mgmt', + ip_profile=ip_profile) + self.__class__.network_id = network + logger.debug("{}".format(network)) + + network_list = test_config["vim_conn"].get_network_list() + for net in network_list: + if self.__class__.network_name in net.get('name'): + self.assertIn(self.__class__.network_name, net.get('name')) + + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_030_new_network_by_isshared(self): + self.__class__.network_name = _get_random_string(20) + shared = True + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type='bridge', + shared=shared) + self.__class__.network_id = network + logger.debug("{}".format(network)) + + network_list = test_config["vim_conn"].get_network_list() + for net in network_list: + if self.__class__.network_name in net.get('name'): + self.assertIn(self.__class__.network_name, net.get('name')) + self.assertEqual(net.get('shared'), shared) + + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_040_new_network_by_negative(self): + self.__class__.network_name = _get_random_string(20) + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type='unknowntype') + self.__class__.network_id = network + logger.debug("{}".format(network)) + network_list = test_config["vim_conn"].get_network_list() + for net in network_list: + if self.__class__.network_name in net.get('name'): + self.assertIn(self.__class__.network_name, net.get('name')) + + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_050_refresh_nets_status(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + # creating new network + network_name = _get_random_string(20) + net_type = 'bridge' + network_id, _ = test_config["vim_conn"].new_network(net_name=network_name, + net_type=net_type) + # refresh net status + net_dict = test_config["vim_conn"].refresh_nets_status([network_id]) + for attr in net_dict[network_id]: + if attr == 'status': + self.assertEqual(net_dict[network_id][attr], 'ACTIVE') + + # Deleting created network + result = test_config["vim_conn"].delete_network(network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(network_id)) + else: + logger.info("Failed to delete network id {}".format(network_id)) + + def test_060_refresh_nets_status_negative(self): + unknown_net_id = str(uuid.uuid4()) + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # refresh net status + net_dict = test_config["vim_conn"].refresh_nets_status([unknown_net_id]) + if test_config['vimtype'] == 'openstack': + self.assertEqual(net_dict[unknown_net_id]['status'], 'DELETED') + else: + # TODO : Fix vmware connector to return status DELETED as per vimconn.py + self.assertEqual(net_dict, {}) + +class test_vimconn_get_network_list(test_base): + network_name = None + + def setUp(self): + # creating new network + self.__class__.network_name = _get_random_string(20) + self.__class__.net_type = 'bridge' + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type=self.__class__.net_type) + self.__class__.network_id = network + logger.debug("{}".format(network)) + + def tearDown(self): + test_base.tearDown(self) + + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_000_get_network_list(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + network_list = test_config["vim_conn"].get_network_list() + for net in network_list: + if self.__class__.network_name in net.get('name'): + self.assertIn(self.__class__.network_name, net.get('name')) + self.assertEqual(net.get('type'), self.__class__.net_type) + self.assertEqual(net.get('status'), 'ACTIVE') + self.assertEqual(net.get('shared'), False) + + def test_010_get_network_list_by_name(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + + # find network from list by it's name + new_network_list = test_config["vim_conn"].get_network_list({'name': network_name}) + for list_item in new_network_list: + if self.__class__.network_name in list_item.get('name'): + self.assertEqual(network_name, list_item.get('name')) + self.assertEqual(list_item.get('type'), self.__class__.net_type) + self.assertEqual(list_item.get('status'), 'ACTIVE') + + def test_020_get_network_list_by_id(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # find network from list by it's id + new_network_list = test_config["vim_conn"].get_network_list({'id':self.__class__.network_id}) + for list_item in new_network_list: + if self.__class__.network_id in list_item.get('id'): + self.assertEqual(self.__class__.network_id, list_item.get('id')) + self.assertEqual(list_item.get('type'), self.__class__.net_type) + self.assertEqual(list_item.get('status'), 'ACTIVE') + + def test_030_get_network_list_by_shared(self): + Shared = False + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + # find network from list by it's shared value + new_network_list = test_config["vim_conn"].get_network_list({'shared':Shared, + 'name':network_name}) + for list_item in new_network_list: + if list_item.get('shared') == Shared: + self.assertEqual(list_item.get('shared'), Shared) + self.assertEqual(list_item.get('type'), self.__class__.net_type) + self.assertEqual(network_name, list_item.get('name')) + + def test_040_get_network_list_by_tenant_id(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + tenant_list = test_config["vim_conn"].get_tenant_list() + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + + for tenant_item in tenant_list: + if test_config['tenant'] == tenant_item.get('name'): + # find network from list by it's tenant id + tenant_id = tenant_item.get('id') + new_network_list = test_config["vim_conn"].get_network_list({'tenant_id':tenant_id, + 'name':network_name}) + for list_item in new_network_list: + self.assertEqual(tenant_id, list_item.get('tenant_id')) + self.assertEqual(network_name, list_item.get('name')) + self.assertEqual(list_item.get('type'), self.__class__.net_type) + self.assertEqual(list_item.get('status'), 'ACTIVE') + + def test_050_get_network_list_by_status(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + status = 'ACTIVE' + + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + + # find network from list by it's status + new_network_list = test_config["vim_conn"].get_network_list({'status':status, + 'name': network_name}) + for list_item in new_network_list: + self.assertIn(self.__class__.network_name, list_item.get('name')) + self.assertEqual(list_item.get('type'), self.__class__.net_type) + self.assertEqual(list_item.get('status'), status) + + def test_060_get_network_list_by_negative(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + network_list = test_config["vim_conn"].get_network_list({'name': 'unknown_name'}) + self.assertEqual(network_list, []) + +class test_vimconn_get_network(test_base): + network_name = None + + def setUp(self): + # creating new network + self.__class__.network_name = _get_random_string(20) + self.__class__.net_type = 'bridge' + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type=self.__class__.net_type) + self.__class__.network_id = network + logger.debug("{}".format(network)) + + def tearDown(self): + test_base.tearDown(self) + + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_000_get_network(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + network_info = test_config["vim_conn"].get_network(self.__class__.network_id) + self.assertEqual(network_info.get('status'), 'ACTIVE') + self.assertIn(self.__class__.network_name, network_info.get('name')) + self.assertEqual(network_info.get('type'), self.__class__.net_type) + self.assertEqual(network_info.get('id'), self.__class__.network_id) + + def test_010_get_network_negative(self): + Non_exist_id = str(uuid.uuid4()) + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + with self.assertRaises(Exception) as context: + test_config["vim_conn"].get_network(Non_exist_id) + + self.assertEqual((context.exception).http_code, 404) + +class test_vimconn_delete_network(test_base): + network_name = None + + def test_000_delete_network(self): + # Creating network + self.__class__.network_name = _get_random_string(20) + self.__class__.net_type = 'bridge' + network, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type=self.__class__.net_type) + self.__class__.network_id = network + logger.debug("{}".format(network)) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + time.sleep(5) + # after deleting network we check in network list + network_list = test_config["vim_conn"].get_network_list({ 'id':self.__class__.network_id }) + self.assertEqual(network_list, []) + + def test_010_delete_network_negative(self): + Non_exist_id = str(uuid.uuid4()) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].delete_network(Non_exist_id) + + self.assertEqual((context.exception).http_code, 404) + +class test_vimconn_get_flavor(test_base): + + def test_000_get_flavor(self): + test_directory_content = os.listdir(test_config["test_directory"]) + + for dir_name in test_directory_content: + if dir_name == 'simple_linux': + self.__class__.scenario_test_path = test_config["test_directory"] + '/'+ dir_name + vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml') + break + + for vnfd in vnfd_files: + with open(vnfd, 'r') as stream: + vnf_descriptor = yaml.load(stream) + + vnfc_list = vnf_descriptor['vnf']['VNFC'] + for item in vnfc_list: + if 'ram' in item and 'vcpus' in item and 'disk' in item: + ram = item['ram'] + vcpus = item['vcpus'] + disk = item['disk'] + + flavor_data = { + 'name' : _get_random_string(20), + 'ram': ram, + 'vcpus': vcpus, + 'disk': disk + } + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + # get flavor by id + result = test_config["vim_conn"].get_flavor(flavor_id) + self.assertEqual(ram, result['ram']) + self.assertEqual(vcpus, result['vcpus']) + self.assertEqual(disk, result['disk']) + + # delete flavor + result = test_config["vim_conn"].delete_flavor(flavor_id) + if result: + logger.info("Flavor id {} sucessfully deleted".format(result)) + else: + logger.info("Failed to delete flavor id {}".format(result)) + + def test_010_get_flavor_negative(self): + Non_exist_flavor_id = str(uuid.uuid4()) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].get_flavor(Non_exist_flavor_id) + + self.assertEqual((context.exception).http_code, 404) + +class test_vimconn_new_flavor(test_base): + flavor_id = None + + def test_000_new_flavor(self): + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vpcus': 1, 'disk': 10} + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # create new flavor + self.__class__.flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + self.assertIsInstance(self.__class__.flavor_id, (str, unicode)) + self.assertIsInstance(uuid.UUID(self.__class__.flavor_id), uuid.UUID) + + def test_010_delete_flavor(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # delete flavor + result = test_config["vim_conn"].delete_flavor(self.__class__.flavor_id) + if result: + logger.info("Flavor id {} sucessfully deleted".format(result)) + else: + logger.error("Failed to delete flavor id {}".format(result)) + raise Exception ("Failed to delete created flavor") + + def test_020_new_flavor_negative(self): + Invalid_flavor_data = {'ram': '1024', 'vcpus': 2.0, 'disk': 2.0} + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].new_flavor(Invalid_flavor_data) + + self.assertEqual((context.exception).http_code, 400) + + def test_030_delete_flavor_negative(self): + Non_exist_flavor_id = str(uuid.uuid4()) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].delete_flavor(Non_exist_flavor_id) + + self.assertEqual((context.exception).http_code, 404) + +# class test_vimconn_new_image(test_base): +# +# def test_000_new_image(self): +# self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], +# self.__class__.test_index, +# inspect.currentframe().f_code.co_name) +# self.__class__.test_index += 1 +# +# image_path = test_config['image_path'] +# if image_path: +# self.__class__.image_id = test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : image_path, 'metadata': {'upload_location':None} }) +# time.sleep(20) +# +# self.assertIsInstance(self.__class__.image_id, (str, unicode)) +# self.assertIsInstance(uuid.UUID(self.__class__.image_id), uuid.UUID) +# else: +# self.skipTest("Skipping test as image file not present at RO container") +# +# def test_010_new_image_negative(self): +# Non_exist_image_path = '/temp1/cirros.ovf' +# +# self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], +# self.__class__.test_index, +# inspect.currentframe().f_code.co_name) +# self.__class__.test_index += 1 +# +# with self.assertRaises(Exception) as context: +# test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path}) +# +# self.assertEqual((context.exception).http_code, 400) +# +# def test_020_delete_image(self): +# self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], +# self.__class__.test_index, +# inspect.currentframe().f_code.co_name) +# self.__class__.test_index += 1 +# +# image_id = test_config["vim_conn"].delete_image(self.__class__.image_id) +# +# self.assertIsInstance(image_id, (str, unicode)) +# +# def test_030_delete_image_negative(self): +# Non_exist_image_id = str(uuid.uuid4()) +# +# self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], +# self.__class__.test_index, +# inspect.currentframe().f_code.co_name) +# self.__class__.test_index += 1 +# +# with self.assertRaises(Exception) as context: +# test_config["vim_conn"].delete_image(Non_exist_image_id) +# +# self.assertEqual((context.exception).http_code, 404) + +# class test_vimconn_get_image_id_from_path(test_base): +# +# def test_000_get_image_id_from_path(self): +# self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], +# self.__class__.test_index, +# inspect.currentframe().f_code.co_name) +# self.__class__.test_index += 1 +# +# image_path = test_config['image_path'] +# if image_path: +# image_id = test_config["vim_conn"].get_image_id_from_path( image_path ) +# self.assertEqual(type(image_id),str) +# else: +# self.skipTest("Skipping test as image file not present at RO container") +# +# def test_010_get_image_id_from_path_negative(self): +# Non_exist_image_path = '/temp1/cirros.ovf' +# +# self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], +# self.__class__.test_index, +# inspect.currentframe().f_code.co_name) +# self.__class__.test_index += 1 +# +# with self.assertRaises(Exception) as context: +# test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path }) +# +# self.assertEqual((context.exception).http_code, 400) + +class test_vimconn_get_image_list(test_base): + image_name = None + image_id = None + + def test_000_get_image_list(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + image_list = test_config["vim_conn"].get_image_list() + + for item in image_list: + if 'name' in item: + self.__class__.image_name = item['name'] + self.__class__.image_id = item['id'] + self.assertIsInstance(self.__class__.image_name, (str, unicode)) + self.assertIsInstance(self.__class__.image_id, (str, unicode)) + + def test_010_get_image_list_by_name(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + image_list = test_config["vim_conn"].get_image_list({'name': self.__class__.image_name}) + + for item in image_list: + self.assertIsInstance(item['id'], (str, unicode)) + self.assertIsInstance(item['name'], (str, unicode)) + self.assertEqual(item['id'], self.__class__.image_id) + self.assertEqual(item['name'], self.__class__.image_name) + + def test_020_get_image_list_by_id(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + filter_image_list = test_config["vim_conn"].get_image_list({'id': self.__class__.image_id}) + + for item1 in filter_image_list: + self.assertIsInstance(item1['id'], (str, unicode)) + self.assertIsInstance(item1['name'], (str, unicode)) + self.assertEqual(item1['id'], self.__class__.image_id) + self.assertEqual(item1['name'], self.__class__.image_name) + + def test_030_get_image_list_negative(self): + Non_exist_image_id = uuid.uuid4() + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + image_list = test_config["vim_conn"].get_image_list({'name': 'Unknown_name', 'id': Non_exist_image_id}) + + self.assertIsNotNone(image_list, None) + self.assertEqual(image_list, []) + +class test_vimconn_new_vminstance(test_base): + network_name = None + net_type = None + network_id = None + image_id = None + instance_id = None + + def setUp(self): + # create network + self.__class__.network_name = _get_random_string(20) + self.__class__.net_type = 'bridge' + + self.__class__.network_id, _ = test_config["vim_conn"].new_network(net_name=self.__class__.network_name, + net_type=self.__class__.net_type) + # find image name and image id + if test_config['image_name']: + image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']}) + if len(image_list) == 0: + raise Exception("Image {} is not found at VIM".format(test_config['image_name'])) + else: + self.__class__.image_id = image_list[0]['id'] + else: + image_list = test_config['vim_conn'].get_image_list() + if len(image_list) == 0: + raise Exception("Not found any image at VIM") + else: + self.__class__.image_id = image_list[0]['id'] + + def tearDown(self): + test_base.tearDown(self) + # Deleting created network + result = test_config["vim_conn"].delete_network(self.__class__.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.__class__.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.__class__.network_id)) + + def test_000_new_vminstance(self): + vpci = "0000:00:11.0" + name = "eth0" + + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + 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}] + + 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) + + self.assertIsInstance(self.__class__.instance_id, (str, unicode)) + + def test_010_new_vminstance_by_model(self): + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} + model_name = 'e1000' + name = 'eth0' + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + 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}] + + 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) + + self.assertIsInstance(instance_id, (str, unicode)) + + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_020_new_vminstance_by_net_use(self): + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} + net_use = 'data' + name = 'eth0' + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': net_use, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id,disk_list=None, + flavor_id=flavor_id, + net_list=net_list) + self.assertIsInstance(instance_id, (str, unicode)) + + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_030_new_vminstance_by_net_type(self): + flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} + _type = 'VF' + name = 'eth0' + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + if test_config['vimtype'] == 'vmware': + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, + 'type': _type, 'net_id': self.__class__.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id, + flavor_id=flavor_id, + net_list=net_list) + self.assertEqual(type(instance_id),str) + + if test_config['vimtype'] == 'openstack': + # create network of type data + network_name = _get_random_string(20) + net_type = 'data' + + network_id, _ = test_config["vim_conn"].new_network(net_name=network_name, + net_type=net_type) + net_list = [{'use': net_type, 'name': name, 'floating_ip': False, 'port_security': True, + 'type': _type, 'net_id': network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, + image_id=self.__class__.image_id, disk_list=None, + flavor_id=flavor_id, + net_list=net_list) + + self.assertEqual(type(instance_id), unicode) + + # delete created network + result = test_config["vim_conn"].delete_network(network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(network_id)) + else: + logger.info("Failed to delete network id {}".format(network_id)) + + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_040_new_vminstance_by_cloud_config(self): + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} + name = 'eth0' + user_name = 'test_user' + + key_pairs = ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy2w9GHMKKNkpCmrDK2ovc3XBYDETuLWwaW24S+feHhLBQiZlzh3gSQoINlA+2ycM9zYbxl4BGzEzpTVyCQFZv5PidG4m6ox7LR+KYkDcITMyjsVuQJKDvt6oZvRt6KbChcCi0n2JJD/oUiJbBFagDBlRslbaFI2mmqmhLlJ5TLDtmYxzBLpjuX4m4tv+pdmQVfg7DYHsoy0hllhjtcDlt1nn05WgWYRTu7mfQTWfVTavu+OjIX3e0WN6NW7yIBWZcE/Q9lC0II3W7PZDE3QaT55se4SPIO2JTdqsx6XGbekdG1n6adlduOI27sOU5m4doiyJ8554yVbuDB/z5lRBD alfonso.tiernosepulveda@telefonica.com'] + + users_data = [{'key-pairs': ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy2w9GHMKKNkpCmrDK2ovc3XBYDETuLWwaW24S+feHhLBQiZlzh3gSQoINlA+2ycM9zYbxl4BGzEzpTVyCQFZv5PidG4m6ox7LR+KYkDcITMyjsVuQJKDvt6oZvRt6KbChcCi0n2JJD/oUiJbBFagDBlRslbaFI2mmqmhLlJ5TLDtmYxzBLpjuX4m4tv+pdmQVfg7DYHsoy0hllhjtcDlt1nn05WgWYRTu7mfQTWfVTavu+OjIX3e0WN6NW7yIBWZcE/Q9lC0II3W7PZDE3QaT55se4SPIO2JTdqsx6XGbekdG1n6adlduOI27sOU5m4doiyJ8554yVbuDB/z5lRBD alfonso.tiernosepulveda@telefonica.com'], 'name': user_name}] + + 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 } + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Cloud_vm', description='', start=False, + image_id=self.__class__.image_id, flavor_id=flavor_id,net_list=net_list,cloud_config=cloud_data) + + self.assertIsInstance(instance_id, (str, unicode)) + + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_050_new_vminstance_by_disk_list(self): + flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} + name = 'eth0' + + device_data = [{'image_id': self.__class__.image_id, 'size': '10'}] + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='VM_test1', description='', start=False, image_id=self.__class__.image_id, + flavor_id=flavor_id, + net_list=net_list, + disk_list=device_data) + + self.assertIsInstance(instance_id, (str, unicode)) + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_060_new_vminstance_negative(self): + unknown_flavor_id = str(uuid.uuid4()) + unknown_image_id = str(uuid.uuid4()) + name = 'eth2' + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=unknown_image_id, + flavor_id=unknown_flavor_id, + net_list=net_list) + + self.assertIn((context.exception).http_code, (400, 404)) + + + def test_070_get_vminstance(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # Get instance by its id + vm_info = test_config["vim_conn"].get_vminstance(self.__class__.instance_id) + + if test_config['vimtype'] == 'vmware': + for attr in vm_info: + if attr == 'status': + self.assertEqual(vm_info[attr], 'ACTIVE') + if attr == 'hostId': + self.assertEqual(type(vm_info[attr]), str) + if attr == 'interfaces': + self.assertEqual(type(vm_info[attr]), list) + self.assertEqual(vm_info[attr][0]['IsConnected'], 'true') + if attr == 'IsEnabled': + self.assertEqual(vm_info[attr], 'true') + + def test_080_get_vminstance_negative(self): + unknown_instance_id = str(uuid.uuid4()) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].get_vminstance(unknown_instance_id) + + self.assertEqual((context.exception).http_code, 404) + + def test_090_refresh_vms_status(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + if test_config['vimtype'] == 'vmware': + vm_list = [] + vm_list.append(self.__class__.instance_id) + + # refresh vm status + vm_info = test_config["vim_conn"].refresh_vms_status(vm_list) + for attr in vm_info[self.__class__.instance_id]: + if attr == 'status': + self.assertEqual(vm_info[self.__class__.instance_id][attr], 'ACTIVE') + if attr == 'interfaces': + self.assertEqual(type(vm_info[self.__class__.instance_id][attr]), list) + + if test_config['vimtype'] == 'openstack': + vpci = "0000:00:11.0" + name = "eth0" + + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + # create new vm instance + 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}] + + 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) + + time.sleep(30) + vm_list = [] + vm_list.append(instance_id) + + # refresh vm status + vm_info = test_config["vim_conn"].refresh_vms_status(vm_list) + for attr in vm_info[instance_id]: + if attr == 'status': + self.assertEqual(vm_info[instance_id][attr], 'ACTIVE') + if attr == 'interfaces': + self.assertEqual(type(vm_info[instance_id][attr]), list) + + #Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + + def test_100_refresh_vms_status_negative(self): + unknown_id = str(uuid.uuid4()) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + vm_dict = test_config["vim_conn"].refresh_vms_status([unknown_id]) + + if test_config['vimtype'] == 'vmware': + self.assertEqual(vm_dict,{}) + + if test_config['vimtype'] == 'openstack': + self.assertEqual(vm_dict[unknown_id]['status'], 'DELETED') + + def test_110_action_vminstance(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + if test_config['vimtype'] == 'vmware': + action_list = ['shutdown', 'start', 'shutoff', 'rebuild', 'pause', 'resume'] + # various action on vminstace + for action in action_list: + instance_id = test_config["vim_conn"].action_vminstance(self.__class__.instance_id, + {action: None}) + self.assertEqual(instance_id, self.__class__.instance_id) + + if test_config['vimtype'] == 'openstack': + # create new vm instance + vpci = "0000:00:11.0" + name = "eth0" + + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + 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}] + + 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) + + action_list = ['shutdown','start','shutoff','rebuild','start','pause','start'] + + # various action on vminstace + for action in action_list: + # sleep for sometime till status is changed + time.sleep(25) + instance_id = test_config["vim_conn"].action_vminstance(new_instance_id, + { action: None}) + + self.assertTrue(instance_id is None) + + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(new_instance_id) + time.sleep(10) + + def test_120_action_vminstance_negative(self): + non_exist_id = str(uuid.uuid4()) + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + action = 'start' + with self.assertRaises(Exception) as context: + test_config["vim_conn"].action_vminstance(non_exist_id, { action: None}) + + self.assertEqual((context.exception).http_code, 404) + + + def test_130_delete_vminstance(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # Deleting created vm instance + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(self.__class__.instance_id) + time.sleep(10) + + def test_140_new_vminstance_sriov(self): + logger.info("Testing creation of sriov vm instance using {}".format(test_config['sriov_net_name'])) + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} + name = 'eth0' + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + sriov_net_name = test_config['sriov_net_name'] + new_network_list = test_config["vim_conn"].get_network_list({'name': sriov_net_name}) + for list_item in new_network_list: + self.assertEqual(sriov_net_name, list_item.get('name')) + self.__class__.sriov_network_id = list_item.get('id') + + net_list = [{'use': 'data', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'VF', 'net_id': self.__class__.sriov_network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_sriov_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list) + + self.assertIsInstance(instance_id, (str, unicode)) + + logger.info("Waiting for created sriov-vm intance") + time.sleep(10) + # Deleting created vm instance + logger.info("Deleting created sriov-vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + +class test_vimconn_get_tenant_list(test_base): + tenant_id = None + + def test_000_get_tenant_list(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # Getting tenant list + tenant_list = test_config["vim_conn"].get_tenant_list() + + for item in tenant_list: + if test_config['tenant'] == item['name']: + self.__class__.tenant_id = item['id'] + self.assertIsInstance(item['name'], (str, unicode)) + self.assertIsInstance(item['id'], (str, unicode)) + + def test_010_get_tenant_list_by_id(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # Getting filter tenant list by its id + filter_tenant_list = test_config["vim_conn"].get_tenant_list({'id': self.__class__.tenant_id}) + + for item in filter_tenant_list: + self.assertIsInstance(item['id'], (str, unicode)) + self.assertEqual(item['id'], self.__class__.tenant_id) + + def test_020_get_tenant_list_by_name(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # Getting filter tenant list by its name + filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant']}) + + for item in filter_tenant_list: + self.assertIsInstance(item['name'], (str, unicode)) + self.assertEqual(item['name'], test_config['tenant']) + + def test_030_get_tenant_list_by_name_and_id(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + # Getting filter tenant list by its name and id + filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant'], + 'id': self.__class__.tenant_id}) + + for item in filter_tenant_list: + self.assertIsInstance(item['name'], (str, unicode)) + self.assertIsInstance(item['id'], (str, unicode)) + self.assertEqual(item['name'], test_config['tenant']) + self.assertEqual(item['id'], self.__class__.tenant_id) + + def test_040_get_tenant_list_negative(self): + non_exist_tenant_name = "Tenant_123" + non_exist_tenant_id = "kjhgrt456-45345kjhdfgnbdk-34dsfjdfg" + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': non_exist_tenant_name, + 'id': non_exist_tenant_id}) + + self.assertEqual(filter_tenant_list, []) + + +class test_vimconn_new_tenant(test_base): + tenant_id = None + + def test_000_new_tenant(self): + tenant_name = _get_random_string(20) + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + self.__class__.tenant_id = test_config["vim_conn"].new_tenant(tenant_name, "") + time.sleep(15) + + self.assertIsInstance(self.__class__.tenant_id, (str, unicode)) + + + def test_010_new_tenant_negative(self): + Invalid_tenant_name = 10121 + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].new_tenant(Invalid_tenant_name, "") + + self.assertEqual((context.exception).http_code, 400) + + + def test_020_delete_tenant(self): + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + tenant_id = test_config["vim_conn"].delete_tenant(self.__class__.tenant_id) + + self.assertIsInstance(tenant_id, (str, unicode)) + + def test_030_delete_tenant_negative(self): + Non_exist_tenant_name = 'Test_30_tenant' + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].delete_tenant(Non_exist_tenant_name) + + self.assertEqual((context.exception).http_code, 404) + + +def get_image_id(): + if test_config['image_name']: + image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']}) + if len(image_list) == 0: + raise Exception("Image {} is not found at VIM".format(test_config['image_name'])) + else: + image_id = image_list[0]['id'] + else: + image_list = test_config['vim_conn'].get_image_list() + if len(image_list) == 0: + raise Exception("Not found any image at VIM") + else: + image_id = image_list[0]['id'] + return image_id + + +class test_vimconn_vminstance_by_ip_address(test_base): + network_name = None + network_id = None + + def setUp(self): + # create network + self.network_name = _get_random_string(20) + + self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name, + net_type='bridge') + + def tearDown(self): + test_base.tearDown(self) + # Deleting created network + result = test_config["vim_conn"].delete_network(self.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.network_id)) + else: + logger.info("Failed to delete network id {}".format(self.network_id)) + + + def test_000_vminstance_by_ip_address(self): + """ + This test case will deploy VM with provided IP address + Pre-requesite: provided IP address should be from IP pool range which has used for network creation + """ + name = "eth0" + # provide ip address + ip_address = '' + + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', + 'net_id': self.network_id, 'ip_address': ip_address}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list) + + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_010_vminstance_by_ip_address_negative(self): + name = "eth1" + # IP address not from subnet range + invalid_ip_address = '10.10.12.1' + + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', + 'net_id': self.network_id, 'ip_address': invalid_ip_address}] + + with self.assertRaises(Exception) as context: + test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, + net_list=net_list) + self.assertEqual((context.exception).http_code, 400) + + def test_020_vminstance_by_floating_ip(self): + name = "eth1" + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 + + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': True, 'port_security': True, 'type': 'virtual', + 'net_id': self.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list) + + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_030_vminstance_by_mac_address(self): + name = "eth1" + mac_address = "74:54:2f:21:da:8c" + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) + self.__class__.test_index += 1 - def test_030_list_attached_datacenter(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', + 'net_id': self.network_id,'mac_address': mac_address}] - self.__class__.test_index += 1 - self.datacenter = test_config["client"].get_datacenter(all_tenants=False, name=self.__class__.datacenter_name) - logger.debug("{}".format(self.datacenter)) - self.assertEqual (self.datacenter.get('datacenter', {}).get('name', ''), self.__class__.datacenter_name) + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list) - def test_040_detach_datacenter(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) - self.__class__.test_index += 1 - self.datacenter = test_config["client"].detach_datacenter(name=self.__class__.datacenter_name) - logger.debug("{}".format(self.datacenter)) - assert ('detached' in self.datacenter.get('result', "")) +class test_vimconn_vminstance_by_adding_10_nics(test_base): + network_name = None + net_ids = [] - def test_050_delete_datacenter(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + def setUp(self): + # create network + i = 0 + for i in range(10): + self.network_name = _get_random_string(20) + network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name, + net_type='bridge') + self.net_ids.append(network_id) + + def tearDown(self): + test_base.tearDown(self) + # Deleting created network + for net_id in self.net_ids: + result = test_config["vim_conn"].delete_network(net_id) + if result: + logger.info("Network id {} sucessfully deleted".format(net_id)) + else: + logger.info("Failed to delete network id {}".format(net_id)) + def test_000_vminstance_by_adding_10_nics(self): + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - self.datacenter = test_config["client"].delete_datacenter(name=self.__class__.datacenter_name) - logger.debug("{}".format(self.datacenter)) - assert('deleted' in self.datacenter.get('result',"")) + net_list = [] + c = 1 + for net_id in self.net_ids: + name = "eth{}".format(c) + net_list.append({'use': 'bridge', 'name': name, 'floating_ip': False, + 'port_security': True, 'type': 'virtual', 'net_id': net_id}) + c = c+1 -class test_VIM_network_operations(unittest.TestCase): - test_index = 1 - vim_network_name = None - test_text = None - vim_network_uuid = None + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list) - @classmethod - def setUpClass(cls): - logger.info("{}. {}".format(test_config["test_number"], cls.__name__)) + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) - @classmethod - def tearDownClass(cls): - test_config["test_number"] += 1 + +class test_vimconn_vminstance_by_existing_disk(test_base): + network_name = None + network_id = None + + def setUp(self): + # create network + self.network_name = _get_random_string(20) + self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name, + net_type='bridge') def tearDown(self): - exec_info = sys.exc_info() - if exec_info == (None, None, None): - logger.info(self.__class__.test_text + " -> TEST OK") + test_base.tearDown(self) + # Deleting created network + result = test_config["vim_conn"].delete_network(self.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.network_id)) else: - logger.warning(self.__class__.test_text + " -> TEST NOK") - error_trace = traceback.format_exception(exec_info[0], exec_info[1], exec_info[2]) - msg = "" - for line in error_trace: - msg = msg + line - logger.critical("{}".format(msg)) + logger.info("Failed to delete network id {}".format(self.network_id)) - def test_000_create_VIM_network(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) - self.__class__.vim_network_name = _get_random_string(20) - self.__class__.test_index += 1 - network = test_config["client"].vim_action("create", "networks", name=self.__class__.vim_network_name) - logger.debug("{}".format(network)) - self.__class__.vim_network_uuid = network["network"]["id"] - self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name) - def test_010_list_VIM_networks(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + def test_000_vminstance_by_existing_disk(self): + """ This testcase will add existing disk only if given catalog/image is free + means not used by any other VM + """ + + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + name = "eth10" + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + cirros_image = test_config["vim_conn"].get_image_list({'name': 'cirros'}) + disk_list = [{'image_id': cirros_image[0]['id'],'size': 5}] + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - networks = test_config["client"].vim_action("list", "networks") - logger.debug("{}".format(networks)) - def test_020_get_VIM_network_by_uuid(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, + 'type': 'virtual', 'net_id': self.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list,disk_list=disk_list) + + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_010_vminstance_by_new_disk(self): + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + name = "eth10" + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + disk_list = [{'size': '5'}] + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - network = test_config["client"].vim_action("show", "networks", uuid=self.__class__.vim_network_uuid) - logger.debug("{}".format(network)) - self.assertEqual(network.get('network', {}).get('name', ''), self.__class__.vim_network_name) - def test_030_delete_VIM_network_by_uuid(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, + 'type': 'virtual', 'net_id': self.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list,disk_list=disk_list) + + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + + def test_020_vminstance_by_CDROM(self): + """ This testcase will insert media file only if provided catalog + has pre-created ISO media file into vCD + """ + flavor_data ={'ram': 1024, 'vcpus': 1, 'disk': 10} + name = "eth10" + image_list = test_config["vim_conn"].get_image_list({'name':'Ubuntu'}) + disk_list = [{'image_id':image_list[0]['id'],'device_type':'cdrom'}] + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + # find image name and image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - network = test_config["client"].vim_action("delete", "networks", uuid=self.__class__.vim_network_uuid) - logger.debug("{}".format(network)) - assert ('deleted' in network.get('result', "")) + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, + 'type': 'virtual', 'net_id': self.network_id}] -class test_VIM_image_operations(unittest.TestCase): - test_index = 1 - test_text = None + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list,disk_list=disk_list ) - @classmethod - def setUpClass(cls): - logger.info("{}. {}".format(test_config["test_number"], cls.__name__)) + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) - @classmethod - def tearDownClass(cls): - test_config["test_number"] += 1 + +class test_vimconn_vminstance_by_affinity_anti_affinity(test_base): + network_name = None + network_id = None + + def setUp(self): + # create network + self.network_name = _get_random_string(20) + self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name, + net_type='bridge') def tearDown(self): - exec_info = sys.exc_info() - if exec_info == (None, None, None): - logger.info(self.__class__.test_text + " -> TEST OK") + test_base.tearDown(self) + # Deleting created network + result = test_config["vim_conn"].delete_network(self.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.network_id)) else: - logger.warning(self.__class__.test_text + " -> TEST NOK") - error_trace = traceback.format_exception(exec_info[0], exec_info[1], exec_info[2]) - msg = "" - for line in error_trace: - msg = msg + line - logger.critical("{}".format(msg)) + logger.info("Failed to delete network id {}".format(self.network_id)) - def test_000_list_VIM_images(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + def test_000_vminstance_by_affinity_anti_affinity(self): + """ This testcase will deploy VM into provided HOSTGROUP in VIM config + Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used + While creating VIM account user has to pass the Host Group names in availability_zone list + """ + flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + name = "eth10" + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + # find image name and image id + image_id = get_image_id() + + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - images = test_config["client"].vim_action("list", "images") - logger.debug("{}".format(images)) -''' -The following is a non critical test that will fail most of the times. -In case of OpenStack datacenter these tests will only success if RO has access to the admin endpoint -This test will only be executed in case it is specifically requested by the user -''' -class test_VIM_tenant_operations(unittest.TestCase): - test_index = 1 - vim_tenant_name = None - test_text = None - vim_tenant_uuid = None + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, + 'type': 'virtual', 'net_id': self.network_id}] - @classmethod - def setUpClass(cls): - logger.info("{}. {}".format(test_config["test_number"], cls.__name__)) - logger.warning("In case of OpenStack datacenter these tests will only success " - "if RO has access to the admin endpoint") + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list,availability_zone_index=1, + availability_zone_list=['HG_174','HG_175']) - @classmethod - def tearDownClass(cls): - test_config["test_number"] += 1 + self.assertEqual(type(instance_id),str) + time.sleep(10) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + +class test_vimconn_vminstance_by_numa_affinity(test_base): + network_name = None + network_id = None + + def setUp(self): + # create network + self.network_name = _get_random_string(20) + self.network_id, _ = test_config["vim_conn"].new_network(net_name=self.network_name, + net_type='bridge') def tearDown(self): - exec_info = sys.exc_info() - if exec_info == (None, None, None): - logger.info(self.__class__.test_text + " -> TEST OK") + test_base.tearDown(self) + # Deleting created network + result = test_config["vim_conn"].delete_network(self.network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(self.network_id)) else: - logger.warning(self.__class__.test_text + " -> TEST NOK") - error_trace = traceback.format_exception(exec_info[0], exec_info[1], exec_info[2]) - msg = "" - for line in error_trace: - msg = msg + line - logger.critical("{}".format(msg)) + logger.info("Failed to delete network id {}".format(self.network_id)) - def test_000_create_VIM_tenant(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) - self.__class__.vim_tenant_name = _get_random_string(20) - self.__class__.test_index += 1 - tenant = test_config["client"].vim_action("create", "tenants", name=self.__class__.vim_tenant_name) - logger.debug("{}".format(tenant)) - self.__class__.vim_tenant_uuid = tenant["tenant"]["id"] - self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name) + def test_000_vminstance_by_numa_affinity(self): + flavor_data = {'extended': {'numas': [{'paired-threads-id': [['1', '3'], ['2', '4']], + ' paired-threads': 2, 'memory': 1}]}, + 'ram': 1024, 'vcpus': 1, 'disk': 10} + name = "eth10" - def test_010_list_VIM_tenants(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) - self.__class__.test_index += 1 - tenants = test_config["client"].vim_action("list", "tenants") - logger.debug("{}".format(tenants)) + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) - def test_020_get_VIM_tenant_by_uuid(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + # find image name and image id + image_id = get_image_id() + self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], + self.__class__.test_index, + inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - tenant = test_config["client"].vim_action("show", "tenants", uuid=self.__class__.vim_tenant_uuid) - logger.debug("{}".format(tenant)) - self.assertEqual(tenant.get('tenant', {}).get('name', ''), self.__class__.vim_tenant_name) - def test_030_delete_VIM_tenant_by_uuid(self): - self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, - inspect.currentframe().f_code.co_name) + net_list = [{'use': 'bridge', 'name': name, 'floating_ip': False, 'port_security': True, + 'type': 'virtual', 'net_id': self.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=image_id, + flavor_id=flavor_id, net_list=net_list) + + self.assertEqual(type(instance_id),str) + logger.info("Deleting created vm instance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) - self.__class__.test_index += 1 - tenant = test_config["client"].vim_action("delete", "tenants", uuid=self.__class__.vim_tenant_uuid) - logger.debug("{}".format(tenant)) - assert ('deleted' in tenant.get('result', "")) ''' IMPORTANT NOTE The following unittest class does not have the 'test_' on purpose. This test is the one used for the scenario based tests. ''' -class descriptor_based_scenario_test(unittest.TestCase): +class descriptor_based_scenario_test(test_base): test_index = 0 - test_text = None scenario_test_path = None - scenario_uuid = None - instance_scenario_uuid = None - to_delete_list = [] @classmethod def setUpClass(cls): cls.test_index = 1 cls.to_delete_list = [] + cls.scenario_uuids = [] + cls.instance_scenario_uuids = [] cls.scenario_test_path = test_config["test_directory"] + '/' + test_config["test_folder"] logger.info("{}. {} {}".format(test_config["test_number"], cls.__name__, test_config["test_folder"])) @@ -386,73 +1976,77 @@ class descriptor_based_scenario_test(unittest.TestCase): def tearDownClass(cls): test_config["test_number"] += 1 - def tearDown(self): - exec_info = sys.exc_info() - if exec_info == (None, None, None): - logger.info(self.__class__.test_text + " -> TEST OK") - else: - logger.warning(self.__class__.test_text + " -> TEST NOK") - error_trace = traceback.format_exception(exec_info[0], exec_info[1], exec_info[2]) - msg = "" - for line in error_trace: - msg = msg + line - logger.critical("{}".format(msg)) - - def test_000_load_scenario(self): self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index, inspect.currentframe().f_code.co_name, test_config["test_folder"]) self.__class__.test_index += 1 - vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml') + # load VNFD and NSD + descriptor_files = glob.glob(self.__class__.scenario_test_path+'/*.yaml') + vnf_descriptors = [] + scenario_descriptors = [] + for descriptor_file in descriptor_files: + with open(descriptor_file, 'r') as stream: + descriptor = yaml.load(stream) + if "vnf" in descriptor or "vnfd:vnfd-catalog" in descriptor or "vnfd-catalog" in descriptor: + vnf_descriptors.append(descriptor) + else: + scenario_descriptors.append(descriptor) + scenario_file = glob.glob(self.__class__.scenario_test_path + '/scenario_*.yaml') - if len(vnfd_files) == 0 or len(scenario_file) > 1: + if not vnf_descriptors or not scenario_descriptors or len(scenario_descriptors) > 1: raise Exception("Test '{}' not valid. It must contain an scenario file and at least one vnfd file'".format( test_config["test_folder"])) - #load all vnfd - for vnfd in vnfd_files: - with open(vnfd, 'r') as stream: - vnf_descriptor = yaml.load(stream) - - vnfc_list = vnf_descriptor['vnf']['VNFC'] - for vnfc in vnfc_list: - vnfc['image name'] = test_config["image_name"] - devices = vnfc.get('devices',[]) - for device in devices: - if device['type'] == 'disk' and 'image name' in device: - device['image name'] = test_config["image_name"] - + # load all vnfd + for vnf_descriptor in vnf_descriptors: logger.debug("VNF descriptor: {}".format(vnf_descriptor)) - vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor) + vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor, image_name=test_config["image_name"]) logger.debug(vnf) + if 'vnf' in vnf: + vnf_uuid = vnf['vnf']['uuid'] + else: + vnf_uuid = vnf['vnfd'][0]['uuid'] self.__class__.to_delete_list.insert(0, {"item": "vnf", "function": test_config["client"].delete_vnf, - "params": {"uuid": vnf['vnf']['uuid']}}) - - #load the scenario definition - with open(scenario_file[0], 'r') as stream: - scenario_descriptor = yaml.load(stream) - networks = scenario_descriptor['scenario']['networks'] - networks[test_config["mgmt_net"]] = networks.pop('mgmt') - logger.debug("Scenario descriptor: {}".format(scenario_descriptor)) - scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor) - logger.debug(scenario) - self.__class__.to_delete_list.insert(0,{"item": "scenario", "function": test_config["client"].delete_scenario, - "params":{"uuid": scenario['scenario']['uuid']} }) - self.__class__.scenario_uuid = scenario['scenario']['uuid'] + "params": {"uuid": vnf_uuid}}) + + # load the scenario definition + for scenario_descriptor in scenario_descriptors: + # networks = scenario_descriptor['scenario']['networks'] + # networks[test_config["mgmt_net"]] = networks.pop('mgmt') + logger.debug("Scenario descriptor: {}".format(scenario_descriptor)) + scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor) + logger.debug(scenario) + if 'scenario' in scenario: + scenario_uuid = scenario['scenario']['uuid'] + else: + scenario_uuid = scenario['nsd'][0]['uuid'] + self.__class__.to_delete_list.insert(0, {"item": "scenario", + "function": test_config["client"].delete_scenario, + "params": {"uuid": scenario_uuid}}) + self.__class__.scenario_uuids.append(scenario_uuid) def test_010_instantiate_scenario(self): self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index, inspect.currentframe().f_code.co_name, test_config["test_folder"]) self.__class__.test_index += 1 - - instance = test_config["client"].create_instance(scenario_id=self.__class__.scenario_uuid, - name=self.__class__.test_text) - self.__class__.instance_scenario_uuid = instance['uuid'] - logger.debug(instance) - self.__class__.to_delete_list.insert(0, {"item": "instance", "function": test_config["client"].delete_instance, - "params": {"uuid": instance['uuid']}}) + for scenario_uuid in self.__class__.scenario_uuids: + instance_descriptor = { + "instance":{ + "name": self.__class__.test_text, + "scenario": scenario_uuid, + "networks":{ + "mgmt": {"sites": [ { "netmap-use": test_config["mgmt_net"]} ]} + } + } + } + instance = test_config["client"].create_instance(instance_descriptor) + self.__class__.instance_scenario_uuids.append(instance['uuid']) + logger.debug(instance) + self.__class__.to_delete_list.insert(0, {"item": "instance", + "function": test_config["client"].delete_instance, + "params": {"uuid": instance['uuid']}}) def test_020_check_deployent(self): self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index, @@ -465,15 +2059,19 @@ class descriptor_based_scenario_test(unittest.TestCase): return keep_waiting = test_config["timeout"] - instance_active = False - while True: - result = check_instance_scenario_active(self.__class__.instance_scenario_uuid) - if result[0]: - break - elif 'ERROR' in result[1]: - msg = 'Got error while waiting for the instance to get active: '+result[1] - logging.error(msg) - raise Exception(msg) + pending_instance_scenario_uuids = list(self.__class__.instance_scenario_uuids) # make a copy + while pending_instance_scenario_uuids: + index = 0 + while index < len(pending_instance_scenario_uuids): + result = check_instance_scenario_active(pending_instance_scenario_uuids[index]) + if result[0]: + del pending_instance_scenario_uuids[index] + break + elif 'ERROR' in result[1]: + msg = 'Got error while waiting for the instance to get active: '+result[1] + logging.error(msg) + raise Exception(msg) + index += 1 if keep_waiting >= 5: time.sleep(5) @@ -515,12 +2113,54 @@ def _get_random_string(maxLength): def test_vimconnector(args): global test_config sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro") + test_config['vimtype'] = args.vimtype if args.vimtype == "vmware": import vimconn_vmware as vim + + test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests" + + tenant_name = args.tenant_name + test_config['tenant'] = tenant_name + config_params = yaml.load(args.config_param) + org_name = config_params.get('orgname') + org_user = config_params.get('user') + org_passwd = config_params.get('passwd') + vim_url = args.endpoint_url + test_config['image_path'] = args.image_path + test_config['image_name'] = args.image_name + test_config['sriov_net_name'] = args.sriov_net_name + + # vmware connector obj + 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) + elif args.vimtype == "aws": import vimconn_aws as vim elif args.vimtype == "openstack": import vimconn_openstack as vim + + test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests" + + tenant_name = args.tenant_name + test_config['tenant'] = tenant_name + config_params = yaml.load(args.config_param) + os_user = config_params.get('user') + os_passwd = config_params.get('passwd') + vim_url = args.endpoint_url + test_config['image_path'] = args.image_path + test_config['image_name'] = args.image_name + test_config['sriov_net_name'] = args.sriov_net_name + + # openstack connector obj + vim_persistent_info = {} + test_config['vim_conn'] = vim.vimconnector( + uuid="test-uuid-1", name="VIO-openstack", + tenant_id=None, tenant_name=tenant_name, + url=vim_url, url_admin=None, + user=os_user, passwd=os_passwd, + config=config_params, persistent_info=vim_persistent_info + ) + test_config['vim_conn'].debug = "true" + elif args.vimtype == "openvim": import vimconn_openvim as vim else: @@ -533,7 +2173,7 @@ def test_vimconnector(args): if args.list_tests: tests_names = [] for cls in clsmembers: - if cls[0].startswith('test_vimconnector'): + if cls[0].startswith('test_vimconn'): tests_names.append(cls[0]) msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names)) @@ -556,7 +2196,7 @@ def test_vimconnector(args): # include all tests for cls in clsmembers: # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user - if cls[0].startswith('test_vimconnector'): + if cls[0].startswith('test_vimconn'): code_based_tests.append(cls[1]) logger.debug("tests to be executed: {}".format(code_based_tests)) @@ -647,6 +2287,72 @@ def test_vim(args): return executed, failed +def test_wim(args): + global test_config + sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro") + import openmanoclient + executed = 0 + failed = 0 + test_config["client"] = openmanoclient.openmanoclient( + endpoint_url=args.endpoint_url, + tenant_name=args.tenant_name, + datacenter_name=args.datacenter, + debug=args.debug, logger=test_config["logger_name"]) + clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass) + # If only want to obtain a tests list print it and exit + if args.list_tests: + tests_names = [] + for cls in clsmembers: + if cls[0].startswith('test_WIM'): + tests_names.append(cls[0]) + + msg = "The 'wim' set tests are:\n\t" + ', '.join(sorted(tests_names)) +\ + "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \ + "unless RO has access to the admin endpoint. Therefore this test is excluded by default" + print(msg) + logger.info(msg) + sys.exit(0) + + # Create the list of tests to be run + code_based_tests = [] + if args.tests: + for test in args.tests: + for t in test.split(','): + matches_code_based_tests = [item for item in clsmembers if item[0] == t] + if len(matches_code_based_tests) > 0: + code_based_tests.append(matches_code_based_tests[0][1]) + else: + logger.critical("Test '{}' is not among the possible ones".format(t)) + sys.exit(1) + if not code_based_tests: + # include all tests + for cls in clsmembers: + # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user + if cls[0].startswith('test_VIM') and cls[0] != 'test_VIM_tenant_operations': + code_based_tests.append(cls[1]) + + logger.debug("tests to be executed: {}".format(code_based_tests)) + + # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests. + # This is handled in the tests using logging. + stream = open('/dev/null', 'w') + + # Run code based tests + basic_tests_suite = unittest.TestSuite() + for test in code_based_tests: + basic_tests_suite.addTest(unittest.makeSuite(test)) + result = unittest.TextTestRunner(stream=stream, failfast=failfast).run(basic_tests_suite) + executed += result.testsRun + failed += len(result.failures) + len(result.errors) + if failfast and failed: + sys.exit(1) + if len(result.failures) > 0: + logger.debug("failures : {}".format(result.failures)) + if len(result.errors) > 0: + logger.debug("errors : {}".format(result.errors)) + return executed, failed + + def test_deploy(args): global test_config sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + "/osm_ro") @@ -660,9 +2366,9 @@ def test_deploy(args): test_directory_content = os.listdir(test_config["test_directory"]) # If only want to obtain a tests list print it and exit if args.list_tests: - msg = "he 'deploy' set tests are:\n\t" + ', '.join(sorted(test_directory_content)) + msg = "the 'deploy' set tests are:\n\t" + ', '.join(sorted(test_directory_content)) print(msg) - logger.info(msg) + # logger.info(msg) sys.exit(0) descriptor_based_tests = [] @@ -764,12 +2470,15 @@ if __name__=="__main__": mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments') mandatory_arguments.add_argument('--vimtype', choices=['vmware', 'aws', 'openstack', 'openvim'], required=True, help='Set the vimconnector type to test') - # TODO add mandatory arguments for vimconn test - # mandatory_arguments.add_argument('-c', '--config', dest='config_param', required=True, help='') - + mandatory_arguments.add_argument('-c', '--config', dest='config_param', required=True, + help='Set the vimconnector specific config parameters in dictionary format') + mandatory_arguments.add_argument('-u', '--url', dest='endpoint_url',required=True, help="Set the vim connector url or Host IP") # Optional arguments + vimconn_parser.add_argument('-i', '--image-path', dest='image_path', help="Provide image path present at RO container") + vimconn_parser.add_argument('-n', '--image-name', dest='image_name', help="Provide image name for test") # TODO add optional arguments for vimconn tests # vimconn_parser.add_argument("-i", '--image-name', dest='image_name', help='')) + vimconn_parser.add_argument('-s', '--sriov-net-name', dest='sriov_net_name', help="Provide SRIOV network name for test") # Datacenter test set # ------------------- @@ -784,6 +2493,19 @@ if __name__=="__main__": vimconn_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano', help="Set the openmano server url. By default 'http://localhost:9090/openmano'") + # WIM test set + # ------------------- + vimconn_parser = subparsers.add_parser('wim', parents=[parent_parser], help="test wim") + vimconn_parser.set_defaults(func=test_wim) + + # Mandatory arguments + mandatory_arguments = vimconn_parser.add_argument_group('mandatory arguments') + mandatory_arguments.add_argument('-d', '--datacenter', required=True, help='Set the datacenter to test') + + # Optional arguments + vimconn_parser.add_argument('-u', '--url', dest='endpoint_url', default='http://localhost:9090/openmano', + help="Set the openmano server url. By default 'http://localhost:9090/openmano'") + argcomplete.autocomplete(parser) args = parser.parse_args() # print str(args)