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)