def __init__(self, **kwargs):
super(SnapsTestRunner, self).__init__(**kwargs)
self.logger = logging.getLogger(__name__)
if 'os_creds' in kwargs:
self.os_creds = kwargs['os_creds']
else:
creds_override = None
if hasattr(CONST, 'snaps_os_creds_override'):
creds_override = CONST.__getattribute__(
'snaps_os_creds_override')
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'),
proxy_settings_str=None,
ssh_proxy_cmd=None,
overrides=creds_override)
if 'ext_net_name' in kwargs:
self.ext_net_name = kwargs['ext_net_name']
else:
self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds)
self.use_fip = CONST.__getattribute__('snaps_use_floating_ips')
self.use_keystone = CONST.__getattribute__('snaps_use_keystone')
scenario = CONST.__getattribute__('DEPLOY_SCENARIO')
self.flavor_metadata = None
if 'ovs' in scenario or 'fdio' in scenario:
self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE
self.logger.info("Using flavor metadata '%s'", self.flavor_metadata)
self.image_metadata = None
if hasattr(CONST, 'snaps_images'):
self.image_metadata = CONST.__getattribute__('snaps_images')
def __init__(self, **kwargs):
"""Initialize RallyBase object."""
super(RallyBase, self).__init__(**kwargs)
if 'os_creds' in kwargs:
self.os_creds = kwargs['os_creds']
else:
creds_override = None
if hasattr(CONST, 'snaps_os_creds_override'):
creds_override = CONST.__getattribute__(
'snaps_os_creds_override')
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'),
overrides=creds_override)
self.guid = '-' + str(uuid.uuid4())
self.creators = []
self.mode = ''
self.summary = []
self.scenario_dir = ''
self.image_name = None
self.ext_net_name = None
self.priv_net_id = None
self.flavor_name = None
self.flavor_alt_name = None
self.smoke = None
self.test_name = None
self.start_time = None
self.result = None
self.details = None
self.compute_cnt = 0
def __init__(self):
self.os_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE)
self.creators = []
self.nova = nova_utils.nova_client(self.os_creds)
self.neutron = neutron_utils.neutron_client(self.os_creds)
self.heat = heat_utils.heat_client(self.os_creds)
self.keystone = keystone_utils.keystone_client(self.os_creds)
def __init__(self, **kwargs):
if "case_name" not in kwargs:
kwargs["case_name"] = "juju_epc"
super(JujuEpc, self).__init__(**kwargs)
# Retrieve the configuration
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/epc')
try:
self.config = CONST.__getattribute__(
'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
requirements=get_config("orchestrator.requirements", config_file),
)
self.created_object = []
self.snaps_creds = ''
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'))
self.details['orchestrator'] = dict(
name=get_config("orchestrator.name", config_file),
version=get_config("orchestrator.version", config_file),
status='ERROR',
result=''
)
self.vnf = dict(
descriptor=get_config("vnf.descriptor", config_file),
requirements=get_config("vnf.requirements", config_file)
)
self.details['vnf'] = dict(
descriptor_version=self.vnf['descriptor']['version'],
name=get_config("vnf.name", config_file),
version=get_config("vnf.version", config_file),
)
self.__logger.debug("VNF configuration: %s", self.vnf)
self.details['test_vnf'] = dict(
name=get_config("vnf_test_suite.name", config_file),
version=get_config("vnf_test_suite.version", config_file),
tag_name=get_config("vnf_test_suite.tag_name", config_file)
)
self.images = get_config("tenant_images", config_file)
self.__logger.info("Images needed for vEPC: %s", self.images)
self.keystone_client = os_utils.get_keystone_client()
self.glance_client = os_utils.get_glance_client()
self.neutron_client = os_utils.get_neutron_client()
self.nova_client = os_utils.get_nova_client()
self.sec_group_id = None
self.public_auth_url = None
self.creds = None
self.filename = None
def get_ext_net_name():
"""
Returns the first external network name
:return:
"""
os_env_file = CONST.openstack_creds
os_creds = openstack_tests.get_credentials(os_env_file=os_env_file)
neutron = neutron_utils.neutron_client(os_creds)
ext_nets = neutron_utils.get_external_networks(neutron)
return ext_nets[0]['network']['name']
def prepare(self):
"""
Prepare the environment for VNF testing:
* Creation of a user,
* Creation of a tenant,
* Allocation admin role to the user on this tenant
Returns base.TestCase.EX_OK if preparation is successfull
Raise VnfPreparationException in case of problem
"""
try:
self.__logger.info("Prepare VNF: %s, description: %s",
self.case_name, self.tenant_description)
snaps_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE)
self.os_project = OpenStackProject(
snaps_creds,
ProjectConfig(name=self.tenant_name,
description=self.tenant_description,
domain=snaps_creds.project_domain_name))
self.os_project.create()
self.created_object.append(self.os_project)
snaps_creds.project_domain_id = \
self.os_project.get_project().domain_id
snaps_creds.user_domain_id = \
self.os_project.get_project().domain_id
for role in ['admin', 'Admin']:
if keystone_utils.get_role_by_name(
keystone_utils.keystone_client(snaps_creds), role):
admin_role = role
break
user_creator = OpenStackUser(
snaps_creds,
UserConfig(name=self.user_name,
password=str(uuid.uuid4()),
project_name=self.tenant_name,
domain_name=snaps_creds.user_domain_name,
roles={admin_role: self.tenant_name}))
user_creator.create()
self.created_object.append(user_creator)
self.snaps_creds = user_creator.get_os_creds(self.tenant_name)
self.__logger.debug("snaps creds: %s", self.snaps_creds)
return vnf.VnfOnBoarding.EX_OK
except Exception: # pylint: disable=broad-except
self.__logger.exception("Exception raised during VNF preparation")
raise VnfPreparationException
def get_credentials(proxy_settings_str=None, ssh_proxy_cmd=None):
"""
Returns snaps OSCreds object instance
:param: proxy_settings_str: proxy settings string <host>:<port>
:param: ssh_proxy_cmd: the SSH proxy command for the environment
:return: an instance of snaps OSCreds object
"""
creds_override = None
if hasattr(config.CONF, 'snaps_os_creds_override'):
creds_override = getattr(config.CONF, 'snaps_os_creds_override')
os_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE, proxy_settings_str=proxy_settings_str,
ssh_proxy_cmd=ssh_proxy_cmd, overrides=creds_override)
return os_creds
def __init__(self,
method_name='runTest',
os_creds=None,
ext_net_name=None,
flavor_metadata=None,
image_metadata=None,
log_level=logging.DEBUG):
"""
Super for test classes requiring a connection to OpenStack
:param method_name: default 'runTest'
:param os_creds: the OSCreds object, when null it searches for the file
in the package snaps.openstack.tests.conf.os_env.yaml
:param ext_net_name: the name of the external network that is used for
creating routers for floating IPs
:param flavor_metadata: dict() to be sent directly into the Nova client
generally used for page sizes
:param image_metadata: ability to override images being used in the
tests (see examples/image-metadata)
:param log_level: the logging level of your test run (default DEBUG)
"""
super(OSComponentTestCase, self).__init__(method_name)
logging.basicConfig(level=log_level)
self.ext_net_name = None
self.flavor_metadata = None
if os_creds:
self.os_creds = os_creds
else:
if file_utils.file_exists(dev_os_env_file):
self.os_creds = openstack_tests.get_credentials(
dev_os_env_file=dev_os_env_file)
test_conf = file_utils.read_yaml(dev_os_env_file)
self.ext_net_name = test_conf.get('ext_net')
os_env_dict = file_utils.read_yaml(dev_os_env_file)
flavor_metadata = os_env_dict.get('flavor_metadata')
if flavor_metadata:
self.flavor_metadata = {'metadata': flavor_metadata}
else:
raise Exception('Unable to obtain OSCreds')
self.os_session = keystone_utils.keystone_session(self.os_creds)
self.image_metadata = image_metadata
if not self.ext_net_name:
self.ext_net_name = ext_net_name
if not self.flavor_metadata:
self.flavor_metadata = flavor_metadata
def __init__(self, **kwargs):
self.os_creds = None
if 'os_creds' in kwargs:
self.os_creds = kwargs['os_creds']
else:
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'))
self.creators = list()
if hasattr(CONST, 'snaps_images_cirros'):
self.cirros_image_config = CONST.__getattribute__(
'snaps_images_cirros')
else:
self.cirros_image_config = None
def __init__(self, **kwargs):
super(VPingBase, self).__init__(**kwargs)
# This line is here simply for pep8 as the 'os' package import appears
# to be required for mock and the unit tests will fail without it
os.environ
self.logger = logging.getLogger(__name__)
if 'os_creds' in kwargs:
self.os_creds = kwargs['os_creds']
else:
creds_override = None
if hasattr(CONST, 'snaps_os_creds_override'):
creds_override = CONST.__getattribute__(
'snaps_os_creds_override')
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'),
overrides=creds_override)
self.creators = list()
self.image_creator = None
self.network_creator = None
self.vm1_creator = None
self.vm2_creator = None
# Shared metadata
self.guid = ''
if CONST.__getattribute__('vping_unique_names'):
self.guid = '-' + str(uuid.uuid4())
self.vm1_name = CONST.__getattribute__('vping_vm_name_1') + self.guid
self.vm2_name = CONST.__getattribute__('vping_vm_name_2') + self.guid
self.vm_boot_timeout = CONST.__getattribute__('vping_vm_boot_timeout')
self.vm_delete_timeout = CONST.__getattribute__(
'vping_vm_delete_timeout')
self.vm_ssh_connect_timeout = CONST.vping_vm_ssh_connect_timeout
self.ping_timeout = CONST.__getattribute__('vping_ping_timeout')
self.flavor_name = 'vping-flavor' + self.guid
# Move this configuration option up for all tests to leverage
if hasattr(CONST, 'snaps_images_cirros'):
self.cirros_image_config = CONST.__getattribute__(
'snaps_images_cirros')
else:
self.cirros_image_config = None
def __init__(self, **kwargs):
super(VPingBase, self).__init__(**kwargs)
self.logger = logging.getLogger(__name__)
if 'os_creds' in kwargs:
self.os_creds = kwargs['os_creds']
else:
creds_override = None
if hasattr(CONST, 'snaps_os_creds_override'):
creds_override = CONST.__getattribute__(
'snaps_os_creds_override')
self.os_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'),
overrides=creds_override)
self.creators = list()
self.image_creator = None
self.network_creator = None
self.vm1_creator = None
self.vm2_creator = None
self.router_creator = None
# Shared metadata
self.guid = '-' + str(uuid.uuid4())
self.router_name = CONST.__getattribute__(
'vping_router_name') + self.guid
self.vm1_name = CONST.__getattribute__('vping_vm_name_1') + self.guid
self.vm2_name = CONST.__getattribute__('vping_vm_name_2') + self.guid
self.vm_boot_timeout = CONST.__getattribute__('vping_vm_boot_timeout')
self.vm_delete_timeout = CONST.__getattribute__(
'vping_vm_delete_timeout')
self.vm_ssh_connect_timeout = CONST.__getattribute__(
'vping_vm_ssh_connect_timeout')
self.ping_timeout = CONST.__getattribute__('vping_ping_timeout')
self.flavor_name = 'vping-flavor' + self.guid
# Move this configuration option up for all tests to leverage
if hasattr(CONST, 'snaps_images_cirros'):
self.cirros_image_config = CONST.__getattribute__(
'snaps_images_cirros')
else:
self.cirros_image_config = None
def prepare(self):
"""
Prepare the environment for VNF testing:
* Creation of a user,
* Creation of a tenant,
* Allocation admin role to the user on this tenant
Returns base.TestCase.EX_OK if preparation is successfull
Raise VnfPreparationException in case of problem
"""
try:
tenant_description = CONST.__getattribute__(
'vnf_{}_tenant_description'.format(self.case_name))
self.__logger.info("Prepare VNF: %s, description: %s",
self.tenant_name, tenant_description)
snaps_creds = openstack_tests.get_credentials(
os_env_file=CONST.__getattribute__('openstack_creds'))
project_creator = OpenStackProject(
snaps_creds,
ProjectConfig(name=self.tenant_name,
description=tenant_description))
project_creator.create()
self.created_object.append(project_creator)
self.os_project = project_creator
user_creator = OpenStackUser(
snaps_creds,
UserConfig(name=self.tenant_name,
password=self.tenant_name,
roles={'admin': self.tenant_name}))
user_creator.create()
self.created_object.append(user_creator)
self.snaps_creds = user_creator.get_os_creds(self.tenant_name)
return base.TestCase.EX_OK
except Exception: # pylint: disable=broad-except
self.__logger.exception("Exception raised during VNF preparation")
raise VnfPreparationException
def __create_sequential_test_suite(source_filename, ext_net_name,
proxy_settings, ssh_proxy_cmd,
run_integration_tests, flavor_metadata,
image_metadata, use_floating_ips,
log_level):
"""
Compiles the tests that cannot be run in parallel
:param source_filename: the OpenStack credentials file (required)
:param ext_net_name: the name of the external network to use for floating
IPs (required)
:param run_integration_tests: when true, the integration tests are executed
:param proxy_settings: <host>:<port> of the proxy server (optional)
:param ssh_proxy_cmd: the command used to connect via SSH over some proxy
server (optional)
:param flavor_metadata: dict() object containing the metadata for flavors
created for test VM instance
:param image_metadata: dict() object containing the metadata for overriding
default images within the tests
:param use_floating_ips: when true, tests requiring floating IPs will be
executed
:param log_level: the logging level
:return:
"""
if use_floating_ips and run_integration_tests:
suite = unittest.TestSuite()
os_creds = openstack_tests.get_credentials(
os_env_file=source_filename,
proxy_settings_str=proxy_settings,
ssh_proxy_cmd=ssh_proxy_cmd)
tsb.add_ansible_integration_tests(suite=suite,
os_creds=os_creds,
ext_net_name=ext_net_name,
use_keystone=True,
flavor_metadata=flavor_metadata,
image_metadata=image_metadata,
log_level=log_level)
return suite
def check_all(self):
"""
Calls all the class functions and returns 0 if all of them succeed.
This is the method called by prepare_env or CLI
"""
self.check_rc()
try:
self.os_creds = openstack_tests.get_credentials(
os_env_file=self.rc_file,
proxy_settings_str=None,
ssh_proxy_cmd=None)
except:
raise Exception("Problem while getting credentials object.")
if self.os_creds is None:
raise Exception("Credentials is None.")
self.check_auth_endpoint()
self.check_public_endpoint()
for service in self.services:
self.check_service_endpoint(service)
self.check_nova()
self.check_neutron()
self.check_glance()
return 0
def get_tacker_client(other_creds={}):
creds_override = None
os_creds = openstack_tests.get_credentials(os_env_file=constants.ENV_FILE,
overrides=creds_override)
sess = keystone_utils.keystone_session(os_creds)
return tackerclient.Client(get_tacker_client_version(), session=sess)
def __create_concurrent_test_suite(
source_filename, ext_net_name, proxy_settings, ssh_proxy_cmd,
run_unit_tests, run_connection_tests, run_api_tests,
run_integration_tests, run_staging_tests, flavor_metadata,
image_metadata, use_floating_ips, continuous_integration, log_level):
"""
Compiles the tests that can be run concurrently
:param source_filename: the OpenStack credentials file (required)
:param ext_net_name: the name of the external network to use for floating
IPs (required)
:param run_unit_tests: when true, the tests not requiring OpenStack will be
added to the test suite
:param run_connection_tests: when true, the tests that perform simple
connections to OpenStack are executed
:param run_api_tests: when true, the tests that perform simple API calls to
OpenStack are executed
:param run_integration_tests: when true, the integration tests are executed
:param run_staging_tests: when true, the staging tests are executed
:param proxy_settings: <host>:<port> of the proxy server (optional)
:param ssh_proxy_cmd: the command used to connect via SSH over some proxy
server (optional)
:param flavor_metadata: dict() object containing the metadata for flavors
created for test VM instance
:param image_metadata: dict() object containing the metadata for overriding
default images within the tests
:param use_floating_ips: when true, tests requiring floating IPs will be
executed
:param continuous_integration: when true, tests for CI will be run
:param log_level: the logging level
:return:
"""
suite = unittest.TestSuite()
os_creds = openstack_tests.get_credentials(
os_env_file=source_filename,
proxy_settings_str=proxy_settings,
ssh_proxy_cmd=ssh_proxy_cmd)
# Tests that do not require a remote connection to an OpenStack cloud
if run_unit_tests:
tsb.add_unit_tests(suite)
# Basic connection tests
if run_connection_tests:
tsb.add_openstack_client_tests(suite=suite,
os_creds=os_creds,
ext_net_name=ext_net_name,
use_keystone=True,
log_level=log_level)
# Tests the OpenStack API calls
if run_api_tests:
tsb.add_openstack_api_tests(suite=suite,
os_creds=os_creds,
ext_net_name=ext_net_name,
use_keystone=True,
flavor_metadata=flavor_metadata,
image_metadata=image_metadata,
log_level=log_level)
# Long running integration type tests
if run_integration_tests:
tsb.add_openstack_integration_tests(suite=suite,
os_creds=os_creds,
ext_net_name=ext_net_name,
use_keystone=True,
flavor_metadata=flavor_metadata,
image_metadata=image_metadata,
use_floating_ips=use_floating_ips,
log_level=log_level)
if run_staging_tests:
tsb.add_openstack_staging_tests(suite=suite,
os_creds=os_creds,
ext_net_name=ext_net_name,
log_level=log_level)
if continuous_integration:
tsb.add_openstack_ci_tests(suite=suite,
os_creds=os_creds,
ext_net_name=ext_net_name,
use_keystone=True,
flavor_metadata=flavor_metadata,
image_metadata=image_metadata,
use_floating_ips=use_floating_ips,
log_level=log_level)
return suite
def __run_tests(source_filename, ext_net_name, proxy_settings, ssh_proxy_cmd, use_keystone, use_floating_ips,
log_level):
"""
Compiles the tests that should run
:param source_filename: the OpenStack credentials file (required)
:param ext_net_name: the name of the external network to use for floating IPs (required)
:param proxy_settings: <host>:<port> of the proxy server (optional)
:param ssh_proxy_cmd: the command used to connect via SSH over some proxy server (optional)
:param use_keystone: when true, tests creating users and projects will be exercised and must be run on a host that
has access to the cloud's administrative network
:param use_floating_ips: when true, tests requiring floating IPs will be executed
:param log_level: the logging level
:return:
"""
os_creds = openstack_tests.get_credentials(os_env_file=source_filename, proxy_settings_str=proxy_settings,
ssh_proxy_cmd=ssh_proxy_cmd)
image_creators = __create_images(os_creds)
meta_list = list()
# Create images from default
meta_list.append(None)
# Create images from specified URL
meta_list.append(
{'glance_tests': {'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL},
'cirros': {'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL},
'centos': {'disk_url': openstack_tests.CENTOS_DEFAULT_IMAGE_URL},
'ubuntu': {'disk_url': openstack_tests.UBUNTU_DEFAULT_IMAGE_URL}})
# Create images from file
meta_list.append(
{'glance_tests': {'disk_file': '../images/cirros-0.3.4-x86_64-disk.img'},
'cirros': {'disk_file': '../images/cirros-0.3.4-x86_64-disk.img'},
'centos': {'disk_file': '../images/CentOS-7-x86_64-GenericCloud.qcow2'},
'ubuntu': {'disk_file': '../images/ubuntu-14.04-server-cloudimg-amd64-disk1.img'}})
# Create images from Existing
meta_list.append(
{'glance_tests': {'disk_file': '../images/cirros-0.3.4-x86_64-disk.img'},
'cirros': {'config': {'name': image_creators['cirros'].image_settings.name,
'exists': True, 'image_user': '******'}},
'centos': {'config': {'name': image_creators['centos'].image_settings.name,
'exists': True, 'image_user': '******'}},
'ubuntu': {'config': {'name': image_creators['ubuntu'].image_settings.name,
'exists': True, 'image_user': '******'}}})
failure_count = 0
error_count = 0
try:
for metadata in meta_list:
logger.info('Starting tests with image metadata of - ' + str(metadata))
suite = unittest.TestSuite()
# Long running integration type tests
suite.addTest(OSComponentTestCase.parameterize(
GlanceUtilsTests, os_creds=os_creds, ext_net_name=ext_net_name, image_metadata=metadata,
log_level=log_level))
test_suite_builder.add_openstack_integration_tests(
suite=suite, os_creds=os_creds, ext_net_name=ext_net_name, use_keystone=use_keystone,
image_metadata=metadata, use_floating_ips=use_floating_ips, log_level=log_level)
result = unittest.TextTestRunner(verbosity=2).run(suite)
if result.errors:
logger.error('Number of errors in test suite - ' + str(len(result.errors)))
for test, message in result.errors:
logger.error(str(test) + " ERROR with " + message)
error_count += 1
if result.failures:
logger.error('Number of failures in test suite - ' + str(len(result.failures)))
for test, message in result.failures:
logger.error(str(test) + " FAILED with " + message)
failure_count += 1
if (result.errors and len(result.errors) > 0) or (result.failures and len(result.failures) > 0):
logger.error('See above for test failures')
else:
logger.info('All tests completed successfully in run')
logger.info('Total number of errors = ' + str(error_count))
logger.info('Total number of failures = ' + str(failure_count))
if error_count + failure_count > 0:
exit(1)
except Exception as e:
logger.warn('Unexpected error running tests - %s', e)
pass
finally:
for image_creator in image_creators.values():
try:
image_creator.clean()
except Exception as e:
logger.error('Exception thrown while cleaning image - %s', e)
